func getArtifactRegistry(preparerConfig *PreparerConfig) (artifact.Registry, error) { if preparerConfig.ArtifactRegistryURL == "" { // This will still work as long as all launchables have "location" urls specified. return artifact.NewRegistry(nil, uri.DefaultFetcher, osversion.DefaultDetector), nil } url, err := url.Parse(preparerConfig.ArtifactRegistryURL) if err != nil { return nil, util.Errorf("Could not parse 'artifact_registry_url': %s", err) } return artifact.NewRegistry(url, uri.DefaultFetcher, osversion.DefaultDetector), nil }
func installBaseAgent(podFactory pods.Factory, agentManifest manifest.Manifest, registryURL *url.URL) error { agentPod := podFactory.NewPod(agentManifest.ID()) err := agentPod.Install(agentManifest, auth.NopVerifier(), artifact.NewRegistry(registryURL, uri.DefaultFetcher, osversion.DefaultDetector)) if err != nil { return err } _, err = agentPod.Launch(agentManifest) return err }
func testHookListener(t *testing.T) (HookListener, string, <-chan struct{}) { hookPrefix := kp.HOOK_TREE destDir, _ := ioutil.TempDir("", "pods") defer os.RemoveAll(destDir) execDir, err := ioutil.TempDir("", "exec") defer os.RemoveAll(execDir) Assert(t).IsNil(err, "should not have erred creating a tempdir") current, err := user.Current() Assert(t).IsNil(err, "test setup: could not get the current user") builder := manifest.NewBuilder() builder.SetID("users") builder.SetRunAsUser(current.Username) builder.SetLaunchables(map[launch.LaunchableID]launch.LaunchableStanza{ "create": { Location: util.From(runtime.Caller(0)).ExpandPath("hoisted-hello_def456.tar.gz"), LaunchableType: "hoist", LaunchableId: "create", }, }) podManifest := builder.GetManifest() manifestBytes, err := podManifest.Marshal() Assert(t).IsNil(err, "manifest bytes error should have been nil") fakeSigner, err := openpgp.NewEntity("p2", "p2-test", "*****@*****.**", nil) Assert(t).IsNil(err, "NewEntity error should have been nil") var buf bytes.Buffer sigWriter, err := clearsign.Encode(&buf, fakeSigner.PrivateKey, nil) Assert(t).IsNil(err, "clearsign encode error should have been nil") sigWriter.Write(manifestBytes) sigWriter.Close() podManifest, err = manifest.FromBytes(buf.Bytes()) Assert(t).IsNil(err, "should have generated manifest from signed bytes") fakeIntent := fakeStoreWithManifests(kp.ManifestResult{ Manifest: podManifest, }) hookFactory := pods.NewHookFactory(destDir, "testNode") listener := HookListener{ Intent: fakeIntent, HookPrefix: hookPrefix, ExecDir: execDir, HookFactory: hookFactory, Logger: logging.DefaultLogger, authPolicy: auth.FixedKeyringPolicy{openpgp.EntityList{fakeSigner}, nil}, artifactVerifier: auth.NopVerifier(), artifactRegistry: artifact.NewRegistry(nil, uri.DefaultFetcher, osversion.DefaultDetector), } return listener, destDir, fakeIntent.quit }
func installConsul(consulPod *pods.Pod, consulManifest manifest.Manifest, registryURL *url.URL) error { // Inject servicebuilder? err := consulPod.Install(consulManifest, auth.NopVerifier(), artifact.NewRegistry(registryURL, uri.DefaultFetcher, osversion.DefaultDetector)) if err != nil { return util.Errorf("Can't install Consul, aborting: %s", err) } ok, err := consulPod.Launch(consulManifest) if err != nil || !ok { return util.Errorf("Can't launch Consul, aborting: %s", err) } return nil }
func TestInstall(t *testing.T) { fetcher := uri.NewLoggedFetcher(nil) testContext := util.From(runtime.Caller(0)) currentUser, err := user.Current() Assert(t).IsNil(err, "test setup: couldn't get current user") testLocation := testContext.ExpandPath("hoisted-hello_3c021aff048ca8117593f9c71e03b87cf72fd440.tar.gz") launchables := map[launch.LaunchableID]launch.LaunchableStanza{ "hello": { LaunchableId: "hello", Location: testLocation, LaunchableType: "hoist", }, } builder := manifest.NewBuilder() builder.SetID("hello") builder.SetLaunchables(launchables) builder.SetRunAsUser(currentUser.Username) manifest := builder.GetManifest() testPodDir, err := ioutil.TempDir("", "testPodDir") Assert(t).IsNil(err, "Got an unexpected error creating a temp directory") defer os.RemoveAll(testPodDir) pod := Pod{ Id: "testPod", home: testPodDir, logger: Log.SubLogger(logrus.Fields{"pod": "testPod"}), Fetcher: fetcher, } err = pod.Install(manifest, auth.NopVerifier(), artifact.NewRegistry(nil, uri.DefaultFetcher, osversion.DefaultDetector)) Assert(t).IsNil(err, "there should not have been an error when installing") Assert(t).AreEqual( fetcher.SrcUri.String(), testLocation, "The correct url wasn't set for the curl library", ) hoistedHelloUnpacked := filepath.Join(testPodDir, "hello", "installs", "hello_3c021aff048ca8117593f9c71e03b87cf72fd440") if info, err := os.Stat(hoistedHelloUnpacked); err != nil || !info.IsDir() { t.Fatalf("Expected %s to be the unpacked artifact location", hoistedHelloUnpacked) } helloLaunch := filepath.Join(hoistedHelloUnpacked, "bin", "launch") if info, err := os.Stat(helloLaunch); err != nil || info.IsDir() { t.Fatalf("Expected %s to be a the launch script for hello", helloLaunch) } }
func TestInstallHooks(t *testing.T) { destDir, _ := ioutil.TempDir("", "pods") defer os.RemoveAll(destDir) execDir, err := ioutil.TempDir("", "exec") defer os.RemoveAll(execDir) Assert(t).IsNil(err, "should not have erred creating a tempdir") current, err := user.Current() Assert(t).IsNil(err, "test setup: could not get the current user") builder := manifest.NewBuilder() builder.SetID("users") builder.SetRunAsUser(current.Username) builder.SetLaunchables(map[launch.LaunchableID]launch.LaunchableStanza{ "create": { Location: util.From(runtime.Caller(0)).ExpandPath("testdata/hoisted-hello_def456.tar.gz"), LaunchableType: "hoist", }, }) podManifest := builder.GetManifest() hookFactory := pods.NewHookFactory(destDir, "testNode") hooksPod := hookFactory.NewHookPod(podManifest.ID()) preparer := Preparer{ hooksManifest: podManifest, hooksPod: hooksPod, hooksExecDir: execDir, Logger: logging.DefaultLogger, artifactRegistry: artifact.NewRegistry(nil, uri.DefaultFetcher, osversion.DefaultDetector), artifactVerifier: auth.NopVerifier(), } err = preparer.InstallHooks() Assert(t).IsNil(err, "There should not have been an error in the call to SyncOnce()") currentAlias := filepath.Join(destDir, "users", "create", "current", "bin", "launch") _, err = os.Stat(currentAlias) Assert(t).IsNil(err, fmt.Sprintf("%s should have been created", currentAlias)) hookFile := filepath.Join(execDir, "users__create__launch") _, err = os.Stat(hookFile) Assert(t).IsNil(err, "should have created the user launch script") }
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) } }
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) } err = authorize(manifest) if err != nil { log.Fatalf("%s", err) } podFactory := pods.NewFactory(*podRoot, types.NodeName(*nodeName)) pod := podFactory.NewLegacyPod(manifest.ID()) err = pod.Install(manifest, auth.NopVerifier(), artifact.NewRegistry(nil, uri.DefaultFetcher, osversion.DefaultDetector)) if err != nil { log.Fatalf("Could not install manifest %s: %s", manifest.ID(), err) } success, err := pod.Launch(manifest) if err != nil { log.Fatalf("Could not launch manifest %s: %s", manifest.ID(), err) } if !success { log.Fatalln("Unsuccessful launch of one or more things in the manifest") } }