func TestInspectData(t *testing.T) { testCreateDataByImport(t, dataName) defer testKillDataCont(t, dataName) do := definitions.NowDo() do.Name = dataName do.Operations.Args = []string{"name"} do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "data container": do.Name, "args": do.Operations.Args, }).Info("Inspecting data (from tests)") if err := InspectData(do); err != nil { log.Error(err) t.FailNow() } do = definitions.NowDo() do.Name = dataName do.Operations.Args = []string{"config.network_disabled"} do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "data container": do.Name, "args": do.Operations.Args, }).Info("Inspecting data (from tests)") if err := InspectData(do); err != nil { log.Error(err) t.Fail() } }
//[zr] TODO move to testings package func testNumbersExistAndRun(t *testing.T, servName string, containerExist, containerRun int) { log.WithFields(log.Fields{ "=>": servName, "existing#": containerExist, "running#": containerRun, }).Info("Checking number of containers for") log.WithField("=>", servName).Debug("Checking existing containers for") exist := util.HowManyContainersExisting(servName, "service") log.WithField("=>", servName).Debug("Checking running containers for") run := util.HowManyContainersRunning(servName, "service") if exist != containerExist { log.WithFields(log.Fields{ "name": servName, "expected": containerExist, "got": exist, }).Error("Wrong number of existing containers") fatal(t, nil) } if run != containerRun { log.WithFields(log.Fields{ "name": servName, "expected": containerExist, "got": run, }).Error("Wrong number of running containers") fatal(t, nil) } log.Info("All good") }
func TestRenameChain(t *testing.T) { aChain := "hichain" rename1 := "niahctset" rename2 := chainName testNewChain(aChain) defer testKillChain(t, rename2) do := def.NowDo() do.Name = aChain do.NewName = rename1 log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming chain (from tests)") if e := RenameChain(do); e != nil { tests.IfExit(e) } testExistAndRun(t, rename1, true, true) do = def.NowDo() do.Name = rename1 do.NewName = rename2 log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming chain (from tests)") if e := RenameChain(do); e != nil { tests.IfExit(e) } testExistAndRun(t, chainName, true, true) }
func TestRenameAction(t *testing.T) { testExist(t, newName, false) testExist(t, oldName, true) do := definitions.NowDo() do.Name = oldName do.NewName = newName log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming action (from tests)") if err := RenameAction(do); err != nil { log.Error(err) t.Fail() } testExist(t, newName, true) testExist(t, oldName, false) do = definitions.NowDo() do.Name = newName do.NewName = oldName log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming action (from tests)") if err := RenameAction(do); err != nil { log.Error(err) t.Fail() } testExist(t, newName, false) testExist(t, oldName, true) }
func MoveOutOfDirAndRmDir(src, dest string) error { log.WithFields(log.Fields{ "from": src, "to": dest, }).Info("Move all files/dirs out of a dir and `rm -fr` that dir") toMove, err := filepath.Glob(filepath.Join(src, "*")) if err != nil { return err } if len(toMove) == 0 { log.Debug("No files to move") } for _, f := range toMove { t := filepath.Join(dest, filepath.Base(f)) log.WithFields(log.Fields{ "from": f, "to": t, }).Debug("Moving") // using a copy (read+write) strategy to get around swap partitions and other // problems that cause a simple rename strategy to fail. it is more io overhead // to do this, but for now that is preferable to alternative solutions. Copy(f, t) } log.WithField("=>", src).Info("Removing directory") err = os.RemoveAll(src) if err != nil { return err } return nil }
func TestExistAndRun(name, t string, contNum int, toExist, toRun bool) error { log.WithFields(log.Fields{ "=>": name, "running": toRun, "existing": toExist, }).Info("Checking container") if existing := FindContainer(name, t, contNum, false); existing != toExist { log.WithFields(log.Fields{ "=>": name, "expected": toExist, "got": existing, }).Info("Checking container existing") return ErrContainerExistMismatch } if running := FindContainer(name, t, contNum, true); running != toRun { log.WithFields(log.Fields{ "=>": name, "expected": toExist, "got": running, }).Info("Checking container running") return ErrContainerRunMismatch } return nil }
func TestInspectService(t *testing.T) { testStartService(t, servName, false) defer testKillService(t, servName, true) do := def.NowDo() do.Name = servName do.Operations.Args = []string{"name"} do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "=>": fmt.Sprintf("%s:%d", servName, do.Operations.ContainerNumber), "args": do.Operations.Args, }).Debug("Inspect service (from tests)") e := InspectService(do) if e != nil { log.Infof("Error inspecting service: %v", e) tests.IfExit(e) } do = def.NowDo() do.Name = servName do.Operations.Args = []string{"config.user"} do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "=>": servName, "args": do.Operations.Args, }).Debug("Inspect service (from tests)") e = InspectService(do) if e != nil { log.Infof("Error inspecting service: %v", e) tests.IfExit(e) } }
func TestNewService(t *testing.T) { do := def.NowDo() servName := "keys" do.Name = servName do.Operations.Args = []string{"quay.io/eris/keys"} log.WithFields(log.Fields{ "=>": do.Name, "args": do.Operations.Args, }).Debug("Creating a new service (from tests)") e := NewService(do) if e != nil { log.Error(e) tests.IfExit(e) } do = def.NowDo() do.Operations.Args = []string{servName} log.WithFields(log.Fields{ "container number": do.Operations.ContainerNumber, "args": do.Operations.Args, }).Debug("Starting service (from tests)") e = StartService(do) if e != nil { log.Error(e) tests.IfExit(e) } testExistAndRun(t, servName, 1, true, true) testNumbersExistAndRun(t, servName, 1, 1) testKillService(t, servName, true) testExistAndRun(t, servName, 1, false, false) }
func TestLoadServiceDefinition(t *testing.T) { var e error srv, e = loaders.LoadServiceDefinition(servName, true, 1) if e != nil { log.Error(e) tests.IfExit(e) } if srv.Name != servName { log.WithFields(log.Fields{ "expected": servName, "got": srv.Name, }).Error("Improper name on load") } if srv.Service.Name != servName { log.WithFields(log.Fields{ "expected": servName, "got": srv.Service.Name, }).Error("Improper service name on load") tests.IfExit(e) } if !srv.Service.AutoData { log.Error("data_container not properly read on load") tests.IfExit(e) } if srv.Operations.DataContainerName == "" { log.Error("data_container_name not set") tests.IfExit(e) } }
func RenameAction(do *definitions.Do) error { if do.Name == do.NewName { return fmt.Errorf("Cannot rename to same name") } do.Name = strings.Replace(do.Name, " ", "_", -1) do.NewName = strings.Replace(do.NewName, " ", "_", -1) act, _, err := LoadActionDefinition(do.Name) if err != nil { log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Debug("Failed renaming action") return err } do.Name = strings.Replace(do.Name, " ", "_", -1) log.WithField("file", do.Name).Debug("Finding action definition file") oldFile := util.GetFileByNameAndType("actions", do.Name) if oldFile == "" { return fmt.Errorf("Could not find that action definition file.") } log.WithField("file", oldFile).Debug("Found action definition file") // if !strings.Contains(oldFile, ActionsPath) { // oldFile = filepath.Join(ActionsPath, oldFile) + ".toml" // } var newFile string newNameBase := strings.Replace(strings.Replace(do.NewName, " ", "_", -1), filepath.Ext(do.NewName), "", 1) if newNameBase == do.Name { newFile = strings.Replace(oldFile, filepath.Ext(oldFile), filepath.Ext(do.NewName), 1) } else { newFile = strings.Replace(oldFile, do.Name, do.NewName, 1) newFile = strings.Replace(newFile, " ", "_", -1) } if newFile == oldFile { log.Info("Not renaming the same file") return nil } act.Name = strings.Replace(newNameBase, "_", " ", -1) log.WithFields(log.Fields{ "old": act.Name, "new": newFile, }).Debug("Writing new action definition file") err = WriteActionDefinitionFile(act, newFile) if err != nil { return err } log.WithField("file", oldFile).Debug("Removing old file") os.Remove(oldFile) return nil }
func StartService(do *definitions.Do) (err error) { var services []*definitions.ServiceDefinition do.Operations.Args = append(do.Operations.Args, do.ServicesSlice...) log.WithField("args", do.Operations.Args).Info("Building services group") for _, srv := range do.Operations.Args { s, e := BuildServicesGroup(srv, do.Operations.ContainerNumber) if e != nil { return e } services = append(services, s...) } // [csk]: controls for ops reconciliation, overwrite will, e.g., merge the maps and stuff for _, s := range services { util.Merge(s.Operations, do.Operations) } log.Debug("Preparing to build chain") for _, s := range services { log.WithFields(log.Fields{ "name": s.Name, "dependencies": s.Dependencies, "links": s.Service.Links, "volumes from": s.Service.VolumesFrom, }).Debug() // Spacer. log.Debug() } services, err = BuildChainGroup(do.ChainName, services) if err != nil { return err } log.Debug("Checking services after build chain") for _, s := range services { log.WithFields(log.Fields{ "name": s.Name, "dependencies": s.Dependencies, "links": s.Service.Links, "volumes from": s.Service.VolumesFrom, }).Debug() // Spacer. log.Debug() } // NOTE: the top level service should be at the end of the list topService := services[len(services)-1] topService.Service.Environment = append(topService.Service.Environment, do.Env...) topService.Service.Links = append(topService.Service.Links, do.Links...) services[len(services)-1] = topService return StartGroup(services) }
func RegisterChain(do *definitions.Do) error { // do.Name is mandatory if do.Name == "" { return fmt.Errorf("RegisterChain requires a chainame") } etcbChain := do.ChainID do.ChainID = do.Name // NOTE: registration expects you to have the data container if !util.IsDataContainer(do.Name, do.Operations.ContainerNumber) { return fmt.Errorf("Registration requires you to have a data container for the chain. Could not find data for %s", do.Name) } chain, err := loaders.LoadChainDefinition(do.Name, false, do.Operations.ContainerNumber) if err != nil { return err } log.WithField("image", chain.Service.Image).Debug("Chain loaded") // set chainid and other vars envVars := []string{ fmt.Sprintf("CHAIN_ID=%s", do.ChainID), // of the etcb chain fmt.Sprintf("PUBKEY=%s", do.Pubkey), // pubkey to register chain with fmt.Sprintf("ETCB_CHAIN_ID=%s", etcbChain), // chain id of the etcb chain fmt.Sprintf("NODE_ADDR=%s", do.Gateway), // etcb node to send the register tx to fmt.Sprintf("NEW_P2P_SEEDS=%s", do.Operations.Args[0]), // seeds to register for the chain // TODO: deal with multi seed (needs support in tendermint) } envVars = append(envVars, do.Env...) log.WithFields(log.Fields{ "environment": envVars, "links": do.Links, }).Debug("Registering chain with") chain.Service.Environment = append(chain.Service.Environment, envVars...) chain.Service.Links = append(chain.Service.Links, do.Links...) if err := bootDependencies(chain, do); err != nil { return err } log.WithFields(log.Fields{ "=>": chain.Service.Name, "image": chain.Service.Image, }).Debug("Performing chain container start") chain.Operations = loaders.LoadDataDefinition(chain.Service.Name, do.Operations.ContainerNumber) chain.Operations.Args = []string{loaders.ErisChainRegister} _, err = perform.DockerRunData(chain.Operations, chain.Service) return err }
func readActionDefinition(actionName []string, dropped map[string]string, varNum int) (*viper.Viper, map[string]string, error) { if len(actionName) == 0 { log.WithFields(log.Fields{ "action": actionName, "drop": dropped, "var#": varNum, }).Debug("Failed to load action definition file") return nil, dropped, fmt.Errorf("The marmots could not find the action definition file.\nPlease check your actions with [eris actions ls]") } log.WithField("file", strings.Join(actionName, "_")).Debug("Preparing to read action definition file") log.WithField("drop", dropped).Debug() var actionConf = viper.New() actionConf.AddConfigPath(dir.ActionsPath) actionConf.SetConfigName(strings.Join(actionName, "_")) err := actionConf.ReadInConfig() if err != nil { log.WithField("action", actionName[len(actionName)-1]).Debug("Dropping and retrying") dropped[fmt.Sprintf("$%d", varNum)] = actionName[len(actionName)-1] actionName = actionName[:len(actionName)-1] varNum++ return readActionDefinition(actionName, dropped, varNum) } else { log.Debug("Successfully read action definition file") } return actionConf, dropped, nil }
func setAppType(app *definitions.Contracts, name, command, typ string) error { var t string log.WithFields(log.Fields{ "task": command, "type": typ, "app": name, }).Debug("Setting app type") if typ != "" { t = typ } else { switch command { case "test": t = app.TestType case "deploy": t = app.DeployType } } switch t { case "embark": app.AppType = definitions.EmbarkApp() case "sunit": app.AppType = definitions.SUnitApp() case "manual": app.AppType = definitions.GulpApp() default: app.AppType = definitions.EPMApp() } log.WithField("app type", app.AppType.Name).Debug() return nil }
func Migrate(dirsToMigrate map[string]string) error { for depDir, newDir := range dirsToMigrate { if !DoesDirExist(depDir) && !DoesDirExist(newDir) { return fmt.Errorf("neither deprecated (%s) or new (%s) exists. please run `init` prior to `update`\n", depDir, newDir) } else if DoesDirExist(depDir) && !DoesDirExist(newDir) { //never updated, just rename dirs if err := os.Rename(depDir, newDir); err != nil { return err } log.WithFields(log.Fields{ "from": depDir, "to": newDir, }).Warn("Directory migration successful") } else if DoesDirExist(depDir) && DoesDirExist(newDir) { //both exist, better check what's in them if err := checkFileNamesAndMigrate(depDir, newDir); err != nil { return err } // [csk] once the files are migrated we need to remove the dir or // the DoesDirExist function will return. if err := os.Remove(depDir); err != nil { return err } } else { //should never throw return fmt.Errorf("unknown and unresolveable conflict between directory to deprecate (%s) and new directory (%s)\n", depDir, newDir) } if DoesDirExist(depDir) { return fmt.Errorf("deprecated directory (%s) still exists, something went wrong", depDir) } } return nil }
// DockerExecData runs a data container with volumes-from field set interactively. // // ops.Args - command line parameters // ops.Interactive - if true, set Entrypoint to ops.Args, // if false, set Cmd to ops.Args // // See parameter description for DockerRunData. func DockerExecData(ops *def.Operation, service *def.Service) (err error) { log.WithFields(log.Fields{ "=>": ops.DataContainerName, "args": ops.Args, }).Info("Executing data container") opts := configureVolumesFromContainer(ops, service) log.WithField("image", opts.Config.Image).Info("Data container configured") _, err = createContainer(opts) if err != nil { return err } // Clean up the container. defer func() { log.WithField("=>", opts.Name).Info("Removing data container") if err2 := removeContainer(opts.Name, true, false); err2 != nil { if os.Getenv("CIRCLE_BRANCH") == "" { err = fmt.Errorf("Tragic! Error removing data container after executing (%v): %v", err, err2) } } log.WithField("=>", opts.Name).Info("Data container removed") }() // Start the container. log.WithField("=>", opts.Name).Info("Executing interactive data container") if err = startInteractiveContainer(opts); err != nil { return err } return nil }
// DockerStop stops a running ops.SrvContainerName container unforcedly. // timeout is a number of seconds to wait before killing the container process // ungracefully. // It returns Docker errors on exit if not successful. DockerStop doesn't return // an error if the container isn't running. func DockerStop(srv *def.Service, ops *def.Operation, timeout uint) error { // don't limit this to verbose because it takes a few seconds // [zr] unless force sets timeout to 0 (for, eg. stdout) if timeout != 0 { log.WithField("=>", srv.Name).Warn("Stopping (may take a few seconds)") } log.WithFields(log.Fields{ "=>": ops.SrvContainerName, "timeout": timeout, }).Info("Stopping container") _, running := ContainerExists(ops) if running { log.WithField("=>", ops.SrvContainerName).Debug("Container found running") err := stopContainer(ops.SrvContainerName, timeout) if err != nil { return err } } else { log.WithField("=>", ops.SrvContainerName).Debug("Container found not running") } log.WithField("=>", ops.SrvContainerName).Info("Container stopped") return nil }
func TestSetGlobalObjectDefaultConfig(t *testing.T) { ChangeErisDir(configErisDir) cli, err := SetGlobalObject(os.Stderr, os.Stdout) if err != nil { t.Fatalf("expected success, got error %v", err) } defaults, err := SetDefaults() if err != nil { t.Fatalf("expected defaults loaded, got error %v", err) } if def, returned := defaults.Get("IpfsHost"), cli.Config.IpfsHost; reflect.DeepEqual(returned, def) != true { t.Fatalf("expected default %q, got %q", returned, def) } if def, returned := defaults.Get("CompilersHost"), cli.Config.CompilersHost; reflect.DeepEqual(returned, def) != true { t.Fatalf("expected default %q, got %q", returned, def) } log.WithFields(log.Fields{ "ipfshost": cli.Config.IpfsHost, "compilers host": cli.Config.CompilersHost, "host": cli.Config.DockerHost, "cert path": cli.Config.DockerCertPath, "verbose": cli.Config.Verbose, }).Info("Checking defaults") }
func TestStartKillServiceWithDependencies(t *testing.T) { do := def.NowDo() do.Operations.Args = []string{"do_not_use"} log.WithFields(log.Fields{ "service": servName, "dependency": "keys", }).Debug("Starting service with dependency (from tests)") if e := StartService(do); e != nil { log.Infof("Error starting service: %v", e) tests.IfExit(e) } defer func() { testKillService(t, "do_not_use", true) testExistAndRun(t, servName, 1, false, false) testNumbersExistAndRun(t, servName, 0, 0) testKillService(t, "keys", true) }() testExistAndRun(t, servName, 1, true, true) testExistAndRun(t, "keys", 1, true, true) testNumbersExistAndRun(t, "keys", 1, 1) testNumbersExistAndRun(t, servName, 1, 1) }
// links and mounts for service dependencies func connectToAService(srv *definitions.Service, ops *definitions.Operation, typ, name, internalName string, link, mount bool) { log.WithFields(log.Fields{ "=>": srv.Name, "type": typ, "name": name, "internal name": internalName, "link": link, "volumes from": mount, }).Debug("Connecting to service") containerName := util.ContainersName(typ, name, ops.ContainerNumber) if link { newLink := containerName + ":" + internalName srv.Links = append(srv.Links, newLink) } if mount { // Automagically mount VolumesFrom for serviceDeps so they can // easily pass files back and forth. note that this is opinionated // and will mount as read-write. we can revisit this if read-only // mounting required for specific use cases newVol := containerName + ":rw" srv.VolumesFrom = append(srv.VolumesFrom, newVol) } }
func Do(do *definitions.Do) error { log.WithFields(log.Fields{ "chain": do.ChainName, "services": do.ServicesSlice, }).Info("Performing action") var err error var actionVars []string do.Action, actionVars, err = LoadActionDefinition(strings.Join(do.Operations.Args, "_")) if err != nil { return err } resolveServices(do) resolveChain(do) fixChain(do.Action, do.ChainName) if err := StartServicesAndChains(do); err != nil { return err } if err := PerformCommand(do.Action, actionVars, do.Quiet); err != nil { return err } return nil }
func NewService(do *definitions.Do) error { srv := definitions.BlankServiceDefinition() srv.Name = do.Name srv.Service.Name = do.Name srv.Service.Image = do.Operations.Args[0] srv.Service.AutoData = true var err error //get maintainer info srv.Maintainer.Name, srv.Maintainer.Email, err = config.GitConfigUser() if err != nil { log.Debug(err.Error()) } log.WithFields(log.Fields{ "service": srv.Service.Name, "image": srv.Service.Image, }).Debug("Creating a new service definition file") err = WriteServiceDefinitionFile(srv, filepath.Join(ServicesPath, do.Name+".toml")) if err != nil { return err } do.Result = "success" return nil }
// ImportData does what it says. It imports from a host's Source to a Dest // in a data container. It returns an error. // // do.Name - name of the data container to use (required) // do.Operations.ContainerNumber - container number (optional) // do.Source - directory which should be imported (required) // do.Destination - directory to _unload_ the payload into (required) // func ImportData(do *definitions.Do) error { log.WithFields(log.Fields{ "from": do.Source, "to": do.Destination, }).Debug("Importing") if util.IsDataContainer(do.Name, do.Operations.ContainerNumber) { srv := PretendToBeAService(do.Name, do.Operations.ContainerNumber) service, exists := perform.ContainerExists(srv.Operations) if !exists { return fmt.Errorf("There is no data container for that service.") } if err := checkErisContainerRoot(do, "import"); err != nil { return err } containerName := util.DataContainersName(do.Name, do.Operations.ContainerNumber) os.Chdir(do.Source) reader, err := util.Tar(do.Source, 0) if err != nil { return err } defer reader.Close() opts := docker.UploadToContainerOptions{ InputStream: reader, Path: do.Destination, NoOverwriteDirNonDir: true, } log.WithField("=>", containerName).Info("Copying into container") log.WithField("path", do.Source).Debug() if err := util.DockerClient.UploadToContainer(service.ID, opts); err != nil { return err } doChown := definitions.NowDo() doChown.Operations.DataContainerName = containerName doChown.Operations.ContainerType = "data" doChown.Operations.ContainerNumber = do.Operations.ContainerNumber //required b/c `docker cp` (UploadToContainer) goes in as root doChown.Operations.Args = []string{"chown", "--recursive", "eris", do.Destination} _, err = perform.DockerRunData(doChown.Operations, nil) if err != nil { return fmt.Errorf("Error changing owner: %v\n", err) } } else { log.WithField("name", do.Name).Info("Data container does not exist.") ops := loaders.LoadDataDefinition(do.Name, do.Operations.ContainerNumber) if err := perform.DockerCreateData(ops); err != nil { return fmt.Errorf("Error creating data container %v.", err) } return ImportData(do) } do.Result = "success" return nil }
func giveMeAllTheNames(name string, srv *def.ServiceDefinition) { log.WithField("=>", name).Debug("Giving myself all the names") srv.Name = name srv.Service.Name = name srv.Operations.SrvContainerName = util.DataContainersName(srv.Name, srv.Operations.ContainerNumber) srv.Operations.DataContainerName = util.DataContainersName(srv.Name, srv.Operations.ContainerNumber) log.WithFields(log.Fields{ "data container": srv.Operations.DataContainerName, "service container": srv.Operations.SrvContainerName, }).Debug("Using names") }
func PerformAppActionService(do *definitions.Do, app *definitions.Contracts) error { log.Warn("Performing action. This can sometimes take a wee while") log.WithFields(log.Fields{ "service": do.Service.Name, "image": do.Service.Image, }).Info() log.WithFields(log.Fields{ "workdir": do.Service.WorkDir, "entrypoint": do.Service.EntryPoint, }).Debug() do.Operations.ContainerType = definitions.TypeService if err := perform.DockerExecService(do.Service, do.Operations); err != nil { do.Result = "could not perform app action" return err } log.Info("Finished performing app action") return nil }
func TestRenameService(t *testing.T) { testStartService(t, "keys", false) testExistAndRun(t, "keys", 1, true, true) testNumbersExistAndRun(t, "keys", 1, 1) do := def.NowDo() do.Name = "keys" do.NewName = "syek" log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Debug("Renaming service (from tests)") if e := RenameService(do); e != nil { tests.IfExit(fmt.Errorf("Error (tests fail) =>\t\t%v\n", e)) } testExistAndRun(t, "syek", 1, true, true) testExistAndRun(t, "keys", 1, false, false) testNumbersExistAndRun(t, "syek", 1, 1) testNumbersExistAndRun(t, "keys", 0, 0) do = def.NowDo() do.Name = "syek" do.NewName = "keys" log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Debug("Renaming service (from tests)") if e := RenameService(do); e != nil { log.Errorf("Error (tests fail): %v", e) tests.IfExit(e) } testExistAndRun(t, "keys", 1, true, true) testExistAndRun(t, "syek", 1, false, false) testNumbersExistAndRun(t, "keys", 1, 1) testNumbersExistAndRun(t, "syek", 0, 0) testKillService(t, "keys", true) testExistAndRun(t, "keys", 1, false, false) }
func removeErisImages(prompt bool) error { opts := docker.ListImagesOptions{ All: true, Filters: nil, Digests: false, } allTheImages, err := DockerClient.ListImages(opts) if err != nil { return err } //get all repo tags & IDs // [zr] this could probably be cleaner repoTags := make(map[int][]string) imageIDs := make(map[int]string) for i, image := range allTheImages { repoTags[i] = image.RepoTags imageIDs[i] = image.ID } erisImages := []string{} erisImageIDs := []string{} //searches through repo tags for eris images & "maps" to ID for i, repoTag := range repoTags { for _, rt := range repoTag { r, err := regexp.Compile(`eris`) if err != nil { log.Errorf("Regexp error: %v", err) } if r.MatchString(rt) == true { erisImages = append(erisImages, rt) erisImageIDs = append(erisImageIDs, imageIDs[i]) } } } if !prompt || canWeRemove(erisImages, "images") { for i, imageID := range erisImageIDs { log.WithFields(log.Fields{ "=>": erisImages[i], "id": imageID, }).Debug("Removing image") if err := DockerClient.RemoveImage(imageID); err != nil { return err } } } else { log.Warn("Permission to remove images not given, continuing with clean") } return nil }
func ListFiles(do *definitions.Do) error { ensureRunning() log.WithFields(log.Fields{ "file": do.Name, "path": do.Path, }).Debug("Listing an object") hash, err := listFile(do.Name) if err != nil { return err } do.Result = hash return nil }
func CatFiles(do *definitions.Do) error { ensureRunning() log.WithFields(log.Fields{ "file": do.Name, "path": do.Path, }).Debug("Dumping the contents of a file") hash, err := catFile(do.Name) if err != nil { return err } do.Result = hash return nil }
func TestRenameData(t *testing.T) { testCreateDataByImport(t, dataName) defer testKillDataCont(t, dataName) testExist(t, dataName, true) testExist(t, newName, false) do := definitions.NowDo() do.Name = dataName do.NewName = newName do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming data (from tests)") if err := RenameData(do); err != nil { log.Error(err) t.FailNow() } testExist(t, dataName, false) testExist(t, newName, true) do = definitions.NowDo() do.Name = newName do.NewName = dataName do.Operations.ContainerNumber = 1 log.WithFields(log.Fields{ "from": do.Name, "to": do.NewName, }).Info("Renaming data (from tests)") if err := RenameData(do); err != nil { log.Error(err) t.FailNow() } testExist(t, dataName, true) testExist(t, newName, false) }