func NewCommonFileMap(fileName string, fi *os.FileInfo) map[string]interface{} {
m := newCamliMap(1, "" /* no type yet */)
lastSlash := strings.LastIndex(fileName, "/")
baseName := fileName[lastSlash+1:]
if isValidUtf8(baseName) {
m["fileName"] = baseName
} else {
m["fileNameBytes"] = []uint8(baseName)
}
// Common elements (from file-common.txt)
m["unixPermission"] = fmt.Sprintf("0%o", fi.Permission())
if fi.Uid != -1 {
m["unixOwnerId"] = fi.Uid
if user := getUserFromUid(fi.Uid); user != "" {
m["unixOwner"] = user
}
}
if fi.Gid != -1 {
m["unixGroupId"] = fi.Gid
if group := getGroupFromGid(fi.Gid); group != "" {
m["unixGroup"] = group
}
}
if mtime := fi.Mtime_ns; mtime != 0 {
m["unixMtime"] = rfc3339FromNanos(mtime)
}
// Include the ctime too, if it differs.
if ctime := fi.Ctime_ns; ctime != 0 && fi.Mtime_ns != fi.Ctime_ns {
m["unixCtime"] = rfc3339FromNanos(ctime)
}
return m
}
func NewCommonFileMap(fileName string, fi *os.FileInfo) map[string]interface{} {
m := NewCommonFilenameMap(fileName)
// Common elements (from file-common.txt)
if !fi.IsSymlink() {
m["unixPermission"] = fmt.Sprintf("0%o", fi.Permission())
}
if fi.Uid != -1 {
m["unixOwnerId"] = fi.Uid
if user := getUserFromUid(fi.Uid); user != "" {
m["unixOwner"] = user
}
}
if fi.Gid != -1 {
m["unixGroupId"] = fi.Gid
if group := getGroupFromGid(fi.Gid); group != "" {
m["unixGroup"] = group
}
}
if mtime := fi.Mtime_ns; mtime != 0 {
m["unixMtime"] = RFC3339FromNanos(mtime)
}
// Include the ctime too, if it differs.
if ctime := fi.Ctime_ns; ctime != 0 && fi.Mtime_ns != fi.Ctime_ns {
m["unixCtime"] = RFC3339FromNanos(ctime)
}
return m
}
func (p *Propolis) SetRequestMetaData(req *http.Request, info *os.FileInfo) {
// file permissions: grant "public-read" if the file grants world read permission
if info.Permission()&s_iroth != 0 {
req.Header.Set("X-Amz-Acl", acl_public)
} else {
req.Header.Set("X-Amz-Acl", acl_private)
}
// user id: store the numeric and symbolic names
user, err := user.LookupId(info.Uid)
if err != nil {
req.Header.Set("X-Amz-Meta-Uid", fmt.Sprintf("%d", info.Uid))
} else {
req.Header.Set("X-Amz-Meta-Uid", fmt.Sprintf("%d (%s)", info.Uid, user.Username))
}
// group id: just store the numeric id for now until Go supports looking up group names
req.Header.Set("X-Amz-Meta-Gid", fmt.Sprintf("%d", info.Gid))
// store the permissions as an octal number
req.Header.Set("X-Amz-Meta-Mode", fmt.Sprintf("0%o", info.Mode))
// store the modified date in a nice format
sec := info.Mtime_ns / 1e9
ns := info.Mtime_ns % 1e9
date := time.SecondsToLocalTime(sec).String()
if ns == 0 {
req.Header.Set("X-Amz-Meta-Mtime", fmt.Sprintf("%d (%s)", sec, date))
} else {
req.Header.Set("X-Amz-Meta-Mtime", fmt.Sprintf("%d.%09d (%s)", sec, ns, date))
}
// set the content-type by looking up the MIME type
mimetype := default_mime_type
switch {
case info.IsDirectory():
mimetype = directory_mime_type
case info.IsSymlink():
mimetype = symlink_mime_type
default:
if dot := strings.LastIndex(info.Name, "."); dot >= 0 && dot+1 < len(info.Name) {
extension := strings.ToLower(info.Name[dot:])
if kind := mime.TypeByExtension(extension); kind != "" {
mimetype = kind
}
}
}
req.Header.Set("Content-Type", mimetype)
}
func (self *Syncer) copyDirectory(srcName string, stat *os.FileInfo, dstName string, out chan SyncStats) {
stats := new(SyncStats)
defer func() { out <- *stats }()
err := os.Mkdir(dstName, stat.Permission())
if err != nil {
stats.ErrorCount++
return
}
stats.DirsCreated++
if self.Verbose {
fmt.Fprintln(self.VerboseWriter, dstName)
}
ops := new(outstandingOps)
go self.SyncDirectories(srcName, dstName, ops.new())
ops.wait(stats)
}
func canWrite(stat *os.FileInfo, euid, egid int) bool {
perm := stat.Permission()
return perm&02 != 0 || perm&020 != 0 && egid == stat.Gid || perm&0200 != 0 && euid == stat.Uid
}
/*
Entry point. Used for setting some variables and parsing the command line.
*/
func main() {
var err os.Error
var rootPathDir *os.FileInfo
// parse command line arguments
flag.Parse()
if *flagQuieterMode {
logger.SetVerbosityLevel(logger.ERROR)
} else if *flagQuietMode {
logger.SetVerbosityLevel(logger.WARN)
} else if *flagVerboseMode {
logger.SetVerbosityLevel(logger.DEBUG)
}
if *flagClean {
clean()
os.Exit(0)
}
// get the compiler/linker executable
switch os.Getenv("GOARCH") {
case "amd64":
compilerBin = "6g"
linkerBin = "6l"
objExt = ".6"
case "386":
compilerBin = "8g"
linkerBin = "8l"
objExt = ".8"
case "arm":
compilerBin = "5g"
linkerBin = "5l"
objExt = ".5"
default:
logger.Error("Please specify a valid GOARCH (amd64/386/arm).\n")
os.Exit(1)
}
// get the complete path to the compiler/linker
compilerBin, err = exec.LookPath(compilerBin)
if err != nil {
logger.Error("Could not find compiler %s: %s\n", compilerBin, err)
os.Exit(127)
}
linkerBin, err = exec.LookPath(linkerBin)
if err != nil {
logger.Error("Could not find linker %s: %s\n", linkerBin, err)
os.Exit(127)
}
gopackBin, err = exec.LookPath(gopackBin)
if err != nil {
logger.Error("Could not find gopack executable (%s): %s\n", gopackBin, err)
os.Exit(127)
}
// get the root path from where the application was called
// and its permissions (used for subdirectories)
if rootPath, err = os.Getwd(); err != nil {
logger.Error("Could not get the root path: %s\n", err)
os.Exit(1)
}
if rootPathDir, err = os.Stat(rootPath); err != nil {
logger.Error("Could not read the root path: %s\n", err)
os.Exit(1)
}
rootPathPerm = rootPathDir.Permission()
// create the package container
goPackages = godata.NewGoPackageContainer()
// check if -o with path
if *flagOutputFileName != "" {
dir, err := os.Stat(*flagOutputFileName)
if err != nil {
// doesn't exist? try to make it if it's a path
if (*flagOutputFileName)[len(*flagOutputFileName)-1] == '/' {
err = os.MkdirAll(*flagOutputFileName, rootPathPerm)
if err == nil {
outputDirPrefix = *flagOutputFileName
}
} else {
godata.DefaultOutputFileName = *flagOutputFileName
}
} else if dir.IsDirectory() {
if (*flagOutputFileName)[len(*flagOutputFileName)-1] == '/' {
outputDirPrefix = *flagOutputFileName
} else {
outputDirPrefix = *flagOutputFileName + "/"
}
} else {
godata.DefaultOutputFileName = *flagOutputFileName
}
// make path to output file
if outputDirPrefix == "" && strings.Index(*flagOutputFileName, "/") != -1 {
err = os.MkdirAll((*flagOutputFileName)[0:strings.LastIndex(*flagOutputFileName, "/")], rootPathPerm)
if err != nil {
logger.Error("Could not create %s: %s\n",
(*flagOutputFileName)[0:strings.LastIndex(*flagOutputFileName, "/")],
err)
}
}
}
// read all go files in the current path + subdirectories and parse them
logger.Info("Parsing go file(s)...\n")
readFiles(rootPath)
if *flagTesting {
buildTestExecutable()
} else if *flagLibrary {
buildLibrary()
} else {
buildExecutable()
}
// make sure exit status is != 0 if there were compiler/linker errors
if compileErrors || linkErrors {
os.Exit(1)
}
}
func (self *Syncer) copyRegularFile(srcName string, stat *os.FileInfo, dstName string, out chan SyncStats) {
stats := new(SyncStats)
defer func() { out <- *stats }()
outfd, err := os.Open(dstName, os.O_CREATE|os.O_EXCL|os.O_WRONLY,
stat.Permission())
if err != nil {
fmt.Fprintf(self.ErrorWriter,
"Error opening copy output file %s: %s\n",
dstName, err)
stats.ErrorCount++
return
}
defer outfd.Close()
infd, err := os.Open(srcName, os.O_RDONLY, 0)
if err != nil {
fmt.Fprintf(self.ErrorWriter,
"Error opening copy source file %s: %s\n",
srcName, err)
stats.ErrorCount++
return
}
defer infd.Close()
const BUF_SIZE = 1024 * 256
buf := make([]byte, BUF_SIZE)
bytesRemain := stat.Size
for bytesRemain > 0 {
n, err := infd.Read(buf)
switch {
case n == 0:
break
case n < 0:
stats.ErrorCount++
fmt.Fprintf(self.ErrorWriter, "Error copying file %s in read: %s",
srcName, err)
return
default:
outN, err := outfd.Write(buf[0:n])
if err != nil || outN != n {
fmt.Fprintf(self.ErrorWriter, "Error copying file %s in write: %s",
srcName, err)
return
}
bytesRemain -= int64(outN)
}
}
// Close it explicitly before we syscall.Utime() it, even
// though the precautionary defer'd Close() above will close
// it again later. That's harmless.
err = outfd.Close()
if err != nil {
stats.ErrorCount++
return
}
// When the Chtimes patch is merged upstream...
// err = os.Chtimes(dstName, stat.Atime_ns, stat.Mtime_ns)
var tv []syscall.Timeval = make([]syscall.Timeval, 2)
tv[0] = syscall.NsecToTimeval(stat.Atime_ns)
tv[1] = syscall.NsecToTimeval(stat.Mtime_ns)
errno := syscall.Utimes(dstName, tv)
if errno != 0 {
fmt.Fprintf(self.ErrorWriter, "Error modifying utimes on %s: %v",
dstName, errno)
stats.ErrorCount++
return
}
stats.FilesCreated++
if self.Verbose {
fmt.Fprintln(self.VerboseWriter, dstName)
}
}