ops_worker 0.0.2

data/README.md

@@ -0,0 +1,35 @@
+# opsworker
+
+Quick command line tool for handling servers on OpsWorks.
+
+## Installation
+    gem install ops_worker
+
+## Example
+```ruby
+require 'ops_worker'
+
+client = OpsWorker::Client.new
+# or, client = OpsWorker::Client.new(:access_key_id => "foo", :secret_access_key => "bar")
+
+pp client.stacks
+# => [#<OpsWorker::Stack f1735a57-51c3-4933-8440-4f7beb2cb2ff, homepage_staging, us-east-1>,
+ #<OpsWorker::Stack 3bf98404-dafc-45c4-9fa2-a17485aba4ec, homepage_production, us-east-1>]
+
+app = client.find_app_by_name("homepage_staging")
+app.instances.each do |instance|
+  puts("#{instance.name} is online: #{instance.online?}")
+end
+
+# Deploy the current revision branch set
+app.deploy()
+
+# Switches the current revision branch to feature/new, deploys, then switches it back
+app.deploy("feature/new")
+
+app.update_cookbooks()
+
+app.execute_recipes(["monit"])
+
+app.rollback()
+```

data/lib/ops_worker/app.rb

@@ -0,0 +1,119 @@
+module OpsWorker
+  class App
+    attr_reader :id, :stack, :name, :revision
+
+    def initialize(id, name, revision, stack, opsworks_client)
+      @id = id
+      @name = name
+      @stack = stack
+      @revision = revision
+      @opsworks_client = opsworks_client
+    end
+
+    def instances
+      if @instances
+        return @instances
+      end
+
+      instances_result = @opsworks_client.describe_instances(:stack_id => @stack.id, :app_id => @id)[:instances]
+      @instances = instances_result.map do |instance_hash|
+        layers = @stack.layers.select {|l| instance_hash[:layer_ids].include?(l.id)}
+        Instance.new(instance_hash[:instance_id],
+                     instance_hash[:hostname],
+                     instance_hash[:status],
+                     instance_hash[:instance_type],
+                     instance_hash[:elastic_ip],
+                     instance_hash[:availability_zone],
+                     self,
+                     layers)
+      end
+    end
+
+    # Updates the revision in this app such that all future deploys pull from this revision
+    # @param revision String revision to update, e.g., "feature/foo" or "d6053592ee39e64c5f092b0ba6e9cd1aa8334828"
+    def update_revision(revision)
+      OpsWorker.logger.info {"Changing revision from #{@revision} to #{revision} for app #{@name}"}
+
+      @opsworks_client.update_app(:app_id => @id, :app_source => {:revision => revision})
+      @revision = revision
+      reload()
+    end
+
+    # @param revision String revision to deploy, e.g., "feature/foo" or "d6053592ee39e64c5f092b0ba6e9cd1aa8334828"
+    def deploy(revision = nil)
+      OpsWorker.logger.info {"Deploying app #{@name} from #{revision || @revision}"}
+
+      if revision
+        existing_revision = @revision.dup()
+        update_revision(revision)
+      end
+
+      deployment_status = create_deployment(:deploy)
+
+      if revision
+        update_revision(existing_revision)
+      end
+
+      deployment_status
+    end
+
+    def rollback
+      OpsWorker.logger.info {"Rolling back #{@name}"}
+      create_deployment(:rollback)
+    end
+
+    def restart
+      OpsWorker.logger.info {"Restarting #{@name}"}
+      create_deployment(:restart)
+    end
+
+    def update_cookbooks
+      OpsWorker.logger.info {"Updating cookbooks for #{@name}"}
+      create_deployment(:update_custom_cookbooks, {}, :all)
+    end
+
+    # @param recipe_names Array of string recipe names, e.g., ["custom::recipe1"]
+    def execute_recipes(recipe_names)
+      OpsWorker.logger.info {"Executing recipes #{recipe_names} on #{@name}"}
+      create_deployment(:execute_recipes, {"recipes" => recipe_names}, :all)
+    end
+
+    def to_s
+      "#<OpsWorker::App #{@id}, #{@name}, stack: #{@stack.name}>"
+    end
+
+    def reload
+      @instances = nil
+    end
+
+    private
+    # @param instance_category Symbol, :all or :app_servers
+    def create_deployment(deployment_name, args = {}, instance_category = :app_servers)
+      case instance_category
+        when :all
+          instances = online_instances()
+        when :app_servers
+          instances = app_server_instances()
+        else
+          raise ArgumentError.new("Unknown instance category argument: #{instance_category}")
+      end
+      instance_ids = instances.map(&:id)
+      result = @opsworks_client.create_deployment(:stack_id => @stack.id,
+                                                  :app_id => @id,
+                                                  :command => {:args => args, :name => deployment_name.to_s()},
+                                                  :instance_ids => instance_ids
+      )
+      DeploymentStatus.new(result[:deployment_id], @opsworks_client)
+    end
+
+    def app_server_instances
+      online_instances().select do |i|
+        i.layers.any? {|l| l.type == "rails-app" || l.type == "custom"}
+      end
+    end
+
+    def online_instances
+      instances().select {|i| i.online?}
+    end
+  end
+end

data/lib/ops_worker/client.rb

@@ -0,0 +1,40 @@
+require 'aws-sdk'
+
+module OpsWorker
+  class Client
+    def initialize(options = {})
+      @opsworks_client = AWS::OpsWorks.new(options).client
+    end
+
+    def find_app_by_name(name)
+      stacks().each do |stack|
+        app = stack.apps.detect {|a| a.name == name}
+
+        if app
+          return app
+        end
+      end
+
+      return nil
+    end
+
+    def stacks
+      if @stacks
+        return @stacks
+      end
+
+      stacks = @opsworks_client.describe_stacks()[:stacks]
+      @stacks = stacks.map do |stack_hash|
+        Stack.new(stack_hash[:stack_id], stack_hash[:name], stack_hash[:region], @opsworks_client)
+      end
+    end
+
+    def reload
+      @stacks = nil
+    end
+
+    def method_missing(method_name, *args, &block)
+      @opsworks_client.__send__(method_name, *args, &block)
+    end
+  end
+end

data/lib/ops_worker/deployment_status.rb

@@ -0,0 +1,17 @@
+module OpsWorker
+  class DeploymentStatus
+    def initialize(id, opsworks_client)
+      @id = id
+      @opsworks_client = opsworks_client
+    end
+
+    def status
+      commands().map {|c| c[:status] }
+    end
+
+    private
+    def commands
+      @opsworks_client.describe_commands(:deployment_id => @id)[:commands]
+    end
+  end
+end

data/lib/ops_worker/instance.rb

@@ -0,0 +1,28 @@
+module OpsWorker
+  class Instance
+    attr_reader :id, :hostname, :status, :app, :layers, :elastic_ip, :instance_type, :availability_zone
+
+    def initialize(id, hostname, status, instance_type, elastic_ip, availability_zone, app, layers)
+      @id = id
+      @hostname = hostname
+      @status = status
+      @instance_type = instance_type
+      @elastic_ip = elastic_ip
+      @availability_zone = availability_zone
+      @app = app
+      @layers = layers
+    end
+
+    def stopped?
+      @status == "stopped"
+    end
+
+    def online?
+      @status == "online"
+    end
+
+    def to_s
+      "#<OpsWorker::Instance #{@id}, host: #{@hostname}, status: #{@status}, type: #{@instance_type}, layers: #{@layers.map(&:name)}>"
+    end
+  end
+end

data/lib/ops_worker/layer.rb

@@ -0,0 +1,17 @@
+module OpsWorker
+  class Layer
+    attr_reader :id, :name, :type, :stack
+
+    def initialize(id, name, type, stack, opsworks_client)
+      @id = id
+      @name = name
+      @stack = stack
+      @type = type
+      @opsworks_client = opsworks_client
+    end
+
+    def to_s
+      "#<OpsWorker::Layer #{@id}, #{@name}, stack: #{@stack.name}>"
+    end
+  end
+end

data/lib/ops_worker/logger.rb

@@ -0,0 +1,15 @@
+require 'logger'
+
+module OpsWorker
+  def self.logger
+    if @logger.nil?
+      @logger = Logger.new(STDOUT)
+    end
+
+    @logger
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+end

data/lib/ops_worker/stack.rb

@@ -0,0 +1,43 @@
+module OpsWorker
+  class Stack
+    attr_reader :id, :name, :region
+
+    def initialize(id, name, region, opsworks_client)
+      @id = id
+      @name = name
+      @region = region
+      @opsworks_client = opsworks_client
+    end
+
+    def apps
+      if @apps
+        return @apps
+      end
+
+      apps_result = @opsworks_client.describe_apps(:stack_id => @id)[:apps]
+      @apps = apps_result.map do |app_hash|
+        App.new(app_hash[:app_id], app_hash[:name], app_hash[:app_source][:revision], self, @opsworks_client)
+      end
+    end
+
+    def layers
+      if @layers
+        return @layers
+      end
+
+      layers_result = @opsworks_client.describe_layers(:stack_id => @id)[:layers]
+      @layers = layers_result.map do |layer_hash|
+        Layer.new(layer_hash[:layer_id], layer_hash[:name], layer_hash[:type], self, @opsworks_client)
+      end
+    end
+
+    def to_s
+      "#<OpsWorker::Stack #{@id}, #{@name}, #{@region}>"
+    end
+
+    def reload
+      @layers = nil
+      @apps = nil
+    end
+  end
+end

data/lib/ops_worker/version.rb

@@ -0,0 +1,3 @@
+module OpsWorker
+  VERSION = "0.0.2"
+end

data/lib/ops_worker.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'ops_worker/app'
+require 'ops_worker/client'
+require 'ops_worker/deployment_status'
+require 'ops_worker/instance'
+require 'ops_worker/layer'
+require 'ops_worker/logger'
+require 'ops_worker/stack'
+require 'ops_worker/version'

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: ops_worker
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jon Hyman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple wrapper for common OpsWorks tasks.
+email: jon@appboy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ops_worker/app.rb
+- lib/ops_worker/client.rb
+- lib/ops_worker/deployment_status.rb
+- lib/ops_worker/instance.rb
+- lib/ops_worker/layer.rb
+- lib/ops_worker/logger.rb
+- lib/ops_worker/stack.rb
+- lib/ops_worker/version.rb
+- lib/ops_worker.rb
+- README.md
+homepage: https://github.com/jonhyman/opsworker
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple wrapper for common OpsWorks tasks.
+test_files: []
+has_rdoc: