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 setDappType(dapp *definitions.Contracts, name, command, typ string) error {
var t string
logger.Debugf("Setting Dapp Type. Task =>\t%s\n", command)
logger.Debugf("\tType =>\t\t%s\n", typ)
logger.Debugf("\tChainName =>\t\t%s\n", name)
if typ != "" {
t = typ
} else {
switch command {
case "test":
t = dapp.TestType
case "deploy":
t = dapp.DeployType
}
}
switch t {
case "embark":
dapp.DappType = definitions.EmbarkDapp()
case "pyepm":
dapp.DappType = definitions.PyEpmDapp()
case "sunit":
dapp.DappType = definitions.SUnitDapp()
case "manual":
dapp.DappType = definitions.GulpDapp()
default:
return fmt.Errorf("Unregistered DappType.\nUnfortunately our marmots cannot deal with that.\nPlease ensure that the dapp type is set in the package.json.")
}
logger.Debugf("\tDapp Type =>\t\t%s\n", dapp.DappType.Name)
return nil
}
func setAppType(app *definitions.Contracts, name, command, typ string) error {
var t string
logger.Debugf("Setting App Type. Task =>\t%s\n", command)
logger.Debugf("\tChainType =>\t\t%s\n", typ)
logger.Debugf("\tChainName =>\t\t%s\n", name)
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()
}
logger.Debugf("\tApp Type =>\t\t%s\n", app.AppType.Name)
return nil
}
func checkAppAndChain(app *definitions.Contracts, name string) error {
var chain string
// name is pulled in from the do struct. need to work with both
// it (as an override) and the app.ChainName
switch name {
case "":
if app.ChainName == "" {
return nil
} else {
chain = app.ChainName
}
case "t", "tmp", "temp":
return nil
default:
chain = name
}
if strings.Contains(app.Name, " ") {
app.Name = strings.Replace(app.Name, " ", "_", -1)
}
// this is hacky.... at best.
if len(app.AppType.ChainTypes) == 1 && app.AppType.ChainTypes[0] == "eth" {
if r := regexp.MustCompile("eth"); r.MatchString(chain) {
return nil
} else {
return fmt.Errorf("The marmots detected a disturbance in the force.\n\nYou asked them to run the App Type: (%s).\nBut the chainName (%s) doesn't contain the name (%s).\nPlease rename the chain or service to contain the name (%s)", app.AppType.Name, chain, "eth", "eth")
}
}
return nil
}
func BootServicesAndChain(do *definitions.Do, dapp *definitions.Contracts) error {
var err error
var srvs []*definitions.ServiceDefinition
// launch the services
for _, s := range do.ServicesSlice {
t, err := services.BuildServicesGroup(s, do.Operations.ContainerNumber, srvs...)
if err != nil {
return err
}
srvs = append(srvs, t...)
}
// TODO: refactor this logic, should only need to call services.StartGroup(srvs)
if len(srvs) >= 1 {
wg, ch := new(sync.WaitGroup), make(chan error, 1)
services.StartGroup(ch, wg, srvs)
go func() {
wg.Wait()
ch <- nil
}()
if err := <-ch; err != nil {
return err
}
}
// boot the chain
switch do.ChainName {
case "":
if dapp.ChainName == "" {
logger.Infof("No chain was given, booting a throwaway chain.\n")
err = bootThrowAwayChain(dapp.Name, do)
} else {
logger.Infof("Booting chain =>\t\t%s\n", dapp.ChainName)
err = bootChain(dapp.ChainName, do)
}
case "t", "tmp", "temp":
logger.Infof("No chain was given, booting a throwaway chain.\n")
err = bootThrowAwayChain(dapp.Name, do)
default:
logger.Infof("Booting chain =>\t\t%s\n", do.ChainName)
err = bootChain(do.ChainName, do)
}
dapp.ChainName = do.Chain.Name
if err != nil {
return err
}
return nil
}
func BootServicesAndChain(do *definitions.Do, app *definitions.Contracts) error {
var err error
var srvs []*definitions.ServiceDefinition
// launch the services
for _, s := range do.ServicesSlice {
t, err := services.BuildServicesGroup(s, do.Operations.ContainerNumber, srvs...)
if err != nil {
return err
}
srvs = append(srvs, t...)
}
if len(srvs) >= 1 {
if err := services.StartGroup(srvs); err != nil {
return err
}
}
// boot the chain
switch do.ChainName {
case "":
if app.ChainName == "" {
// TODO [csk]: first check if there is a chain checked out. if not, then use throwAway
log.Info("No chain was given, booting a throwaway chain")
err = bootThrowAwayChain(app.Name, do)
} else {
log.WithField("=>", app.ChainName).Info("Booting chain")
err = bootChain(app.ChainName, do)
}
case "t", "tmp", "temp":
log.Info("No chain was given, booting a throwaway chain")
err = bootThrowAwayChain(app.Name, do)
default:
log.WithField("=>", do.ChainName).Info("Booting chain")
err = bootChain(do.ChainName, do)
}
app.ChainName = do.Chain.Name
if err != nil {
return err
}
return nil
}
func BootServicesAndChain(do *definitions.Do, dapp *definitions.Contracts) error {
var err error
var srvs []*definitions.ServiceDefinition
// launch the services
for _, s := range do.ServicesSlice {
t, err := services.BuildServicesGroup(s, do.Operations.ContainerNumber, srvs...)
if err != nil {
return err
}
srvs = append(srvs, t...)
}
if len(srvs) >= 1 {
if err := services.StartGroup(srvs); err != nil {
return err
}
}
// boot the chain
switch do.ChainName {
case "":
if dapp.ChainName == "" {
logger.Infof("No chain was given, booting a throwaway chain.\n")
err = bootThrowAwayChain(dapp.Name, do)
} else {
logger.Infof("Booting chain =>\t\t%s\n", dapp.ChainName)
err = bootChain(dapp.ChainName, do)
}
case "t", "tmp", "temp":
logger.Infof("No chain was given, booting a throwaway chain.\n")
err = bootThrowAwayChain(dapp.Name, do)
default:
logger.Infof("Booting chain =>\t\t%s\n", do.ChainName)
err = bootChain(do.ChainName, do)
}
dapp.ChainName = do.Chain.Name
if err != nil {
return err
}
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 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
}