func main() {
kingpin.Version(version.VERSION)
kingpin.Parse()
dir := hooks.Hooks(*HookDir, &logging.DefaultLogger)
hookType, err := hooks.AsHookType(*Lifecycle)
if err != nil {
log.Fatalln(err)
}
pod := pods.NewPod(path.Base(*PodDir), *PodDir)
var manifest *pods.Manifest
if *Manifest != "" {
manifest, err = pods.ManifestFromPath(*Manifest)
if err != nil {
log.Fatalln(err)
}
} else {
manifest, err = pod.CurrentManifest()
if err != nil {
log.Fatalln(err)
}
}
log.Printf("About to run %s hooks for pod %s\n", hookType, pod.Path())
err = dir.RunHookType(hookType, pod, manifest)
if err != nil {
log.Fatalln(err)
}
}
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
}
dir := hooks.Hooks(*hookDir, &logging.DefaultLogger)
hookType, err := hooks.AsHookType(*hookType)
if err != nil {
log.Fatalln(err)
}
pod, err := pods.PodFromPodHome(types.NodeName(*nodeName), *podDir)
if err != nil {
log.Fatalln(err)
}
var podManifest manifest.Manifest
if *manifestPath != "" {
podManifest, err = manifest.FromPath(*manifestPath)
if err != nil {
log.Fatalln(err)
}
} else {
podManifest, err = pod.CurrentManifest()
if err != nil {
log.Fatalln(err)
}
}
log.Printf("About to run %s hooks for pod %s\n", hookType, pod.Home())
err = dir.RunHookType(hookType, pod, podManifest)
if err != nil {
log.Fatalln(err)
}
}
func New(preparerConfig *PreparerConfig, logger logging.Logger) (*Preparer, error) {
addHooks(preparerConfig, logger)
if preparerConfig.ConsulAddress == "" {
return nil, util.Errorf("No Consul address given to the preparer")
}
if preparerConfig.PodRoot == "" {
return nil, util.Errorf("No pod root given to the preparer")
}
if preparerConfig.LogLevel != "" {
lv, err := logrus.ParseLevel(preparerConfig.LogLevel)
if err != nil {
return nil, util.Errorf("Received invalid log level %q", preparerConfig.LogLevel)
}
logger.Logger.Level = lv
}
authPolicy, err := getDeployerAuth(preparerConfig)
if err != nil {
return nil, err
}
artifactVerifier, err := getArtifactVerifier(preparerConfig, &logger)
if err != nil {
return nil, err
}
artifactRegistry, err := getArtifactRegistry(preparerConfig)
if err != nil {
return nil, err
}
store, err := preparerConfig.GetStore()
if err != nil {
return nil, err
}
maxLaunchableDiskUsage := launch.DefaultAllowableDiskUsage
if preparerConfig.MaxLaunchableDiskUsage != "" {
maxLaunchableDiskUsage, err = size.Parse(preparerConfig.MaxLaunchableDiskUsage)
if err != nil {
return nil, util.Errorf("Unparseable value for max_launchable_disk_usage %v, %v", preparerConfig.MaxLaunchableDiskUsage, err)
}
}
listener := HookListener{
Intent: store,
HookPrefix: kp.HOOK_TREE,
Node: preparerConfig.NodeName,
HookFactory: pods.NewHookFactory(filepath.Join(preparerConfig.PodRoot, "hooks"), preparerConfig.NodeName),
ExecDir: preparerConfig.HooksDirectory,
Logger: logger,
authPolicy: authPolicy,
artifactVerifier: artifactVerifier,
artifactRegistry: artifactRegistry,
}
err = os.MkdirAll(preparerConfig.PodRoot, 0755)
if err != nil {
return nil, util.Errorf("Could not create preparer pod directory: %s", err)
}
var logExec []string
if len(preparerConfig.LogExec) > 0 {
logExec = preparerConfig.LogExec
} else {
logExec = runit.DefaultLogExec()
}
var finishExec []string
if len(preparerConfig.FinishExec) > 0 {
finishExec = preparerConfig.FinishExec
} else {
finishExec = pods.DefaultFinishExec
}
return &Preparer{
node: preparerConfig.NodeName,
store: store,
hooks: hooks.Hooks(preparerConfig.HooksDirectory, &logger),
hookListener: listener,
Logger: logger,
podFactory: pods.NewFactory(preparerConfig.PodRoot, preparerConfig.NodeName),
authPolicy: authPolicy,
maxLaunchableDiskUsage: maxLaunchableDiskUsage,
finishExec: finishExec,
logExec: logExec,
logBridgeBlacklist: preparerConfig.LogBridgeBlacklist,
artifactVerifier: artifactVerifier,
artifactRegistry: artifactRegistry,
}, nil
}
func New(preparerConfig *PreparerConfig, logger logging.Logger) (*Preparer, error) {
addHooks(preparerConfig, logger)
if preparerConfig.ConsulAddress == "" {
return nil, util.Errorf("No Consul address given to the preparer")
}
if preparerConfig.PodRoot == "" {
return nil, util.Errorf("No pod root given to the preparer")
}
if preparerConfig.LogLevel != "" {
lv, err := logrus.ParseLevel(preparerConfig.LogLevel)
if err != nil {
return nil, util.Errorf("Received invalid log level %q", preparerConfig.LogLevel)
}
logger.Logger.Level = lv
}
authPolicy, err := getDeployerAuth(preparerConfig)
if err != nil {
return nil, err
}
artifactVerifier, err := getArtifactVerifier(preparerConfig, &logger)
if err != nil {
return nil, err
}
artifactRegistry, err := getArtifactRegistry(preparerConfig)
if err != nil {
return nil, err
}
client, err := preparerConfig.GetConsulClient()
if err != nil {
return nil, err
}
statusStore := statusstore.NewConsul(client)
podStatusStore := podstatus.NewConsul(statusStore, kp.PreparerPodStatusNamespace)
podStore := podstore.NewConsul(client.KV())
store := kp.NewConsulStore(client)
maxLaunchableDiskUsage := launch.DefaultAllowableDiskUsage
if preparerConfig.MaxLaunchableDiskUsage != "" {
maxLaunchableDiskUsage, err = size.Parse(preparerConfig.MaxLaunchableDiskUsage)
if err != nil {
return nil, util.Errorf("Unparseable value for max_launchable_disk_usage %v, %v", preparerConfig.MaxLaunchableDiskUsage, err)
}
}
err = os.MkdirAll(preparerConfig.PodRoot, 0755)
if err != nil {
return nil, util.Errorf("Could not create preparer pod directory: %s", err)
}
var logExec []string
if len(preparerConfig.LogExec) > 0 {
logExec = preparerConfig.LogExec
} else {
logExec = runit.DefaultLogExec()
}
finishExec := pods.NopFinishExec
var podProcessReporter *podprocess.Reporter
if preparerConfig.PodProcessReporterConfig.FullyConfigured() {
podProcessReporterLogger := logger.SubLogger(logrus.Fields{
"component": "PodProcessReporter",
})
podProcessReporter, err = podprocess.New(preparerConfig.PodProcessReporterConfig, podProcessReporterLogger, podStatusStore)
if err != nil {
return nil, err
}
finishExec = preparerConfig.PodProcessReporterConfig.FinishExec()
}
var hooksManifest manifest.Manifest
var hooksPod *pods.Pod
if preparerConfig.HooksManifest != NoHooksSentinelValue {
if preparerConfig.HooksManifest == "" {
return nil, util.Errorf("Most provide a hooks_manifest or sentinel value %q to indicate that there are no hooks", NoHooksSentinelValue)
}
hooksManifest, err = manifest.FromBytes([]byte(preparerConfig.HooksManifest))
if err != nil {
return nil, util.Errorf("Could not parse configured hooks manifest: %s", err)
}
hooksPodFactory := pods.NewHookFactory(filepath.Join(preparerConfig.PodRoot, "hooks"), preparerConfig.NodeName)
hooksPod = hooksPodFactory.NewHookPod(hooksManifest.ID())
}
return &Preparer{
node: preparerConfig.NodeName,
store: store,
hooks: hooks.Hooks(preparerConfig.HooksDirectory, preparerConfig.PodRoot, &logger),
podStatusStore: podStatusStore,
podStore: podStore,
Logger: logger,
podFactory: pods.NewFactory(preparerConfig.PodRoot, preparerConfig.NodeName),
authPolicy: authPolicy,
maxLaunchableDiskUsage: maxLaunchableDiskUsage,
finishExec: finishExec,
logExec: logExec,
logBridgeBlacklist: preparerConfig.LogBridgeBlacklist,
artifactVerifier: artifactVerifier,
artifactRegistry: artifactRegistry,
PodProcessReporter: podProcessReporter,
hooksManifest: hooksManifest,
hooksPod: hooksPod,
hooksExecDir: preparerConfig.HooksDirectory,
}, nil
}
func New(preparerConfig *PreparerConfig, logger logging.Logger) (*Preparer, error) {
addHooks(preparerConfig, logger)
if preparerConfig.ConsulAddress == "" {
return nil, util.Errorf("No Consul address given to the preparer")
}
if preparerConfig.PodRoot == "" {
return nil, util.Errorf("No pod root given to the preparer")
}
if preparerConfig.LogLevel != "" {
lv, err := logrus.ParseLevel(preparerConfig.LogLevel)
if err != nil {
return nil, util.Errorf("Received invalid log level %q", preparerConfig.LogLevel)
}
logger.Logger.Level = lv
}
var err error
var authPolicy auth.Policy
switch t, _ := preparerConfig.Auth["type"].(string); t {
case "":
return nil, util.Errorf("must specify authorization policy type")
case "none":
authPolicy = auth.NullPolicy{}
case "keyring":
var authConfig KeyringAuth
err := castYaml(preparerConfig.Auth, &authConfig)
if err != nil {
return nil, util.Errorf("error configuring keyring auth: %s", err)
}
if authConfig.KeyringPath == "" {
return nil, util.Errorf("keyring auth must contain a path to the keyring")
}
authPolicy, err = auth.NewFileKeyringPolicy(
authConfig.KeyringPath,
map[string][]string{POD_ID: authConfig.AuthorizedDeployers},
)
if err != nil {
return nil, util.Errorf("error configuring keyring auth: %s", err)
}
case "user":
var userConfig UserAuth
err := castYaml(preparerConfig.Auth, &userConfig)
if err != nil {
return nil, util.Errorf("error configuring user auth: %s", err)
}
if userConfig.KeyringPath == "" {
return nil, util.Errorf("user auth must contain a path to the keyring")
}
if userConfig.DeployPolicyPath == "" {
return nil, util.Errorf("user auth must contain a path to the deploy policy")
}
authPolicy, err = auth.NewUserPolicy(
userConfig.KeyringPath,
userConfig.DeployPolicyPath,
POD_ID,
POD_ID,
)
if err != nil {
return nil, util.Errorf("error configuring user auth: %s", err)
}
default:
if t, ok := preparerConfig.Auth["type"].(string); ok {
return nil, util.Errorf("unrecognized auth type: %s", t)
}
return nil, util.Errorf("unrecognized auth type")
}
store, err := preparerConfig.GetStore()
if err != nil {
return nil, err
}
listener := HookListener{
Intent: store,
HookPrefix: kp.HOOK_TREE,
DestinationDir: path.Join(pods.DEFAULT_PATH, "hooks"),
ExecDir: preparerConfig.HooksDirectory,
Logger: logger,
authPolicy: authPolicy,
}
err = os.MkdirAll(preparerConfig.PodRoot, 0755)
if err != nil {
return nil, util.Errorf("Could not create preparer pod directory: %s", err)
}
consulCAFile := preparerConfig.ConsulCAFile
if consulCAFile == "" {
consulCAFile = preparerConfig.CAFile
}
return &Preparer{
node: preparerConfig.NodeName,
store: store,
hooks: hooks.Hooks(preparerConfig.HooksDirectory, &logger),
hookListener: listener,
Logger: logger,
podRoot: preparerConfig.PodRoot,
authPolicy: authPolicy,
caFile: consulCAFile,
}, nil
}