skyed 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b3dff20f796f444c5110db4e24ab5fbe30640f2a
-  data.tar.gz: 4c90c8a4b5d6f667ee8f4d21e3734c1dd9a09146
+  metadata.gz: 9135fef3c347f9bd2ffcc03c6a9621aaa8429f5f
+  data.tar.gz: ae7793935198775b5bc8afad4378b29cf337495b
 SHA512:
-  metadata.gz: b7c950fbf09f8d159da451fcb1cb89c5775de866b224d18396373724f480db5028054cff8a9bc6cf49079fbffbaa91b2e168c2f78efcd63d905da893551ff739
-  data.tar.gz: dd78e8e85aacf0f4ea3aea195d8450759a245503b14268caffa25a53dbe5204f7b723ea1bc60393ccde03abd0274e4ec235724d6443aef47f28433c2adabe8fc
+  metadata.gz: 0219be28bd5d5fd6612e01f6f0b5cd2f55123fe0d6ae141ad3df5fcd16dc09b7bd744f403513c237b0940d72ba5687232c42cf881e726429f90f3520a2737144
+  data.tar.gz: d0decb2b5c243ae2059bd753b18282447875a5bc3387d7b484e14120d72f16ac0ceb0df3b031f97b688b148933a31fa2f1e158f09471b0a0606163b2671aa894

data/lib/skyed.rb

@@ -1,4 +1,7 @@
+require 'skyed/list'
+require 'skyed/create'
 require 'skyed/utils'
+require 'skyed/git'
 require 'skyed/aws'
 require 'skyed/destroy'
 require 'skyed/run'

data/lib/skyed/aws.rb

@@ -38,6 +38,100 @@ module Skyed
       end
     end
 
+    # This module encapsulates all the RDS related functions.
+    module RDS
+      class << self
+        def create_instance_from_snapshot(
+          instance_name,
+          snapshot,
+          _options,
+          rds = nil)
+          rds = login if rds.nil?
+          rds.restore_db_instance_from_db_snapshot(
+            db_instance_identifier: instance_name,
+            db_snapshot_identifier: snapshot)[:db_instance]
+          db_instance = wait_for_instance(instance_name, 'available', 0, rds)
+          "#{db_instance[:endpoint][:address]}:#{db_instance[:endpoint][:port]}"
+        end
+
+        def list_snapshots(_options, args, rds = nil)
+          rds = login if rds.nil?
+          request = {}
+          request[:db_instance_identifier] = args.first unless args.nil?
+          response = rds.describe_db_snapshots(request)
+          response.db_snapshots
+        end
+
+        def destroy_instance(instance_name, options, rds = nil)
+          rds = login if rds.nil?
+          rds.delete_db_instance(
+            generate_params(instance_name, options))[:db_instance]
+        end
+
+        def generate_delete_params(instance_name, options)
+          snapshot = !options[:final_snapshot_name].empty?
+          params = {
+            db_instance_identifier: instance_name,
+            skip_final_snapshot: !snapshot
+          }
+          params[
+            :final_snapshot_name] = options[:final_snapshot_name] if snapshot
+          params
+        end
+
+        def generate_create_params(instance_name, options)
+          {
+            db_instance_identifier: instance_name,
+            allocated_storage: options[:size],
+            db_instance_class: "db.#{options[:type]}",
+            engine: 'postgres',
+            master_username: options[:user],
+            master_user_password: options[:password],
+            db_security_groups: [options[:db_security_group]],
+            db_parameter_group_name: options[:db_parameters_group]
+          }
+        end
+
+        def wait_for_instance(instance_name, status, wait = 0, rds = nil)
+          rds = login if rds.nil?
+          instance = rds.describe_db_instances(
+            db_instance_identifier: instance_name)[:db_instances][0]
+          while instance[:db_instance_status] != status
+            sleep(wait)
+            instance = rds.describe_db_instances(
+              db_instance_identifier: instance_name)[:db_instances][0]
+          end
+          instance
+        end
+
+        def generate_params(instance_name, options)
+          params = generate_delete_params(
+            instance_name, options) if options.key? :final_snapshot_name
+          params = generate_create_params(
+            instance_name, options) if options.key? :user
+          params
+        end
+
+        def create_instance(instance_name, options, rds = nil)
+          rds = login if rds.nil?
+          rds.create_db_instance(
+            generate_params(instance_name, options))[:db_instance]
+          db_instance = wait_for_instance(instance_name, 'available', 0, rds)
+          "#{db_instance[:endpoint][:address]}:#{db_instance[:endpoint][:port]}"
+        end
+
+        def login(
+          access = Skyed::Settings.access_key,
+          secret = Skyed::Settings.secret_key,
+          region = Skyed::AWS.region)
+          Aws::RDS::Client.new(
+            access_key_id: access,
+            secret_access_key: secret,
+            region: region)
+        end
+      end
+    end
+
     # This module encapsulates all the OpsWorks related functions.
     module OpsWorks
       STACK = {
@@ -66,6 +160,33 @@ module Skyed
       }
 
       class << self
+        def deregister_instance(hostname, opsworks)
+          instance = instance_by_name(
+            hostname, Skyed::Settings.stack_id, opsworks)
+          opsworks.deregister_instance(
+            instance_id: instance.instance_id) unless instance.nil?
+          wait_for_instance(
+            hostname, Skyed::Settings.stack_id, 'terminated', opsworks)
+        end
+
+        def delete_user(opsworks)
+          stack = opsworks.describe_stacks(
+            stack_ids: [Skyed::Settings.stack_id])[:stacks][0][:name]
+          layer = opsworks.describe_layers(
+            layer_ids: [Skyed::Settings.layer_id])[:layers][0][:name]
+          Skyed::AWS::IAM.delete_user "OpsWorks-#{stack}-#{layer}"
+        end
+
+        def wait_for_instance(instance_name, stack_id, status, opsworks)
+          instance = Skyed::AWS::OpsWorks.instance_by_name(
+            instance_name, stack_id, opsworks)
+          until instance.nil? || instance.status == status
+            sleep(0)
+            instance = Skyed::AWS::OpsWorks.instance_by_name(
+              instance_name, stack_id, opsworks)
+          end
+        end
+
         def stack(stack_criteria, opsworks)
           stack_by_name(
             stack_criteria,
@@ -239,6 +360,7 @@ module Skyed
 
         def generate_stack_params(options)
           params = basic_stack_params
+          params[:custom_json] = options[:custom_json] || ''
           params[:custom_cookbooks_source] = custom_cookbooks_source(
             STACK[:custom_cookbooks_source])
           params[:configuration_manager] = configuration_manager(

data/lib/skyed/commands.rb

@@ -2,12 +2,22 @@ desc 'Initialize skyed'
 long_desc 'Sets up skyed configuration for a repository'
 
 command :init do |cmd|
-  cmd.flag :remote, default_value: nil,
+  cmd.flag [:remote], default_value: nil,
+                      type: String,
+                      desc: 'Remote to use in OpsWorks'
+  cmd.flag [:repo], default_value: '.',
                     type: String,
-                    desc: 'Remote to use in OpsWorks'
-  cmd.flag :chef_version, default_value: '11.10',
-                          type: String,
-                          desc: 'Chef version to use in OpsWorks'
+                    desc: 'OpsWorks repository location'
+  cmd.flag [:repo_key, 'repo-key'], default_value: nil,
+                                    type: String,
+                                    desc: 'Key to use with repo'
+  cmd.flag [:j, :custom_json, 'custom-json'], default_value: '',
+                                              type: String,
+                                              desc: 'Custom JSON to pass to OW'
+  desc = 'Chef version to use in OpsWorks'
+  cmd.flag [:chef_version, 'chef-version'], default_value: '11.10',
+                                            type: String,
+                                            desc: desc
   cmd.action do |global_options, options|
     Skyed::Init.execute(global_options, options)
   end
@@ -34,12 +44,13 @@ command :run do |cmd|
   cmd.flag [:l, :layer], default_value: nil,
                          type: String,
                          desc: layer_desc
-  cmd.flag [:w, :wait_interval], default_value: 30,
-                                 type: Integer,
-                                 desc: 'Time to wait for AWS responses'
-  cmd.flag [:j, :custom_json], default_value: '',
-                               type: String,
-                               desc: 'Custom JSON to pass to OW'
+  desc = 'Time to wait for AWS responses'
+  cmd.flag [:w, :wait_interval, 'wait-interval'], default_value: 30,
+                                                  type: Integer,
+                                                  desc: desc
+  cmd.flag [:j, :custom_json, 'custom-json'], default_value: '',
+                                              type: String,
+                                              desc: 'Custom JSON to pass to OW'
   cmd.action do |global_options, options, args|
     Skyed::Run.execute(global_options, options, args)
   end
@@ -49,7 +60,58 @@ desc 'Destroy instance'
 long_desc 'Destroy instance'
 
 command :destroy do |cmd|
+  cmd.switch [:rds], default_value: false,
+                     desc: 'Destroys RDS instance'
+  desc = 'Final snapshot name. Ommit to skip'
+  cmd.flag [:final_snapshot_name, 'final-snapshot-name'], default_value: '',
+                                                          type: String,
+                                                          desc: desc
   cmd.action do |global_options, options, args|
     Skyed::Destroy.execute(global_options, options, args)
   end
 end
+
+desc 'Create instance'
+long_desc 'Create instance'
+
+command :create do |cmd|
+  cmd.switch [:rds], default_value: false,
+                     desc: 'Creates RDS instance'
+  cmd.flag [:size], default_value: 100,
+                    type: Integer,
+                    desc: 'Size of the RDS instance'
+  cmd.flag [:type], default_value: 'm1.large',
+                    type: String,
+                    desc: 'Type of the RDS instance'
+  cmd.flag [:user], default_value: 'root',
+                    type: String,
+                    desc: 'Master user of the RDS instance'
+  cmd.flag [:password], default_value: 'password',
+                        type: String,
+                        desc: 'Master password of the RDS instance'
+  defval = 'rds-launch-wizard'
+  desc = 'Name of the DB Security Group'
+  cmd.flag [:db_security_group, 'db-security-group'], default_value: defval,
+                                                      type: String,
+                                                      desc: desc
+  defval = 'default'
+  desc = 'Name of the DB Parameter Group'
+  cmd.flag [:db_parameters_group, 'db-parameters-group'], default_value: defval,
+                                                          type: String,
+                                                          desc: desc
+  cmd.action do |global_options, options, args|
+    Skyed::Create.execute(global_options, options, args)
+  end
+end
+
+desc 'List objects'
+long_desc 'List objects'
+
+command :list do |cmd|
+  cmd.switch [:rds], default_value: false,
+                     desc: 'Lists RDS objects'
+
+  cmd.action do |global_options, options, args|
+    Skyed::List.execute(global_options, options, args)
+  end
+end

data/lib/skyed/create.rb

@@ -0,0 +1,26 @@
+module Skyed
+  # This module encapsulates all the create command steps.
+  module Create
+    class << self
+      def execute(_global_options, options, args)
+        Skyed::Init.credentials if Skyed::Settings.empty?
+        endpoint = create_new(options, args) if args.length == 1
+        endpoint = restore_new(options, args) if args.length == 2
+        puts endpoint
+      end
+
+      def restore_new(options, args)
+        Skyed::AWS::RDS.create_instance_from_snapshot(
+          args[0],
+          args[1],
+          options.select { |k| k != :rds })
+      end
+
+      def create_new(options, args)
+        Skyed::AWS::RDS.create_instance(
+          args[0],
+          options.select { |k| k != :rds })
+      end
+    end
+  end
+end

data/lib/skyed/deploy.rb

@@ -4,6 +4,7 @@ module Skyed
     class << self
       def execute(global_options)
         fail 'Not initialized, please run skyed init' if Skyed::Settings.empty?
+        Skyed::Utils.export_credentials
         push_devel_branch(global_options)
         output = `cd #{Skyed::Settings.repo} && vagrant up`
         fail output unless $CHILD_STATUS.success?
@@ -11,7 +12,7 @@ module Skyed
       end
 
       def push_devel_branch(_global_options)
-        repo = Git.open(Skyed::Settings.repo)
+        repo = ::Git.open(Skyed::Settings.repo)
         repo.push(Skyed::Settings.remote_name, Skyed::Settings.branch)
       end
     end

data/lib/skyed/destroy.rb

@@ -2,40 +2,19 @@ module Skyed
   # This module encapsulates all the destroy command steps.
   module Destroy
     class << self
-      def execute(_global_options, _options, _args)
+      def execute(global_options, options, args)
+        Skyed::Init.credentials if Skyed::Settings.empty?
+        destroy_vagrant(global_options, options, args) unless options[:rds]
+        Skyed::AWS::RDS.destroy_instance(args[0], options) if options[:rds]
+      end
+
+      def destroy_vagrant(_global_options, _options, _args)
         repo_path = Skyed::Settings.repo
         hostname = `cd #{repo_path} && vagrant ssh -c hostname`.strip
         `cd #{repo_path} && vagrant destroy -f`
         ow = Skyed::AWS::OpsWorks.login
-        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
+        Skyed::AWS::OpsWorks.deregister_instance hostname, ow
+        Skyed::AWS::OpsWorks.delete_user ow
       end
     end
   end

data/lib/skyed/git.rb

@@ -0,0 +1,21 @@
+require 'securerandom'
+require 'erb'
+
+module Skyed
+  # This module encapsulates all the Git features.
+  module Git
+    class << self
+      def clone_stack_remote(stack)
+        Skyed::Init.opsworks_git_key unless Skyed::Settings.current_stack?(
+         stack[:stack_id])
+        ENV['PKEY'] = Skyed::Settings.opsworks_git_key
+        Skyed::Utils.create_template('/tmp', 'ssh-git', 'ssh-git.erb')
+        File.chmod(0755, '/tmp/ssh-git')
+        ENV['GIT_SSH'] = '/tmp/ssh-git'
+        path = "/tmp/skyed.#{SecureRandom.hex}"
+        ::Git.clone(stack[:custom_cookbooks_source][:url], path)
+        path
+      end
+    end
+  end
+end

data/lib/skyed/init.rb

@@ -12,10 +12,10 @@ module Skyed
     class << self
       def execute(global_options, options)
         fail 'Already initialized' unless Skyed::Settings.empty?
-        Skyed::Settings.repo = repo_path(get_repo).to_s
+        Skyed::Settings.repo = repo_path(get_repo(options[:repo])).to_s
         branch global_options, options
         credentials
-        opsworks_git_key
+        opsworks_git_key options
         opsworks options
         vagrant
         Skyed::Settings.save
@@ -44,13 +44,13 @@ module Skyed
         provisioning_path = File.join(Skyed::Settings.repo, '.provisioning')
         tasks_path = File.join(provisioning_path, 'tasks')
         aws_path = File.join(provisioning_path, 'templates', 'aws')
-        create_template(Skyed::Settings.repo, 'Vagrantfile',
-                        'templates/Vagrantfile.erb')
-        create_template(tasks_path, 'ow-on-premise.yml',
-                        'templates/ow-on-premise.yml.erb')
-        create_template(aws_path, 'config.j2', 'templates/config.j2.erb')
-        create_template(aws_path, 'credentials.j2',
-                        'templates/credentials.j2.erb')
+        Skyed::Utils.create_template(Skyed::Settings.repo, 'Vagrantfile',
+                                     'Vagrantfile.erb')
+        Skyed::Utils.create_template(tasks_path, 'ow-on-premise.yml',
+                                     'ow-on-premise.yml.erb')
+        Skyed::Utils.create_template(aws_path, 'config.j2', 'config.j2.erb')
+        Skyed::Utils.create_template(aws_path, 'credentials.j2',
+                                     'credentials.j2.erb')
       end
 
       def vagrant
@@ -61,19 +61,6 @@ module Skyed
         create_vagrant_files
       end
 
-      def create_template(base, subpath, template_file)
-        b = binding
-        folders = subpath.split('/')
-        template = ERB.new(
-          File.read(
-            File.join(
-              File.dirname(File.dirname(File.dirname(__FILE__))),
-              template_file)))
-        File.open(File.join(base, folders), 'w') do |f|
-          f.write(template.result b)
-        end
-      end
-
       def create_directory(base, subpath)
         folders = subpath.split('/')
         new_dir = File.join(base, folders)
@@ -129,9 +116,9 @@ module Skyed
         ask(question + remotes_names.to_s)
       end
 
-      def opsworks_git_key
+      def opsworks_git_key(options)
         question = 'Which ssh key should be used for the git repository? '
-        Skyed::Settings.opsworks_git_key = ask(question)
+        Skyed::Settings.opsworks_git_key = options[:repo_key] || ask(question)
       end
 
       def credentials(
@@ -149,21 +136,19 @@ module Skyed
         Pathname.new(repo.repo.path).dirname
       end
 
-      def get_repo(path = '.', ask = true)
+      def get_repo(path = '.')
         question = 'Which is your CM repository? '
+        force_ask = path == '.'
         repo = repo?(path)
-        if !repo
-          say("ERROR: #{path} is not a repository")
-          repo = get_repo(ask(question), false)
-        elsif ask
-          repo = get_repo(
-            ask(question) { |q| q.default = repo_path(repo).to_s }, false)
-        end
+        say("ERROR: #{path} is not a repository") unless repo
+        repo = get_repo(
+            ask(question) { |q| q.default = repo_path(repo).to_s }
+        ) if !repo || force_ask
         repo
       end
 
       def repo?(path)
-        Git.open(path)
+        ::Git.open(path)
       rescue ArgumentError
         return false
       end

data/lib/skyed/list.rb

@@ -0,0 +1,22 @@
+module Skyed
+  # This module encapsulates all the list command steps.
+  module List
+    class << self
+      def execute(global_options, options, args)
+        db_snapshots(global_options, options, args[1..args.length])
+      end
+
+      def db_snapshots(_global_options, options, args)
+        Skyed::Init.credentials if Skyed::Settings.empty?
+        snapshots = Skyed::AWS::RDS.list_snapshots(
+          options,
+          args)
+        snapshots.each do |snapshot|
+          msg = "#{snapshot.db_snapshot_identifier}"
+          msg += " #{snapshot.db_instance_identifier} #{snapshot.snapshot_type}"
+          puts msg
+        end
+      end
+    end
+  end
+end

data/lib/skyed/run.rb

@@ -3,10 +3,10 @@ module Skyed
   module Run
     class << self
       def execute(global_options, options, args)
+        recipes = check_recipes_exist(options, args)
         if !options.nil? && options.key?(:stack) && !options[:stack].nil?
-          run(global_options, options, args)
+          run(global_options, options, recipes)
         else
-          recipes = check_recipes_exist(args)
           check_vagrant
           execute_recipes(Skyed::AWS::OpsWorks.login, recipes)
         end
@@ -67,8 +67,12 @@ module Skyed
         fail msg unless output =~ /running/
       end
 
-      def check_recipes_exist(args)
-        recipes = args.select { |recipe| recipe_in_cookbook(recipe) }
+      def check_recipes_exist(options, args)
+        if !options.nil? && options.key?(:stack) && !options[:stack].nil?
+          recipes = args.select { |recipe| recipe_in_remote(options, recipe) }
+        else
+          recipes = args.select { |recipe| recipe_in_cookbook(recipe) }
+        end
         msg = "Couldn't found #{args - recipes} recipes in repository"
         fail msg unless recipes == args
         recipes
@@ -87,16 +91,23 @@ module Skyed
         fail 'Deployment failed' unless status[0] == 'successful'
       end
 
-      def recipe_in_cookbook(recipe)
+      def recipe_in_cookbook(recipe, path = nil)
+        path ||= Skyed::Settings.repo
         cookbook, recipe = recipe.split('::')
         recipe = 'default' if recipe.nil?
         File.exist?(
           File.join(
-            Skyed::Settings.repo,
+            path,
             cookbook,
             'recipes',
             "#{recipe}.rb"))
       end
+
+      def recipe_in_remote(options, recipe)
+        clone = Skyed::Git.clone_stack_remote(
+          Skyed::AWS::OpsWorks.stack(options[:stack], login))
+        recipe_in_cookbook(recipe, clone)
+      end
     end
   end
 end

data/lib/skyed/settings.rb

@@ -6,6 +6,10 @@ module Skyed
     attr_accessor :_settings
 
     class << self
+      def current_stack?(stack_id)
+        !Skyed::Settings.empty? && Skyed::Settings.stack_id == stack_id
+      end
+
       def load!(filename = CONFIG_FILE)
         newsets = {}
         newsets = YAML.load_file(filename) if File.file? filename

data/lib/skyed/utils.rb

@@ -1,7 +1,27 @@
+require 'erb'
+
 module Skyed
   # This module encapsulates some generic utility functions.
   module Utils
     class << self
+      def export_credentials
+        ENV['AWS_ACCESS_KEY'] = Skyed::Settings.access_key
+        ENV['AWS_SECRET_KEY'] = Skyed::Settings.secret_key
+      end
+
+      def create_template(base, subpath, template_file)
+        b = binding
+        folders = subpath.split('/')
+        template = ERB.new(
+          File.read(File.join(
+              File.dirname(File.dirname(File.dirname(__FILE__))),
+              'templates',
+              template_file)))
+        File.open(File.join(base, folders), 'w') do |f|
+          f.write(template.result b)
+        end
+      end
+
       def read_key_file(key_file)
         File.open(key_file, 'rb').read
       end

data/templates/ssh-git.erb

@@ -0,0 +1,7 @@
+#!/bin/sh
+if [ -z "$PKEY" ]; then
+  # if PKEY is not specified, run ssh using default keyfile
+  ssh "$@"
+else
+  ssh -i "$PKEY" "$@"
+fi

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skyed
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Ignasi Fosch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: git
@@ -77,9 +77,12 @@ files:
 - lib/skyed.rb
 - lib/skyed/aws.rb
 - lib/skyed/commands.rb
+- lib/skyed/create.rb
 - lib/skyed/deploy.rb
 - lib/skyed/destroy.rb
+- lib/skyed/git.rb
 - lib/skyed/init.rb
+- lib/skyed/list.rb
 - lib/skyed/run.rb
 - lib/skyed/settings.rb
 - lib/skyed/utils.rb
@@ -87,6 +90,7 @@ files:
 - templates/config.j2.erb
 - templates/credentials.j2.erb
 - templates/ow-on-premise.yml.erb
+- templates/ssh-git.erb
 homepage: http://rubygems.org/gems/skyed
 licenses:
 - MIT