// NewLogger creates a new logger
func NewLogger(stdout string, stderr string) (logger *Logger, err error) {
var (
stderrWriter = os.Stderr
stdoutWriter = os.Stdout
toClose []closeable
)
if stderr != "" {
if stderrWriter, err = os.OpenFile(stderr, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666); err != nil {
return
}
toClose = append(toClose, stderrWriter)
}
if stdout != "" {
if stdoutWriter, err = os.OpenFile(stdout, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666); err != nil {
return
}
toClose = append(toClose, stderrWriter)
}
logger = &Logger{
stderr: log.New(stderrWriter, "ERROR ", log.LstdFlags|log.Lshortfile),
stdout: log.New(stdoutWriter, "INFO ", log.LstdFlags|log.Lshortfile),
toClose: toClose,
}
return
}
func benchmarkBTreeSetACIDFiler(b *testing.B, sz int) {
dir, testDbName := temp()
defer os.RemoveAll(dir)
f, err := os.OpenFile(testDbName, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600)
if err != nil {
b.Fatal(err)
}
defer f.Close()
wal, err := os.OpenFile(testDbName+".wal", os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600)
if err != nil {
b.Fatal(err)
}
defer wal.Close()
filer, err := NewACIDFiler(NewSimpleFileFiler(f), wal)
if err != nil {
b.Error(err)
return
}
benchmarkBTreeSetFiler(b, filer, sz)
}
func (node *Node) OpenForReading() (*os.File, error) {
file, err := os.OpenFile(node.path, os.O_RDONLY|syscall.O_NOATIME, 0)
if os.IsPermission(err) {
return os.OpenFile(node.path, os.O_RDONLY, 0)
}
return file, err
}
func initDebugLogger() {
debugfile := os.Getenv("DEBUG_LOG")
if debugfile == "" {
return
}
fmt.Fprintf(os.Stderr, "debug log file %v\n", debugfile)
f, err := os.OpenFile(debugfile, os.O_WRONLY|os.O_APPEND, 0600)
if err == nil {
_, err = f.Seek(2, 0)
if err != nil {
fmt.Fprintf(os.Stderr, "unable to seek to the end of %v: %v\n", debugfile, err)
os.Exit(3)
}
}
if err != nil && os.IsNotExist(err) {
f, err = os.OpenFile(debugfile, os.O_WRONLY|os.O_CREATE, 0600)
}
if err != nil {
fmt.Fprintf(os.Stderr, "unable to open debug log file: %v\n", err)
os.Exit(2)
}
opts.logger = log.New(f, "", log.LstdFlags)
}
func (v *Volume) load(alsoLoadIndex bool) error {
var e error
fileName := path.Join(v.dir, v.Id.String())
if exists, canRead, canWrite, _ := checkFile(fileName + ".dat"); exists && !canRead {
return fmt.Errorf("cannot read Volume Data file %s.dat", fileName)
} else if !exists || canWrite {
v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644)
} else if exists && canRead {
glog.V(0).Infoln("opening " + fileName + ".dat in READONLY mode")
v.dataFile, e = os.Open(fileName + ".dat")
v.readOnly = true
} else {
return fmt.Errorf("Unknown state about Volume Data file %s.dat", fileName)
}
if e != nil {
if !os.IsPermission(e) {
return fmt.Errorf("cannot load Volume Data %s.dat: %s", fileName, e.Error())
}
}
if v.ReplicaType == CopyNil {
e = v.readSuperBlock()
} else {
e = v.maybeWriteSuperBlock()
}
if e == nil && alsoLoadIndex {
var indexFile *os.File
if v.readOnly {
glog.V(1).Infoln("open to read file", fileName+".idx")
if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDONLY, 0644); e != nil {
return fmt.Errorf("cannot read Volume Data %s.dat: %s", fileName, e.Error())
}
if v.ensureConvertIdxToCdb(fileName) {
v.nm, e = OpenCdbMap(fileName + ".cdb")
return e
}
if indexFile != nil {
glog.V(0).Infoln("converting %s.idx to %s.cdb", fileName, fileName)
if e = ConvertIndexToCdb(fileName+".cdb", indexFile); e != nil {
glog.Errorln("error converting %s.idx to %s.cdb: %s", fileName, fileName, e)
} else {
indexFile.Close()
os.Remove(indexFile.Name())
indexFile = nil
}
}
} else {
glog.V(1).Infoln("open to write file", fileName+".idx")
if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDWR|os.O_CREATE, 0644); e != nil {
return fmt.Errorf("cannot write Volume Data %s.dat: %s", fileName, e.Error())
}
}
glog.V(0).Infoln("loading file", fileName+".idx", "readonly", v.readOnly)
if v.nm, e = LoadNeedleMap(indexFile); e != nil {
glog.V(0).Infoln("loading error:", e)
}
}
return e
}
// WriteTo writes the entire database to a writer.
// If err == nil then exactly tx.Size() bytes will be written into the writer.
func (tx *Tx) WriteTo(w io.Writer) (n int64, err error) {
// Attempt to open reader directly.
var f *os.File
if f, err = os.OpenFile(tx.db.path, os.O_RDONLY|odirect, 0); err != nil {
// Fallback to a regular open if that doesn't work.
if f, err = os.OpenFile(tx.db.path, os.O_RDONLY, 0); err != nil {
return 0, err
}
}
// Copy the meta pages.
tx.db.metalock.Lock()
n, err = io.CopyN(w, f, int64(tx.db.pageSize*2))
tx.db.metalock.Unlock()
if err != nil {
_ = f.Close()
return n, fmt.Errorf("meta copy: %s", err)
}
// Copy data pages.
wn, err := io.CopyN(w, f, tx.Size()-int64(tx.db.pageSize*2))
n += wn
if err != nil {
_ = f.Close()
return n, err
}
return n, f.Close()
}
func TestFStatFs(t *testing.T) {
ts := NewTestCase(t)
defer ts.Cleanup()
fOrig, err := os.OpenFile(ts.orig+"/file", os.O_CREATE|os.O_TRUNC|os.O_RDWR, 0644)
if err != nil {
t.Fatalf("OpenFile failed: %v", err)
}
defer fOrig.Close()
empty := syscall.Statfs_t{}
s1 := empty
errno := syscall.Fstatfs(int(fOrig.Fd()), &s1)
if errno != nil {
t.Fatal("statfs orig", err)
}
fMnt, err := os.OpenFile(ts.mnt+"/file", os.O_RDWR, 0644)
if err != nil {
t.Fatalf("OpenFile failed: %v", err)
}
defer fMnt.Close()
s2 := empty
errno = syscall.Fstatfs(int(fMnt.Fd()), &s2)
if errno != nil {
t.Fatal("statfs mnt", err)
}
clearStatfs(&s1)
clearStatfs(&s2)
if fmt.Sprintf("%v", s2) != fmt.Sprintf("%v", s1) {
t.Errorf("statfs mismatch: %#v != %#v", s1, s2)
}
}
// openFileAndCehckpoint will create a checkpoint file, open a new file for
// writing a data index, write the header and return the file
func (e *Engine) openFileAndCheckpoint(fileName string) (*os.File, error) {
checkpointFile := fmt.Sprintf("%s.%s", fileName, CheckpointExtension)
cf, err := os.OpenFile(checkpointFile, os.O_CREATE, 0666)
if err != nil {
return nil, err
}
// _, err = cf.Write(u32tob(magicNumber))
// if err != nil {
// panic(err)
// }
if err := cf.Close(); err != nil {
return nil, err
}
_, err = os.Stat(checkpointFile)
f, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR, 0666)
if err != nil {
return nil, err
}
// write the header, which is just the magic number
if _, err := f.Write(u32tob(magicNumber)); err != nil {
f.Close()
return nil, err
}
return f, nil
}
func benchmarkAllocatorRndGetACIDFiler(b *testing.B, sz int) {
os.Remove(testDbName)
os.Remove(walName)
f, err := os.OpenFile(testDbName, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600)
if err != nil {
b.Fatal(err)
}
defer func() {
f.Close()
os.Remove(testDbName)
}()
wal, err := os.OpenFile(walName, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0600)
if err != nil {
b.Fatal(err)
}
defer func() {
wal.Close()
os.Remove(walName)
}()
filer, err := NewACIDFiler(NewSimpleFileFiler(f), wal)
if err != nil {
b.Error(err)
return
}
benchmarkAllocatorRndGet(b, filer, sz)
}
func ReloadLogger(tutumLogFile string, dockerLogFile string) {
if TutumLogDescriptor.Fd() != os.Stdout.Fd() {
f, err := os.OpenFile(tutumLogFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
SendError(err, "Failed to open tutum log file", nil)
log.Println(err)
log.Println("Log to stdout instead")
f = os.Stdout
}
Logger = log.New(f, "", log.Ldate|log.Ltime)
TutumLogDescriptor.Close()
TutumLogDescriptor = f
Logger.Print("SIGHUP: Tutum log file descriptor has been reloaded")
} else {
Logger.Print("SIGHUP: No need to reload tutum logs when printing to stdout")
}
Logger.Print("SIGHUP: Reloading docker log file descriptor")
f, err := os.OpenFile(dockerLogFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
SendError(err, "Failed to set docker log file", nil)
Logger.Println(err)
Logger.Println("Cannot set docker log to", dockerLogFile)
} else {
go io.Copy(f, DockerLogStdoutDescriptor)
go io.Copy(f, DockerLogStderrDescriptor)
DockerLogDescriptor.Close()
DockerLogDescriptor = f
Logger.Print("SIGHUP: Docker log file descriptor has been reloaded")
}
}
func (n NetworkLinks) Write(path string, appends bool) error {
var file *os.File
var err error
if appends {
file, err = os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0660)
} else {
file, err = os.OpenFile(path, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0660)
if os.IsExist(err) {
file, err = os.OpenFile(path, os.O_TRUNC|os.O_WRONLY, 0660)
}
}
if err != nil {
log.Print("network_links: Unable to open network links file: ", err)
return err
}
defer file.Close()
for i := range n {
if _, errw := fmt.Fprintf(file, "%s\t%d\t%d\t%s\n", n[i].FromHost, n[i].FromPort, n[i].ToPort, n[i].ToHost); errw != nil {
log.Print("network_links: Unable to write network links: ", err)
return err
}
}
if errc := file.Close(); errc != nil {
log.Print("network_links: Unable to network links: ", errc)
return err
}
return nil
}
func (v *Volume) load(alsoLoadIndex bool, createDatIfMissing bool) error {
var e error
fileName := v.FileName()
if exists, canRead, canWrite, _ := checkFile(fileName + ".dat"); exists {
if !canRead {
return fmt.Errorf("cannot read Volume Data file %s.dat", fileName)
}
if canWrite {
v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644)
} else {
glog.V(0).Infoln("opening " + fileName + ".dat in READONLY mode")
v.dataFile, e = os.Open(fileName + ".dat")
v.readOnly = true
}
} else {
if createDatIfMissing {
v.dataFile, e = os.OpenFile(fileName+".dat", os.O_RDWR|os.O_CREATE, 0644)
} else {
return fmt.Errorf("Volume Data file %s.dat does not exist.", fileName)
}
}
if e != nil {
if !os.IsPermission(e) {
return fmt.Errorf("cannot load Volume Data %s.dat: %s", fileName, e.Error())
}
}
if v.ReplicaPlacement == nil {
e = v.readSuperBlock()
} else {
e = v.maybeWriteSuperBlock()
}
if e == nil && alsoLoadIndex {
if v.readOnly {
if v.ensureConvertIdxToCdb(fileName) {
v.nm, e = OpenCdbMap(fileName + ".cdb")
return e
}
}
var indexFile *os.File
if v.readOnly {
glog.V(1).Infoln("open to read file", fileName+".idx")
if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDONLY, 0644); e != nil {
return fmt.Errorf("cannot read Volume Index %s.idx: %s", fileName, e.Error())
}
} else {
glog.V(1).Infoln("open to write file", fileName+".idx")
if indexFile, e = os.OpenFile(fileName+".idx", os.O_RDWR|os.O_CREATE, 0644); e != nil {
return fmt.Errorf("cannot write Volume Index %s.idx: %s", fileName, e.Error())
}
}
glog.V(0).Infoln("loading file", fileName+".idx", "readonly", v.readOnly)
if v.nm, e = LoadNeedleMap(indexFile); e != nil {
glog.V(0).Infoln("loading error:", e)
}
}
return e
}
func Configure(fileName string, appendFile bool) error {
StripPackage = true
PadLocation = false
HideLocation = false
if len(fileName) > 0 {
fh, e := os.OpenFile(fileName, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0660)
if e != nil {
if appendFile {
fh, e = os.OpenFile(fileName, os.O_RDWR|os.O_APPEND, 0660)
} else {
e = os.Rename(fileName, fileName+time.Now().Format(".20060102-150405"))
fh, e = os.OpenFile(fileName, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0660)
}
}
if e != nil {
return e
}
fileHandle = fh
writer = io.MultiWriter(fh, os.Stdout)
} else {
writer = os.Stdout
}
golog.SetFlags(golog.Ltime)
golog.SetOutput(writer)
maxLevel = Info
return nil
}
func (c *containerProcess) openIo() (err error) {
defer func() {
if err != nil {
c.Cleanup()
}
}()
c.io.stdinf, err = os.OpenFile(c.io.stdin, os.O_RDWR, 0)
if err != nil {
return err
}
c.io.stdoutf, err = os.OpenFile(c.io.stdout, os.O_RDWR, 0)
if err != nil {
return err
}
go io.Copy(&c.io.stdoutBuffer, c.io.stdoutf)
c.io.stderrf, err = os.OpenFile(c.io.stderr, os.O_RDWR, 0)
if err != nil {
return err
}
go io.Copy(&c.io.stderrBuffer, c.io.stderrf)
return nil
}
func OutputRes() {
//save all result
allFile, err := os.OpenFile(*saveFile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
logger.Println("Open file error,", err)
}
defer allFile.Close()
//save has result
hasFile, err := os.OpenFile(*hasFile, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
logger.Println("Open file error,", err)
}
defer hasFile.Close()
var num int64 = 0
var has int64 = 0
for k, address := range Visit {
str := fmt.Sprintf("%-4d has: %-5t, url: %s\n", num, address.Has, k)
// logger.Printf("%-4d has: %t,url: %-40s\n", num, address.Has, k)
logger.Printf(str)
allFile.WriteString(str)
if address.Has {
hasFile.WriteString(fmt.Sprintf("%-4d has: %-5t, url: %s\n", has, address.Has, k))
}
num++
has++
}
}
func (q *Query) startWriteMode() error {
var e error
ci := q.Connection().(*Connection).Info()
if q.newFileWrite {
q.tempfile, e = os.OpenFile(q.filePath+".temp", os.O_CREATE, 0666)
} else {
q.tempfile, e = os.OpenFile(q.filePath, os.O_RDWR|os.O_APPEND, 0666)
}
if e != nil {
return e
}
q.writer = csv.NewWriter(q.tempfile)
if delimiter := ci.Settings.Get("delimiter", "").(string); delimiter != "" {
q.writer.Comma = rune(delimiter[0])
}
if q.newFileWrite && q.isUseHeader && len(q.headerColumn) > 0 {
datatemp := make([]string, 0)
for _, v := range q.headerColumn {
datatemp = append(datatemp, v.name)
}
q.writer.Write(datatemp)
q.writer.Flush()
}
return nil
}
func logIRC(irc map[string]string) {
if _, err := os.Stat("./logs"); err != nil {
if os.IsNotExist(err) {
color.Green("Creating directory logs")
os.Mkdir("./logs", 0766)
}
}
if strings.HasPrefix(irc["params"], "#") {
s := strings.Split(irc["params"], " ")
f, err := os.OpenFile("logs/"+s[0]+".log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("Error opening logfile for %s: %v", irc["params"], err)
}
log.SetOutput(f)
log.Printf("%s %s %s %s\n", irc["prefix"], irc["command"], irc["params"], irc["trailing"])
defer f.Close()
} else {
f, err := os.OpenFile("logs/all.log", os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("Error opening logfile all: %v", err)
}
log.SetOutput(f)
log.Printf("%s %s %s %s %s\n", irc["tags"], irc["prefix"], irc["command"], irc["params"], irc["trailing"])
defer f.Close()
}
}
func configureLogger() log.Logger {
level := configParameters["nagios2opsgenie.logger"]
var logFilePath = parameters["logPath"]
if len(logFilePath) == 0 {
logFilePath = "/var/log/opsgenie/nagios2opsgenie.log"
}
var tmpLogger log.Logger
file, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
fmt.Println("Could not create log file \""+logFilePath+"\", will log to \"/tmp/nagios2opsgenie.log\" file. Error: ", err)
fileTmp, errTmp := os.OpenFile("/tmp/nagios2opsgenie.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if errTmp != nil {
fmt.Println("Logging disabled. Reason: ", errTmp)
} else {
tmpLogger = golog.New(fileTmp, levels[strings.ToLower(level)])
}
} else {
tmpLogger = golog.New(file, levels[strings.ToLower(level)])
}
return tmpLogger
}
func (f *FileStorage) writeToFile(item FileStorageItem) error {
f.mxt.Lock()
if f.currentFile != nil {
fInfo, err := f.currentFile.Stat()
if err != nil || fInfo.Name() != f.getCurrentFileName() {
f.currentFile.Close()
f.currentFile, err = os.OpenFile(f.getCurrentFileName(), os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
}
} else {
f.currentFile, _ = os.OpenFile(f.getCurrentFileName(), os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
}
lineBytes, err := item.MarshalBinary()
if err != nil {
log.Errorf("Error marshaling %s data %#v", err.Error(), item)
}
_, err = f.currentFile.WriteString(string(lineBytes) + "\n")
if err != nil {
log.Errorf("Error write to local storage %s data %s", err.Error(), string(lineBytes))
}
f.mxt.Unlock()
return err
}
func (d *digitalPin) setMode(mode string) {
d.Mode = mode
if mode == "w" {
fi, err := os.OpenFile(GPIO_PATH+"/gpio"+d.PinNum+"/direction", os.O_WRONLY, 0666)
if err != nil {
panic(err)
}
fi.WriteString(GPIO_DIRECTION_WRITE)
fi.Close()
d.PinFile, err = os.OpenFile(GPIO_PATH+"/gpio"+d.PinNum+"/value", os.O_WRONLY, 0666)
if err != nil {
panic(err)
}
} else if mode == "r" {
fi, err := os.OpenFile(GPIO_PATH+"/gpio"+d.PinNum+"/direction", os.O_WRONLY, 0666)
if err != nil {
panic(err)
}
fi.WriteString(GPIO_DIRECTION_READ)
fi.Close()
d.PinFile, err = os.OpenFile(GPIO_PATH+"/gpio"+d.PinNum+"/value", os.O_RDONLY, 0666)
if err != nil {
panic(err)
}
}
}
func GenerateOjModle(path_ string, m *Model) error {
_, err := os.Stat(path_)
if !goutils.CheckErr(err) {
os.RemoveAll(path_)
}
err = os.Mkdir(path_, 0777)
if goutils.CheckErr(err) {
// return err
}
fname := m.FuncName + ".go"
tname := m.FuncName + "_test.go"
func_file, err := os.OpenFile(filepath.Join(path_, fname), os.O_CREATE|os.O_WRONLY, 0644)
defer func_file.Close()
if goutils.CheckErr(err) {
return err
}
if goutils.CheckErr(generateOjFunc(m.Content, func_file)) {
return fmt.Errorf("generateOjFunc error")
}
test_file, err := os.OpenFile(filepath.Join(path_, tname), os.O_CREATE|os.O_WRONLY, 0644)
defer test_file.Close()
if goutils.CheckErr(err) {
return err
}
args := make(map[string]interface{})
args["FUNC"] = m.FuncName
args["ArgsType"] = m.ArgsType
args["RetsType"] = m.RetsType
args["TestCases"] = m.TestCases
return renderOjModle(args, test_file)
}
func makeUpgradeKeys([]string) error {
priv, pub := upgradebin.GenerateKeys(rand.Reader)
privPem, pubPem := upgradebin.EncodeKeys(priv, pub)
fmt.Println("")
fmt.Println(string(privPem))
fmt.Println("")
fmt.Println(string(pubPem))
privFile, err1 := os.OpenFile("upgrades-private-key.pem",
os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
defer privFile.Close()
pubFile, err2 := os.OpenFile("upgrades-public-key.pem",
os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
defer pubFile.Close()
if err1 != nil {
return err1
}
if err2 != nil {
return err2
}
_, err1 = privFile.Write(privPem)
_, err2 = pubFile.Write(pubPem)
if err1 != nil {
return err1
}
if err2 != nil {
return err2
}
return nil
}
func main() {
flag.Parse()
if *showVersion {
fmt.Printf("json2csv v1.1\n")
return
}
var reader *bufio.Reader
var writer *csv.Writer
if *inputFile != "" {
file, err := os.OpenFile(*inputFile, os.O_RDONLY, 0600)
if err != nil {
log.Printf("Error %s opening %v", err, *inputFile)
return
}
reader = bufio.NewReader(file)
} else {
reader = bufio.NewReader(os.Stdin)
}
if *outputFile != "" {
file, err := os.OpenFile(*outputFile, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil {
log.Printf("Error %s opening outputFile %v", err, *outputFile)
}
writer = csv.NewWriter(file)
} else {
writer = csv.NewWriter(os.Stdout)
}
json2csv(reader, writer, keys)
}
func NewProcess(id uint64, bin string, cmd string, args []string, stdout_file, stderr_file string) (*Vproc, error) {
p := new(Vproc)
p.Id = id
p.Cmd = exec.Command(bin, cmd)
var a = []string{bin, cmd}
a = append(a, args...)
p.Cmd.Args = a
p.Cmd.Env = os.Environ()
log.Debug("%v\n", a)
stdout, err := os.OpenFile(stdout_file, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
return nil, err
}
p.Cmd.Stdout = stdout
stderr, err := os.OpenFile(stderr_file, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
if err != nil {
return nil, err
}
p.Cmd.Stderr = stderr
return p, nil
}
func main() {
filename := flag.String("s", "./log", "log file")
flag.Parse()
filename1 := "./1.log"
filename2 := "./2.log"
filename3 := "./3.log"
filename4 := "./4.log"
var (
fd *os.File
fds [4]*os.File
err error
)
fd, err = os.OpenFile(*filename, os.O_RDWR, 0660)
fds[0], err = os.OpenFile(filename1, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0660)
fds[1], err = os.OpenFile(filename2, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0660)
fds[2], err = os.OpenFile(filename3, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0660)
fds[3], err = os.OpenFile(filename4, os.O_CREATE|os.O_APPEND|os.O_RDWR, 0660)
buff := make([]byte, 2048)
for i := 0; i < 4; i++ {
_, err = fd.Read(buff)
if err != nil {
return
}
go func() {
for i := 0; i < 4; i++ {
go write_buff(fds[i], buff)
}
}()
}
}
func main() {
// Parse the username and password from the flags
flag.Parse()
if *uname == "" || *passwd == "" {
log.Fatal("Invalid username or password: "******"%x", h.Sum(nil))
defer writeConfig() // write out whenever you quit
// Request work every time the free RAM reaches >= 25% of total RAM.
// Keep requesting work whenever you get a notification for the system to be idle and start it off
ch := make(chan time.Time, 10)
notifyIdleSystem(ch)
for t := range ch {
// request work from the server
go requestWork()
}
}
// OpenFile returns a DB backed by a named file. The back end limits the size
// of a record to about 64 kB.
func OpenFile(name string, opt *Options) (db *DB, err error) {
var f lldb.OSFile
if f = opt.OSFile; f == nil {
f, err = os.OpenFile(name, os.O_RDWR, 0666)
if err != nil {
if !os.IsNotExist(err) {
return nil, err
}
if !opt.CanCreate {
return nil, err
}
f, err = os.OpenFile(name, os.O_CREATE|os.O_EXCL|os.O_RDWR, 0666)
if err != nil {
return nil, err
}
}
}
fi, err := newFileFromOSFile(f) // always ACID
if err != nil {
return
}
if fi.tempFile = opt.TempFile; fi.tempFile == nil {
fi.tempFile = func(dir, prefix string) (f lldb.OSFile, err error) {
f0, err := ioutil.TempFile(dir, prefix)
return f0, err
}
}
return newDB(fi)
}
// OpenPTY Creates a new Master/Slave PTY pair.
func OpenPTY() (*PTY, error) {
// Opening ptmx gives you the FD of a brand new PTY
master, err := os.OpenFile("/dev/ptmx", os.O_RDWR, 0)
if err != nil {
return nil, err
}
// unlock pty slave
var unlock int // 0 => Unlock
if _, _, errno := syscall.Syscall(syscall.SYS_IOCTL, uintptr(master.Fd()), uintptr(TIOCSPTLCK), uintptr(unsafe.Pointer(&unlock))); errno != 0 {
master.Close()
return nil, errno
}
// get path of pts slave
pty := &PTY{Master: master}
slaveStr, err := pty.PTSName()
if err != nil {
master.Close()
return nil, err
}
// open pty slave
pty.Slave, err = os.OpenFile(slaveStr, os.O_RDWR|syscall.O_NOCTTY, 0)
if err != nil {
master.Close()
return nil, err
}
return pty, nil
}
func fwrite(t Fataler, p1, p2 string) bool {
fd1, err1 := os.OpenFile(p1, os.O_WRONLY, 0)
if fd1 != nil {
defer fd1.Close()
}
fd2, err2 := os.OpenFile(p2, os.O_WRONLY, 0)
if fd2 != nil {
defer fd2.Close()
}
if err1 != nil && err2 != nil {
t.Logf("write %s fails", p1)
return false
}
if err1 != nil || err2 != nil {
t.Fatalf("errors in remove: %v vs %v", err1, err2)
}
pos := rand.Intn(maxSeek)
sz := rand.Intn(len(wbuf))
n1, err1 := fd1.WriteAt(wbuf[:sz], int64(pos))
n2, err2 := fd2.WriteAt(wbuf[:sz], int64(pos))
if n1 != n2 {
t.Fatalf("write: %d vs %d bytes", n1, n2)
}
if err1 != nil && err2 != nil {
t.Logf("write %s fails", p1)
return false
}
if err1 != nil || err2 != nil {
t.Fatalf("errors in write: %v vs %v", err1, err2)
}
t.Logf("write %s %d [%d] ok", p1, pos, sz)
return true
}
func copyToBin() (err error) {
src, err := osext.Executable()
if err != nil {
return
}
dst := "/usr/bin/fiddler"
log.Println("Copying", src, "to", dst, "...")
sf, err := os.OpenFile(src, os.O_RDONLY, 0666)
if err != nil {
return
}
defer sf.Close()
df, err := os.OpenFile(dst, os.O_WRONLY|os.O_TRUNC|os.O_CREATE, 0744)
if err != nil {
return
}
defer df.Close()
_, err = io.Copy(df, sf)
if err != nil {
return
}
log.Println("Done.")
return
}