bbc-cosmos-tools 0.5.2 → 0.6.0

data/lib/bbc/cosmos/tools/commands/release.rb

@@ -1,8 +1,8 @@
-require 'json'
-require 'pathname'
-require 'bbc/cosmos/tools/commands/base'
-require 'bbc/cosmos/tools/cosmos_configuration'
-require 'bbc/cosmos/tools/api'
+require "json"
+require "pathname"
+require "bbc/cosmos/tools/commands/base"
+require "bbc/cosmos/tools/cosmos_configuration"
+require "bbc/cosmos/tools/api"
 
 module BBC
   module Cosmos
@@ -15,168 +15,156 @@ module BBC
 
           def initialize(args = [], local_options = {}, thor_config = {})
             super(args, local_options, thor_config)
-            @api = BBC::Cosmos::Tools::API.new(config.app['api'], options[:key_path])
+            @api = BBC::Cosmos::Tools::API.new(config.app["api"], options[:key_path])
           end
 
           method_option :tags, :type => :array, :default => nil
           desc "release list [COMPONENT = nil]", "Lists releases for a component"
           def list(component = nil)
-            begin
+            say banner
 
-              say banner
+            components(options, component).each do |id|
+              response = api.get sprintf(config.app["release"], id)
+              say get_key_value("\nComponent", id)
 
-              components(options, component).each do |id|
-
-                response = api.get sprintf(config.app['release'], id)
-                say get_key_value("\nComponent", id)
-
-                if response.success?
-                  data = []
-                  JSON.parse(response.body)['releases'].slice!(0, options[:limit]).map do |release|
-                    data << [release['version'], release['created_at']]
-                  end
-
-                  print_table(
-                    build_table(['Version', 'Created at'], data)
-                  )
-                  say "\n"
-                else
-                  api_error response
+              if response.success?
+                data = []
+                JSON.parse(response.body)["releases"].slice!(0, options[:limit]).map do |release|
+                  data << [release["version"], release["created_at"]]
                 end
-              end
 
-            rescue Exception => e
-              error e.message
+                print_table(
+                  build_table(["Version", "Created at"], data)
+                )
+                say "\n"
+              else
+                api_error response
+              end
             end
+
+          rescue Exception => e
+            error e.message
           end
 
           desc "release deploy [COMPONENT = nil, RELEASE_ID = nil]", "Deploys a release to the specific enironment"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
-          method_option :from, :type => :string, :default => 'release', :desc => "The location that the deployment shold be taken from (release|int|test)"
+          method_option :from, :type => :string, :default => "release", :desc => "The location that the deployment shold be taken from (release|int|test)"
           def deploy(component = nil, release_id = nil)
+            say banner
+
+            components(options, component).each do |id|
+              begin
+
+                component_release = release_id
+                if release_id.nil?
+
+                  post_data = {}
+                  endpoint = config.app["deploy"]
+
+                  case options[:from]
+                  when "release"
+                    response = api.get sprintf(config.app["release"], id)
+                    api_error response unless response.success?
+                    component_release = JSON.parse(response.body)["releases"].first["version"]
+                    post_data = {
+                      "release_version" => component_release
+                    }
+                  when "int", "test", "live"
+
+                    endpoint = config.app["snapshot_deploy"]
+                    response = api.get sprintf(config.app["deployments"], id, options[:from])
+                    api_error response unless response.success?
+                    snapshot_id = JSON.parse(response.body).first["snapshot"]["snapshot_id"]
+                    post_data = {
+                      "snapshot_id" => snapshot_id
+                    }
 
-              say banner
-
-              components(options, component).each do |id|
-                begin
-
-                  component_release = release_id
-                  if release_id.nil?
-
-                    post_data = {}
-                    endpoint = config.app['deploy']
-
-                    case options[:from]
-                    when 'release'
-                      response = api.get sprintf(config.app['release'], id)
-                      api_error response unless response.success?
-                      component_release = JSON.parse(response.body)['releases'].first['version']
-                      post_data = {
-                        'release_version' => component_release
-                      }
-                    when 'int', 'test', 'live'
-
-                      endpoint = config.app['snapshot_deploy']
-                      response = api.get sprintf(config.app['deployments'], id, options[:from])
-                      api_error response unless response.success?
-                      snapshot_id = JSON.parse(response.body).first['snapshot']['snapshot_id']
-                      post_data = {
-                        'snapshot_id' => snapshot_id
-                      }
-
-                    else
-                      raise("Invalid location: #{options[:from]} to deploy from")
-                    end
+                  else
+                    fail("Invalid location: #{options[:from]} to deploy from")
                   end
+                end
 
-                  response = api.post sprintf(endpoint, options[:env], id), JSON.generate(post_data)
-
-                  if response.success?
+                response = api.post sprintf(endpoint, options[:env], id), JSON.generate(post_data)
 
-                    say get_key_value("\nComponent", id)
-                    say get_key_value("Version", post_data['snapshot_id'] ? post_data['snapshot_id'] : post_data['release_version'])
+                if response.success?
 
-                    data = JSON.parse(response.body)
-                    say "\nDeployment started successfully: #{config.app['api']}#{data['url']}\n", :green
+                  say get_key_value("\nComponent", id)
+                  say get_key_value("Version", post_data["snapshot_id"] ? post_data["snapshot_id"] : post_data["release_version"])
 
-                  else
-                    api_error response
-                  end
+                  data = JSON.parse(response.body)
+                  say "\nDeployment started successfully: #{config.app['api']}#{data['url']}\n", :green
 
-                rescue Exception => e
-                  error(e.message, false)
+                else
+                  api_error response
                 end
-              end
 
+              rescue Exception => e
+                error(e.message, false)
+              end
+            end
           end
 
           desc "release deployed [COMPONENT = nil]", "Lists releases deloyed for a component in the specified environment"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
           def deployed(component = nil)
-            begin
-
-              say banner
+            say banner
 
-              components(options, component).each do |id|
+            components(options, component).each do |id|
+              response = api.get sprintf(config.app["deployments"], id, options[:env])
+              say get_key_value("\nComponent", id)
 
-                response = api.get sprintf(config.app['deployments'], id, options[:env])
-                say get_key_value("\nComponent", id)
+              if response.success?
+                data = JSON.parse(response.body)
 
-                if response.success?
-                  data = JSON.parse(response.body)
-
-                  if data.empty?
-                    say "There are currently no deployments for this component", :yellow
-                  else
+                if data.empty?
+                  say "There are currently no deployments for this component", :yellow
+                else
 
-                    deployments = []
+                  deployments = []
 
-                    data.slice!(0, options[:limit].to_i).map do |release|
-                      deployments << [
-                        release['release']['version'],
-                        release['started_at'],
-                        release['id'],
-                        release['created_by']['email_address'],
-                        deploy_status(release['status'])
-                      ]
-                    end
+                  data.slice!(0, options[:limit].to_i).map do |release|
+                    deployments << [
+                      release["release"]["version"],
+                      release["started_at"],
+                      release["id"],
+                      release["created_by"]["email_address"],
+                      deploy_status(release["status"])
+                    ]
+                  end
 
-                    print_table(
-                      build_table(['Release', 'Deployed at', 'Deployment id', 'Deployed by', 'Status'], deployments)
-                    )
+                  print_table(
+                    build_table(["Release", "Deployed at", "Deployment id", "Deployed by", "Status"], deployments)
+                  )
 
-                    say "\n"
-                  end
-                else
-                  api_error response
+                  say "\n"
                 end
+              else
+                api_error response
               end
-
-            rescue Exception => e
-              error e.message
             end
+
+          rescue Exception => e
+            error e.message
           end
 
           private
 
           def deploy_status(status)
             case status
-            when 'pending_bake'
+            when "pending_bake"
               set_color(status, :yellow)
-            when 'pending_stack_update_resolution'
+            when "pending_stack_update_resolution"
               set_color(status, :yellow)
-            when 'done'
+            when "done"
               set_color(status, :green)
-            when 'failed'
+            when "failed"
               set_color(status, :red)
             else
               set_color(status, :white)
             end
           end
-
         end
       end
     end
   end
 end
-

data/lib/bbc/cosmos/tools/commands/stack.rb

@@ -1,7 +1,7 @@
 require "json"
 require "bbc/cosmos/tools/config"
-require 'bbc/cosmos/tools/commands/base'
-require 'bbc/cosmos/tools/cloudformation/generator'
+require "bbc/cosmos/tools/commands/base"
+require "bbc/cosmos/tools/cloudformation/generator"
 require "bbc/cosmos/tools/types/factory"
 
 module BBC
@@ -11,46 +11,44 @@ module BBC
         class Stack < Base
           attr_accessor :api
 
-          class_option :stack, :type => :string, :default => 'main', :desc => "The name of the stack to use"
-          class_option :type, :type => :string, :default => 'cfndsl', :desc => "The format of your your CloudFormation (default is cfndsl, but can also be json or yaml)", :enum => ["cfndsl", "json", "yaml"]
+          class_option :stack, :type => :string, :default => "main", :desc => "The name of the stack to use"
+          class_option :type, :type => :string, :default => "cfndsl", :desc => "The format of your your CloudFormation (default is cfndsl, but can also be json or yaml)", :enum => %w(cfndsl json yaml)
 
           def initialize(args = [], local_options = {}, thor_config = {})
             super(args, local_options, thor_config)
 
             @l = -> data, component, environment do
-              if data['Parameters'] && data['Parameters']['ImageId']
-                data['Parameters']['ImageId']['Default'] = latest_ami_for(component, environment)
+              if data["Parameters"] && data["Parameters"]["ImageId"]
+                data["Parameters"]["ImageId"]["Default"] = latest_ami_for(component, environment)
               end
             end
 
-            @api = BBC::Cosmos::Tools::API.new(config.app['api'], options[:key_path])
+            @api = BBC::Cosmos::Tools::API.new(config.app["api"], options[:key_path])
           end
 
           desc "stack list [COMPONENT = nil]", "Lists stacks for a component"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
           def list(component = nil)
-
             say "#{banner}\n"
 
             components(options, component).each do |id|
-
-              response = api.get sprintf(config.app['stacks'], options[:env], id)
+              response = api.get sprintf(config.app["stacks"], options[:env], id)
               say get_key_value("\nComponent", id)
 
               if response.success?
 
                 data = JSON.parse(response.body).map do |stack|
                   [
-                    stack['name'].split('-').last,
-                    stack['main_stack'],
-                    stack['updated_at'],
-                    stack['status']
+                    stack["name"].split("-").last,
+                    stack["main_stack"],
+                    stack["updated_at"],
+                    stack["status"]
                   ]
                 end
 
                 print_table(
                   build_table(
-                    ['Name', 'Main stack', 'Updated at', 'Status'],
+                    ["Name", "Main stack", "Updated at", "Status"],
                     data
                   )
                 )
@@ -61,61 +59,56 @@ module BBC
             end
           end
 
-          method_option :variant, :type => :string, :default => 'default', :desc => "The variant to use, i.e default|scheduled"
+          method_option :variant, :type => :string, :default => "default", :desc => "The variant to use, i.e default|scheduled"
           method_option :group, :type => :string, :default => nil, :desc => "The group name to override the component id"
           desc "stack generate [COMPONENT]", "Generates a cloudformation template based on a type of component, the identifier and the environment"
           def generate(component)
-
             say "#{banner(component)}\n"
 
             type = Tools::Types::Factory.create(component, options, config)
             data = type.generate_data true
             say data, :white
-
           end
 
-          method_option :variant, :type => :string, :default => 'default', :desc => "The variant to use, i.e default|scheduled"
+          method_option :variant, :type => :string, :default => "default", :desc => "The variant to use, i.e default|scheduled"
           method_option :group, :type => :string, :default => nil, :desc => "The group name to override the component id"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
           desc "stack create [COMPONENT, MAIN_STACK = true]", "Generates and create the cloudformation template for the specific component"
-          def create(component = nil, main_stack = 'true')
-            begin
-              say "#{banner}\n"
-
-              components(options, component).each do |id|
-                say get_key_value("\nComponent", id)
-
-                type       = Tools::Types::Factory.create(id, options, config)
-                data       = type.generate_data
-                stack_data = Tools::Cloudformation::Generator.component_stack_details(config.resources, options, id)
-
-                post_data = {
-                  'name_suffix'    => options[:stack],
-                  'service_stack'  => main_stack.match(/(true|t|yes|y|1)$/i) != nil,
-                  'template'       => data,
-                  'parameters'     => Tools::Cloudformation::Generator.parameters(data, main_stack),
-                }
+          def create(component = nil, main_stack = "true")
+            say "#{banner}\n"
 
-                post_data['aws_account_id'] = stack_data['account_id'] unless stack_data['account_id'].nil?
-                response = api.post sprintf(config.app['stack_create_endpoint'], options[:env], id), JSON.pretty_generate(post_data)
+            components(options, component).each do |id|
+              say get_key_value("\nComponent", id)
 
-                if response.success?
-                  say "Stack creation for component '#{component}' successfully started", :green
-                else
-                  api_error(response, false)
-                end
+              type       = Tools::Types::Factory.create(id, options, config)
+              data       = type.generate_data
+              stack_data = Tools::Cloudformation::Generator.component_stack_details(config.resources, options, id)
+
+              post_data = {
+                "name_suffix"   => options[:stack],
+                "service_stack" => !main_stack.match(/(true|t|yes|y|1)$/i).nil?,
+                "template"      => data,
+                "parameters"    => Tools::Cloudformation::Generator.parameters(data, main_stack)
+              }
+
+              post_data["aws_account_id"] = stack_data["account_id"] unless stack_data["account_id"].nil?
+              response = api.post sprintf(config.app["stack_create_endpoint"], options[:env], id), JSON.pretty_generate(post_data)
+
+              if response.success?
+                say "Stack creation for component '#{component}' successfully started", :green
+              else
+                api_error(response, false)
               end
-            rescue Exception => e
-                error e.message
             end
+          rescue Exception => e
+            error e.message
           end
 
-          method_option :variant, :type => :string, :default => 'default', :desc => "The variant to use, i.e default|scheduled"
+          method_option :variant, :type => :string, :default => "default", :desc => "The variant to use, i.e default|scheduled"
           method_option :group, :type => :string, :default => nil, :desc => "The group name to override the component id"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
           desc "stack update [COMPONENT = nil]", "Generates and updates the cloudformation template for the specific component"
           def update(component = nil)
-
             say "#{banner}\n"
 
             components(options, component).each do |id|
@@ -125,26 +118,26 @@ module BBC
 
               type = Tools::Types::Factory.create(id, options, config)
               data = type.generate_data.tap do |d|
-                @l.(d, id, options[:env])
+                @l.call(d, id, options[:env])
               end
 
               stack_meta = stack_data(component, stack_name, options[:env])
 
-              if data['Parameters']
-                data['Parameters'] = deep_merge(
-                  stack_parameters(stack_meta['parameters']),
-                  data['Parameters']
+              if data["Parameters"]
+                data["Parameters"] = deep_merge(
+                  stack_parameters(stack_meta["parameters"]),
+                  data["Parameters"]
                 )
 
                 params = Tools::Cloudformation::Generator.parameters(data, false)
               end
 
               post_data = {
-                'template'    => data,
-                'parameters'  => params || {}
+                "template"   => data,
+                "parameters" => params || {}
               }
 
-              response = api.post sprintf(config.app['stack_update_endpoint'], options[:env], id, stack_name), JSON.pretty_generate(post_data)
+              response = api.post sprintf(config.app["stack_update_endpoint"], options[:env], id, stack_name), JSON.pretty_generate(post_data)
 
               if response.success?
                 say "Stack update for component '#{id}' successfully started", :green
@@ -152,12 +145,10 @@ module BBC
                 api_error(response, false)
               end
             end
-
           end
 
           desc "stack delete [COMPONENT]", "Deletes a stack"
           def delete(component)
-
             say "#{banner(component)}\n"
 
             reply = yes?("Are you sure you want to delete the above stack?", :yellow)
@@ -165,7 +156,7 @@ module BBC
 
               stack_name = "#{options[:env]}-#{component}-#{options[:stack]}"
 
-              response = api.post sprintf(config.app['stack_delete'], options[:env], component, stack_name), JSON.pretty_generate({})
+              response = api.post sprintf(config.app["stack_delete"], options[:env], component, stack_name), JSON.pretty_generate({})
 
               if response.success?
                 say "Stack delete for component '#{component}' successfully started", :green
@@ -173,35 +164,33 @@ module BBC
                 api_error response
               end
             else
-              error 'Action cancelled'
+              error "Action cancelled"
             end
-
           end
 
           desc "stack events [COMPONENT = nil]", "Shows the stack events for a component"
-          method_option :stack, :type => :string, :default => 'main', :desc => "The name of the stack to use"
+          method_option :stack, :type => :string, :default => "main", :desc => "The name of the stack to use"
           method_option :limit, :type => :numeric, :default => 5, :desc => "Limit how many records to show"
           method_option :tags, :type => :array, :default => nil, :desc => "The tags of the components you want to deploy (i.e 'renderer')"
           def events(component = nil)
-
             say "#{banner}\n"
 
             components(options, component).each do |id|
               say get_key_value("\nComponent", id)
 
               stack_name = "#{options[:env]}-#{id}-#{options[:stack]}"
-              response = api.get sprintf(config.app['stack_events'], options[:env], id, stack_name)
+              response = api.get sprintf(config.app["stack_events"], options[:env], id, stack_name)
 
               if response.success?
                 events = JSON.parse(response.body)
 
-                data = events.slice(0,(options[:limit])).map do |event|
+                data = events.slice(0, (options[:limit])).map do |event|
                   event.split(" ")
                 end
 
                 print_table(
                   build_table(
-                    ['Event type', 'CF type', 'Name', 'Status'],
+                    ["Event type", "CF type", "Name", "Status"],
                     data
                   )
                 )
@@ -223,22 +212,21 @@ module BBC
             end
           end
 
-          def stack_data(component, stack_name, env = 'int')
-            response = api.get sprintf(config.app['stack_details'], env, component, stack_name)
+          def stack_data(component, stack_name, env = "int")
+            response = api.get sprintf(config.app["stack_details"], env, component, stack_name)
             JSON.parse(response.body)
           end
 
-          def latest_ami_for(component, env = 'int')
-            response = api.get sprintf(config.app['deployments'], component, env)
+          def latest_ami_for(component, env = "int")
+            response = api.get sprintf(config.app["deployments"], component, env)
             api_error response unless response.success?
-            JSON.parse(response.body).first['image']['ami_id']
+            JSON.parse(response.body).first["image"]["ami_id"]
           end
 
           def deep_merge(merger, mergee)
-            merge_proc = Proc.new { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merge_proc) : v2 }
+            merge_proc = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merge_proc) : v2 }
             merger.merge(mergee, &merge_proc)
           end
-
         end
       end
     end