func doCluster(c *cli.Context) {
ecsManager, err := buildECSManager()
if err != nil {
fmt.Fprintf(os.Stderr, "[ERROR]%s\n", color.Red(err.Error()))
os.Exit(1)
}
operation, errSubCommand := createOperation(c.Args())
if errSubCommand != nil {
fmt.Fprintf(os.Stderr, "[ERROR]%s\n", color.Red(errSubCommand.Error()))
os.Exit(1)
}
projectDir, err := os.Getwd()
if err != nil {
panic(err)
}
clusterController := cluster.ClusterControler{
Ecs: ecsManager,
TargetResource: operation.TargetResource,
}
plans := createClusterPlans(&clusterController, projectDir)
if operation.SubCommand == "apply" {
clusterController.ApplyClusterPlans(plans)
}
}
func createClusterPlans(controller *cluster.ClusterControler, projectDir string) []*plan.ClusterUpdatePlan {
clusters := controller.SearchClusters(projectDir)
plans := controller.CreateClusterUpdatePlans(clusters)
for _, plan := range plans {
fmt.Printf("Cluster '%s'\n", plan.Name)
fmt.Println(color.Cyan(fmt.Sprintf("\t[Add] num = %d", len(plan.NewServices))))
for _, add := range plan.NewServices {
fmt.Println(color.Cyan(fmt.Sprintf("\t\t (+) %s", add.Name)))
}
fmt.Println(color.Green(fmt.Sprintf("\t[Update] num = %d", len(plan.UpdateServices))))
for _, update := range plan.UpdateServices {
fmt.Println(color.Green(fmt.Sprintf("\t\t (+) %s(%s)", *update.Before.ServiceName, *update.Before.ClusterARN)))
}
fmt.Println(color.Red(fmt.Sprintf("\t[Remove] num = %d", len(plan.DeleteServices))))
for _, delete := range plan.DeleteServices {
fmt.Println(color.Red(fmt.Sprintf("\t\t (-) %s(%s)", *delete.ServiceName, *delete.ClusterARN)))
}
fmt.Println()
}
return plans
}
func doTask(c *cli.Context) {
ecsManager, err := buildECSManager()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
operation, errSubCommand := createOperation(c.Args())
if errSubCommand != nil {
logger.Main.Error(color.Red(errSubCommand.Error()))
os.Exit(1)
}
projectDir, err := os.Getwd()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
taskController, err := task.NewTaskDefinitionController(ecsManager, projectDir, operation.TargetResource)
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
plans := createTaskPlans(taskController, projectDir)
if operation.SubCommand == "apply" {
results, errapp := taskController.ApplyTaskDefinitionPlans(plans)
if errapp != nil {
logger.Main.Error(color.Red(errapp.Error()))
os.Exit(1)
}
for _, output := range results {
logger.Main.Infof("Registered Task Definition '%s'", *output.TaskDefinition.Family)
logger.Main.Info(color.Cyan(util.StringValueWithIndent(output.TaskDefinition, 1)))
}
}
}
func (self *ServiceController) ApplyServicePlans(plans []*plan.ServiceUpdatePlan) {
logger.Main.Info("Start apply serivces...")
for _, plan := range plans {
if err := self.ApplyServicePlan(plan); err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
}
}
func (self *ServiceController) RoundColorStatus(status string) *color.Escape {
if status == "RUNNING" {
return color.Green(status)
} else if status == "PENDING" {
return color.Yellow(status)
} else if status == "STOPPED" {
return color.Red(status)
} else {
return color.Magenta(status)
}
}
func doBluegreen(c *cli.Context) {
ecsManager, err := buildECSManager()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
operation, errSubCommand := createOperation(c.Args())
if errSubCommand != nil {
logger.Main.Error(color.Red(errSubCommand.Error()))
os.Exit(1)
}
projectDir, err := os.Getwd()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
bgController, errbgc := bluegreen.NewBlueGreenController(ecsManager, projectDir, operation.TargetResource)
if errbgc != nil {
logger.Main.Error(color.Red(errbgc.Error()))
os.Exit(1)
}
jsonOutput := c.Bool("json-output")
bgPlans, err := createBlueGreenPlans(bgController, jsonOutput)
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
// cluster check
if operation.SubCommand == "apply" {
nodeploy := c.Bool("nodeploy")
if len(bgPlans) > 0 {
errbg := bgController.ApplyBlueGreenDeploys(bgPlans, nodeploy)
if errbg != nil {
logger.Main.Error(color.Red(errbg.Error()))
os.Exit(1)
}
} else {
logger.Main.Infof("Not found Blue Green Definition")
if len(operation.TargetResource) > 0 && !nodeploy {
logger.Main.Infof("Try to update service '%s'", operation.TargetResource)
doService(c)
}
}
}
}
func doTask(c *cli.Context) {
ecsManager, err := buildECSManager()
if err != nil {
fmt.Fprintf(os.Stderr, "[ERROR]%s\n", color.Red(err.Error()))
os.Exit(1)
}
operation, errSubCommand := createOperation(c.Args())
if errSubCommand != nil {
fmt.Fprintf(os.Stderr, "[ERROR]%s\n", color.Red(errSubCommand.Error()))
os.Exit(1)
}
projectDir, err := os.Getwd()
if err != nil {
panic(err)
}
// plan
taskController := &task.TaskDefinitionController{
Ecs: ecsManager,
TargetResource: operation.TargetResource,
}
plans := createTaskPlans(taskController, projectDir)
if operation.SubCommand == "apply" {
results := taskController.ApplyTaskDefinitionPlans(plans)
for _, output := range results {
fmt.Printf("Registered Task Definition '%s'", *output.TaskDefinition.Family)
fmt.Print(color.Cyan(util.StringValueWithIndent(output.TaskDefinition, 1)))
}
}
}
func doService(c *cli.Context) {
ecsManager, err := buildECSManager()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
operation, errSubCommand := createOperation(c.Args())
if errSubCommand != nil {
logger.Main.Error(color.Red(errSubCommand.Error()))
os.Exit(1)
}
projectDir, err := os.Getwd()
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
jsonOutput := c.Bool("json-output")
clusterController, err := service.NewServiceController(ecsManager, projectDir, operation.TargetResource)
plans, err := createClusterPlans(clusterController, projectDir, jsonOutput)
if err != nil {
logger.Main.Error(color.Red(err.Error()))
os.Exit(1)
}
if operation.SubCommand == "apply" {
clusterController.ApplyServicePlans(plans)
}
}
func (self *ClusterControler) CreateClusterUpdatePlan(cluster schema.Cluster) *plan.ClusterUpdatePlan {
output, err := self.Ecs.DescribeClusters([]*string{&cluster.Name})
if err != nil {
fmt.Fprintln(os.Stderr, color.Red("[ERROR] discribe_cluster"))
os.Exit(1)
}
if len(output.Failures) > 0 {
fmt.Fprintln(os.Stderr, color.Red(fmt.Sprintf("[ERROR] Cluster '%s' not found", cluster.Name)))
os.Exit(1)
}
target := output.Clusters[0]
if *target.Status != "ACTIVE" {
fmt.Fprintln(os.Stderr, color.Red(fmt.Sprintf("[ERROR] Cluster '%s' is not ACTIVE.", cluster.Name)))
os.Exit(1)
}
resListServices, _ := self.Ecs.ListServices(cluster.Name)
resDescribeService, _ := self.Ecs.DescribeService(cluster.Name, resListServices.ServiceARNs)
currentServices := map[string]*ecs.Service{}
for _, service := range resDescribeService.Services {
currentServices[*service.ServiceName] = service
}
deleteServices := map[string]*ecs.Service{}
updateServices := map[string]*plan.UpdateService{}
for name, currentService := range currentServices {
if newService, ok := cluster.Services[name]; ok {
// update
updateServices[name] = &plan.UpdateService{
Before: currentService,
After: &newService,
}
} else {
// delete
deleteServices[name] = currentService
}
}
newServices := map[string]*schema.Service{}
for name, newService := range cluster.Services {
if _, ok := currentServices[name]; !ok {
// create
newServices[name] = &newService
}
}
return &plan.ClusterUpdatePlan{
Name: cluster.Name,
CurrentServices: currentServices,
DeleteServices: deleteServices,
UpdateServices: updateServices,
NewServices: newServices,
}
}