ops_deploy 0.1.5 → 0.1.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1770134bbe27e803e4c5905c6bed626973443527
-  data.tar.gz: 97f6cd9f48cb327737fa4341e8ad3cee9d673dc8
+  metadata.gz: b9e5870d3c3aeb5b01f87a22fe89785712961b8e
+  data.tar.gz: b15265f789b33d983bdf903138975cc43ff6ac69
 SHA512:
-  metadata.gz: 49001ff3e7e53d504719b0d02e6a59d352bb627791c449126c7ccf38d400ebba51781c55cc625ce2e1e5e2a70f66242165ecebecd9d134a33b00ba354dbc5336
-  data.tar.gz: cca776e64f629e8e4c022f53f3505c62669120ba04f95fe90d3c13f225fc002b37284c46fdeca405102491c46672fa8da18786912a95455da2439a709476e012
+  metadata.gz: 33fc3e1de65d22f4c2effd84005923c3b032197b2cd701ecabdc032b84e55980040cdb62aea8b60aad74b4443ee8f2831e2f3ac0a1ca346b3478d2bdd1c290ca
+  data.tar.gz: 59f358f786dcb92d434c7c0cc9bd79737839d9f4641c74aeb633d1c97801435709b7344f30b3f74c6d86810b0adec924db930a345ba5b947936f4b504669be66

data/README.md

@@ -4,13 +4,13 @@ A simple gem to perform deployment & checks on AWS OpsWorks. You can deploy, wai
 
 ### Usage
 
-```
+```shell
 gem install ops_deploy
 ```
 
 In your code:
 
-```
+```ruby
 require 'ops_deploy'
 ops = OpsDeploy.new(aws_config)
 
@@ -19,25 +19,25 @@ success = ops.start_deployment(stack_id, app_id, migrate)
 
 # Wait for deployments (async)
 ops.deployments_callback = Proc.new {
-	|aws_deployment_obj|
-	# whatever
+  |aws_deployment_obj|
+  # whatever
 }
 a_thread = ops.wait_for_deployments(stack_id)
 a_thread.join
 
 # Check instances (async)
 ops.instances_check_callback = Proc.new {
-	|aws_instance_obj, http_response, exception|
-	# whatever
+  |aws_instance_obj, http_response, exception|
+  # whatever
 }
-a_thread = ops.check_instances(stack_id).join
+a_thread = ops.check_instances(stack_id)
 a_thread.join
 
 ```
 
 or using the CLI:
 
-```
+```shell
 opsdeploy <tasks> --aws-region=<aws_region> --aws-profile=<...> --stack=<stack_name_or_id> --slack-webhook-url=<...> --slack-username=<...> --slack-channel=<...>
 ```
 
@@ -50,7 +50,7 @@ The tasks are:
 
 Example:
 
-```
+```shell
 opsdeploy deploy wait check --stack="Example" --aws-region="us-east-1"
 ```
 

data/bin/opsdeploy

@@ -4,19 +4,22 @@ require 'ops_deploy'
 
 cli = OpsDeploy::CLI.new
 
-if OpsDeploy::CLI.argument("server")
+if OpsDeploy::CLI.argument('server')
   cli.start_server
-elsif OpsDeploy::CLI.argument("check-server")
+elsif OpsDeploy::CLI.argument('check-server')
   puts "The 'check-server' argument is deprecated. Please use 'server'."
   cli.start_server
 else
-  stack = OpsDeploy::CLI.argument("stack", "STACK_ID")
-  app_id = OpsDeploy::CLI.argument("app-id", "APP_ID")
-  migrate = OpsDeploy::CLI.argument("migrate")
-  check_via_proxy = OpsDeploy::CLI.argument("check-via-proxy")
-  wait_via_proxy = OpsDeploy::CLI.argument("wait-via-proxy")
+  stack = OpsDeploy::CLI.argument('stack', 'STACK_ID')
+  app_id = OpsDeploy::CLI.argument('app-id', 'APP_ID')
+  deploy = OpsDeploy::CLI.argument('deploy')
+  migrate = OpsDeploy::CLI.argument('migrate')
+  check = OpsDeploy::CLI.argument('check')
+  check_via_proxy = OpsDeploy::CLI.argument('check-via-proxy')
+  wait = OpsDeploy::CLI.argument('wait')
+  wait_via_proxy = OpsDeploy::CLI.argument('wait-via-proxy')
 
-  cli.start_deployment(stack, app_id, migrate) if OpsDeploy::CLI.argument("deploy")
-  cli.wait_for_deployments(stack, wait_via_proxy) if OpsDeploy::CLI.argument("wait") || wait_via_proxy
-  cli.check_instances(stack, check_via_proxy) if OpsDeploy::CLI.argument("check") || check_via_proxy
+  cli.start_deployment(stack, app_id, migrate) if deploy
+  cli.wait_for_deployments(stack, wait_via_proxy) if wait || wait_via_proxy
+  cli.check_instances(stack, check_via_proxy) if check || check_via_proxy
 end

data/lib/ops_deploy/cli/notifier.rb

@@ -1,3 +1,4 @@
+# Notifier
 class OpsDeploy::CLI::Notifier
   attr_accessor :options
   attr_accessor :messages
@@ -5,7 +6,7 @@ class OpsDeploy::CLI::Notifier
 
   def initialize(options)
     @options = options
-    @options.delete(:slack) if @options[:slack].nil? or @options[:slack][:webhook_url].nil?
+    @options.delete(:slack) if @options[:slack].nil? || @options[:slack][:webhook_url].nil?
     @messages = OpsDeploy::CLI::Notifier::Messages.new
     @notification_type = :info
   end
@@ -24,15 +25,24 @@ class OpsDeploy::CLI::Notifier
   end
 
   def info_notify(stack, message)
-    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).notify(message) if @options[:slack]
+    return unless @options[:slack]
+
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack])
+      .notify(message)
   end
 
   def success_notify(stack, message)
-    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).success_notify(message) if @options[:slack]
+    return unless @options[:slack]
+
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack])
+      .success_notify(message)
   end
 
   def failure_notify(stack, message)
-    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).failure_notify(message) if @options[:slack]
+    return unless @options[:slack]
+
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack])
+      .failure_notify(message) if @options[:slack]
   end
 
   def reset
@@ -41,6 +51,7 @@ class OpsDeploy::CLI::Notifier
   end
 end
 
+# A messages container class
 class OpsDeploy::CLI::Notifier::Messages
   attr_accessor :info, :success, :failure
 
@@ -51,22 +62,24 @@ class OpsDeploy::CLI::Notifier::Messages
   end
 end
 
+# A generic notification class from which all notification services will inherit
 class OpsDeploy::CLI::Notifier::Generic
 end
 
+# A notification class for Slack
 class OpsDeploy::CLI::Notifier::Slack < OpsDeploy::CLI::Notifier::Generic
   attr_accessor :slack_notifier
 
   def initialize(stack, options)
     @stack = stack
     @options = options
-    @options[:username] = "OpsDeploy" unless @options[:username]
+    @options[:username] = 'OpsDeploy' unless @options[:username]
     @slack_notifier = Slack::Notifier.new @options[:webhook_url], @options
   end
 
   def notify(message)
-    message = message.gsub(/\[[0-9;]+?m/, "")
-    @slack_notifier.ping "", channel: @options[:channel], attachments: [
+    message = message.gsub(/\[[0-9;]+?m/, '')
+    @slack_notifier.ping '', channel: @options[:channel], attachments: [
       {
         fallback: message,
         author_name: @stack.name,
@@ -77,33 +90,35 @@ class OpsDeploy::CLI::Notifier::Slack < OpsDeploy::CLI::Notifier::Generic
   end
 
   def success_notify(message)
-    message = message.gsub(/\[[0-9;]+?m/, "")
-    @slack_notifier.ping "", channel: @options[:channel], attachments: [
+    message = message.gsub(/\[[0-9;]+?m/, '')
+    @slack_notifier.ping '', channel: @options[:channel], attachments: [
       {
         fallback: message,
         text: message,
         author_name: @stack.name,
         author_link: stack_link(@stack),
-        color: "good"
+        color: 'good'
       }
     ]
   end
 
   def failure_notify(message)
-    message = message.gsub(/\[[0-9;]+?m/, "")
-    @slack_notifier.ping "", channel: @options[:channel], attachments: [
+    message = message.gsub(/\[[0-9;]+?m/, '')
+    @slack_notifier.ping '', channel: @options[:channel], attachments: [
       {
         fallback: message,
         text: "#{message} <!channel>",
         author_name: @stack.name,
         author_link: stack_link(@stack),
-        color: "danger"
+        color: 'danger'
       }
     ]
   end
 
   def stack_link(stack)
-    region = OpsDeploy::CLI.argument("aws-region", "AWS_REGION") || "us-east-1"
-    "https://console.aws.amazon.com/opsworks/home?region=#{region}#/stack/#{stack.stack_id}/stack"
+    region = OpsDeploy::CLI.argument('aws-region', 'AWS_REGION') || 'us-east-1'
+    params = "?region=#{region}#/stack/#{stack.stack_id}/stack"
+
+    "https://console.aws.amazon.com/opsworks/home#{params}"
   end
 end

data/lib/ops_deploy/cli.rb

@@ -2,21 +2,19 @@
 class OpsDeploy::CLI
   def initialize
     config = {
-      region: OpsDeploy::CLI.argument("aws-region", "AWS_REGION", true),
+      region: OpsDeploy::CLI.argument('aws-region', 'AWS_REGION', true)
     }
 
-    profile = OpsDeploy::CLI.argument("aws-profile", "AWS_PROFILE")
+    profile = OpsDeploy::CLI.argument('aws-profile', 'AWS_PROFILE')
     config[:credentials] = Aws::SharedCredentials.new(profile_name: profile) if profile
 
     @main = OpsDeploy.new(config)
     @stacks = {}
-    @notifier = OpsDeploy::CLI::Notifier.new({
-      slack: {
-        webhook_url: OpsDeploy::CLI.argument("slack-webhook-url", "SLACK_WEBHOOK_URL"),
-        username: OpsDeploy::CLI.argument("slack-username", "SLACK_USERNAME"),
-        channel: OpsDeploy::CLI.argument("slack-channel", "SLACK_CHANNEL")
-      }
-    })
+    @notifier = OpsDeploy::CLI::Notifier.new(slack: {
+                                               webhook_url: OpsDeploy::CLI.argument('slack-webhook-url', 'SLACK_WEBHOOK_URL'),
+                                               username: OpsDeploy::CLI.argument('slack-username', 'SLACK_USERNAME'),
+                                               channel: OpsDeploy::CLI.argument('slack-channel', 'SLACK_CHANNEL')
+                                             })
 
     @notification_messages = {
       info: [],
@@ -30,10 +28,10 @@ class OpsDeploy::CLI
   def start_deployment(stack_id_name_or_object, application_id = nil, migrate = false)
     stack = find_stack(stack_id_name_or_object)
 
-    step_msg("Starting deployment on stack", "'#{stack.name.blue}'...")
+    step_msg('Starting deployment on stack', "'#{stack.name.blue}'...")
 
     if @main.start_deployment(stack, application_id, migrate)
-      success_msg("Deployment started on stack", "'#{stack.name.green}'")
+      success_msg('Deployment started on stack', "'#{stack.name.green}'")
       send_notification(stack)
 
       true
@@ -49,34 +47,29 @@ class OpsDeploy::CLI
     stack = find_stack(stack_id_name_or_object)
 
     if via_proxy
-      Pusher.url = OpsDeploy::CLI.argument("pusher-url", "PUSHER_URL", true)
-      Pusher['OpsDeploy'].trigger('wait_for_deployments', {
-        stack: stack.stack_id
-      })
+      Pusher.url = OpsDeploy::CLI.argument('pusher-url', 'PUSHER_URL', true)
+      Pusher['OpsDeploy'].trigger('wait_for_deployments', stack: stack.stack_id)
     else
-      step_msg("Checking deployments...")
-      @main.deployments_callback = Proc.new {
-        |deployment|
-
+      step_msg('Checking deployments...')
+      @main.deployments_callback = proc { |deployment|
         puts
-
-        if (deployment.status == "successful")
-          success_msg("Deployment", "OK".green.bold, deployment.duration ? "(#{deployment.duration.to_s}s)" : "")
+        if (deployment.status == 'successful')
+          success_msg('Deployment', 'OK'.green.bold, deployment.duration ? "(#{deployment.duration}s)" : '')
         else
-          failure_msg("Deployment", "Failed".red.bold, deployment.duration ? "(#{deployment.duration.to_s}s)" : "")
+          failure_msg('Deployment', 'Failed'.red.bold, deployment.duration ? "(#{deployment.duration}s)" : '')
         end
       }
 
       waiter = @main.wait_for_deployments(stack)
       if waiter
-        step_msg("Waiting for deployments to finish...")
+        step_msg('Waiting for deployments to finish...')
 
-        print ".".blue
-        print ".".blue until waiter.join(1)
+        print '.'.blue
+        print '.'.blue until waiter.join(1)
 
-        info_msg("Deployments finished")
+        info_msg('Deployments finished')
       else
-        info_msg("No running deployments on stack", "'#{stack_id_name_or_object.blue}'")
+        info_msg('No running deployments on stack', "'#{stack_id_name_or_object.blue}'")
       end
 
       send_notification(stack)
@@ -87,22 +80,17 @@ class OpsDeploy::CLI
     stack = find_stack(stack_id_name_or_object)
 
     if via_proxy
-      Pusher.url = OpsDeploy::CLI.argument("pusher-url", "PUSHER_URL", true)
-      Pusher['OpsDeploy'].trigger('check_instances', {
-        stack: stack.stack_id
-      })
+      Pusher.url = OpsDeploy::CLI.argument('pusher-url', 'PUSHER_URL', true)
+      Pusher['OpsDeploy'].trigger('check_instances', stack: stack.stack_id)
     else
-      @main.instances_check_callback = Proc.new {
-        |instance, response, error|
-
+      @main.instances_check_callback = proc { |instance, response, error|
         puts
-
-        if (error.nil? and response.code == 200)
-          success_msg("Response from", "#{instance.hostname.green}:", "200 OK".green)
+        if error.nil? && response.code == 200
+          success_msg('Response from', "#{instance.hostname.green}:", '200 OK'.green)
         elsif error.nil?
-          failure_msg("Response from", "#{instance.hostname.red}:", "#{response.code}".red)
+          failure_msg('Response from', "#{instance.hostname.red}:", "#{response.code}".red)
         else
-          failure_msg("Error checking", "#{instance.hostname.red}:", error.to_s)
+          failure_msg('Error checking', "#{instance.hostname.red}:", error.to_s)
         end
       }
 
@@ -110,12 +98,12 @@ class OpsDeploy::CLI
       if waiter
         step_msg("Checking instances' HTTP response...")
 
-        print ".".blue
-        print ".".blue until waiter.join(1)
+        print '.'.blue
+        print '.'.blue until waiter.join(1)
 
-        info_msg("Response check finished")
+        info_msg('Response check finished')
       else
-        info_msg("No online instances on stack", "'#{stack_id_name_or_object.blue}'")
+        info_msg('No online instances on stack', "'#{stack_id_name_or_object.blue}'")
       end
 
       send_notification(stack)
@@ -123,16 +111,16 @@ class OpsDeploy::CLI
   end
 
   def start_server
-    pusher_comp = URI.parse(OpsDeploy::CLI.argument("pusher-url", "PUSHER_URL", true))
+    pusher_comp = URI.parse(OpsDeploy::CLI.argument('pusher-url', 'PUSHER_URL', true))
     PusherClient.logger.level = Logger::ERROR
     socket = PusherClient::Socket.new(pusher_comp.user, secure: true)
-    socket.subscribe("OpsDeploy")
+    socket.subscribe('OpsDeploy')
 
-    socket["OpsDeploy"].bind("check_instances") do |data|
+    socket['OpsDeploy'].bind('check_instances') do |data|
       begin
         info = data
-        info = JSON.parse(data) if data.kind_of?(String)
-        stack_id = info["stack"] || info[:stack]
+        info = JSON.parse(data) if data.is_a?(String)
+        stack_id = info['stack'] || info[:stack]
 
         check_instances(stack_id)
       rescue StandardError => e
@@ -140,11 +128,11 @@ class OpsDeploy::CLI
       end
     end
 
-    socket["OpsDeploy"].bind("wait_for_deployments") do |data|
+    socket['OpsDeploy'].bind('wait_for_deployments') do |data|
       begin
         info = data
-        info = JSON.parse(data) if data.kind_of?(String)
-        stack_id = info["stack"] || info[:stack]
+        info = JSON.parse(data) if data.is_a?(String)
+        stack_id = info['stack'] || info[:stack]
 
         wait_for_deployments(stack_id)
       rescue StandardError => e
@@ -152,7 +140,7 @@ class OpsDeploy::CLI
       end
     end
 
-    info_msg("Started OpsDeploy server")
+    info_msg("Started OpsDeploy server #{OpsDeploy::VERSION}")
     socket.connect
   end
 
@@ -164,16 +152,18 @@ class OpsDeploy::CLI
       value = ARGV.include?(argv_name) ? true : nil
       return value if value
 
-      ARGV.each {
-        |arg|
+      ARGV.each do |arg|
         if arg.start_with?("--#{argv_name}=")
           value = arg.split("--#{argv_name}=").last
         end
-      }
+      end
     end
 
     if required && value.nil?
-      raise StandardError.new("Argument '#{argv_name}' unspecified. Please set #{env_name ? 'the environment variable '+env_name+' or ' : ''}the argument --#{argv_name}=<value>")
+      env_name_message = env_name ? "the environment variable #{env_name} or " : ''
+      error = "Argument '#{argv_name}' unspecified."
+      suggestion = "Please set #{env_name_message}the argument --#{argv_name}=<value>"
+      fail StandardError.new("#{error} #{suggestion}")
     end
 
     value
@@ -182,13 +172,13 @@ class OpsDeploy::CLI
   private
 
   def find_stack(stack_id_name_or_object)
-    if stack_id_name_or_object.kind_of?(String)
+    if stack_id_name_or_object.is_a?(String)
       hash = stack_id_name_or_object.hash
 
       if @stacks[hash].nil?
-        step_msg("Getting stack", "'#{stack_id_name_or_object.blue}'...")
+        step_msg('Getting stack', "'#{stack_id_name_or_object.blue}'...")
         stack = @main.find_stack(stack_id_name_or_object)
-        step_msg("Found stack", "'#{stack.name.blue}' (#{stack.stack_id})")
+        step_msg('Found stack', "'#{stack.name.blue}' (#{stack.stack_id})")
 
         @notifier.messages.info.pop
         @notifier.messages.info.pop
@@ -203,7 +193,7 @@ class OpsDeploy::CLI
   end
 
   def success_msg(*args)
-    message = "✓ ".green+args.join(" ")
+    message = '✓ '.green + args.join(' ')
     @notifier.messages.success << message
     @notifier.notification_type = :success unless @notifier.notification_type == :failure
     puts message
@@ -211,14 +201,14 @@ class OpsDeploy::CLI
   end
 
   def info_msg(*args)
-    message = "// ".blue+args.join(" ")
+    message = '// '.blue + args.join(' ')
     @notifier.messages.info << message
     puts message
     message
   end
 
   def failure_msg(*args)
-    message = "╳  ".red+args.join(" ")
+    message = '╳  '.red + args.join(' ')
     @notifier.messages.failure << message
     @notifier.notification_type = :failure
     puts message
@@ -226,7 +216,7 @@ class OpsDeploy::CLI
   end
 
   def step_msg(*args)
-    message = "-> ".cyan+args.join(" ")
+    message = '-> '.cyan + args.join(' ')
     @notifier.messages.info << message
     puts message
     message
@@ -236,6 +226,16 @@ class OpsDeploy::CLI
     @notifier.notify(stack)
     @notifier.reset
   end
+
+  def puts(message = nil)
+    $stdout.puts(message) if message
+    $stdout.flush
+  end
+
+  def print(message = nil)
+    $stdout.print(message) if message
+    $stdout.flush
+  end
 end
 
-require_relative "cli/notifier"
+require_relative 'cli/notifier'

data/lib/ops_deploy/version.rb

@@ -1,3 +1,3 @@
-module OpsDeploy
-  VERSION = "0.1.5"
+class OpsDeploy
+  VERSION = '0.1.6.1'
 end

data/lib/ops_deploy/waiter.rb

@@ -1,14 +1,15 @@
+# A class defining a generic 'waiter' thread that waits for tasks to finish
 class OpsDeploy::Waiter < Thread
   attr_accessor :end_when, :callback, :data
 
   def initialize(&task)
     @task = task
 
-    super() {
+    super() do
       error = nil
 
       begin
-        until false
+        loop do
           @data = @task.call
           break if @end_when.call(@data)
           sleep 5
@@ -20,47 +21,56 @@ class OpsDeploy::Waiter < Thread
       @callback.call(@data, error) if @callback
 
       @data
-    }
+    end
   end
 end
 
-class OpsDeploy::DeploymentWaiter < OpsDeploy::Waiter
+# A waiter for deployments
+class DeploymentWaiter < OpsDeploy::Waiter
   def initialize(opsworks, deployment, callback = nil)
-    super() {
-      deploy = opsworks.describe_deployments(deployment_ids: [deployment.deployment_id]).deployments.first
+    super() do
+      find_deployment(opsworks, deployment.deployment_id)
+    end
 
-      # Retry if there's no duration
-      if deploy.status != "running" and deploy.duration.nil?
-        deploy = opsworks.describe_deployments(deployment_ids: [deployment.deployment_id]).deployments.first
-      end
+    @end_when = proc do |deployment_obj|
+      deployment_obj.status != 'running'
+    end
+
+    @callback = callback
+  end
 
-      deploy
-    }
+  private
 
-    @end_when = Proc.new {
-      |deployment_obj|
-      deployment_obj.status != "running"
-    }
+  def find_deployment(opsworks, deployment_id)
+    deploy = opsworks.describe_deployments(deployment_ids: [deployment_id])
+             .deployments.first
 
-    @callback = callback
+    # Retry if there's no duration
+    if deploy.status != 'running' && deploy.duration.nil?
+      deploy = opsworks.describe_deployments(deployment_ids: [deployment_id])
+               .deployments.first
+    end
+
+    deploy
   end
 end
 
-class OpsDeploy::InstanceResponseWaiter < OpsDeploy::Waiter
+# A waiter for instance response checks
+class InstanceResponseWaiter < OpsDeploy::Waiter
   class HTTParty::Basement
+    # Overriding HTTParty's timeout
     default_timeout 30
   end
 
-  def initialize(opsworks, instance, callback = nil)
-    super() {
+  def initialize(_opsworks, instance, callback = nil)
+    super() do
       instance_ip = instance.public_ip || instance.private_ip
       HTTParty.get("http://#{instance_ip}", verify: false)
-    }
+    end
 
-    @end_when = Proc.new { true }
-    @callback = Proc.new {
-      |data, error|
+    @end_when = proc { true }
+    @callback = proc do |data, error|
       callback.call(instance, data, error)
-    }
+    end
   end
 end

data/lib/ops_deploy.rb

@@ -1,9 +1,9 @@
-require "aws-sdk"
-require "httparty"
-require "colorize"
-require "slack-notifier"
-require "pusher"
-require "pusher-client"
+require 'aws-sdk'
+require 'httparty'
+require 'colorize'
+require 'slack-notifier'
+require 'pusher'
+require 'pusher-client'
 
 class OpsDeploy
   attr_accessor :waiter
@@ -11,8 +11,8 @@ class OpsDeploy
   attr_accessor :instances_check_callback
 
   def initialize(config = nil)
-    config = config || {
-      region: "us-east-1"
+    config ||= {
+      region: 'us-east-1'
     }
 
     @opsworks = Aws::OpsWorks::Client.new(config)
@@ -22,48 +22,43 @@ class OpsDeploy
     @opsworks.describe_stacks.stacks
   end
 
-  def start_deployment(stack_id_name_or_object, application_id_name_or_object = nil, migrate = false)
+  def start_deployment(stack_id_name_or_object,
+                       application_id_name_or_object = nil,
+                       migrate = false)
     stack = find_stack(stack_id_name_or_object)
     app = find_app(stack, application_id_name_or_object)
 
-    command = { name: "deploy" }
-    command["args"] = { migrate: ["true"] } if migrate
+    command = { name: 'deploy' }
+    command['args'] = { migrate: ['true'] } if migrate
 
-    resp = @opsworks.create_deployment({
-      stack_id: stack.stack_id,
-      app_id: app.app_id,
-      command: command
-    })
+    resp = @opsworks.create_deployment(stack_id: stack.stack_id,
+                                       app_id: app.app_id,
+                                       command: command)
 
-    return (resp && resp.deployment_id)
+    (resp && resp.deployment_id)
   end
 
   def wait_for_deployments(stack_id_name_or_object)
     stack = find_stack(stack_id_name_or_object)
 
-    running_deployments = @opsworks.describe_deployments(stack_id: stack.stack_id).deployments.select {
-      |deployment|
-
-      deployment.status == "running"
-    }
+    running_deployments = @opsworks.describe_deployments(stack_id: stack.stack_id)
+                          .deployments.select do |deployment|
+      deployment.status == 'running'
+    end
 
     if running_deployments.empty?
       false
     else
       waiters = []
 
-      running_deployments.each {
-        |deployment|
-
+      running_deployments.each do |deployment|
         waiters << OpsDeploy::DeploymentWaiter.new(@opsworks, deployment, @deployments_callback)
-      }
-
-      @waiter = Thread.new(waiters) {
-        |deploy_threads|
+      end
 
+      @waiter = Thread.new(waiters) do |deploy_threads|
         deploy_threads.each(&:run)
         deploy_threads.each(&:join)
-      }
+      end
 
       @waiter.run
     end
@@ -72,25 +67,19 @@ class OpsDeploy
   def check_instances(stack_id_name_or_object)
     stack = find_stack(stack_id_name_or_object)
 
-    running_instances = @opsworks.describe_instances(stack_id: stack.stack_id).instances.select {
-      |instance|
-
-      instance.status == "online"
-    }
+    running_instances = @opsworks.describe_instances(stack_id: stack.stack_id).instances.select do |instance|
+      instance.status == 'online'
+    end
 
     waiters = []
-    running_instances.each {
-      |instance|
-
+    running_instances.each do |instance|
       waiters << OpsDeploy::InstanceResponseWaiter.new(@opsworks, instance, @instances_check_callback)
-    }
-
-    @waiter = Thread.new(waiters) {
-      |check_threads|
+    end
 
+    @waiter = Thread.new(waiters) do |check_threads|
       check_threads.each(&:run)
       check_threads.each(&:join)
-    }
+    end
 
     @waiter.run
   end
@@ -98,29 +87,29 @@ class OpsDeploy
   def find_stack(stack_id_name_or_object)
     found_stack = nil
 
-    if stack_id_name_or_object.kind_of?(String)
+    if stack_id_name_or_object.is_a?(String)
       begin
         if stack_id_name_or_object.match(/^[0-9a-f\-]+$/)
           found_stack = @opsworks.describe_stacks(stack_ids: [stack_id_name_or_object]).stacks.first
         end
       rescue Aws::OpsWorks::Errors::ResourceNotFoundException
+        found_stack = nil
       end
 
       if found_stack.nil?
-        @opsworks.describe_stacks.stacks.each {
-          |stack|
-
+        @opsworks.describe_stacks.stacks.each do |stack|
           if stack.name == stack_id_name_or_object
             found_stack = stack
             break
           end
-        }
+        end
       end
     end
 
     found_stack = stack_id_name_or_object if found_stack.nil?
-    invalid_stack_error = StandardError.new("Invalid stack #{found_stack} (#{stack_id_name_or_object}).")
-    raise invalid_stack_error unless found_stack.kind_of?(Aws::OpsWorks::Types::Stack)
+    error_message = "Invalid stack #{found_stack} (#{stack_id_name_or_object})."
+    invalid_stack_error = StandardError.new(error_message)
+    fail invalid_stack_error unless found_stack.is_a?(Aws::OpsWorks::Types::Stack)
 
     found_stack
   end
@@ -128,25 +117,22 @@ class OpsDeploy
   def find_app(stack, application_id_name_or_object)
     found_app = nil
 
-    if application_id_name_or_object.kind_of?(String)
+    if application_id_name_or_object.is_a?(String)
       begin
         if application_id_name_or_object.match(/^[0-9a-f\-]+$/)
-          found_app = @opsworks.describe_apps({
-            app_ids: [application_id_name_or_object]
-          }).apps.first
+          found_app = @opsworks.describe_apps(app_ids: [application_id_name_or_object]).apps.first
         end
       rescue Aws::OpsWorks::Errors::ResourceNotFoundException
+        found_app = nil
       end
 
       if found_app.nil?
-        @opsworks.describe_apps(stack_id: stack.stack_id).apps.each {
-          |app|
-
+        @opsworks.describe_apps(stack_id: stack.stack_id).apps.each do |app|
           if app.name == application_id_name_or_object
             found_app = app
             break
           end
-        }
+        end
       end
     elsif application_id_name_or_object.nil?
       apps = @opsworks.describe_apps(stack_id: stack.stack_id).apps
@@ -154,12 +140,14 @@ class OpsDeploy
     end
 
     found_app = application_id_name_or_object if found_app.nil?
-    invalid_app_error = StandardError.new("Invalid app #{found_app} (#{application_id_name_or_object}).")
-    raise invalid_app_error unless found_app.kind_of?(Aws::OpsWorks::Types::App)
+    error_message = "Invalid app #{found_app} (#{application_id_name_or_object})."
+    invalid_app_error = StandardError.new(error_message)
+    fail invalid_app_error unless found_app.is_a?(Aws::OpsWorks::Types::App)
 
     found_app
   end
 end
 
-require_relative "ops_deploy/waiter"
-require_relative "ops_deploy/cli"
+require_relative 'ops_deploy/waiter'
+require_relative 'ops_deploy/version'
+require_relative 'ops_deploy/cli'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ops_deploy
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6.1
 platform: ruby
 authors:
 - Mahdi Bchetnia
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-08 00:00:00.000000000 Z
+date: 2016-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -136,3 +136,4 @@ signing_key:
 specification_version: 4
 summary: Perform deployment & checks on AWS OpsWorks
 test_files: []
+has_rdoc: