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
}
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
}
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
}
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
}