func loadImageFiles(image *image.Image, objectClient *objectclient.ObjectClient,
filterFilename, triggersFilename string) error {
var err error
if filterFilename != "" {
image.Filter, err = filter.Load(filterFilename)
if err != nil {
return err
}
}
if triggersFilename != "" {
image.Triggers, err = triggers.Load(triggersFilename)
if err != nil {
return err
}
}
image.BuildLog, err = getAnnotation(objectClient, *buildLog)
if err != nil {
return err
}
image.ReleaseNotes, err = getAnnotation(objectClient, *releaseNotes)
if err != nil {
return err
}
return nil
}
func applyDeleteFilter(fs *filesystem.FileSystem) (
*filesystem.FileSystem, error) {
if *deleteFilter == "" {
return fs, nil
}
filter, err := filter.Load(*deleteFilter)
if err != nil {
return nil, err
}
return fs.Filter(filter), nil
}
func main() {
flag.Usage = printUsage
flag.Parse()
if flag.NArg() < 1 {
printUsage()
os.Exit(2)
}
if *expiresIn > 0 && *expiresIn < minimumExpiration {
fmt.Fprintf(os.Stderr, "Minimum expiration: %s\n", minimumExpiration)
os.Exit(2)
}
listSelector = makeListSelector(*skipFields)
var err error
if *filterFile != "" {
listFilter, err = filter.Load(*filterFile)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(2)
}
}
if err := setupclient.SetupTls(true); err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
numSubcommandArgs := flag.NArg() - 1
for _, subcommand := range subcommands {
if flag.Arg(0) == subcommand.command {
if numSubcommandArgs < subcommand.minArgs ||
(subcommand.maxArgs >= 0 &&
numSubcommandArgs > subcommand.maxArgs) {
printUsage()
os.Exit(2)
}
subcommand.cmdFunc(flag.Args()[1:])
os.Exit(3)
}
}
printUsage()
os.Exit(2)
}
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
}