skyed 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4919c799f528c92156839651694c2daea7d0ad2
-  data.tar.gz: d327289353ebc57d40bb4c52e258ae1491471c1d
+  metadata.gz: b3dff20f796f444c5110db4e24ab5fbe30640f2a
+  data.tar.gz: 4c90c8a4b5d6f667ee8f4d21e3734c1dd9a09146
 SHA512:
-  metadata.gz: 5dafeb6a8f80a254dac4a235093dba68771fbc9d4b7373359231bba304815cdb2e456e4842bb7254cf9c3fe48998b7f450d78e7ee0bb29a47932368e2897c8a5
-  data.tar.gz: 8055ad8d312c27a1e06379ef45dc7d76c607642e4e5b848f9aa4116d5995d07e6ce9fdaffd860af48898439a6b655964bb0f374f62474301eec744156778cc74
+  metadata.gz: b7c950fbf09f8d159da451fcb1cb89c5775de866b224d18396373724f480db5028054cff8a9bc6cf49079fbffbaa91b2e168c2f78efcd63d905da893551ff739
+  data.tar.gz: dd78e8e85aacf0f4ea3aea195d8450759a245503b14268caffa25a53dbe5204f7b723ea1bc60393ccde03abd0274e4ec235724d6443aef47f28433c2adabe8fc

data/lib/skyed/aws.rb

@@ -66,6 +66,98 @@ module Skyed
       }
 
       class << self
+        def stack(stack_criteria, opsworks)
+          stack_by_name(
+            stack_criteria,
+            opsworks
+          ) || stack_by_id(stack_criteria, opsworks)
+        end
+
+        def layer(layer_criteria, opsworks)
+          layer_by_name(
+            layer_criteria,
+            opsworks
+          ) || layer_by_id(layer_criteria, opsworks)
+        end
+
+        def deploy(opts)
+          xtra = { instance_ids: opts[:instance_ids] }
+          xtra[:custom_json] = opts[:custom_json] if opts.key? :custom_json
+          Skyed::AWS::OpsWorks.wait_for_deploy(
+            opts[:client].create_deployment(
+              Skyed::AWS::OpsWorks.generate_deploy_params(
+                opts[:stack_id],
+                opts[:command],
+                xtra)),
+            opts[:client],
+            opts[:wait_interval])
+        end
+
+        def layer_by_id(layer_id, opsworks)
+          layers(opsworks).select { |x| x[:layer_id] == layer_id }[0] || nil
+        end
+
+        def layer_by_name(layer_name, opsworks)
+          layers(opsworks).select { |x| x[:name] == layer_name }[0] || nil
+        end
+
+        def layers(opsworks)
+          opsworks.describe_layers(stack_id: Skyed::Settings.stack_id)[:layers]
+        end
+
+        def stack_by_id(stack_id, opsworks)
+          stacks(opsworks).select { |x| x[:stack_id] == stack_id }[0] || nil
+        end
+
+        def running_instances(options = {}, opsworks)
+          instances = opsworks.describe_instances(options)
+          instances[:instances].map do |instance|
+            instance[:instance_id] if instance[:status] != 'stopped'
+          end.compact
+        end
+
+        def instance_by_name(hostname, stack_id, opsworks)
+          opsworks.describe_instances(
+            stack_id: stack_id)[:instances].select do |i|
+            i.hostname == hostname
+          end[0]
+        end
+
+        def wait_for_deploy(deploy, opsworks, wait = 0)
+          status = Skyed::AWS::OpsWorks.deploy_status(deploy, opsworks)
+          while status[0] == 'running'
+            sleep(wait)
+            status = Skyed::AWS::OpsWorks.deploy_status(deploy, opsworks)
+          end
+          status
+        end
+
+        def deploy_status(deploy, opsworks)
+          deploy = opsworks.describe_deployments(
+            deployment_ids: [deploy[:deployment_id]])
+          deploy[:deployments].map do |s|
+            s[:status]
+          end.compact
+        end
+
+        def generate_deploy_params(stack_id, command, options = {})
+          options = {} if options.nil?
+          params = {
+            stack_id: stack_id,
+            command: generate_command_params(command)
+          }
+          params.merge(options)
+        end
+
+        def generate_command_params(options = {})
+          response = options
+          response = {
+            name: options[:name],
+            args: options.reject { |k, _v| k == :name }
+          } unless options[:name] != 'execute_recipes'
+          response
+        end
+
         def create_layer(layer_params, opsworks)
           layer = opsworks.create_layer(layer_params)
           Skyed::Settings.layer_id = layer.data[:layer_id]
@@ -179,6 +271,52 @@ module Skyed
     # This module encapsulates all the IAM related functions.
     module IAM
       class << self
+        def remove_user_from_group(user, group)
+          iam = login
+          puts "Removes #{user} from #{group}"
+          iam.remove_user_from_group(
+            group_name: group,
+            user_name: user)
+        rescue Aws::IAM::Errors::NoSuchEntity
+          puts "User #{user} already removed from group #{group}"
+        end
+
+        def clear_user_access_keys(user)
+          iam = login
+          iam.list_access_keys(
+            user_name: user)[:access_key_metadata].each do |access_key|
+            id = access_key.to_h[:access_key_id]
+            puts "Delete access key #{id}"
+            iam.delete_access_key(user_name: user, access_key_id: id)
+          end
+        rescue Aws::IAM::Errors::NoSuchEntity
+          puts "User #{user} access keys already removed"
+        end
+
+        def clear_user_policies(user)
+          iam = login
+          iam.list_user_policies(
+            user_name: user)[:policy_names].each do |policy|
+            puts "Delete user policy #{policy}"
+            iam.delete_user_policy(user_name: user, policy_name: policy)
+          end
+        rescue Aws::IAM::Errors::NoSuchEntity
+          puts "User #{user} policies already removed"
+        end
+
+        def delete_user(user)
+          iam = login
+          clear_user_policies user
+          clear_user_access_keys user
+          remove_user_from_group user, "OpsWorks-#{Skyed::Settings.stack_id}"
+          puts "Delete group OpsWorks-#{Skyed::Settings.stack_id}"
+          iam.delete_group(group_name: "OpsWorks-#{Skyed::Settings.stack_id}")
+          puts "Delete User #{user}"
+          iam.delete_user(user_name: user)
+        rescue Aws::IAM::Errors::NoSuchEntity
+          puts "User #{user} already removed"
+        end
+
         def login(
           access = Skyed::Settings.access_key,
           secret = Skyed::Settings.secret_key,

data/lib/skyed/destroy.rb

@@ -7,11 +7,34 @@ module Skyed
         hostname = `cd #{repo_path} && vagrant ssh -c hostname`.strip
         `cd #{repo_path} && vagrant destroy -f`
         ow = Skyed::AWS::OpsWorks.login
-        instances = ow.describe_instances(stack_id: Skyed::Settings.stack_id)
-        instances[:instances].each do |instance|
-          if instance[:hostname] == hostname
-            ow.deregister_instance(instance_id: instance[:instance_id])
-          end
+        deregister_instance hostname, ow
+        delete_user ow
+      end
+
+      def deregister_instance(hostname, ow)
+        instance = Skyed::AWS::OpsWorks.instance_by_name(
+          hostname, Skyed::Settings.stack_id, ow)
+        ow.deregister_instance(
+          instance_id: instance.instance_id) unless instance.nil?
+        wait_for_instance(
+          hostname, Skyed::Settings.stack_id, ow)
+      end
+
+      def delete_user(ow)
+        stack = ow.describe_stacks(
+          stack_ids: [Skyed::Settings.stack_id])[:stacks][0][:name]
+        layer = ow.describe_layers(
+          layer_ids: [Skyed::Settings.layer_id])[:layers][0][:name]
+        Skyed::AWS::IAM.delete_user "OpsWorks-#{stack}-#{layer}"
+      end
+
+      def wait_for_instance(hostname, stack_id, opsworks)
+        instance = Skyed::AWS::OpsWorks.instance_by_name(
+          hostname, stack_id, opsworks)
+        until instance.nil? || instance.status == 'terminated'
+          sleep(0)
+          instance = Skyed::AWS::OpsWorks.instance_by_name(
+            hostname, stack_id, opsworks)
         end
       end
     end

data/lib/skyed/run.rb

@@ -17,66 +17,36 @@ module Skyed
         ow = login
         Skyed::Settings.stack_id = stack(ow, options)
         Skyed::Settings.layer_id = layer(ow, options)
-        instances = running_instances(ow, Skyed::Settings.layer_id)
+        instances = Skyed::AWS::OpsWorks.running_instances(
+          { layer_id: Skyed::Settings.layer_id },
+          ow)
         update_custom_cookbooks(ow, Skyed::Settings.stack_id, instances,
                                 options[:wait_interval])
         execute_recipes(ow, args, instances, options)
       end
 
-      def deploy_status(ow, id)
-        deploy = ow.describe_deployments(deployment_ids: [id[:deployment_id]])
-        deploy[:deployments].map do |s|
-          s[:status]
-        end.compact
-      end
-
-      def wait_for_deploy(ow, deploy_id, wait = 0)
-        status = deploy_status(ow, deploy_id)
-        while status[0] == 'running'
-          sleep(wait)
-          status = deploy_status(ow, deploy_id)
-        end
-        fail 'Deployment failed' unless status[0] == 'successful'
-        status
-      end
-
       def update_custom_cookbooks(ow, stack_id, instances, wait = 0)
-        command = { name: 'update_custom_cookbooks' }
-        wait_for_deploy(ow, ow.create_deployment(
+        status = Skyed::AWS::OpsWorks.deploy(
           stack_id: stack_id,
+          command: { name: 'update_custom_cookbooks' },
           instance_ids: instances,
-          command: command), wait)
-      end
-
-      def running_instances(ow, layer_id)
-        instances = ow.describe_instances(layer_id: layer_id)
-        instances[:instances].map do |instance|
-          instance[:instance_id] if instance[:status] != 'stopped'
-        end.compact
+          client: ow,
+          wait_interval: wait)
+        fail 'Deployment failed' unless status[0] == 'successful'
       end
 
       def layer(ow, options)
-        layers = ow.describe_layers(stack_id: options[:stack])[:layers]
-        layer = nil
-        layers.each do |layer_reply|
-          id = layer_reply[:layer_id]
-          layer = id if id == options[:layer]
-        end
+        layer = Skyed::AWS::OpsWorks.layer(options[:layer], ow)
         msg = "There's no such layer with id #{options[:layer]}"
         fail msg unless layer
-        layer
+        layer[:layer_id]
       end
 
       def stack(ow, options)
-        stacks = ow.describe_stacks[:stacks]
-        stack = nil
-        stacks.each do |stack_reply|
-          id = stack_reply[:stack_id]
-          stack = id if id == options[:stack]
-        end
+        stack = Skyed::AWS::OpsWorks.stack(options[:stack], ow)
         msg = "There's no such stack with id #{options[:stack]}"
         fail msg unless stack
-        stack
+        stack[:stack_id]
       end
 
       def login
@@ -104,24 +74,17 @@ module Skyed
         recipes
       end
 
-      def execute_recipes(
-        ow,
-        recipes,
-        instances = nil,
-        options = {})
-        options[:wait_interval] ||= 0
-        options[:custom_json] ||= ''
-        deploy_id = ow.create_deployment(
-          execute_params(recipes, instances, options[:custom_json]))
-        wait_for_deploy(ow, deploy_id, options[:wait_interval])
-      end
-
-      def execute_params(recipes, instances, custom_json)
-        command = { name: 'execute_recipes', args: { recipes: recipes } }
-        deploy_params = { stack_id: Skyed::Settings.stack_id, command: command }
-        deploy_params[:custom_json] = custom_json unless custom_json.empty?
-        deploy_params[:instance_ids] = instances unless instances.nil?
-        deploy_params
+      def execute_recipes(ow, recipes, instances = nil, opts = {})
+        args = {
+          stack_id: Skyed::Settings.stack_id,
+          command: { name: 'execute_recipes', recipes: recipes },
+          instance_ids: instances,
+          client: ow,
+          wait_interval: opts[:wait_interval] || 0
+        }
+        args[:custom_json] = opts[:custom_json] if opts.key? :custom_json
+        status = Skyed::AWS::OpsWorks.deploy(args)
+        fail 'Deployment failed' unless status[0] == 'successful'
       end
 
       def recipe_in_cookbook(recipe)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skyed
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Ignasi Fosch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-04 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git