45 | using API in os package (Part 2)
In our last article. This paper introduces a series of related contents from the issue of "which io package interfaces are implemented by os.File types". Today we continue to expand around this knowledge point.
Knowledge expansion
Question 1: what are the operation modes that can be applied to the File value?
The operation modes for File values mainly include read-only mode, write only mode and read-write mode.
These modes are represented by the constant OS. O, respectively_ RDONLY,os.O_WRONLY and os.O_RDWR represents. When we create or open a file, we must set one of these three modes as the operation mode of the file.
In addition, we can set additional operation modes for the files here. The options are as follows.
- os.O_APPEND: when writing content to a file, append the new content to the back of the existing content.
- os.O_CREATE: creates a new file when the file on the given path does not exist.
- os.O_EXCL: need to work with OS. O_ Used with create to indicate that there cannot be an existing file on the given path.
- os.O_SYNC: implement synchronous I/O on the open file. It ensures that the contents read and written are always synchronized with the data on the hard disk.
- os.O_TRUNC: if the file already exists and is a regular file, empty any existing content in it first.
For the use of the above operation modes, the os.Create function and the os.Open function are ready-made examples.
func Create(name string) (*File, error) {
return OpenFile(name, O_RDWR|O_CREATE|O_TRUNC, 0666)
}When os.Create function calls os.OpenFile function, the operation mode given is os.O_RDWR,os.O_CREATE and OS. O_ Combination of TRUNC.
This basically determines the behavior of the former, that is, if the parameter name represents that the file on the path does not exist, create a new one. Otherwise, empty all the contents of the existing file first.
In addition, the read method and write method of the File value returned by it are available. It should be noted here that multiple operation modes are combined by bitwise OR operator |.
func Open(name string) (*File, error) {
return OpenFile(name, O_RDONLY, 0)
}As I said earlier, the os.Open function opens an existing file in read-only mode. The root cause is that it only provides a single operation mode OS. O when calling the os.OpenFile function_ RDONLY.
The above is my simple explanation of the operation mode that can be applied to the File value. There are a few examples in the demo88.go File for your reference.
package main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
)
type flagDesc struct {
flag int
desc string
}
func main() {
fileName1 := "something2.txt"
filePath1 := filepath.Join(os.TempDir(), fileName1)
fmt.Printf("The file path: %s\n", filePath1)
fmt.Println()
// Example 1.
contents0 := "OpenFile is the generalized open call."
flagDescList := []flagDesc{
{
os.O_WRONLY | os.O_CREATE | os.O_TRUNC,
"os.O_WRONLY|os.O_CREATE|os.O_TRUNC",
},
{
os.O_WRONLY,
"os.O_WRONLY",
},
{
os.O_WRONLY | os.O_APPEND,
"os.O_WRONLY|os.O_APPEND",
},
}
for i, v := range flagDescList {
fmt.Printf("Open the file with flag %s ...\n", v.desc)
file1a, err := os.OpenFile(filePath1, v.flag, 0666)
if err != nil {
fmt.Printf("error: %v\n", err)
continue
}
fmt.Printf("The file descriptor: %d\n", file1a.Fd())
contents1 := fmt.Sprintf("[%d]: %s ", i+1, contents0)
fmt.Printf("Write %q to the file ...\n", contents1)
n, err := file1a.WriteString(contents1)
if err != nil {
fmt.Printf("error: %v\n", err)
continue
}
fmt.Printf("The number of bytes written is %d.\n", n)
file1b, err := os.Open(filePath1)
fmt.Println("Read bytes from the file ...")
bytes, err := ioutil.ReadAll(file1b)
if err != nil {
fmt.Printf("error: %v\n", err)
continue
}
fmt.Printf("Read(%d): %q\n", len(bytes), bytes)
fmt.Println()
}
// Example 2.
fmt.Println("Try to create an existing file with flag os.O_TRUNC ...")
file2, err := os.OpenFile(filePath1, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0666)
if err != nil {
fmt.Printf("error: %v\n", err)
return
}
fmt.Printf("The file descriptor: %d\n", file2.Fd())
fmt.Println("Try to create an existing file with flag os.O_EXCL ...")
_, err = os.OpenFile(filePath1, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
fmt.Printf("error: %v\n", err)
}Question 2: how to set the access rights of general files?
We already know that the third parameter perm of os.OpenFile function represents the permission mode, and its type is os.FileMode. But in fact, os.FileMode type can represent not only permission mode, but also file mode (also known as file type).
Since os.FileMode is a redefinition type based on uint32 type, its value contains 32 bits. Among the 32 bits, each bit has its specific meaning.
For example, if the binary number in its highest bit is 1, the file mode represented by this value is equivalent to os.ModeDir, that is, the corresponding file represents a directory.
For another example, if the 26th bit is 1, the file mode represented by the corresponding value is equivalent to os.ModeNamedPipe, that is, the file represents a named pipe.
In fact, in a value of os.FileMode type (hereinafter referred to as FileMode value), only the lowest 9 bits are used to represent the permission of the file. When we get a value of this type, we can bitwise and operate it with the value of os.ModePerm constant.
The value of this constant is 0777, which is an octal unsigned integer with 1 in the lowest 9 bits and 0 in the higher 23 bits.
Therefore, after such bitwise and operation, we can get all the bits used to represent the file permission in the FileMode value, that is, the permission mode represented by the value. This will be consistent with the result value obtained by calling the Perm method of FileMode value.
Among the nine bits used to represent file permissions, every three bits are a group, which can be divided into three groups.
From high to low, these three groups represent the file owner (that is, the user who created the file), the user group to which the file owner belongs, and the access rights of other users to the file. For each group, the three bits from high to low represent read permission, write permission and execution permission respectively.
If 1 is on one of the bits, it means that the corresponding permission is turned on. Otherwise, it means that the corresponding permission is turned off.
Therefore, the octal integer 0777 indicates that all users in the operating system have read, write and execute permissions on the current file, while the octal integer 0666 indicates that all users have read and write permissions on the current file, but do not have execute permissions.
When we call the os.OpenFile function, we can set its third parameter according to the above instructions. However, it should be noted that the third parameter value here is valid only when creating a new file. In other cases, even if we set this parameter, it will not have any impact on the target file.
package main
import (
"fmt"
"os"
"path/filepath"
)
type argDesc struct {
action string
flag int
perm os.FileMode
}
func main() {
// Example 1.
fmt.Printf("The mode for dir:\n%32b\n", os.ModeDir)
fmt.Printf("The mode for named pipe:\n%32b\n", os.ModeNamedPipe)
fmt.Printf("The mode for all of the irregular files:\n%32b\n", os.ModeType)
fmt.Printf("The mode for permissions:\n%32b\n", os.ModePerm)
fmt.Println()
// Example 2.
fileName1 := "something3.txt"
filePath1 := filepath.Join(os.TempDir(), fileName1)
fmt.Printf("The file path: %s\n", filePath1)
argDescList := []argDesc{
{
"Create",
os.O_RDWR | os.O_CREATE,
0644,
},
{
"Reuse",
os.O_RDWR | os.O_TRUNC,
0666,
},
{
"Open",
os.O_RDWR | os.O_APPEND,
0777,
},
}
defer os.Remove(filePath1)
for _, v := range argDescList {
fmt.Printf("%s the file with perm %o ...\n", v.action, v.perm)
file1, err := os.OpenFile(filePath1, v.flag, v.perm)
if err != nil {
fmt.Printf("error: %v\n", err)
continue
}
info1, err := file1.Stat()
if err != nil {
fmt.Printf("error: %v\n", err)
continue
}
fmt.Printf("The file permissions: %o\n", info1.Mode().Perm())
}
}summary
In order to focus on the os.File type itself, I mainly described how to apply the os.File type to regular files in these two articles. The pointer type of this type implements the interfaces in many io packages, so its specific functions can be self-evident.
Through this type of value, we can not only read, write and close files, but also set the starting index position for the next read or write.
Before using this type of value, we must first create it. So I've highlighted a few functions that you can create and get values of this type.
Includes: os.Create, os.NewFile, os.Open, and os.OpenFile. The way we create the File value determines what we can do with it.
Using the os.Create function, we can create a new file in the operating system, or empty all the contents of an existing file and reuse it.
Above the corresponding File value, we can read and write the File. Although the os.NewFile function is not used to create a new File, it can wrap an available File value based on a valid File descriptor.
The os.Open function opens an existing File. However, we can only read the corresponding File through the File value returned by it.
os.OpenFile is the most flexible of these functions. Through it, we can set the operation mode and permission mode of the open file. In fact, the os.Create function and os.Open function are just a simple encapsulation of it.
When using os.OpenFile function, we must find out the true meaning of operation mode and permission mode, and the correct way to set them.
I have explained them in detail in the extension of this paper. At the same time, I also wrote some code in the corresponding sample file.
You need to carefully read and understand these codes, and realize the true meaning of these two modes in the process of running them.
What I'm talking about in this article is only the iceberg on the sea for the os package. This code contains a lot of knowledge and is very extensible.
If you want to fully understand them, you may also need to refer to documents and tutorials on operating systems and other aspects. Due to space reasons, I just made a guide here to help you get to know some important program entities in the package, and give you an entry point that you can go deep into. I hope you are already on the way.
Thinking questions
Today's question is: how to create and manipulate a system process through the API in the os package?