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)
}
}
