func newProject(name string, cfg *config.CloudConfig, environmentLookup project.EnvironmentLookup) (*project.Project, error) {
clientFactory, err := rosDocker.NewClientFactory(docker.ClientOpts{})
if err != nil {
return nil, err
}
if environmentLookup == nil {
environmentLookup = rosDocker.NewConfigEnvironment(cfg)
}
serviceFactory := &rosDocker.ServiceFactory{
Deps: map[string][]string{},
}
context := &docker.Context{
ClientFactory: clientFactory,
Context: project.Context{
ProjectName: name,
NoRecreate: true, // for libcompose to not recreate on project reload, looping up the boot :)
EnvironmentLookup: environmentLookup,
ServiceFactory: serviceFactory,
Log: cfg.Rancher.Log,
LoggerFactory: logger.NewColorLoggerFactory(),
},
}
serviceFactory.Context = context
return docker.NewProject(context)
}
// Create implements ProjectFactory.Create using docker client.
func (p *ProjectFactory) Create(c *cli.Context) (*project.Project, error) {
context := &docker.Context{}
context.LoggerFactory = logger.NewColorLoggerFactory()
Populate(context, c)
command.Populate(&context.Context, c)
return docker.NewProject(context)
}
func BuildComposeProject(composeFile string) (*project.Project, error) {
project, err := docker.NewProject(&docker.Context{
Context: project.Context{
ComposeFile: composeFile,
ProjectName: projectNameByGitProject(),
LoggerFactory: logger.NewColorLoggerFactory(),
},
})
if err != nil {
return nil, err
}
sanitizeConfig(project)
return project, nil
}
func createEnv(rancherUrl, projectName string, composeBytes []byte, rancherComposeMap map[string]rancher.RancherConfig, env *client.Environment) error {
context := rancher.Context{
Url: rancherUrl,
RancherConfig: rancherComposeMap,
Uploader: nil,
}
context.ProjectName = projectName
context.ComposeBytes = composeBytes
context.ConfigLookup = nil
context.EnvironmentLookup = &lookup.OsEnvLookup{}
context.LoggerFactory = logger.NewColorLoggerFactory()
context.ServiceFactory = &rancher.RancherServiceFactory{
Context: &context,
}
p := project.NewProject(&context.Context)
err := p.Parse()
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Errorf("Error parsing docker-compose.yml")
return err
}
apiClient, err := client.NewRancherClient(&client.ClientOpts{
Url: rancherUrl,
AccessKey: os.Getenv("CATTLE_ACCESS_KEY"),
SecretKey: os.Getenv("CATTLE_SECRET_KEY"),
})
context.Client = apiClient
c := &context
c.Environment = env
context.SidekickInfo = rancher.NewSidekickInfo(p)
err = p.Create([]string{}...)
if err != nil {
log.WithFields(log.Fields{
"err": err,
}).Error("Error while creating project.")
return err
}
return nil
}
func (p *ProjectFactory) Create(c *cli.Context) (project.APIProject, error) {
rancherComposeFile, err := rancher.ResolveRancherCompose(c.GlobalString("file"),
c.GlobalString("rancher-file"))
if err != nil {
return nil, err
}
qLookup, err := rLookup.NewQuestionLookup(rancherComposeFile, &lookup.OsEnvLookup{})
if err != nil {
return nil, err
}
envLookup, err := rLookup.NewFileEnvLookup(c.GlobalString("env-file"), qLookup)
if err != nil {
return nil, err
}
context := &rancher.Context{
Context: project.Context{
ResourceLookup: &rLookup.FileResourceLookup{},
EnvironmentLookup: envLookup,
LoggerFactory: logger.NewColorLoggerFactory(),
},
RancherComposeFile: c.GlobalString("rancher-file"),
Url: c.GlobalString("url"),
AccessKey: c.GlobalString("access-key"),
SecretKey: c.GlobalString("secret-key"),
PullCached: c.Bool("cached"),
Uploader: &rancher.S3Uploader{},
Args: c.Args(),
BindingsFile: c.GlobalString("bindings-file"),
}
qLookup.Context = context
command.Populate(&context.Context, c)
context.Upgrade = c.Bool("upgrade") || c.Bool("force-upgrade")
context.ForceUpgrade = c.Bool("force-upgrade")
context.Rollback = c.Bool("rollback")
context.BatchSize = int64(c.Int("batch-size"))
context.Interval = int64(c.Int("interval"))
context.ConfirmUpgrade = c.Bool("confirm-upgrade")
context.Pull = c.Bool("pull")
return rancher.NewProject(context)
}
// Create implements ProjectFactory.Create using docker client.
func (p *ProjectFactory) Create(c *cli.Context) (project.APIProject, error) {
context := &docker.Context{}
context.LoggerFactory = logger.NewColorLoggerFactory()
Populate(context, c)
context.ComposeFiles = c.GlobalStringSlice("file")
if len(context.ComposeFiles) == 0 {
context.ComposeFiles = []string{"docker-compose.yml"}
if _, err := os.Stat("docker-compose.override.yml"); err == nil {
context.ComposeFiles = append(context.ComposeFiles, "docker-compose.override.yml")
}
}
context.ProjectName = c.GlobalString("project-name")
return docker.NewProject(context, nil)
}
func newProject(name string, cfg *config.CloudConfig) (*project.Project, error) {
clientFactory, err := rosDocker.NewClientFactory(docker.ClientOpts{})
if err != nil {
return nil, err
}
serviceFactory := &rosDocker.ServiceFactory{
Deps: map[string][]string{},
}
context := &docker.Context{
ClientFactory: clientFactory,
Context: project.Context{
ProjectName: name,
EnvironmentLookup: rosDocker.NewConfigEnvironment(cfg),
ServiceFactory: serviceFactory,
Rebuild: true,
Log: cfg.Rancher.Log,
LoggerFactory: logger.NewColorLoggerFactory(),
},
}
serviceFactory.Context = context
return docker.NewProject(context)
}
func newProject(name string, cfg *config.CloudConfig, environmentLookup composeConfig.EnvironmentLookup, authLookup *rosDocker.ConfigAuthLookup) (*project.Project, error) {
clientFactory, err := rosDocker.NewClientFactory(composeClient.Options{})
if err != nil {
return nil, err
}
if environmentLookup == nil {
environmentLookup = rosDocker.NewConfigEnvironment(cfg)
}
if authLookup == nil {
authLookup = rosDocker.NewConfigAuthLookup(cfg)
}
serviceFactory := &rosDocker.ServiceFactory{
Deps: map[string][]string{},
}
context := &docker.Context{
ClientFactory: clientFactory,
AuthLookup: authLookup,
Context: project.Context{
ProjectName: name,
EnvironmentLookup: environmentLookup,
ServiceFactory: serviceFactory,
LoggerFactory: logger.NewColorLoggerFactory(),
},
}
serviceFactory.Context = context
authLookup.SetContext(context)
return docker.NewProject(context, &composeConfig.ParseOptions{
Interpolate: true,
Validate: false,
Preprocess: preprocessServiceMap,
})
}
func NewProject(context *Context) (*project.Project, error) {
context.ConfigLookup = &lookup.FileConfigLookup{}
context.EnvironmentLookup = &lookup.OsEnvLookup{}
context.LoggerFactory = logger.NewColorLoggerFactory()
context.ServiceFactory = &RancherServiceFactory{
Context: context,
}
p := project.NewProject(&context.Context)
err := p.Parse()
if err != nil {
return nil, err
}
if err = context.open(); err != nil {
logrus.Errorf("Failed to open project %s: %v", p.Name, err)
return nil, err
}
context.SidekickInfo = NewSidekickInfo(p)
return p, err
}
// Create implements ProjectFactory.Create using docker client.
func (p *ProjectFactory) Create(c *cli.Context) (project.APIProject, error) {
context := &ctx.Context{}
context.LoggerFactory = logger.NewColorLoggerFactory()
Populate(context, c)
return docker.NewProject(context, nil)
}