skyed 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c191f7b0605dc2e8d68779b5cd1eaf2712e43447
-  data.tar.gz: d1daad8c34f40f89dfd6fc28d9c794465f15b564
+  metadata.gz: 252c06eb53f9953de17404e021ee2f3deb44fe4f
+  data.tar.gz: 4e920d1b31974964520910e9f71c07eed3f9a8b6
 SHA512:
-  metadata.gz: 0ba58d81e95e50e8258abb2ff06a4c775c24eb4b17356939239f94179abf150ac750dc4fac4f97f248fe19030fd310e21c367ad5c0c6e739636eb0c952523a90
-  data.tar.gz: 792ce1e3b5756bbfae02b31e39111ba7d7cece30f1c65cadef1656ab52c319ccb7d952e259248974a8f51ac1c351c34b496d7f354a8342cbbdba2c177df86e9d
+  metadata.gz: 427e9d0a29fb3f1e77f64f76d0e81f415d96600bfb7b85ccba869744d5a9e101acd149658964d9e0762496088fecf2d7c108cd043250a0f3bd3044c81fe2b346
+  data.tar.gz: 2a305e4db96e5029f28d35c3a64eb1fdceab0fa572ca30c67f1ce1c96b94de71b1bc250f253693f56fa34ef207d12cc8b51a280d37b86fab1a25cb6a9b34ca11

data/lib/skyed.rb

@@ -1,5 +1,6 @@
 require 'skyed/list'
 require 'skyed/create'
+require 'skyed/check'
 require 'skyed/utils'
 require 'skyed/git'
 require 'skyed/aws'
@@ -12,5 +13,5 @@ require 'skyed/settings'
 
 # Skyed is a set of tools for cloud computing
 module Skyed
-  VERSION = '0.1.12'
+  VERSION = '0.1.13'
 end

data/lib/skyed/aws.rb

@@ -38,6 +38,46 @@ module Skyed
       end
     end
 
+    # This module encapsulates all the RDS related functions.
+    module ELB
+      class << self
+        def instance_ok?(elb_name, ec2_instance_id, elb = nil)
+          elb.describe_instance_health(
+            load_balancer_name: elb_name,
+            instances: [{ instance_id: ec2_instance_id }]
+          ).instance_states[0].state == 'InService'
+        end
+
+        def set_health_check(elb_name, health_check, elb = nil)
+          elb.configure_health_check(
+            load_balancer_name: elb_name,
+            health_check: {
+              target: health_check.target,
+              interval: health_check.interval,
+              timeout: health_check.timeout,
+              unhealthy_threshold: health_check.unhealthy_threshold,
+              healthy_threshold: health_check.healthy_threshold
+            }
+          )
+        end
+
+        def get_health_check(elb_name, elb = nil)
+          elbs = elb.describe_load_balancers(load_balancer_names: [elb_name])
+          elbs.load_balancer_descriptions[0].health_check
+        end
+
+        def login(
+          access = Skyed::Settings.access_key,
+          secret = Skyed::Settings.secret_key,
+          region = Skyed::AWS.region)
+          Aws::ElasticLoadBalancing::Client.new(
+            access_key_id: access,
+            secret_access_key: secret,
+            region: region)
+        end
+      end
+    end
+
     # This module encapsulates all the RDS related functions.
     module RDS
       class << self
@@ -237,11 +277,15 @@ module Skyed
           ) || stack_by_id(stack_criteria, opsworks)
         end
 
-        def layer(layer_criteria, opsworks)
-          layer_by_name(
-            layer_criteria,
-            opsworks
-          ) || layer_by_id(layer_criteria, opsworks)
+        def layer(layer_criteria, opsworks, stack_id = nil)
+          layer = layer_by_name(layer_criteria, opsworks) ||
+                  layer_by_id(layer_criteria, opsworks)
+          instance = nil
+          instance = instance_by_name(
+            layer_criteria, stack_id, opsworks) unless stack_id.nil?
+          layer ||= layer_by_id(
+            instance.layer_ids[0], opsworks) unless instance.nil?
+          layer
         end
 
         def deploy(opts)

data/lib/skyed/check.rb

@@ -0,0 +1,64 @@
+module Skyed
+  # This module encapsulates all the create command steps.
+  module Check
+    class << self
+      def execute(_global_options, options, args)
+        settings(options)
+        elb = login('elb')
+        original_health_check = Skyed::AWS::ELB.get_health_check(args[0], elb)
+        reduce_health_check(args[0], original_health_check, elb)
+        wait_for_backend_restart(args[0], args[1], options)
+        Skyed::AWS::ELB.set_health_check(args[0], original_health_check, elb)
+      end
+
+      def wait_for_backend_restart(elb_name, instance_name, opts)
+        ow = settings(opts)
+        instance = Skyed::AWS::OpsWorks.instance_by_name(
+          instance_name,
+          Skyed::Settings.stack_id,
+          ow)
+        elb = login('elb')
+        [true, false].each do |op|
+          wait_for_backend(
+            elb_name, instance.ec2_instance_id, elb, op, opts[:wait_interval])
+        end
+      end
+
+      def wait_for_backend(elb_name, ec2_instance_id, elb, ok = true, wait = 0)
+        until ok == Skyed::AWS::ELB.instance_ok?(
+          elb_name,
+          ec2_instance_id,
+          elb
+        )
+          Kernel.sleep(wait)
+        end
+      end
+
+      def reduce_health_check(elb_name, original_health_check, elb = nil)
+        elb = login('elb') if elb.nil?
+        new_health_check = original_health_check.clone
+        new_health_check.timeout = 2
+        new_health_check.interval = 5
+        new_health_check.unhealthy_threshold = 2
+        new_health_check.healthy_threshold = 2
+        Skyed::AWS::ELB.set_health_check(elb_name, new_health_check, elb)
+      end
+
+      def settings(options)
+        ow = login('ow')
+        Skyed::Settings.stack_id = Skyed::AWS::OpsWorks.stack(
+          options[:stack], ow)[:stack_id]
+        Skyed::Settings.layer_id = Skyed::AWS::OpsWorks.layer(
+          options[:layer], ow)[:layer_id]
+        ow
+      end
+
+      def login(kind = 'elb')
+        Skyed::Init.credentials if Skyed::Settings.empty?
+        result = Skyed::AWS::ELB.login if kind == 'elb'
+        result = Skyed::AWS::OpsWorks.login if kind == 'ow'
+        result
+      end
+    end
+  end
+end

data/lib/skyed/commands.rb

@@ -46,6 +46,9 @@ command :run do |cmd|
   cmd.flag [:l, :layer], default_value: nil,
                          type: String,
                          desc: layer_desc
+  cmd.flag [:i, :instance], default_value: nil,
+                            type: String,
+                            desc: layer_desc
   desc = 'Time to wait for AWS responses'
   cmd.flag [:w, :wait_interval, 'wait-interval'], default_value: 30,
                                                   type: Integer,
@@ -146,3 +149,23 @@ command :list do |cmd|
     Skyed::List.execute(global_options, options, args)
   end
 end
+
+desc 'Check ELB'
+long_desc 'Check ELB'
+
+start_desc = 'Allows check ELB health state'
+command :check do |cmd|
+  cmd.flag [:s, :stack], default_value: nil,
+                         type: String,
+                         desc: stack_desc
+  cmd.flag [:l, :layer], default_value: nil,
+                         type: String,
+                         desc: layer_desc
+  desc = 'Time to wait for AWS responses'
+  cmd.flag [:w, :wait_interval, 'wait-interval'], default_value: 30,
+                                                  type: Integer,
+                                                  desc: desc
+  cmd.action do |global_options, options, args|
+    Skyed::Check.execute(global_options, options, args)
+  end
+end

data/lib/skyed/run.rb

@@ -15,14 +15,23 @@ module Skyed
       def run(_global_options, options, args)
         check_run_options(options)
         ow = settings(options)
-        instances = Skyed::AWS::OpsWorks.running_instances(
-          { layer_id: Skyed::Settings.layer_id },
-          ow)
+        instances = select_instances(options, ow)
         update_custom_cookbooks(ow, Skyed::Settings.stack_id, instances,
                                 options[:wait_interval])
         execute_recipes(ow, args, instances, options)
       end
 
+      def select_instances(options, ow)
+        instances = nil
+        instances = Skyed::AWS::OpsWorks.running_instances(
+          { layer_id: Skyed::Settings.layer_id },
+          ow) unless options[:layer].nil?
+        instances = [Skyed::AWS::OpsWorks.instance_by_name(
+          options[:instance], Skyed::Settings.stack_id,
+          ow).instance_id] unless options[:instance].nil?
+        instances
+      end
+
       def settings(options)
         ow = login
         Skyed::Settings.stack_id = stack(ow, options)
@@ -42,7 +51,10 @@ module Skyed
 
       def layer(ow, options)
         layer = Skyed::AWS::OpsWorks.layer(options[:layer], ow)
+        layer = Skyed::AWS::OpsWorks.layer(
+          options[:instance], ow, Skyed::Settings.stack_id) unless layer
         msg = "There's no such layer with id #{options[:layer]}"
+        msg += " or for instance #{options[:instance]}"
         fail msg unless layer
         layer[:layer_id]
       end
@@ -61,7 +73,8 @@ module Skyed
 
       def check_run_options(options)
         msg = 'Specify stack and layer or initialize for local management'
-        fail msg unless options[:stack] && options[:layer]
+        required = options[:stack] && (options[:layer] || options[:instance])
+        fail msg unless required
       end
 
       def check_vagrant

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skyed
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Ignasi Fosch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-30 00:00:00.000000000 Z
+date: 2015-12-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -76,6 +76,7 @@ files:
 - bin/skyed
 - lib/skyed.rb
 - lib/skyed/aws.rb
+- lib/skyed/check.rb
 - lib/skyed/commands.rb
 - lib/skyed/create.rb
 - lib/skyed/deploy.rb