Exemplo n.º 1
0
func CleanUp(do *definitions.Do, app *definitions.Contracts) error {
	log.Info("Cleaning up")

	if do.Chain.ChainType == "throwaway" {
		log.WithField("=>", do.Chain.Name).Debug("Destroying throwaway chain")
		doRm := definitions.NowDo()
		doRm.Operations = do.Operations
		doRm.Name = do.Chain.Name
		doRm.Rm = true
		doRm.RmD = true
		chains.KillChain(doRm)

		latentDir := filepath.Join(common.DataContainersPath, do.Chain.Name)
		latentFile := filepath.Join(common.ChainsPath, do.Chain.Name+".toml")
		log.WithFields(log.Fields{
			"dir":  latentDir,
			"file": latentFile,
		}).Debug("Removing latent dir and file")

		os.RemoveAll(latentDir)
		os.Remove(latentFile)
	} else {
		log.Debug("No throwaway chain to destroy")
	}

	doData := definitions.NowDo()
	doData.Name = do.Service.Name
	doData.Operations = do.Operations

	doData.Source = common.ErisContainerRoot
	if do.Path != pwd {
		doData.Destination = do.Path
	} else {
		doData.Destination = filepath.Join(common.DataContainersPath, doData.Name)
	}
	var loca string
	if do.Path != pwd {
		loca = filepath.Join(common.DataContainersPath, doData.Name, do.Path)
	} else {
		loca = filepath.Join(common.DataContainersPath, doData.Name, "apps", app.Name)
	}

	log.WithFields(log.Fields{
		"path":     doData.Source,
		"location": loca,
	}).Debug("Exporting results")
	data.ExportData(doData)

	if app.AppType.Name == "epm" {
		files, _ := filepath.Glob(filepath.Join(loca, "*"))
		for _, f := range files {
			dest := filepath.Join(do.Path, filepath.Base(f))
			log.WithFields(log.Fields{
				"from": f,
				"to":   dest,
			}).Debug("Moving file")
			common.Copy(f, dest)
		}
	}

	if !do.RmD {
		log.WithField("dir", filepath.Join(common.DataContainersPath, do.Service.Name)).Debug("Removing data dir on host")
		os.RemoveAll(filepath.Join(common.DataContainersPath, do.Service.Name))
	}

	if !do.Rm {
		doRemove := definitions.NowDo()
		doRemove.Operations.SrvContainerName = do.Operations.DataContainerName
		log.WithField("=>", doRemove.Operations.SrvContainerName).Debug("Removing data container")
		if err := perform.DockerRemove(nil, doRemove.Operations, false, true); err != nil {
			return err
		}
	}

	return nil
}
Exemplo n.º 2
0
func DefineDappActionService(do *definitions.Do, dapp *definitions.Contracts) error {
	var cmd string

	switch do.Name {
	case "test":
		cmd = dapp.DappType.TestCmd
	case "deploy":
		cmd = dapp.DappType.DeployCmd
	default:
		return fmt.Errorf("I do not know how to perform that task (%s)\nPlease check what you can do with contracts by typing [eris contracts].\n", do.Name)
	}

	// if manual, set task
	if dapp.DappType.Name == "manual" {
		switch do.Name {
		case "test":
			cmd = dapp.TestTask
		case "deploy":
			cmd = dapp.DeployTask
		}
	}

	// task flag override
	if do.Task != "" {
		dapp.DappType = definitions.GulpDapp()
		cmd = do.Task
	}

	if cmd == "nil" {
		return fmt.Errorf("I cannot perform that task against that dapp type.\n")
	}

	// dapp-specific tests
	if dapp.DappType.Name == "pyepm" {
		if do.ConfigFile == "" {
			return fmt.Errorf("The pyepm dapp type requires a --yaml flag for the package definition you would like to deploy.\n")
		} else {
			cmd = do.ConfigFile
		}
	}

	// build service that will run
	do.Service.Name = dapp.Name + "_tmp_" + do.Name
	do.Service.Image = dapp.DappType.BaseImage
	do.Service.AutoData = true
	do.Service.EntryPoint = dapp.DappType.EntryPoint
	do.Service.Command = cmd
	if do.NewName != "" {
		do.Service.WorkDir = do.NewName // do.NewName is actually where the workdir inside the container goes
	}
	do.Service.User = "******"

	srv := definitions.BlankServiceDefinition()
	srv.Service = do.Service
	srv.Operations = do.Operations
	loaders.ServiceFinalizeLoad(srv)
	do.Service = srv.Service
	do.Operations = srv.Operations
	do.Operations.Remove = true

	linkDappToChain(do, dapp)

	// make data container and import do.Path to do.NewName (if exists)
	doData := definitions.NowDo()
	doData.Name = do.Service.Name
	doData.Operations = do.Operations
	if do.NewName != "" {
		doData.Path = do.NewName
	}

	loca := path.Join(common.DataContainersPath, doData.Name)
	logger.Debugf("Creating Dapp Data Cont =>\t%s:%s\n", do.Path, loca)
	common.Copy(do.Path, loca)
	data.ImportData(doData)
	do.Operations.DataContainerName = util.DataContainersName(doData.Name, doData.Operations.ContainerNumber)

	logger.Debugf("DApp Action Built.\n")

	return nil
}
Exemplo n.º 3
0
func DefineAppActionService(do *definitions.Do, app *definitions.Contracts) error {
	var cmd string

	switch do.Name {
	case "test":
		cmd = app.AppType.TestCmd
	case "deploy":
		cmd = app.AppType.DeployCmd
	default:
		return fmt.Errorf("I do not know how to perform that task (%s)\nPlease check what you can do with contracts by typing [eris contracts].\n", do.Name)
	}

	// if manual, set task
	if app.AppType.Name == "manual" {
		switch do.Name {
		case "test":
			cmd = app.TestTask
		case "deploy":
			cmd = app.DeployTask
		}
	}

	// task flag override
	if do.Task != "" {
		app.AppType = definitions.GulpApp()
		cmd = do.Task
	}

	if cmd == "nil" {
		return fmt.Errorf("I cannot perform that task against that app type.\n")
	}

	// build service that will run
	do.Service.Name = app.Name + "_tmp_" + do.Name
	do.Service.Image = app.AppType.BaseImage
	do.Service.AutoData = true
	do.Service.EntryPoint = app.AppType.EntryPoint
	do.Service.Command = cmd
	if do.Path != pwd {
		do.Service.WorkDir = do.Path // do.Path is actually where the workdir inside the container goes
	} else {
		do.Service.WorkDir = filepath.Join(common.ErisContainerRoot, "apps", app.Name)
	}
	do.Service.User = "******"

	srv := definitions.BlankServiceDefinition()
	srv.Service = do.Service
	srv.Operations = do.Operations
	loaders.ServiceFinalizeLoad(srv)
	do.Service = srv.Service
	do.Operations = srv.Operations
	do.Operations.Follow = true

	linkAppToChain(do, app)

	if app.AppType.Name == "epm" {
		prepareEpmAction(do, app)
	}

	// make data container and import do.Path to do.Path (if exists)
	doData := definitions.NowDo()
	doData.Name = do.Service.Name
	doData.Operations = do.Operations
	if do.Path != pwd {
		doData.Destination = do.Path
	} else {
		doData.Destination = common.ErisContainerRoot
	}

	doData.Source = filepath.Join(common.DataContainersPath, doData.Name)
	var loca string
	if do.Path != pwd {
		loca = filepath.Join(common.DataContainersPath, doData.Name, do.Path)
	} else {
		loca = filepath.Join(common.DataContainersPath, doData.Name, "apps", app.Name)
	}
	log.WithFields(log.Fields{
		"path":     do.Path,
		"location": loca,
	}).Debug("Creating app data container")
	common.Copy(do.Path, loca)
	if err := data.ImportData(doData); err != nil {
		return err
	}
	do.Operations.DataContainerName = util.DataContainersName(doData.Name, doData.Operations.ContainerNumber)

	log.Debug("App action built")
	return nil
}
Exemplo n.º 4
0
func CleanUp(do *definitions.Do, app *definitions.Contracts) error {
	logger.Infof("Commensing CleanUp.\n")

	if do.Chain.ChainType == "throwaway" {
		logger.Debugf("Destroying Throwaway Chain =>\t%s\n", do.Chain.Name)
		doRm := definitions.NowDo()
		doRm.Operations = do.Operations
		doRm.Name = do.Chain.Name
		doRm.Rm = true
		doRm.RmD = true
		chains.KillChain(doRm)

		logger.Debugf("Removing latent files/dirs =>\t%s:%s\n", path.Join(common.DataContainersPath, do.Chain.Name), path.Join(common.ChainsPath, do.Chain.Name+".toml"))
		os.RemoveAll(path.Join(common.DataContainersPath, do.Chain.Name))
		os.Remove(path.Join(common.ChainsPath, do.Chain.Name+".toml"))
	} else {
		logger.Debugf("No Throwaway Chain to destroy.\n")
	}

	doData := definitions.NowDo()
	doData.Name = do.Service.Name
	doData.Operations = do.Operations

	doData.Source = common.ErisContainerRoot
	if do.Path != pwd {
		doData.Destination = do.Path
	} else {
		doData.Destination = filepath.Join(common.DataContainersPath, doData.Name)
	}
	var loca string
	if do.Path != pwd {
		loca = path.Join(common.DataContainersPath, doData.Name, do.Path)
	} else {
		loca = path.Join(common.DataContainersPath, doData.Name, "apps", app.Name)
	}

	logger.Debugf("Exporting Results =>\t\t%s:%s\n", doData.Source, loca)
	data.ExportData(doData)

	if app.AppType.Name == "epm" {
		files, _ := filepath.Glob(filepath.Join(loca, "*"))
		for _, f := range files {
			dest := filepath.Join(do.Path, filepath.Base(f))
			logger.Debugf("Moving file =>\t\t\t%s:%s\n", f, dest)
			common.Copy(f, dest)
		}
	}

	if !do.RmD {
		logger.Debugf("Removing data dir on host =>\t%s\n", path.Join(common.DataContainersPath, do.Service.Name))
		os.RemoveAll(path.Join(common.DataContainersPath, do.Service.Name))
	}

	if !do.Rm {
		doRemove := definitions.NowDo()
		doRemove.Operations.SrvContainerName = do.Operations.DataContainerName
		logger.Debugf("Removing data contnr =>\t\t%s\n", doRemove.Operations.SrvContainerName)
		if err := perform.DockerRemove(nil, doRemove.Operations, false, true); err != nil {
			return err
		}
	}

	return nil
}