fhcap-cli 0.3.0

data/lib/fhcap/tasks/misc/create_ssl_cert.rb

@@ -0,0 +1,82 @@
+require 'fhcap/tasks/task_base'
+require 'openssl'
+
+module Fhcap
+  module Tasks
+    module Misc
+      class CreateSslCert < TaskBase
+
+        def initialize(options)
+          super
+          @domain = options[:domain]
+          @name = options[:name]
+          @directory = options[:directory]
+          @format = options[:format]
+        end
+
+        def run
+          case @format
+            when 'pem'
+              certificate_file = File.join(@directory, "#{@name}-certificate.pem")
+              private_key_file = File.join(@directory, "#{@name}-private-key.pem")
+              if File.exists?(certificate_file) && File.exists?(private_key_file)
+                thor.say_status 'exists', certificate_file, :green
+                thor.say_status 'exists', private_key_file, :green
+              else
+                key, cert = generate_cert(@domain)
+                thor.create_file(private_key_file, key.to_pem)
+                thor.create_file(certificate_file, cert.to_pem)
+              end
+            when 'json'
+              certificate_file = File.join(@directory, "#{@name}.json")
+
+              if File.exists?(certificate_file)
+                thor.say_status 'exists', certificate_file, :green
+              else
+                key, cert = generate_cert(@domain)
+                cert_conf = {
+                    id: @name,
+                    cert: cert.to_pem.split(/\n/),
+                    key: key.to_pem.split(/\n/)
+                }
+                thor.create_file(certificate_file, JSON.pretty_generate(cert_conf))
+              end
+            else
+              exit_with_error("Unsupported format #{@format}")
+          end
+        end
+
+        private
+
+        def generate_cert(domain)
+          #https://gist.github.com/nickyp/886884
+          key = OpenSSL::PKey::RSA.new(2048)
+          public_key = key.public_key
+
+          subject = "/C=BE/O=RH/OU=RH/CN=*.#{domain}"
+
+          cert = OpenSSL::X509::Certificate.new
+          cert.subject = cert.issuer = OpenSSL::X509::Name.parse(subject)
+          cert.not_before = Time.now
+          cert.not_after = Time.now + 365 * 24 * 60 * 60
+          cert.public_key = public_key
+          cert.serial = 0x0
+          cert.version = 2
+
+          ef = OpenSSL::X509::ExtensionFactory.new
+          ef.subject_certificate = cert
+          ef.issuer_certificate = cert
+          cert.extensions = [
+              ef.create_extension("basicConstraints","CA:TRUE", true),
+              ef.create_extension("subjectKeyIdentifier", "hash")
+          ]
+          cert.add_extension ef.create_extension("authorityKeyIdentifier",
+                                                 "keyid:always,issuer:always")
+          cert.sign key, OpenSSL::Digest::SHA256.new
+          [key, cert]
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/provider/add.rb

@@ -0,0 +1,136 @@
+require 'fhcap/tasks/task_base'
+require 'aws-sdk'
+
+module Fhcap
+  module Tasks
+    module Provider
+      class Add < TaskBase
+
+        attr_reader :name, :credentials, :type
+
+        AWS_REQUIRED_CREDENTIALS = %w{aws-access-key aws-secret-key}
+        OS_REQUIRED_CREDENTIALS = %w{os-auth-url os-tenant-id os-tenant-name os-username os-password}
+
+        def initialize(options)
+          super
+          @name = options[:name]
+          @type = options[:type]
+          @credentials = options[:credentials] || {}
+          if options[:type] == 'aws'
+            @required_credentials = AWS_REQUIRED_CREDENTIALS
+          elsif options[:type] == 'openstack'
+            @required_credentials = OS_REQUIRED_CREDENTIALS
+          end
+        end
+
+        def run
+          thor.say "Provider::Add: name = #{name}, type = #{type}", :yellow
+
+          config[:providers] = {} unless config[:providers]
+          config[:providers][type.to_sym] = {} unless config[:providers][type.to_sym]
+          config[:providers][type.to_sym][name.to_sym] = {} unless config[:providers][type.to_sym][name.to_sym]
+
+          @provider_config = config[:providers][type.to_sym][name.to_sym]
+          @provider_config[:provides] = [] unless @provider_config[:provides]
+          @provider_config[:credentials] = {} unless @provider_config[:credentials]
+          @provider_config[:credentials].merge!(credentials)
+
+          @required_credentials.each do |rc|
+            if !@provider_config[:credentials][rc.to_sym] || options[:interactive]
+              default = @provider_config[:credentials][rc.to_sym] || ENV[rc.to_s.upcase.gsub('-', '_')]
+              @provider_config[:credentials][rc.to_sym] = thor.ask "#{rc}:", {default: default}
+            end
+          end
+
+          send(:"#{type}_config", @provider_config)
+
+          thor.create_file(config.default_config_file, JSON.pretty_generate(config.data), :force => true)
+          config.reload
+        end
+
+        private
+
+        def openstack_config(cfg)
+          ask_config({
+                         image_ref: {},
+                         flavor_ref: {},
+                         floating_ip_pool: {},
+                         ssh_username: {}
+                     }, cfg)
+          cfg[:provides] << 'compute'
+        end
+
+        def aws_config(cfg)
+          aws_compute(cfg)
+          aws_dns(cfg)
+        end
+
+        def aws_compute(cfg)
+          creds = cfg[:credentials]
+          cfg[:regions] = {}
+          ec2 = Aws::EC2::Client.new(
+              region: 'eu-west-1',
+              access_key_id: creds[:'aws-access-key'],
+              secret_access_key: creds[:'aws-secret-key']
+          )
+
+          resp = ec2.describe_regions
+          thor.say "Found #{resp.regions.length} regions for this AWS account: #{resp.regions.collect{|r|r.region_name}}"
+          resp.regions.each do |region|
+            thor.say "Configure #{region.region_name}", :yellow
+            ec2 = Aws::EC2::Client.new(
+                region: region.region_name,
+                access_key_id: creds[:'aws-access-key'],
+                secret_access_key: creds[:'aws-secret-key']
+            )
+
+            resp = ec2.describe_images({
+                                           filters: [
+                                               {
+                                                   name: "tag:fhcap-base",
+                                                   values: ["true"],
+                                               },
+                                           ],
+                                       })
+            if resp.images.empty?
+              thor.say "Could not determine valid base image, tag an appropriate image with \"fhcap-base:true\", and re-run this command to add this region!"
+              next
+            end
+            cfg[:regions][region.region_name.to_sym] = {}
+
+            base_image = resp.images.first.image_id
+            thor.say "Adding Base Image: #{base_image}"
+            cfg[:regions][region.region_name.to_sym][:base_image] = base_image
+
+            resp = ec2.describe_availability_zones
+            zones = resp.availability_zones.collect do |az|
+              az.zone_name
+            end
+            thor.say "Adding #{zones.length} Availability Zones: #{zones}"
+            cfg[:regions][region.region_name.to_sym][:availability_zones] = zones
+
+          end
+          cfg[:provides] << 'compute'
+          cfg[:provides].uniq!
+        end
+
+        def aws_dns(cfg)
+          creds = cfg[:credentials]
+          client = Aws::Route53::Client.new(
+              region: 'eu-west-1',
+              access_key_id: creds[:'aws-access-key'],
+              secret_access_key: creds[:'aws-secret-key']
+          )
+          resp = client.list_hosted_zones
+
+          domains = resp.hosted_zones.map {|z|z.name.gsub(/\.$/, '')}
+          thor.say "Adding Domains: #{domains}"
+          cfg[:domains] = domains
+          cfg[:provides] << 'dns'
+          cfg[:provides].uniq!
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/provider/list.rb

@@ -0,0 +1,31 @@
+require 'fhcap/tasks/task_base'
+
+module Fhcap
+  module Tasks
+    module Provider
+      class List < TaskBase
+
+        def run
+          thor.say "Provider::List", :yellow
+
+          table_contents = [table_header('ID', 'Provides', 'Regions', 'Credentials')]
+
+          providers_config.each do |type, type_cfg|
+            type_cfg.each do |provider_id, provider_cfg|
+              regions = (provider_cfg[:regions] ? provider_cfg[:regions].keys : []).join(',')
+              provides = (provider_cfg[:provides] ? provider_cfg[:provides] : []).join(',')
+              credentials = provider_cfg[:credentials].each do |k,v|
+                if k.to_s =~ /password|secret/
+                  provider_cfg[:credentials][k] = '*' * v.length
+                end
+              end
+              table_contents << table_row("#{type}:#{provider_id}", provides, regions, credentials)
+            end
+          end
+          thor.print_table table_contents
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/provider/remove.rb

@@ -0,0 +1,28 @@
+require 'fhcap/tasks/task_base'
+
+module Fhcap
+  module Tasks
+    module Provider
+      class Remove < TaskBase
+
+        attr_reader :name, :type
+
+        def initialize(options)
+          super
+          @name = options[:name]
+          @type = options[:type]
+        end
+
+        def run
+          thor.say "Provider::Remove: name = #{name}", :yellow
+          if thor.yes? "Remove provider #{name}? (y/n)"
+            config[:providers][type.to_sym].delete(name.to_sym)
+            thor.create_file(config.default_config_file, JSON.pretty_generate(config.data), :force => true)
+            config.reload
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/repo/add.rb

@@ -0,0 +1,57 @@
+require 'fhcap/tasks/task_base'
+require 'fhcap/tasks/repo/checkout'
+require 'fhcap/tasks/setup'
+
+module Fhcap
+  module Tasks
+    module Repo
+      class Add < TaskBase
+
+        attr_reader :name, :repo_config
+
+        def initialize(options)
+          super
+          @name = options[:name]
+
+          @repo_config = config[:repos][@name.to_sym] || {}
+          @repo_config = {
+              url: options[:url],
+              clusters_dir: options[:'clusters-dir'] || 'clusters',
+          }.merge(@repo_config)
+
+          @skip_setup = options[:'skip-setup']
+        end
+
+        def run
+          thor.say "Repo::Add: name = #{name}", :yellow
+
+          ask_config(required_config, repo_config)
+
+          if repo_config[:url] =~ /fhcap.git$/
+            repo_config[:archives] = {
+                cookbooks: config.fhcap_cookbook_archive_url
+            }
+          end
+
+          config[:repos][name.to_sym] = repo_config
+          thor.create_file(config.default_config_file, JSON.pretty_generate(config.data), :force => true)
+          config.reload
+          Checkout.new(@options.dup.merge({:repo => name, :'git-ref' => 'master'})).run
+          Tasks::Setup.new(@options).run unless @skip_setup
+        end
+
+        private
+
+        def required_config
+          {
+              url: {
+              },
+              clusters_dir: {
+              }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/repo/checkout.rb

@@ -0,0 +1,144 @@
+require 'fhcap/tasks/task_base'
+require 'open-uri'
+require 'uri'
+
+module Fhcap
+  module Tasks
+    module Repo
+      class Checkout < TaskBase
+
+        attr_reader :gitref, :repo, :fallback_gitref, :remote
+
+        def initialize(options)
+          super
+          @gitref = options[:"git-ref"]
+          @repo = options[:repo] || options[:name]
+          @fallback_gitref = options[:'fallback-git-ref']
+          @remote = options[:remote] || options[:'git-remote'] || 'origin'
+        end
+
+        def run
+          thor.say "Repo::Checkout: repo = #{repo}, git-ref = #{gitref}, remote = #{remote}\n", :yellow
+          if git_clone(repo)
+            if gitref
+              if clean?(repo)
+                unless checkout_git_ref
+                  exit_with_error("Failed to checkout #{gitref} on #{repo} repo!")
+                end
+              else
+                exit_with_error("You specified a git-ref option, but have uncommitted changes in your local repo (#{repo_dir(repo)}). Please commit your local changes before continuing!")
+              end
+            else
+              current_ref = Dir.chdir repo_dir(repo) do
+                options[:verbose] ? `git rev-list HEAD -n 1 --pretty` : `git rev-parse HEAD`
+              end
+              thor.say "No git-ref option specified, using current ref: #{current_ref}"
+            end
+          else
+            exit_with_error("Failed to clone #{repo}!")
+          end
+        end
+
+        private
+
+        def git_clone(repo)
+          Dir.exists?(repo_dir(repo)) ? true : do_clone_cmd(repo)
+        end
+
+        def do_clone_cmd(repo)
+          cmd = %w{git clone}
+          cmd << '--quiet' unless verbose
+          cmd << repo_cfg(repo)[:url]
+          cmd << repo
+          cmd = cmd.join(' ')
+          status = -1
+          thor.inside(repos_dir) do
+            thor.run(cmd, :capture => !verbose)
+            status = $?.exitstatus
+          end
+          status == 0
+        end
+
+        def git_checkout_deploy(repo)
+          cmd = %w{git checkout -B deploy}
+          cmd << '--quiet' unless verbose
+          cmd = cmd.join(' ')
+          run_inside_repo_dir(repo_dir(repo), cmd)
+        end
+
+        def git_reset(repo)
+          result = do_reset_cmd(repo, gitref)
+          unless result == true
+            if fallback_gitref
+              thor.say "Unable to checkout #{gitref} on #{repo}, falling back to #{fallback_gitref}"
+              result = do_reset_cmd(repo, fallback_gitref)
+            end
+          end
+          result
+        end
+
+        def do_fetch_cmd(repo, gitref)
+          cmd = %w{git fetch}
+          cmd << remote
+          cmd << gitref
+          cmd << '--quiet' unless verbose
+          cmd = cmd.join(' ')
+          run_inside_repo_dir(repo_dir(repo), cmd)
+        end
+
+        def do_reset_cmd(repo, gitref)
+          if do_fetch_cmd(repo, gitref)
+            cmd = %w{git reset --hard FETCH_HEAD}
+            cmd << '--quiet' unless verbose
+            cmd = cmd.join(' ')
+            run_inside_repo_dir(repo_dir(repo), cmd)
+          else
+            false
+          end
+        end
+
+        def repo_post_checkout(repo)
+          repo_cfg = repo_cfg(repo)
+          repo_dir = repo_dir(repo)
+          repo_extract_archives(repo_dir, repo_cfg)
+          repo_librarian_install(repo_dir)
+        end
+
+        def repo_extract_archives(repo_dir, repo_cfg)
+          if repo_cfg && repo_cfg[:archives]
+            repo_cfg[:archives].each do |dir, url|
+              dir = dir.to_s
+              url = url.to_s
+              uri = URI.parse(url)
+              filename = File.join(Dir.tmpdir, File.basename(uri.path))
+              open(filename, 'wb') do |file|
+                file << open(url).read
+              end
+              cmd = "tar xf #{filename} -C #{repo_dir}"
+              run_inside_repo_dir(repo_dir, cmd)
+            end
+          end
+        end
+
+        def repo_librarian_install(repo_dir)
+          if File.exists? File.join(repo_dir, 'Cheffile')
+            cmd = %w{librarian-chef install}
+            cmd << '--quiet' unless verbose
+            cmd = cmd.join(' ')
+            run_inside_repo_dir(repo_dir, cmd)
+          end
+          true
+        end
+
+        def clean?(repo)
+          !modified?(repo_dir(repo), 'HEAD')
+        end
+
+        def checkout_git_ref
+          clean?(repo) && git_checkout_deploy(repo) && git_reset(repo) && repo_post_checkout(repo)
+        end
+
+      end
+    end
+  end
+end