skyed 0.1.16 → 0.2.0.dev

data/lib/skyed/check.rb

@@ -1,69 +0,0 @@
-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_id = instance_by_name(instance_name, ow)
-                      .ec2_instance_id
-        elb = login('elb')
-        wait = opts[:wait_interval] || 0
-        timeout = opts[:timeout] || 0
-        [true, false].each do |op|
-          wait_for_backend(elb_name, instance_id, elb, op, wait, timeout)
-        end
-      end
-
-      def instance_by_name(name, ow)
-        Skyed::AWS::OpsWorks
-          .instance_by_name(name, Skyed::Settings.stack_id, ow)
-      end
-
-      def wait_for_backend(
-        elb_name, instance_id, elb, *other_args)
-        ok, wait, timeout = other_args
-        time = 0
-        until ok == Skyed::AWS::ELB.instance_ok?(elb_name, instance_id, elb) ||
-              time >= timeout
-          Kernel.sleep(wait)
-          time += 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

@@ -1,174 +0,0 @@
-version Skyed::VERSION
-
-desc 'Initialize skyed'
-long_desc 'Sets up skyed configuration for a repository'
-
-command :init do |cmd|
-  cmd.flag [:remote], default_value: nil,
-                      type: String,
-                      desc: 'Remote to use in OpsWorks'
-  cmd.flag [:repo], default_value: '.',
-                    type: String,
-                    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
-end
-
-desc 'Deploy current setup'
-long_desc 'Deploys from current repository'
-
-command :deploy do |cmd|
-  cmd.action do |global_options|
-    Skyed::Deploy.execute(global_options)
-  end
-end
-
-desc 'Run specific recipes on instance'
-long_desc 'Runs specified recipes on all running instances'
-
-stack_desc = 'Stack to which the command affects.'
-layer_desc = 'Layer to which the command affects.'
-command :run 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
-  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,
-                                                  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
-end
-
-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 'Stop instance'
-long_desc 'Stop instance'
-
-command :stop do |cmd|
-  cmd.flag [:s, :stack], default_value: nil,
-                         type: String,
-                         desc: stack_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::Stop.execute(global_options, options, args)
-  end
-end
-
-desc 'Create instance'
-long_desc 'Create instance'
-
-start_desc = 'Avoids creation if stopped OW instance already exists'
-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'
-  cmd.flag [:s, :stack], default_value: nil,
-                         type: String,
-                         desc: stack_desc
-  cmd.flag [:l, :layer], default_value: nil,
-                         type: String,
-                         desc: layer_desc
-  cmd.switch [:start], default_value: false,
-                       desc: start_desc
-  desc = 'Time to wait for AWS responses'
-  cmd.flag [:w, :wait_interval, 'wait-interval'], default_value: 30,
-                                                  type: Integer,
-                                                  desc: desc
-  defval = 'default'
-  desc = 'Name of the DB Security Group'
-  cmd.flag [:db_security_group, 'db-security-group'], default_value: defval,
-                                                      type: String,
-                                                      desc: desc
-  defval = 'default.postgres9.4'
-  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
-
-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 [:t, :timeout, 'timeout'], default_value: 30,
-                                      type: Integer,
-                                      desc: 'Defines timout for the check'
-  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/create.rb

@@ -1,84 +0,0 @@
-module Skyed
-  # This module encapsulates all the create command steps.
-  module Create
-    @non_rds_options = [:rds, :start, :stack, :layer]
-    class << self
-      def execute(_global_options, options, args)
-        Skyed::Init.credentials if Skyed::Settings.empty?
-        execute_rds(options, args) if options[:rds]
-        create_opsworks(options, args) unless options[:rds]
-      end
-
-      def start_opsworks(options, ow)
-        stopped_instances = Skyed::AWS::OpsWorks.instances_by_status(
-          options[:stack], options[:layer], 'stopped', ow)
-        return false if stopped_instances.empty?
-        Skyed::AWS::OpsWorks.start_instance(
-          stopped_instances.first.instance_id,
-          ow)
-        true
-      end
-
-      def check_create_options(options)
-        msg = 'Specify stack and layer or initialize for local management'
-        fail msg unless options[:stack] && options[:layer]
-      end
-
-      def create_opsworks(options, _args)
-        check_create_options(options)
-        ow = settings(options)
-        options[:start] = start_opsworks(options, ow) if options[:start]
-        Skyed::AWS::OpsWorks.create_instance(
-          Skyed::Settings.stack_id,
-          Skyed::Settings.layer_id,
-          options[:type],
-          ow) unless options[:start]
-      end
-
-      def stack(ow, options)
-        stack = Skyed::AWS::OpsWorks.stack(options[:stack], ow)
-        msg = "There's no such stack with id #{options[:stack]}"
-        fail msg unless stack
-        stack[:stack_id]
-      end
-
-      def layer(ow, options)
-        layer = Skyed::AWS::OpsWorks.layer(options[:layer], ow)
-        msg = "There's no such layer with id #{options[:layer]}"
-        fail msg unless layer
-        layer[:layer_id]
-      end
-
-      def execute_rds(options, args)
-        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| ! @non_rds_options.include? k })
-      end
-
-      def create_new(options, args)
-        Skyed::AWS::RDS.create_instance(
-          args[0],
-          options.select { |k| ! @non_rds_options.include? k })
-      end
-
-      def settings(options)
-        ow = login
-        Skyed::Settings.stack_id = stack(ow, options)
-        Skyed::Settings.layer_id = layer(ow, options)
-        ow
-      end
-
-      def login
-        Skyed::Init.credentials if Skyed::Settings.empty?
-        Skyed::AWS::OpsWorks.login
-      end
-    end
-  end
-end

data/lib/skyed/deploy.rb

@@ -1,20 +0,0 @@
-module Skyed
-  # This module encapsulates all the deploy command steps.
-  module Deploy
-    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?
-        $CHILD_STATUS.success?
-      end
-
-      def push_devel_branch(_global_options)
-        repo = ::Git.open(Skyed::Settings.repo)
-        repo.push(Skyed::Settings.remote_name, Skyed::Settings.branch)
-      end
-    end
-  end
-end

data/lib/skyed/destroy.rb

@@ -1,21 +0,0 @@
-module Skyed
-  # This module encapsulates all the destroy command steps.
-  module Destroy
-    class << self
-      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
-        Skyed::AWS::OpsWorks.deregister_instance hostname, ow
-        Skyed::AWS::OpsWorks.delete_user ow
-      end
-    end
-  end
-end

data/lib/skyed/git.rb

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

data/lib/skyed/init.rb

@@ -1,157 +0,0 @@
-require 'English'
-require 'fileutils'
-require 'erb'
-require 'git'
-require 'aws-sdk'
-require 'highline/import'
-require 'digest/sha1'
-
-module Skyed
-  # This module encapsulates all the init command steps.
-  module Init
-    class << self
-      def execute(global_options, options)
-        fail 'Already initialized' unless Skyed::Settings.empty?
-        Skyed::Settings.repo = repo_path(get_repo(options[:repo])).to_s
-        branch global_options, options
-        credentials
-        opsworks_git_key options
-        opsworks options
-        vagrant
-        Skyed::Settings.save
-      end
-
-      def opsworks(options = {})
-        opsworks = Skyed::AWS::OpsWorks.login
-        params = Skyed::AWS::OpsWorks.generate_params nil, options
-        check_stack(opsworks, params[:name])
-        Skyed::AWS::OpsWorks.create_stack(params, opsworks)
-        params = Skyed::AWS::OpsWorks.generate_params(Skyed::Settings.stack_id)
-        Skyed::AWS::OpsWorks.create_layer(params, opsworks)
-      end
-
-      def check_stack(ow, name)
-        stack = Skyed::AWS::OpsWorks.stack_summary_by_name(name, ow)
-        Skyed::AWS::OpsWorks.delete_stack(stack[:name], ow) unless stack.nil?
-        File.delete(vagrantfile) if File.exist?(vagrantfile)
-      end
-
-      def vagrantfile
-        File.join(Skyed::Settings.repo, 'Vagrantfile')
-      end
-
-      def create_vagrant_files
-        provisioning_path = File.join(Skyed::Settings.repo, '.provisioning')
-        tasks_path = File.join(provisioning_path, 'tasks')
-        aws_path = File.join(provisioning_path, 'templates', 'aws')
-        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
-        return if File.exist?(vagrantfile)
-        pip_install 'ansible'
-        create_directory(Skyed::Settings.repo, '.provisioning/templates/aws')
-        create_directory(Skyed::Settings.repo, '.provisioning/tasks')
-        create_vagrant_files
-      end
-
-      def create_directory(base, subpath)
-        folders = subpath.split('/')
-        new_dir = File.join(base, folders)
-        FileUtils.mkdir_p(new_dir)
-      end
-
-      def pip_install(package)
-        `pip list | grep #{package}`
-        return if $CHILD_STATUS.success?
-        `which pip`
-        easy_install 'pip' unless $CHILD_STATUS.success?
-        `sudo pip install #{package}`
-        fail "Can't install #{package}" unless $CHILD_STATUS.success?
-      end
-
-      def easy_install(package)
-        `easy_install #{package}`
-        fail "Can't install #{package}" unless $CHILD_STATUS.success?
-      end
-
-      def branch(global_options, options)
-        branch = "devel-#{Digest::SHA1.hexdigest Skyed::Settings.repo}"
-        repo = repo?(Skyed::Settings.repo)
-        repo.branch(branch).checkout
-        Skyed::Settings.branch = branch
-        remote_data = git_remote_data(repo, global_options, options)
-        Skyed::Settings.remote_name = remote_data[:name]
-        Skyed::Settings.remote_url = remote_data[:url]
-      end
-
-      def git_remote_data(repo, _global_options, options = {})
-        name ||= options[:remote]
-        name = ask_remote_name(
-          repo.remotes.map(&:name)) if repo.remotes.length > 1 && name.nil?
-        name = repo.remotes[0].name if name.nil?
-        select_remote(name, repo.remotes)
-      end
-
-      def select_remote(name, remotes)
-        url = nil
-        remotes.each do |remote|
-          url = remote.url if remote.name == name
-        end
-        if url.nil?
-          { name: remotes[0].name, url: remotes[0].url }
-        else
-          { name: name, url: url }
-        end
-      end
-
-      def ask_remote_name(remotes_names)
-        question = 'Which remote should be used for the git repository? '
-        ask(question + remotes_names.to_s)
-      end
-
-      def opsworks_git_key(options = nil)
-        question = 'Which ssh key should be used for the git repository? '
-        Skyed::Settings.opsworks_git_key = options[:repo_key] || ask(question)
-      end
-
-      def credentials(
-        access       = ENV['AWS_ACCESS_KEY'],
-        secret       = ENV['AWS_SECRET_KEY'],
-        role_arn     = ENV['OW_SERVICE_ROLE'],
-        profile_arn  = ENV['OW_INSTANCE_PROFILE'],
-        aws_key_name = ENV['AWS_SSH_KEY_NAME'])
-        Skyed::AWS.set_credentials(access, secret)
-        Skyed::AWS::OpsWorks.set_arns(profile_arn, role_arn)
-        Skyed::Settings.aws_key_name = aws_key_name
-      end
-
-      def repo_path(repo)
-        Pathname.new(repo.repo.path).dirname
-      end
-
-      def get_repo(path = '.')
-        question = 'Which is your CM repository? '
-        force_ask = path == '.'
-        repo = repo?(path)
-        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)
-      rescue ArgumentError
-        return false
-      end
-    end
-  end
-end