// Returns true if no update needs to be performed.
func (sub *Sub) sendUpdate(srpcClient *srpc.Client) (bool, subStatus) {
logger := sub.herd.logger
if !sub.pendingSafetyClear {
// Perform a cheap safety check.
if sub.requiredImage.Filter != nil &&
len(sub.fileSystem.InodeTable)>>1 >
len(sub.requiredImage.FileSystem.InodeTable) {
return false, statusUnsafeUpdate
}
}
var request subproto.UpdateRequest
var reply subproto.UpdateResponse
if idle, missing := sub.buildUpdateRequest(&request); missing {
return false, statusMissingComputedFile
} else if idle {
return true, statusSynced
}
if sub.mdb.DisableUpdates || sub.herd.updatesDisabledReason != "" {
return false, statusUpdatesDisabled
}
sub.status = statusSendingUpdate
sub.lastUpdateTime = time.Now()
if err := client.CallUpdate(srpcClient, request, &reply); err != nil {
srpcClient.Close()
logger.Printf("Error calling %s:Subd.Update(): %s\n", sub, err)
if err == srpc.ErrorAccessToMethodDenied {
return false, statusUpdateDenied
}
return false, statusFailedToUpdate
}
sub.pendingSafetyClear = false
return false, statusUpdating
}
func deleteUnneededFiles(srpcClient *srpc.Client, subFS *filesystem.FileSystem,
imgFS *filesystem.FileSystem, logger *log.Logger) bool {
startTime := showStart("compute early files to delete")
pathsToDelete := make([]string, 0)
imgHashToInodesTable := imgFS.HashToInodesTable()
imgFilenameToInodeTable := imgFS.FilenameToInodeTable()
for pathname, inum := range subFS.FilenameToInodeTable() {
if inode, ok := subFS.InodeTable[inum].(*filesystem.RegularInode); ok {
if inode.Size > 0 {
if _, ok := imgHashToInodesTable[inode.Hash]; !ok {
pathsToDelete = append(pathsToDelete, pathname)
}
} else {
if _, ok := imgFilenameToInodeTable[pathname]; !ok {
pathsToDelete = append(pathsToDelete, pathname)
}
}
}
}
showTimeTaken(startTime)
if len(pathsToDelete) < 1 {
return false
}
updateRequest := sub.UpdateRequest{
Wait: true,
PathsToDelete: pathsToDelete}
var updateReply sub.UpdateResponse
startTime = showStart("Subd.Update() for early files to delete")
err := client.CallUpdate(srpcClient, updateRequest, &updateReply)
showTimeTaken(startTime)
if err != nil {
logger.Println(err)
}
return true
}
// Returns true if no update needs to be performed.
func (sub *Sub) sendUpdate(srpcClient *srpc.Client) (bool, subStatus) {
logger := sub.herd.logger
var request subproto.UpdateRequest
var reply subproto.UpdateResponse
if sub.buildUpdateRequest(&request) {
return true, statusSynced
}
if err := client.CallUpdate(srpcClient, request, &reply); err != nil {
logger.Printf("Error calling %s:Subd.Update()\t%s\n", sub.hostname, err)
return false, statusFailedToUpdate
}
return false, statusUpdating
}
func pushFile(getSubClient getSubClientFunc, source, dest string) error {
var sourceStat wsyscall.Stat_t
if err := wsyscall.Stat(source, &sourceStat); err != nil {
return err
}
sourceFile, err := os.Open(source)
if err != nil {
return err
}
defer sourceFile.Close()
srpcClient := getSubClient()
objClient := objclient.AttachObjectClient(srpcClient)
defer objClient.Close()
if err != nil {
return err
}
hashVal, _, err := objClient.AddObject(sourceFile, uint64(sourceStat.Size),
nil)
if err != nil {
return err
}
newRegularInode := &filesystem.RegularInode{
Mode: filesystem.FileMode(sourceStat.Mode),
Uid: sourceStat.Uid,
Gid: sourceStat.Gid,
MtimeNanoSeconds: int32(sourceStat.Mtim.Nsec),
MtimeSeconds: sourceStat.Mtim.Sec,
Size: uint64(sourceStat.Size),
Hash: hashVal}
newInode := sub.Inode{Name: dest, GenericInode: newRegularInode}
var updateRequest sub.UpdateRequest
var updateReply sub.UpdateResponse
updateRequest.Wait = true
updateRequest.InodesToMake = append(updateRequest.InodesToMake, newInode)
if *triggersFile != "" {
updateRequest.Triggers, err = triggers.Load(*triggersFile)
if err != nil {
return err
}
} else if *triggersString != "" {
updateRequest.Triggers, err = triggers.Decode([]byte(*triggersString))
if err != nil {
return err
}
}
startTime := showStart("Subd.Update()")
err = client.CallUpdate(srpcClient, updateRequest, &updateReply)
showTimeTaken(startTime)
return err
}
func pushImage(getSubClient getSubClientFunc, imageName string) error {
logger := log.New(os.Stderr, "", log.LstdFlags)
computedInodes := make(map[string]*filesystem.RegularInode)
// Start querying the imageserver for the image.
imageServerAddress := fmt.Sprintf("%s:%d",
*imageServerHostname, *imageServerPortNum)
imgChannel := getImageChannel(imageServerAddress, imageName, timeoutTime)
startTime := showStart("getSubClient()")
srpcClient := getSubClient()
showTimeTaken(startTime)
subObj := lib.Sub{
Hostname: *subHostname,
Client: srpcClient,
ComputedInodes: computedInodes}
if *computedFilesRoot == "" {
subObj.ObjectGetter = nullObjectGetterType{}
} else {
fs, err := scanner.ScanFileSystem(*computedFilesRoot, nil, nil, nil,
nil, nil)
if err != nil {
return err
}
subObj.ObjectGetter = fs
for filename, inum := range fs.FilenameToInodeTable() {
if inode, ok := fs.InodeTable[inum].(*filesystem.RegularInode); ok {
computedInodes[filename] = inode
}
}
}
startTime = showStart("<-imgChannel")
imageResult := <-imgChannel
showTimeTaken(startTime)
fmt.Fprintf(os.Stderr, "Background image fetch took %s\n",
format.Duration(imageResult.duration))
img := imageResult.image
var err error
if *filterFile != "" {
img.Filter, err = filter.Load(*filterFile)
if err != nil {
return err
}
}
if *triggersFile != "" {
img.Triggers, err = triggers.Load(*triggersFile)
if err != nil {
return err
}
} else if *triggersString != "" {
img.Triggers, err = triggers.Decode([]byte(*triggersString))
if err != nil {
return err
}
}
if err := pollFetchAndPush(&subObj, img, imageServerAddress, timeoutTime,
logger); err != nil {
return err
}
var updateRequest sub.UpdateRequest
var updateReply sub.UpdateResponse
startTime = showStart("lib.BuildUpdateRequest()")
if lib.BuildUpdateRequest(subObj, img, &updateRequest, true, logger) {
showBlankLine()
return errors.New("missing computed file(s)")
}
showTimeTaken(startTime)
updateRequest.ImageName = imageName
updateRequest.Wait = true
startTime = showStart("Subd.Update()")
err = client.CallUpdate(srpcClient, updateRequest, &updateReply)
if err != nil {
showBlankLine()
return err
}
showTimeTaken(startTime)
return nil
}