// Initializes a pod from the current_manifest.yaml file in the pod's home directory. This function
// will error or return an old manifest if run during an inappropriate hook event, use of this
// function is discouraged in most cases
func (h *HookEnv) PodFromDisk() (*pods.Pod, error) {
node, err := h.Node()
if err != nil {
return nil, err
}
podHome, err := h.PodHome()
if err != nil {
return nil, err
}
return pods.PodFromPodHome(types.NodeName(node), podHome)
}
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 TestDirectoriesDoNotBreakEverything(t *testing.T) {
tempDir, err := ioutil.TempDir("", "hook")
Assert(t).IsNil(err, "the error should have been nil")
defer os.RemoveAll(tempDir)
podDir, err := ioutil.TempDir("", "pod")
defer os.RemoveAll(podDir)
Assert(t).IsNil(err, "the error should have been nil")
Assert(t).IsNil(os.Mkdir(path.Join(tempDir, "mydir"), 0755), "Should not have erred")
// So PodFromPodHome doesn't bail out, write a minimal current_manifest.yaml
ioutil.WriteFile(path.Join(podDir, "current_manifest.yaml"), []byte("id: my_hook"), 0755)
pod, err := pods.PodFromPodHome("testNode", podDir)
Assert(t).IsNil(err, "the error should have been nil")
logger := logging.TestLogger()
hooks := Hooks(os.TempDir(), &logger)
err = hooks.runHooks(tempDir, AFTER_INSTALL, pod, testManifest(), logging.DefaultLogger)
Assert(t).IsNil(err, "Got an error when running a directory inside the hooks directory")
}
func TestNonExecutableHooksAreNotRun(t *testing.T) {
tempDir, err := ioutil.TempDir("", "hook")
Assert(t).IsNil(err, "the error should have been nil")
defer os.RemoveAll(tempDir)
podDir, err := ioutil.TempDir("", "pod")
defer os.RemoveAll(podDir)
Assert(t).IsNil(err, "the error should have been nil")
err = ioutil.WriteFile(path.Join(tempDir, "test2"), []byte("#!/bin/sh\ntouch $(dirname $0)/failed"), 0644)
Assert(t).IsNil(err, "the error should have been nil")
// So PodFromPodHome doesn't bail out, write a minimal current_manifest.yaml
ioutil.WriteFile(path.Join(podDir, "current_manifest.yaml"), []byte("id: my_hook"), 0755)
hooks := Hooks(os.TempDir(), &logging.DefaultLogger)
pod, err := pods.PodFromPodHome("testNode", podDir)
Assert(t).IsNil(err, "the error should have been nil")
hooks.runHooks(tempDir, AFTER_INSTALL, pod, testManifest(), logging.DefaultLogger)
if _, err := os.Stat(path.Join(tempDir, "failed")); err == nil {
t.Fatal("`failed` file exists; non-executable hook ran but should not have run")
}
}
func TestExecutableHooksAreRun(t *testing.T) {
tempDir, err := ioutil.TempDir("", "hook")
Assert(t).IsNil(err, "the error should have been nil")
defer os.RemoveAll(tempDir)
podDir, err := ioutil.TempDir("", "pod")
defer os.RemoveAll(podDir)
Assert(t).IsNil(err, "the error should have been nil")
ioutil.WriteFile(path.Join(tempDir, "test1"), []byte("#!/bin/sh\necho $HOOKED_POD_ID > $(dirname $0)/output"), 0755)
// So PodFromPodHome doesn't bail out, write a minimal current_manifest.yaml
ioutil.WriteFile(path.Join(podDir, "current_manifest.yaml"), []byte("id: my_hook"), 0755)
hooks := Hooks(os.TempDir(), &logging.DefaultLogger)
pod, err := pods.PodFromPodHome("testNode", podDir)
Assert(t).IsNil(err, "the error should have been nil")
hooks.runHooks(tempDir, AFTER_INSTALL, pod, testManifest(), logging.DefaultLogger)
contents, err := ioutil.ReadFile(path.Join(tempDir, "output"))
Assert(t).IsNil(err, "the error should have been nil")
Assert(t).AreEqual(string(contents), "TestPod\n", "hook should output pod ID into output file")
}
func main() {
kingpin.Version(version.VERSION)
kingpin.Parse()
log.Println("Starting bootstrap")
hostname, err := os.Hostname()
if err != nil {
log.Fatalf("error getting node name: %v", err)
}
nodeName := types.NodeName(hostname)
agentManifest, err := manifest.FromPath(*agentManifestPath)
if err != nil {
log.Fatalln("Could not get agent manifest: %s", err)
}
log.Println("Installing and launching consul")
podFactory := pods.NewFactory(*podRoot, nodeName)
var consulPod *pods.Pod
var consulManifest manifest.Manifest
if *existingConsul == "" {
consulManifest, err = manifest.FromPath(*consulManifestPath)
if err != nil {
log.Fatalf("Could not get consul manifest: %s", err)
}
// Consul will never have a uuid (for now)
consulPod = podFactory.NewLegacyPod(consulManifest.ID())
err = installConsul(consulPod, consulManifest, *registryURL)
if err != nil {
log.Fatalf("Could not install consul: %s", err)
}
} else {
log.Printf("Using existing Consul at %s\n", *existingConsul)
consulPod, err = pods.PodFromPodHome(nodeName, *existingConsul)
if err != nil {
log.Fatalf("The existing consul pod is invalid: %s", err)
}
consulManifest, err = consulPod.CurrentManifest()
if err != nil {
log.Fatalf("Cannot get the current consul manifest: %s", err)
}
}
if err = verifyConsulUp(*timeout); err != nil {
log.Fatalln(err)
}
time.Sleep(500 * time.Millisecond)
// schedule consul in the reality store as well, to ensure the preparers do
// not all restart their consul agents simultaneously after bootstrapping
err = scheduleForThisHost(consulManifest, true)
if err != nil {
log.Fatalf("Could not register consul in the intent store: %s", err)
}
log.Println("Registering base agent in consul")
err = scheduleForThisHost(agentManifest, false)
if err != nil {
log.Fatalf("Could not register base agent with consul: %s", err)
}
log.Println("Installing and launching base agent")
err = installBaseAgent(podFactory, agentManifest, *registryURL)
if err != nil {
log.Fatalf("Could not install base agent: %s", err)
}
if err := verifyReality(30*time.Second, consulManifest.ID(), agentManifest.ID()); err != nil {
log.Fatalln(err)
}
log.Println("Bootstrapping complete")
}