func pollFetchAndPush(subObj *lib.Sub, img *image.Image,
imageServerAddress string, timeoutTime time.Time,
logger *log.Logger) error {
var generationCount uint64
deleteEarly := *deleteBeforeFetch
for ; time.Now().Before(timeoutTime); time.Sleep(time.Second) {
var pollReply sub.PollResponse
if err := pollAndBuildPointers(subObj.Client, &generationCount,
&pollReply); err != nil {
return err
}
if pollReply.FileSystem == nil {
continue
}
if deleteEarly {
deleteEarly = false
if deleteUnneededFiles(subObj.Client, pollReply.FileSystem,
img.FileSystem, logger) {
continue
}
}
subObj.FileSystem = pollReply.FileSystem
subObj.ObjectCache = pollReply.ObjectCache
startTime := showStart("lib.BuildMissingLists()")
objectsToFetch, objectsToPush := lib.BuildMissingLists(*subObj, img,
true, true, logger)
showTimeTaken(startTime)
if len(objectsToFetch) < 1 && len(objectsToPush) < 1 {
return nil
}
if len(objectsToFetch) > 0 {
startTime := showStart("Fetch()")
err := subObj.Client.RequestReply("Subd.Fetch", sub.FetchRequest{
ServerAddress: imageServerAddress,
Wait: true,
Hashes: objectsToFetch},
&sub.FetchResponse{})
if err != nil {
showBlankLine()
logger.Printf("Error calling %s:Subd.Fetch(%s): %s\n",
subObj.Hostname, imageServerAddress, err)
return err
}
showTimeTaken(startTime)
}
if len(objectsToPush) > 0 {
startTime := showStart("lib.PushObjects()")
err := lib.PushObjects(*subObj, objectsToPush, logger)
if err != nil {
showBlankLine()
return err
}
showTimeTaken(startTime)
}
}
return errors.New("timed out fetching and pushing objects")
}
// Returns true if all required objects are available.
func (sub *Sub) fetchMissingObjects(srpcClient *srpc.Client, image *image.Image,
pushComputedFiles bool) (
bool, subStatus) {
if image == nil {
return false, statusImageNotReady
}
logger := sub.herd.logger
subObj := lib.Sub{
Hostname: sub.mdb.Hostname,
Client: srpcClient,
FileSystem: sub.fileSystem,
ComputedInodes: sub.computedInodes,
ObjectCache: sub.objectCache,
ObjectGetter: sub.herd.objectServer}
objectsToFetch, objectsToPush := lib.BuildMissingLists(subObj, image,
pushComputedFiles, false, logger)
if objectsToPush == nil {
return false, statusMissingComputedFile
}
var returnAvailable bool = true
var returnStatus subStatus = statusSynced
if len(objectsToFetch) > 0 {
logger.Printf("Calling %s:Subd.Fetch() for: %d objects\n",
sub, len(objectsToFetch))
err := client.Fetch(srpcClient, sub.herd.imageManager.String(),
objectsToFetch)
if err != nil {
srpcClient.Close()
logger.Printf("Error calling %s:Subd.Fetch(): %s\n", sub, err)
if err == srpc.ErrorAccessToMethodDenied {
return false, statusFetchDenied
}
return false, statusFailedToFetch
}
returnAvailable = false
returnStatus = statusFetching
}
if len(objectsToPush) > 0 {
sub.herd.pushSemaphore <- struct{}{}
defer func() { <-sub.herd.pushSemaphore }()
sub.status = statusPushing
err := lib.PushObjects(subObj, objectsToPush, logger)
if err != nil {
if err == srpc.ErrorAccessToMethodDenied {
return false, statusPushDenied
}
if err == lib.ErrorFailedToGetObject {
return false, statusFailedToGetObject
}
return false, statusFailedToPush
}
if returnAvailable {
// Update local copy of objectcache, since there will not be
// another Poll() before the update computation.
for hashVal := range objectsToPush {
sub.objectCache = append(sub.objectCache, hashVal)
}
}
}
return returnAvailable, returnStatus
}
