ops_deploy 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2d6296c4432618e6f1dd7318a2e121580013c594
+  data.tar.gz: bf7140d4e1e1f062113a225dbd8253a6c088dab7
+SHA512:
+  metadata.gz: f2e4b346c91db5bedf9a2e3a85cab0c36cbf50343486b35e6d2b0319b88140b1bf3905909c61cb11fd0933bccd61d83389a4e28b28c53de5d396c81b82be9b36
+  data.tar.gz: 2c312608dfbb5cc0c33bde8acd57103dbdffbcfa5c2aa6687c5c8d51d8731cb51619677ba8b10d1887fc0e32dab82cc58b348a732284a98274e56501c9945f82

data/README.md

@@ -0,0 +1,73 @@
+### OpsDeploy
+
+A simple gem to perform deployment & checks on AWS OpsWorks. You can deploy, wait for deployments to finish, and check on the instances responses for a successful deployment flow. Also implements Slack notifications for each step.
+
+### Usage
+
+```
+gem install ops_deploy
+```
+
+In your code:
+
+```
+require 'ops_deploy'
+ops = OpsDeploy.new(aws_config)
+
+# Start deployment (sync)
+success = ops.start_deployment(stack_id, app_id, migrate)
+
+# Wait for deployments (async)
+ops.deployments_callback = Proc.new {
+	|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
+}
+a_thread = ops.check_instances(stack_id).join
+a_thread.join
+
+```
+
+or using the CLI:
+
+```
+opsdeploy <tasks> --aws-region=<aws_region> --aws-profile=<...> --stack=<stack_name_or_id> --slack-webhook-url=<...> --slack-username=<...> --slack-channel=<...>
+```
+
+The tasks are:
+
+- deploy (starts a deployment)
+- migrate (will also migrate during the deployment [for Rails apps])
+- wait (waits for the deployments)
+- check (checks the instances)
+
+Example:
+
+```
+opsdeploy deploy wait check --stack="Example" --aws-region="us-east-1"
+```
+
+Output:
+
+```
+-> Getting stack 'Example'...
+-> Found stack 'Example' (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx)
+-> Starting deployment on stack 'Example'...
+✓ Deployment started on stack 'Example'
+-> Checking deployments...
+-> Waiting for deployments to finish...
+..............................................................
+✓ Deployment OK (58s)
+// Deployments finished
+-> Checking instances' HTTP response...
+.
+✓ Response from rails-app1: 200 OK
+// Response check finished
+```

data/bin/opsdeploy

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require 'ops_deploy'
+
+cli = OpsDeploy::CLI.new
+
+if OpsDeploy::CLI.argument("check-server")
+  cli.start_check_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")
+
+  cli.start_deployment(stack, app_id, migrate) if OpsDeploy::CLI.argument("deploy")
+  cli.wait_for_deployments(stack) if OpsDeploy::CLI.argument("wait")
+  cli.check_instances(stack, check_via_proxy) if OpsDeploy::CLI.argument("check") or check_via_proxy
+end

data/lib/ops_deploy.rb

@@ -0,0 +1,167 @@
+require "aws-sdk"
+require "httparty"
+require "pry-byebug"
+require "colorize"
+require "slack-notifier"
+require "pusher"
+require "pusher-client"
+
+class OpsDeploy
+  attr_accessor :waiter
+  attr_accessor :deployments_callback
+  attr_accessor :instances_check_callback
+
+  def initialize(config = nil)
+    config = config || {
+      region: "us-east-1"
+    }
+
+    @opsworks = Aws::OpsWorks::Client.new(config)
+  end
+
+  def stacks
+    @opsworks.describe_stacks.stacks
+  end
+
+  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
+
+    resp = @opsworks.create_deployment({
+      stack_id: stack.stack_id,
+      app_id: app.app_id,
+      command: command
+    })
+
+    return (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"
+    }
+
+    if running_deployments.empty?
+      false
+    else
+      waiters = []
+
+      running_deployments.each {
+        |deployment|
+
+        waiters << OpsDeploy::DeploymentWaiter.new(@opsworks, deployment, @deployments_callback)
+      }
+
+      @waiter = Thread.new(waiters) {
+        |deploy_threads|
+
+        deploy_threads.each(&:run)
+        deploy_threads.each(&:join)
+      }
+
+      @waiter.run
+    end
+  end
+
+  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"
+    }
+
+    waiters = []
+    running_instances.each {
+      |instance|
+
+      waiters << OpsDeploy::InstanceResponseWaiter.new(@opsworks, instance, @instances_check_callback)
+    }
+
+    @waiter = Thread.new(waiters) {
+      |check_threads|
+
+      check_threads.each(&:run)
+      check_threads.each(&:join)
+    }
+
+    @waiter.run
+  end
+
+  def find_stack(stack_id_name_or_object)
+    found_stack = nil
+
+    if stack_id_name_or_object.kind_of?(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
+      end
+
+      if found_stack.nil?
+        @opsworks.describe_stacks.stacks.each {
+          |stack|
+
+          if stack.name == stack_id_name_or_object
+            found_stack = stack
+            break
+          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)
+
+    found_stack
+  end
+
+  def find_app(stack, application_id_name_or_object)
+    found_app = nil
+
+    if application_id_name_or_object.kind_of?(String)
+      begin
+        if application_id_name_or_object.match(/^[0-9a-f\-]+$/)
+          found_app = @opsworks.describe_apps({
+            stack_id: stack.stack_id,
+            app_ids: [application_id_name_or_object]
+          }).apps.first
+        end
+      rescue Aws::OpsWorks::Errors::ResourceNotFoundException
+      end
+
+      if found_app.nil?
+        @opsworks.describe_apps(stack_id: stack.stack_id).apps.each {
+          |app|
+
+          if app.name == application_id_name_or_object
+            found_app = app
+            break
+          end
+        }
+      end
+    elsif application_id_name_or_object.nil?
+      apps = @opsworks.describe_apps(stack_id: stack.stack_id).apps
+      found_app = apps.first if apps.count == 1
+    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)
+
+    found_app
+  end
+end
+
+require_relative "ops_deploy/waiter"
+require_relative "ops_deploy/cli"

data/lib/ops_deploy/cli.rb

@@ -0,0 +1,220 @@
+class OpsDeploy::CLI
+  def initialize
+    config = {
+      region: OpsDeploy::CLI.argument("aws-region", "AWS_REGION", true),
+    }
+
+    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")
+      }
+    })
+
+    @notification_messages = {
+      info: [],
+      success: [],
+      failure: []
+    }
+    @notification_success = false
+    @notification_failure = false
+  end
+
+  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}'...")
+
+    if @main.start_deployment(stack, application_id, migrate)
+      success_msg("Deployment started on stack", "'#{stack.name.green}'")
+      send_notification(stack)
+
+      true
+    else
+      failure_msg("Couldn't start deployment on stack", "'#{stack.name.red}'")
+      send_notification(stack)
+
+      false
+    end
+  end
+
+  def wait_for_deployments(stack_id_name_or_object)
+    stack = find_stack(stack_id_name_or_object)
+
+    step_msg("Checking deployments...")
+    @main.deployments_callback = Proc.new {
+      |deployment|
+
+      puts
+
+      if (deployment.status == "successful")
+        success_msg("Deployment", "OK".green.bold, deployment.duration ? "(#{deployment.duration.to_s}s)" : "")
+      else
+        failure_msg("Deployment", "Failed".red.bold, deployment.duration ? "(#{deployment.duration.to_s}s)" : "")
+      end
+    }
+
+    waiter = @main.wait_for_deployments(stack)
+    if waiter
+      step_msg("Waiting for deployments to finish...")
+
+      print ".".blue
+      print ".".blue until waiter.join(1)
+
+      info_msg("Deployments finished")
+    else
+      info_msg("No running deployments on stack", "'#{stack_id_name_or_object.blue}'")
+    end
+
+    send_notification(stack)
+  end
+
+  def check_instances(stack_id_name_or_object, via_proxy = false)
+    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
+      })
+    else
+      @main.instances_check_callback = Proc.new {
+        |instance, response, error|
+
+        puts
+
+        if (error.nil? and 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)
+        else
+          failure_msg("Error checking", "#{instance.hostname.red}:", error.to_s)
+        end
+      }
+
+      waiter = @main.check_instances(stack)
+      if waiter
+        step_msg("Checking instances' HTTP response...")
+
+        print ".".blue
+        print ".".blue until waiter.join(1)
+
+        info_msg("Response check finished")
+      else
+        info_msg("No online instances on stack", "'#{stack_id_name_or_object.blue}'")
+      end
+
+      send_notification(stack)
+    end
+  end
+
+  def start_check_server
+    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["OpsDeploy"].bind("check_instances") do |data|
+      begin
+        info = data
+        info = JSON.parse(data) if data.kind_of?(String)
+        stack_id = info["stack"] || info[:stack]
+
+        check_instances(stack_id)
+      rescue StandardError => e
+        puts e
+      end
+    end
+
+    info_msg("Started OpsDeploy server")
+    socket.connect
+  end
+
+  def self.argument(argv_name, env_name = nil, required = false)
+    value = nil
+    value = ENV[env_name] if env_name
+
+    if value.nil?
+      value = ARGV.include?(argv_name) ? true : nil
+      return value if value
+
+      ARGV.each {
+        |arg|
+        if arg.start_with?("--#{argv_name}=")
+          value = arg.split("--#{argv_name}=").last
+        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>")
+    end
+
+    value
+  end
+
+  private
+
+  def find_stack(stack_id_name_or_object)
+    if stack_id_name_or_object.kind_of?(String)
+      hash = stack_id_name_or_object.hash
+
+      if @stacks[hash].nil?
+        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})")
+
+        @notifier.messages.info.pop
+        @notifier.messages.info.pop
+
+        @stacks[hash] = stack
+      end
+
+      @stacks[hash]
+    else
+      @main.find_stack(stack_id_name_or_object)
+    end
+  end
+
+  def success_msg(*args)
+    message = "✓ ".green+args.join(" ")
+    @notifier.messages.success << message
+    @notifier.notification_type = :success unless @notifier.notification_type == :failure
+    puts message
+    message
+  end
+
+  def info_msg(*args)
+    message = "// ".blue+args.join(" ")
+    @notifier.messages.info << message
+    puts message
+    message
+  end
+
+  def failure_msg(*args)
+    message = "╳  ".red+args.join(" ")
+    @notifier.messages.failure << message
+    @notifier.notification_type = :failure
+    puts message
+    message
+  end
+
+  def step_msg(*args)
+    message = "-> ".cyan+args.join(" ")
+    @notifier.messages.info << message
+    puts message
+    message
+  end
+
+  def send_notification(stack)
+    @notifier.notify(stack)
+    @notifier.reset
+  end
+end
+
+require_relative "cli/notifier"

data/lib/ops_deploy/cli/notifier.rb

@@ -0,0 +1,101 @@
+class OpsDeploy::CLI::Notifier
+  attr_accessor :options
+  attr_accessor :messages
+  attr_accessor :notification_type
+
+  def initialize(options)
+    @options = options
+    @options.delete(:slack) if @options[:slack].nil? or @options[:slack][:webhook_url].nil?
+    @messages = OpsDeploy::CLI::Notifier::Messages.new
+    @notification_type = :info
+  end
+
+  def notify(stack)
+    if @notification_type == :failure
+      message = @messages.failure.join("\n")
+      failure_notify(stack, message)
+    elsif @notification_type == :success
+      message = @messages.success.join("\n")
+      success_notify(stack, message)
+    else
+      message = @messages.info.join("\n")
+      info_notify(stack, message)
+    end
+  end
+
+  def info_notify(stack, message)
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).notify(message) if @options[:slack]
+  end
+
+  def success_notify(stack, message)
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).success_notify(message) if @options[:slack]
+  end
+
+  def failure_notify(stack, message)
+    OpsDeploy::CLI::Notifier::Slack.new(stack, @options[:slack]).failure_notify(message) if @options[:slack]
+  end
+
+  def reset
+    @messages = OpsDeploy::CLI::Notifier::Messages.new
+    @notification_type = :info
+  end
+end
+
+class OpsDeploy::CLI::Notifier::Messages
+  attr_accessor :info, :success, :failure
+
+  def initialize
+    @info = []
+    @success = []
+    @failure = []
+  end
+end
+
+class OpsDeploy::CLI::Notifier::Generic
+end
+
+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]
+    @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: [
+      {
+        fallback: message,
+        author_name: @stack.name,
+        text: message
+      }
+    ]
+  end
+
+  def success_notify(message)
+    message = message.gsub(/\[[0-9;]+?m/, "")
+    @slack_notifier.ping "", channel: @options[:channel], attachments: [
+      {
+        fallback: message,
+        text: message,
+        author_name: @stack.name,
+        color: "good"
+      }
+    ]
+  end
+
+  def failure_notify(message)
+    message = message.gsub(/\[[0-9;]+?m/, "")
+    @slack_notifier.ping "", channel: @options[:channel], attachments: [
+      {
+        fallback: message,
+        text: message,
+        author_name: @stack.name,
+        color: "danger"
+      }
+    ]
+  end
+end

data/lib/ops_deploy/version.rb

@@ -0,0 +1,3 @@
+module OpsDeploy
+  VERSION = "0.1.0"
+end

data/lib/ops_deploy/waiter.rb

@@ -0,0 +1,66 @@
+class OpsDeploy::Waiter < Thread
+  attr_accessor :end_when, :callback, :data
+
+  def initialize(&task)
+    @task = task
+
+    super() {
+      error = nil
+
+      begin
+        until false
+          @data = @task.call
+          break if @end_when.call(@data)
+          sleep 5
+        end
+      rescue StandardError => e
+        error = e
+      end
+
+      @callback.call(@data, error) if @callback
+
+      @data
+    }
+  end
+end
+
+class OpsDeploy::DeploymentWaiter < OpsDeploy::Waiter
+  def initialize(opsworks, deployment, callback = nil)
+    super() {
+      deploy = opsworks.describe_deployments(deployment_ids: [deployment.deployment_id]).deployments.first
+
+      # 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
+
+      deploy
+    }
+
+    @end_when = Proc.new {
+      |deployment_obj|
+      deployment_obj.status != "running"
+    }
+
+    @callback = callback
+  end
+end
+
+class OpsDeploy::InstanceResponseWaiter < OpsDeploy::Waiter
+  class HTTParty::Basement
+    default_timeout 30
+  end
+
+  def initialize(opsworks, instance, callback = nil)
+    super() {
+      instance_ip = instance.public_ip || instance.private_ip
+      HTTParty.get("http://#{instance_ip}", verify: false)
+    }
+
+    @end_when = Proc.new { true }
+    @callback = Proc.new {
+      |data, error|
+      callback.call(instance, data, error)
+    }
+  end
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: ops_deploy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mahdi Bchetnia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-14 00:00:00.000000000 Z
+dependencies: []
+description: Perform deployment & checks on AWS OpsWorks. You can deploy, wait for
+  deployments to finish, and check on the instances responses for a successful deployment
+  flow. Also implements Slack notifications for each step.
+email:
+- injekter@gmail.com
+executables:
+- opsdeploy
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/opsdeploy
+- lib/ops_deploy.rb
+- lib/ops_deploy/cli.rb
+- lib/ops_deploy/cli/notifier.rb
+- lib/ops_deploy/version.rb
+- lib/ops_deploy/waiter.rb
+homepage: http://github.com/inket/OpsDeploy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: ops_deploy
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Perform deployment & checks on AWS OpsWorks
+test_files: []