func main() { kingpin.Version(version.VERSION) kingpin.Parse() manifest, err := pods.ManifestFromURI(*manifestURI) if err != nil { log.Fatalf("%s", err) } // /data/pods/hooks/<event>/<id> // if the event is the empty string (global hook), then that path segment // will be cleaned out pod := pods.NewPod(manifest.ID(), pods.PodPath(filepath.Join(*podRoot, "hooks", *hookType), manifest.ID())) err = pod.Install(manifest) if err != nil { log.Fatalf("Could not install manifest %s: %s", manifest.ID(), err) } // hooks write their current manifest manually since it's normally done at // launch time _, err = pod.WriteCurrentManifest(manifest) if err != nil { log.Fatalf("Could not write current manifest for %s: %s", manifest.ID(), err) } err = hooks.InstallHookScripts(*hookRoot, pod, manifest, logging.DefaultLogger) if err != nil { log.Fatalf("Could not write hook scripts: %s", err) } }
func (l *HookListener) installHook(result kp.ManifestResult) error { sub := l.Logger.SubLogger(logrus.Fields{ "pod": result.Manifest.ID(), }) err := l.authPolicy.AuthorizeHook(result.Manifest, sub) if err != nil { if err, ok := err.(auth.Error); ok { sub.WithFields(err.Fields).Errorln(err) } else { sub.NoFields().Errorln(err) } return err } hookPod := l.HookFactory.NewHookPod(result.Manifest.ID()) // Figure out if we even need to install anything. // Hooks aren't running services and so there isn't a need // to write the current manifest to the reality store. Instead // we just compare to the manifest on disk. current, err := hookPod.CurrentManifest() if err != nil && err != pods.NoCurrentManifest { l.Logger.WithError(err).Errorln("Could not check current manifest") return err } var currentSHA string if current != nil { currentSHA, _ = current.SHA() } newSHA, _ := result.Manifest.SHA() if err != pods.NoCurrentManifest && currentSHA == newSHA { // we are up-to-date, continue return nil } // The manifest is new, go ahead and install err = hookPod.Install(result.Manifest, l.artifactVerifier, l.artifactRegistry) if err != nil { sub.WithError(err).Errorln("Could not install hook") return err } _, err = hookPod.WriteCurrentManifest(result.Manifest) if err != nil { sub.WithError(err).Errorln("Could not write current manifest") return err } // Now that the pod is installed, link it up to the exec dir. err = hooks.InstallHookScripts(l.ExecDir, hookPod, result.Manifest, sub) if err != nil { sub.WithError(err).Errorln("Could not write hook link") return err } sub.NoFields().Infoln("Updated hook") return nil }
func (p *Preparer) InstallHooks() error { if p.hooksManifest == nil { p.Logger.Infoln("No hooks configured, skipping hook installation") return nil } sub := p.Logger.SubLogger(logrus.Fields{ "pod": p.hooksManifest.ID(), }) // Figure out if we even need to install anything. // Hooks aren't running services and so there isn't a need // to write the current manifest to the reality store. Instead // we just compare to the manifest on disk. current, err := p.hooksPod.CurrentManifest() if err != nil && err != pods.NoCurrentManifest { p.Logger.WithError(err).Errorln("Could not check current manifest") return err } var currentSHA string if current != nil { currentSHA, _ = current.SHA() } newSHA, _ := p.hooksManifest.SHA() if err != pods.NoCurrentManifest && currentSHA == newSHA { p.Logger.Infoln("Hooks up to date, nothing to do") // we are up-to-date, continue return nil } p.Logger.Infoln("Installing new hook manifest") // The manifest is new, go ahead and install err = p.hooksPod.Install(p.hooksManifest, p.artifactVerifier, p.artifactRegistry) if err != nil { sub.WithError(err).Errorln("Could not install hook") return err } _, err = p.hooksPod.WriteCurrentManifest(p.hooksManifest) if err != nil { sub.WithError(err).Errorln("Could not write current manifest") return err } // Now that the pod is installed, link it up to the exec dir. err = hooks.InstallHookScripts(p.hooksExecDir, p.hooksPod, p.hooksManifest, sub) if err != nil { sub.WithError(err).Errorln("Could not write hook link") return err } sub.NoFields().Infoln("Updated hook") return nil }
func main() { kingpin.Version(version.VERSION) kingpin.Parse() if *nodeName == "" { hostname, err := os.Hostname() if err != nil { log.Fatalf("error getting node name: %v", err) } *nodeName = hostname } manifest, err := manifest.FromURI(*manifestURI) if err != nil { log.Fatalf("%s", err) } hookFactory := pods.NewHookFactory(filepath.Join(*podRoot, "hooks", *hookType), types.NodeName(*nodeName)) // /data/pods/hooks/<event>/<id> // if the event is the empty string (global hook), then that path segment // will be cleaned out pod := hookFactory.NewHookPod(manifest.ID()) // for now use noop verifier in this CLI err = pod.Install(manifest, auth.NopVerifier(), artifact.NewRegistry(*registryURI, uri.DefaultFetcher, osversion.DefaultDetector)) if err != nil { log.Fatalf("Could not install manifest %s: %s", manifest.ID(), err) } // hooks write their current manifest manually since it's normally done at // launch time _, err = pod.WriteCurrentManifest(manifest) if err != nil { log.Fatalf("Could not write current manifest for %s: %s", manifest.ID(), err) } err = hooks.InstallHookScripts(*hookRoot, pod, manifest, logging.DefaultLogger) if err != nil { log.Fatalf("Could not write hook scripts: %s", err) } }