opsworks_wrapper 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 382ccf56835c9a6787c03a12a2de311989492b72
-  data.tar.gz: 3efeb0cacd432e2e87f8b5d3f34945b289959c5b
+  metadata.gz: 40e9f15632090461fc0c1243cd6dd94370882945
+  data.tar.gz: 247915c8d6b5105abdabf2b960aa7650a0414268
 SHA512:
-  metadata.gz: fae78c1576999010eb4ac8dfce4582f33d631da2445fec1f8839ac2ef744c1e711644b04ce2b34012dde28478ebde107ea4dde37c1f7e96de4ad405f2552f5d0
-  data.tar.gz: e227d5f12324eb3ef06d5f5b68e7bb38499bb1ad69d09bb2513a4eb2d0824f0f4e891d72b645fa0046fa89f91a77dceb8cbaa83f673bc50519e20495397eade6
+  metadata.gz: 5666992cdb2760f699dc2bdc671408734ca9fadfda59c79be5ac09ea6eb0c75c165ede33994a21b45dec1c6b0a9bd08ef312adbbf1cb1cea3e7a0c680c72d96d
+  data.tar.gz: 3bf986520f92cd8a7edd3ec2ecafea23278f6f1a0e574be6c4f1a40c6fed464e16634a9de7a05eecbe2142629018f1d3c618477639d5943d875e29fc777f3a87

data/README.md

@@ -8,8 +8,6 @@ A simple wrapper for aws-sdk to make handling opsworks operations easier.
 - Deployment Creation for all layers except a specified layer (exclusion by layer name)
 - Retrieve all instances for a given layer name
 
-TODO: Delete this and the text above, and describe your gem
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/lib/opsworks_wrapper.rb

@@ -17,8 +17,12 @@ module OpsworksWrapper
       @opsworks_app ||= get_opsworks_app
     end
 
-    def client
-      @client ||= Aws::OpsWorks::Client.new
+    def opsworks_client
+      @opsworks_client ||= Aws::OpsWorks::Client.new
+    end
+
+    def load_balancer_client
+      @client ||= Aws::ElasticLoadBalancing::Client.new
     end
 
     def app_id
@@ -29,8 +33,10 @@ module OpsworksWrapper
       @layers ||= get_opsworks_layers
     end
 
+    # Returns a dictionary for all OpsWorks layers keyed by layer name
+    # @return [Dictionary]
     def get_opsworks_layers
-      data = client.describe_layers(stack_id: opsworks_app[:stack_id])
+      data = opsworks_client.describe_layers(stack_id: opsworks_app[:stack_id])
       layers = {}
       data.layers.each do |layer|
         layers[layer.name] = layer
@@ -38,59 +44,143 @@ module OpsworksWrapper
       layers
     end
 
+    # Returns OpsWorks app details
+    # @return [Object]
     def get_opsworks_app
-      data = client.describe_apps(app_ids: [app_id])
-      unless data[:apps] && data[:apps].count == 1
+      data = opsworks_client.describe_apps(app_ids: [app_id])
+      if !(data[:apps] && data[:apps].count == 1)
         raise Error, "App #{app_id} not found.", error.backtrace
       end
       data[:apps].first
     end
 
+
+    # Returns a list of OpsWorks instances for a specific layer or all layers if @layer_name is not provided
+    # @param [String] layer_name
+    # @return [List[Object]] - List of OpsWorks instances
     def get_instances(layer_name = nil)
       if layer_name == nil
-        data = client.describe_instances(stack_id: opsworks_app[:stack_id])
+        data = opsworks_client.describe_instances(stack_id: opsworks_app[:stack_id])
       else
         layer_id = layers[layer_name].layer_id
-        data = client.describe_instances(layer_id: layer_id)
+        data = opsworks_client.describe_instances(layer_id: layer_id)
       end
 
       data.instances
     end
 
-    # update cookbooks on all layers
+    # Returns ELB instance for layer if one is attached
+    # @param [String] layer_name
+    # @return [Object?] - ELB instance
+    def get_elb(layer_name)
+      layer_id = layers[layer_name].layer_id
+      elbs = opsworks_client.describe_elastic_load_balancers(layer_ids:[layer_id])
+      if elbs.elastic_load_balancers.size > 0
+        name = elbs.elastic_load_balancers.first.elastic_load_balancer_name
+        ELB.new(name)
+      else
+        nil
+      end
+    end
+
+    # Run update cookbooks on all layers
+    # @param [Number] timeout
+    # @return [Boolean]
     def update_cookbooks(timeout = 150)
       puts 'Updating cookbooks'.light_white.bold
       create_deployment({name: 'update_custom_cookbooks'}, nil, timeout)
     end
 
-    # deploy to specified layer or all layers (default)
+    # Run deploy command on specified layer or all layers if @layer_name is not specified (non rolling)
+    # @param [String] layer_name
+    # @param [Number] timeout
+    # @return [Boolean]
     def deploy(layer_name = nil, timeout = 600)
       if layer_name
         puts "Deploying on #{layer_name} layer".light_white.bold
-        instance_ids = get_instances(layer_name).map(&:instance_id)
+        instances = get_instances(layer_name)
       else
         puts "Deploying on all layers".light_white.bold
-        instance_ids = nil
+        instances = nil
+      end
+
+      create_deployment({name: 'deploy'}, instances, timeout)
+    end
+
+    # Performs a rolling deploy on each instance in the layer
+    # If an elb is attached to the layer, de-registration and registration will be performed for the instance
+    # @param [String] layer_name
+    # @param [Number] timeout
+    # @return [Boolean]
+    def deploy_layer_rolling(layer_name, timeout = 600)
+      instances = get_instances(layer_name)
+      elb = get_elb(layer_name)
+      success = true
+      instances.each do |instance|
+        success = deploy_instance_rolling(instance, elb, timeout)
+        break if !success
+      end
+      success
+    end
+
+    # Performs rolling deployment on an instance
+    # Will detach instance if elb is provided and re-attach after deployment succeeds
+    # @param [Object] instance - opsworks instance
+    # @param [Object] elb - elb instance
+    # @param [Number] timeout
+    # @return [Boolean]
+    def deploy_instance_rolling(instance, elb, timeout = 600)
+      if !elb.nil?
+        elb.remove_instance(instance)
       end
 
-      create_deployment({name: 'deploy'}, instance_ids, timeout)
+      success = create_deployment({name: 'deploy'}, [instance], timeout)
+
+      # only add instance back to elb if deployment succeeded
+      if !elb.nil? && success
+        success = elb.add_instance(instance)
+      end
+
+      success
     end
 
-    # deploy to all layers except specified layer
+    # Deploy to all layers except specified layer (non-rolling)
+    # @param [String] layer_name
+    # @param [Number] timeout
+    # @return [Boolean]
     def deploy_exclude(layer_name, timeout = 600)
       puts "Deploying to all layers except #{layer_name}".light_white.bold
       create_deployment_exclude({name: 'deploy'}, layer_name, timeout)
     end
 
+    # Creates an OpsWorks deployment with specified command on all layers excluding layer_to_exclude
+    # @param [Object] command - Opsworks deployment command
+    # @param [String] layer_to_exclude
+    # @param [Number] timeout
+    # @return [Boolean]
     def create_deployment_exclude(command, layer_to_exclude, timeout)
-      all_instance_ids = get_instances.map(&:instance_id)
-      excluded_instance_ids = get_instances(layer_to_exclude).map(&:instance_id)
-      included_instance_ids = all_instance_ids - excluded_instance_ids
+      all_instances = get_instances
+      excluded_instances = get_instances(layer_to_exclude)
+      included_instances = all_instances - excluded_instances
 
-      create_deployment(command, included_instance_ids, timeout)
+      create_deployment(command, included_instances, timeout)
     end
 
-    def create_deployment(command, instance_ids, timeout)
+    # Creates an OpsWorks deployment with specified command
+    # If @instances is not nil, the deployment will only be performed on specified instances
+    # @param [Object] command
+    # @param [Array[Object]] instances
+    # @param [Number] timeout
+    # @return [Boolean]
+    def create_deployment(command, instances, timeout)
+      instance_ids = nil
+      instance_description = "all instances"
+
+      if !instances.nil?
+        instance_ids = instances.map(&:instance_id)
+        instance_description = instances.map(&:hostname).join(',')
+      end
+
       deployment_config = {
           stack_id: opsworks_app[:stack_id],
           app_id: app_id,
@@ -99,12 +189,13 @@ module OpsworksWrapper
           comment: "Git Sha: #{current_sha}"
       }
 
-      deployment = client.create_deployment(deployment_config)
-      puts "Deployment created: #{deployment[:deployment_id]}".blue
-      puts "Running Command: #{command[:name]} ".light_blue
+      deployment = opsworks_client.create_deployment(deployment_config)
+      print "Running command ".light_blue
+      print "#{command[:name]}".light_blue.bold
+      puts " on #{instance_description}".light_blue
 
       begin
-        wait_until_deployed(deployment[:deployment_id], timeout)
+        _wait_until_deployed(deployment[:deployment_id], timeout)
         puts "Deployment successful".green
         true
       rescue Aws::Waiters::Errors::WaiterFailed => e
@@ -114,8 +205,8 @@ module OpsworksWrapper
     end
 
     # Waits on the provided deployment for specified timeout (seconds)
-    def wait_until_deployed(deployment_id, timeout)
-      client.wait_until(:deployment_successful, deployment_ids: [deployment_id]) do |w|
+    def _wait_until_deployed(deployment_id, timeout)
+      opsworks_client.wait_until(:deployment_successful, deployment_ids: [deployment_id]) do |w|
         w.before_attempt do |attempt|
           puts "Attempt #{attempt} to check deployment status".light_black
         end
@@ -123,7 +214,110 @@ module OpsworksWrapper
         w.max_attempts = timeout / w.interval
       end
     end
-    private :wait_until_deployed
+
+  end
+
+  class ELB
+    require 'aws-sdk'
+    require 'colorize'
+
+    def initialize(name)
+      @name = name
+    end
+
+    def name
+      @name
+    end
+
+    def client
+      @client ||= Aws::ElasticLoadBalancing::Client.new
+    end
+
+    def attributes
+      @attributes ||= client.describe_load_balancer_attributes(load_balancer_name: name)
+    end
+
+    def health_check
+      elb = client.describe_load_balancers(load_balancer_names: [name]).load_balancer_descriptions.first
+      @health_check ||= elb.health_check
+    end
+
+    # Determines if elb has connection draining enabled and waits for the timeout period or (20s) default
+    def _wait_for_connection_draining
+      connection_draining = attributes.load_balancer_attributes.connection_draining
+      if connection_draining.enabled
+        timeout = connection_draining.timeout
+        puts "Connection Draining Enabled - sleeping for #{timeout}".light_black
+        sleep(timeout)
+      else
+        puts "Connection Draining Disabled - sleeping for 20 seconds".light_black
+        sleep(20)
+      end
+    end
+
+    # Waits on instance to be in service according to the ELB
+    # @param [Object] instance
+    # @return [Boolean]
+    def _wait_for_instance_health_check(instance)
+      health_threshold = health_check.healthy_threshold
+      interval = health_check.interval
+
+      # wait a little longer than the defined threshold to account for application launch time
+      timeout = ((health_threshold + 2) * interval)
+
+      begin
+        client.wait_until(:instance_in_service, {load_balancer_name: name,
+                                                 instances: [{instance_id: instance.ec2_instance_id}]}) do |w|
+          w.before_attempt do |attempt|
+            puts "Attempt #{attempt} to check health status for #{instance.hostname}".light_black
+          end
+          w.interval = 10
+          w.max_attempts = timeout / w.interval
+        end
+        puts "Instance #{instance.hostname} is now InService".green
+        true
+      rescue Aws::Waiters::Errors::WaiterFailed => e
+        puts "Instance #{instance.hostname} failed to move to InService, #{e.message}".red
+        false
+      end
+
+    end
+
+    # Removes instance from ELB and waits for connection draining
+    # @param [Object] instance - object with ec2_instance_id and hostname
+    def remove_instance(instance)
+      deregister_response = client.deregister_instances_from_load_balancer(load_balancer_name: name,
+                                                                           instances: [{instance_id: instance.ec2_instance_id}])
+      remaining_instance_count = deregister_response.instances.size
+      puts "Removed #{instance.hostname} from ELB #{name}. Remaining instances: #{remaining_instance_count}".light_blue
+      _wait_for_connection_draining
+    end
+
+    # Adds instance to ELB and waits for instance health check to pass
+    # @param [Object] instance - object with ec2_instance_id and hostname
+    # @return [Boolean]
+    def add_instance(instance)
+      register_response = client.register_instances_with_load_balancer(load_balancer_name: name,
+                                                                       instances: [{instance_id: instance.ec2_instance_id}])
+      remaining_instance_count = register_response.instances.size
+      puts "Added #{instance.hostname} to ELB #{name}. Attached instances: #{remaining_instance_count}".light_blue
+      _wait_for_instance_health_check(instance)
+    end
+
+    # Checks whether an instance attached to ELB is healthy
+    # @param [Object] instance - object with ec2_instance_id and hostname
+    # @return [Boolean]
+    def is_instance_healthy(instance)
+      instance_health = client.describe_instance_health(load_balancer_name: name,
+                                                        instances: [{instance_id: instance.ec2_instance_id}])
+      state_info = instance_health.instance_states.first
+      status_detail = ''
+      if state_info.state != 'InService'
+        status_detail = "#{state_info.reason_code} - #{state_info.description}."
+      end
+      puts "Instance state is #{state_info.state} #{status_detail}"
+      state_info.state == 'InService'
+    end
 
   end
 end

data/opsworks_wrapper.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "opsworks_wrapper"
-  spec.version       = '0.1.0'
+  spec.version       = '0.2.0'
   spec.authors       = ["Umair Kayani", "Calvin Fernandes"]
   spec.email         = ["ukayani@loyalty.com", "cfernandes@loyalty.com"]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opsworks_wrapper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Umair Kayani
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-15 00:00:00.000000000 Z
+date: 2016-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -82,7 +82,6 @@ files:
 - README.md
 - Rakefile
 - lib/opsworks_wrapper.rb
-- lib/opsworks_wrapper/version.rb
 - opsworks_wrapper.gemspec
 homepage: https://github.com/ukayani/opsworks-wrapper
 licenses:

data/lib/opsworks_wrapper/version.rb

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