Skip to content

Commit 3c90d17

Browse files
author
Daniel Kang
authored
Merge pull request #23 from coldbrewcloud/status
Adding load balancer info to `status` command
2 parents a3cf5f6 + 41feef6 commit 3c90d17

5 files changed

Lines changed: 197 additions & 147 deletions

File tree

‎VERSION‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1 +1 @@
1-
1.3.0
1+
1.3.1

‎aws/elb/client.go‎

Lines changed: 24 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,30 @@ func (c *Client) CreateLoadBalancer(elbName string, internetFacing bool, securit
4242
return res.LoadBalancers[0], nil
4343
}
4444

45-
func (c *Client) RetrieveLoadBalancer(elbName string) (*_elb.LoadBalancer, error) {
45+
func (c *Client) RetrieveLoadBalancer(elbARN string) (*_elb.LoadBalancer, error) {
46+
params := &_elb.DescribeLoadBalancersInput{
47+
LoadBalancerArns: _aws.StringSlice([]string{elbARN}),
48+
}
49+
res, err := c.svc.DescribeLoadBalancers(params)
50+
if err != nil {
51+
if awsErr, ok := err.(awserr.Error); ok {
52+
if awsErr.Code() == "LoadBalancerNotFound" {
53+
return nil, nil
54+
}
55+
}
56+
return nil, err
57+
}
58+
59+
if len(res.LoadBalancers) == 0 {
60+
return nil, nil
61+
} else if len(res.LoadBalancers) == 1 {
62+
return res.LoadBalancers[0], nil
63+
}
64+
65+
return nil, fmt.Errorf("Invalid result: %v", res.LoadBalancers)
66+
}
67+
68+
func (c *Client) RetrieveLoadBalancerByName(elbName string) (*_elb.LoadBalancer, error) {
4669
params := &_elb.DescribeLoadBalancersInput{
4770
Names: _aws.StringSlice([]string{elbName}),
4871
}

‎commands/delete/command.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ func (c *Command) Run() error {
7272

7373
// ELB Load Balancer
7474
elbLoadBalancerName := conv.S(conf.AWS.ELBLoadBalancerName)
75-
elbLoadBalancer, err := c.awsClient.ELB().RetrieveLoadBalancer(elbLoadBalancerName)
75+
elbLoadBalancer, err := c.awsClient.ELB().RetrieveLoadBalancerByName(elbLoadBalancerName)
7676
if err != nil {
7777
return console.ExitWithErrorString("Failed to retrieve ELB Load Balancer [%s]: %s", elbLoadBalancerName, err.Error())
7878
}

‎commands/deploy/aws_elb.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@ func (c *Command) prepareELBLoadBalancer(ecsServiceRoleName, ecsTaskContainerNam
2424
}
2525

2626
// Check if specified ELB Load Balancer exists or not.
27-
elbLoadBalancer, err := c.awsClient.ELB().RetrieveLoadBalancer(elbLoadBalancerName)
27+
elbLoadBalancer, err := c.awsClient.ELB().RetrieveLoadBalancerByName(elbLoadBalancerName)
2828
if err != nil {
2929
return nil, fmt.Errorf("Failed to retrieve ELB Load Balancer [%s]: %s", elbLoadBalancerName, err.Error())
3030
}

‎commands/status/command.go‎

Lines changed: 170 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -72,173 +72,200 @@ func (c *Command) Run() error {
7272

7373
// ECS
7474
console.Info("ECS")
75-
{
76-
// ECS cluster
77-
ecsClusterName := core.DefaultECSClusterName(clusterName)
78-
ecsCluster, err := c.awsClient.ECS().RetrieveCluster(ecsClusterName)
79-
if err != nil {
80-
return console.ExitWithErrorString("Failed to retrieve ECS Cluster [%s]: %s", ecsClusterName, err.Error())
81-
}
82-
if ecsCluster == nil || conv.S(ecsCluster.Status) != "ACTIVE" {
83-
console.DetailWithResourceNote("ECS Cluster", ecsClusterName, "(not found)", true)
84-
ecsCluster = nil
85-
} else {
86-
console.DetailWithResource("ECS Cluster", ecsClusterName)
87-
}
8875

89-
// ECS Task Definition
90-
ecsTaskDefinitionName := core.DefaultECSTaskDefinitionName(appName)
91-
ecsTaskDefinition, err := c.awsClient.ECS().RetrieveTaskDefinition(ecsTaskDefinitionName)
92-
if err != nil {
93-
return console.ExitWithErrorString("Failed to retrieve ECS Task Definition [%s]: %s", ecsTaskDefinitionName, err.Error())
94-
}
95-
if ecsTaskDefinition == nil {
96-
console.DetailWithResourceNote("ECS Task Definition", ecsTaskDefinitionName, "(not found)", true)
97-
} else {
98-
console.DetailWithResource("ECS Task Definition",
99-
fmt.Sprintf("%s:%d", conv.S(ecsTaskDefinition.Family), conv.I64(ecsTaskDefinition.Revision)))
100-
}
76+
// ECS cluster
77+
ecsClusterName := core.DefaultECSClusterName(clusterName)
78+
ecsCluster, err := c.awsClient.ECS().RetrieveCluster(ecsClusterName)
79+
if err != nil {
80+
return console.ExitWithErrorString("Failed to retrieve ECS Cluster [%s]: %s", ecsClusterName, err.Error())
81+
}
82+
if ecsCluster == nil || conv.S(ecsCluster.Status) != "ACTIVE" {
83+
console.DetailWithResourceNote("ECS Cluster", ecsClusterName, "(not found)", true)
84+
return nil // stop here
85+
} else {
86+
console.DetailWithResource("ECS Cluster", ecsClusterName)
87+
}
10188

102-
// ECS Service
103-
ecsServiceActive := false
104-
ecsServiceName := core.DefaultECSServiceName(appName)
105-
if ecsCluster != nil {
106-
ecsService, err := c.awsClient.ECS().RetrieveService(ecsClusterName, ecsServiceName)
107-
if err != nil {
108-
return console.ExitWithErrorString("Failed to retrieve ECS Service [%s]: %s", ecsServiceName, err.Error())
109-
}
110-
if ecsService == nil {
111-
console.DetailWithResourceNote("ECS Service", ecsServiceName, "(not found)", true)
112-
} else if conv.S(ecsService.Status) == "ACTIVE" {
113-
ecsServiceActive = true
114-
console.DetailWithResource("ECS Service", ecsServiceName)
115-
} else {
116-
console.DetailWithResourceNote("ECS Service", ecsServiceName, fmt.Sprintf("(%s)", conv.S(ecsService.Status)), true)
117-
ecsService = nil
89+
// ECS Service
90+
ecsServiceName := core.DefaultECSServiceName(appName)
91+
ecsService, err := c.awsClient.ECS().RetrieveService(ecsClusterName, ecsServiceName)
92+
if err != nil {
93+
return console.ExitWithErrorString("Failed to retrieve ECS Service [%s]: %s", ecsServiceName, err.Error())
94+
}
95+
if ecsService == nil {
96+
console.DetailWithResourceNote("ECS Service", ecsServiceName, "(not found)", true)
97+
return nil // stop here
98+
} else if conv.S(ecsService.Status) == "ACTIVE" {
99+
console.DetailWithResource("ECS Service", ecsServiceName)
100+
} else {
101+
console.DetailWithResourceNote("ECS Service", ecsServiceName, fmt.Sprintf("(%s)", conv.S(ecsService.Status)), true)
102+
return nil // stop here
103+
}
104+
105+
// ECS Task Definition
106+
ecsTaskDefinitionName := conv.S(ecsService.TaskDefinition)
107+
ecsTaskDefinition, err := c.awsClient.ECS().RetrieveTaskDefinition(ecsTaskDefinitionName)
108+
if err != nil {
109+
return console.ExitWithErrorString("Failed to retrieve ECS Task Definition [%s]: %s", ecsTaskDefinitionName, err.Error())
110+
}
111+
if ecsTaskDefinition == nil {
112+
console.DetailWithResourceNote("ECS Task Definition", ecsTaskDefinitionName, "(not found)", true)
113+
return nil // stop here
114+
} else {
115+
console.DetailWithResource("ECS Task Definition",
116+
fmt.Sprintf("%s:%d", conv.S(ecsTaskDefinition.Family), conv.I64(ecsTaskDefinition.Revision)))
117+
}
118+
119+
// Tasks count / status
120+
isDeploying := false
121+
if ecsService.Deployments != nil {
122+
for _, d := range ecsService.Deployments {
123+
switch conv.S(d.Status) {
124+
case "ACTIVE":
125+
isDeploying = true
126+
case "PRIMARY":
118127
}
128+
}
129+
}
130+
if isDeploying {
131+
console.DetailWithResourceNote("Tasks (current/desired/pending)", fmt.Sprintf("%d/%d/%d",
132+
conv.I64(ecsService.RunningCount),
133+
conv.I64(ecsService.DesiredCount),
134+
conv.I64(ecsService.PendingCount)),
135+
"(deploying)", true)
136+
} else {
137+
console.DetailWithResource("Tasks (current/desired/pending)", fmt.Sprintf("%d/%d/%d",
138+
conv.I64(ecsService.RunningCount),
139+
conv.I64(ecsService.DesiredCount),
140+
conv.I64(ecsService.PendingCount)))
141+
}
119142

120-
// ECS Service Details
121-
if ecsService != nil {
122-
for _, lb := range ecsService.LoadBalancers {
123-
elbTargetGroup, err := c.awsClient.ELB().RetrieveTargetGroup(conv.S(lb.TargetGroupArn))
124-
if err != nil {
125-
return console.ExitWithErrorString("Failed to retrieve ELB Target Group [%s]: %s", conv.S(lb.TargetGroupArn), err.Error())
126-
}
143+
// Container Definition
144+
for _, containerDefinition := range ecsTaskDefinition.ContainerDefinitions {
145+
console.Info("Container Definition")
127146

128-
console.DetailWithResource("ELB Target Group", fmt.Sprintf("%s:%d",
129-
conv.S(elbTargetGroup.TargetGroupName),
130-
conv.I64(lb.ContainerPort)))
131-
}
147+
console.DetailWithResource("Name", conv.S(containerDefinition.Name))
148+
console.DetailWithResource("Image", conv.S(containerDefinition.Image))
132149

133-
isDeploying := false
134-
if ecsService.Deployments != nil {
135-
for _, d := range ecsService.Deployments {
136-
switch conv.S(d.Status) {
137-
case "ACTIVE":
138-
isDeploying = true
139-
case "PRIMARY":
140-
}
141-
}
142-
}
150+
cpu := float64(conv.I64(containerDefinition.Cpu)) / 1024.0
151+
console.DetailWithResource("CPU", fmt.Sprintf("%.2f", cpu))
143152

144-
if isDeploying {
145-
console.DetailWithResourceNote("Tasks (current/desired/pending)", fmt.Sprintf("%d/%d/%d",
146-
conv.I64(ecsService.RunningCount),
147-
conv.I64(ecsService.DesiredCount),
148-
conv.I64(ecsService.PendingCount)),
149-
"(deploying)", true)
150-
} else {
151-
console.DetailWithResource("Tasks (current/desired/pending)", fmt.Sprintf("%d/%d/%d",
152-
conv.I64(ecsService.RunningCount),
153-
conv.I64(ecsService.DesiredCount),
154-
conv.I64(ecsService.PendingCount)))
155-
}
156-
}
153+
memory := conv.I64(containerDefinition.Memory)
154+
console.DetailWithResource("Memory", fmt.Sprintf("%dm", memory))
155+
156+
for _, pm := range containerDefinition.PortMappings {
157+
console.DetailWithResource("Port Mapping (protocol:container:host)", fmt.Sprintf("%s:%d:%d",
158+
conv.S(pm.Protocol), conv.I64(pm.ContainerPort), conv.I64(pm.HostPort)))
157159
}
158160

159-
// Container Definition
160-
if ecsServiceActive && ecsTaskDefinition != nil {
161-
for _, containerDefinition := range ecsTaskDefinition.ContainerDefinitions {
162-
console.Info("Container Definition")
161+
for _, ev := range containerDefinition.Environment {
162+
console.DetailWithResource("Env", fmt.Sprintf("%s=%s",
163+
conv.S(ev.Name), conv.S(ev.Value)))
164+
}
165+
}
166+
167+
// Tasks
168+
taskARNs, err := c.awsClient.ECS().ListServiceTaskARNs(ecsClusterName, ecsServiceName)
169+
if err != nil {
170+
return console.ExitWithErrorString("Failed to list ECS Tasks for ECS Service [%s]: %s", ecsServiceName, err.Error())
171+
}
172+
tasks, err := c.awsClient.ECS().RetrieveTasks(ecsClusterName, taskARNs)
173+
if err != nil {
174+
return console.ExitWithErrorString("Failed to retrieve ECS Tasks for ECS Service [%s]: %s", ecsServiceName, err.Error())
175+
}
176+
177+
// retrieve container instance info
178+
containerInstanceARNs := []string{}
179+
for _, task := range tasks {
180+
containerInstanceARNs = append(containerInstanceARNs, conv.S(task.ContainerInstanceArn))
181+
}
182+
containerInstances, err := c.awsClient.ECS().RetrieveContainerInstances(ecsClusterName, containerInstanceARNs)
183+
if err != nil {
184+
return console.ExitWithErrorString("Failed to retrieve ECS Container Instances: %s", err.Error())
185+
}
163186

164-
console.DetailWithResource("Name", conv.S(containerDefinition.Name))
165-
console.DetailWithResource("Image", conv.S(containerDefinition.Image))
187+
// retrieve EC2 Instance info
188+
ec2InstanceIDs := []string{}
189+
for _, ci := range containerInstances {
190+
ec2InstanceIDs = append(ec2InstanceIDs, conv.S(ci.Ec2InstanceId))
191+
}
192+
ec2Instances, err := c.awsClient.EC2().RetrieveInstances(ec2InstanceIDs)
193+
if err != nil {
194+
return console.ExitWithErrorString("Failed to retrieve EC2 Instances: %s", err.Error())
195+
}
166196

167-
cpu := float64(conv.I64(containerDefinition.Cpu)) / 1024.0
168-
console.DetailWithResource("CPU", fmt.Sprintf("%.2f", cpu))
197+
for _, task := range tasks {
198+
console.Info("ECS Task")
169199

170-
memory := conv.I64(containerDefinition.Memory)
171-
console.DetailWithResource("Memory", fmt.Sprintf("%dm", memory))
200+
taskDefinition := aws.GetECSTaskDefinitionFamilyAndRevisionFromARN(conv.S(task.TaskDefinitionArn))
201+
console.DetailWithResource("Task Definition", taskDefinition)
172202

173-
for _, pm := range containerDefinition.PortMappings {
174-
console.DetailWithResource("Port Mapping (protocol:container:host)", fmt.Sprintf("%s:%d:%d",
175-
conv.S(pm.Protocol), conv.I64(pm.ContainerPort), conv.I64(pm.HostPort)))
176-
}
203+
console.DetailWithResource("Status (current/desired)", fmt.Sprintf("%s/%s",
204+
conv.S(task.LastStatus), conv.S(task.DesiredStatus)))
177205

178-
for _, ev := range containerDefinition.Environment {
179-
console.DetailWithResource("Env", fmt.Sprintf("%s=%s",
180-
conv.S(ev.Name), conv.S(ev.Value)))
206+
for _, ci := range containerInstances {
207+
if conv.S(task.ContainerInstanceArn) == conv.S(ci.ContainerInstanceArn) {
208+
console.DetailWithResource("EC2 Instance ID", conv.S(ci.Ec2InstanceId))
209+
210+
for _, ec2Instance := range ec2Instances {
211+
if conv.S(ci.Ec2InstanceId) == conv.S(ec2Instance.InstanceId) {
212+
if !utils.IsBlank(conv.S(ec2Instance.PrivateIpAddress)) {
213+
console.DetailWithResource(" Private IP", conv.S(ec2Instance.PrivateIpAddress))
214+
}
215+
if !utils.IsBlank(conv.S(ec2Instance.PublicIpAddress)) {
216+
console.DetailWithResource(" Public IP", conv.S(ec2Instance.PublicIpAddress))
217+
}
218+
break
219+
}
181220
}
221+
break
182222
}
183223
}
224+
}
184225

185-
// Tasks
186-
if ecsServiceActive {
187-
// retrieve ECS tasks info
188-
taskARNs, err := c.awsClient.ECS().ListServiceTaskARNs(ecsClusterName, ecsServiceName)
189-
if err != nil {
190-
return console.ExitWithErrorString("Failed to list ECS Tasks for ECS Service [%s]: %s", ecsServiceName, err.Error())
191-
}
192-
tasks, err := c.awsClient.ECS().RetrieveTasks(ecsClusterName, taskARNs)
193-
if err != nil {
194-
return console.ExitWithErrorString("Failed to retrieve ECS Tasks for ECS Service [%s]: %s", ecsServiceName, err.Error())
195-
}
226+
// Load Balancer
227+
if ecsService.LoadBalancers != nil && len(ecsService.LoadBalancers) > 0 {
228+
for _, lb := range ecsService.LoadBalancers {
229+
console.Info("Load Balancer")
196230

197-
// retrieve container instance info
198-
containerInstanceARNs := []string{}
199-
for _, task := range tasks {
200-
containerInstanceARNs = append(containerInstanceARNs, conv.S(task.ContainerInstanceArn))
201-
}
202-
containerInstances, err := c.awsClient.ECS().RetrieveContainerInstances(ecsClusterName, containerInstanceARNs)
231+
elbTargetGroup, err := c.awsClient.ELB().RetrieveTargetGroup(conv.S(lb.TargetGroupArn))
203232
if err != nil {
204-
return console.ExitWithErrorString("Failed to retrieve ECS Container Instances: %s", err.Error())
233+
return console.ExitWithErrorString("Failed to retrieve ELB Target Group [%s]: %s", conv.S(lb.TargetGroupArn), err.Error())
205234
}
206235

207-
// retrieve EC2 Instance info
208-
ec2InstanceIDs := []string{}
209-
for _, ci := range containerInstances {
210-
ec2InstanceIDs = append(ec2InstanceIDs, conv.S(ci.Ec2InstanceId))
211-
}
212-
ec2Instances, err := c.awsClient.EC2().RetrieveInstances(ec2InstanceIDs)
213-
if err != nil {
214-
return console.ExitWithErrorString("Failed to retrieve EC2 Instances: %s", err.Error())
215-
}
236+
console.DetailWithResource("Container Port", fmt.Sprintf("%d", conv.I64(lb.ContainerPort)))
237+
console.DetailWithResource("ELB Target Group", conv.S(elbTargetGroup.TargetGroupName))
216238

217-
for _, task := range tasks {
218-
console.Info("ECS Task")
219-
220-
taskDefinition := aws.GetECSTaskDefinitionFamilyAndRevisionFromARN(conv.S(task.TaskDefinitionArn))
221-
console.DetailWithResource("Task Definition", taskDefinition)
222-
223-
console.DetailWithResource("Status (current/desired)", fmt.Sprintf("%s/%s",
224-
conv.S(task.LastStatus), conv.S(task.DesiredStatus)))
225-
226-
for _, ci := range containerInstances {
227-
if conv.S(task.ContainerInstanceArn) == conv.S(ci.ContainerInstanceArn) {
228-
console.DetailWithResource("EC2 Instance ID", conv.S(ci.Ec2InstanceId))
229-
230-
for _, ec2Instance := range ec2Instances {
231-
if conv.S(ci.Ec2InstanceId) == conv.S(ec2Instance.InstanceId) {
232-
if !utils.IsBlank(conv.S(ec2Instance.PrivateIpAddress)) {
233-
console.DetailWithResource(" Private IP", conv.S(ec2Instance.PrivateIpAddress))
234-
}
235-
if !utils.IsBlank(conv.S(ec2Instance.PublicIpAddress)) {
236-
console.DetailWithResource(" Public IP", conv.S(ec2Instance.PublicIpAddress))
237-
}
238-
break
239-
}
239+
if elbTargetGroup.LoadBalancerArns != nil {
240+
for _, elbARN := range elbTargetGroup.LoadBalancerArns {
241+
elbLoadBalancer, err := c.awsClient.ELB().RetrieveLoadBalancer(conv.S(elbARN))
242+
if err != nil {
243+
return console.ExitWithErrorString("Failed to retrieve ELB Load Balancer [%s]: %s", elbARN, err.Error())
244+
}
245+
246+
console.DetailWithResource("ELB Load Balancer", conv.S(elbLoadBalancer.LoadBalancerName))
247+
console.DetailWithResource(" Scheme", conv.S(elbLoadBalancer.Scheme))
248+
//console.DetailWithResource(" DNS", conv.S(elbLoadBalancer.DNSName))
249+
if elbLoadBalancer.State != nil {
250+
console.DetailWithResource(" State", fmt.Sprintf("%s %s",
251+
conv.S(elbLoadBalancer.State.Code),
252+
conv.S(elbLoadBalancer.State.Reason)))
253+
}
254+
255+
// listeners
256+
listeners, err := c.awsClient.ELB().RetrieveLoadBalancerListeners(conv.S(elbARN))
257+
if err != nil {
258+
return console.ExitWithErrorString("Failed to retrieve Listeners for ELB Load Balancer [%s]: %s", elbARN, err.Error())
259+
}
260+
for _, listener := range listeners {
261+
if listener.DefaultActions != nil &&
262+
len(listener.DefaultActions) > 0 &&
263+
conv.S(listener.DefaultActions[0].TargetGroupArn) == conv.S(elbTargetGroup.TargetGroupArn) {
264+
console.DetailWithResource(" Endpoint", fmt.Sprintf("%s://%s:%d",
265+
strings.ToLower(conv.S(listener.Protocol)),
266+
conv.S(elbLoadBalancer.DNSName),
267+
conv.I64(listener.Port)))
240268
}
241-
break
242269
}
243270
}
244271
}

0 commit comments

Comments
 (0)