fhcap-cli 0.3.0

data/lib/fhcap/tasks/cluster/destroy.rb

@@ -0,0 +1,30 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/provisioning/destroy'
+require 'fhcap/tasks/chef/environments/destroy'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class Destroy < ClusterTaskBase
+
+        def initialize(options)
+          super(options, false)
+          @skip_destroy = options[:'skip-destroy']
+        end
+
+        def run
+          thor.say "Cluster::Destroy: name = #{@name}", :yellow
+          Chef::Provisioning::Destroy.new(options).run unless @skip_destroy
+
+          if thor.yes? "Delete all local repo files?"
+            cluster_environments.each do |env_name, cfg|
+              Chef::Environments::Destroy.new(@options.dup.merge({:name => env_name, :chef_server => @cluster_config[:chef_server], :repo => @cluster_config[:repo]})).run
+            end
+            thor.remove_file find_cluster(@name)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/destroy_environment.rb

@@ -0,0 +1,28 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/environments/destroy'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class DestroyEnvironment < ClusterTaskBase
+
+        attr_reader :environment_name, :domain, :environment_config
+
+        def initialize(options)
+          super(options)
+          @environment_name = options[:'environment-name']
+        end
+
+        def run
+          thor.say "Cluster::DestroyEnvironment: cluster = #{name}, environment = #{environment_name}", :yellow
+
+          cluster_config[:environments].delete environment_name.to_sym
+          thor.create_file(cluster_file, JSON.pretty_generate(cluster_config), force: true)
+
+          Chef::Environments::Destroy.new(@options.dup.merge({:name => environment_name, :chef_server => cluster_config[:chef_server]})).run
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/info.rb

@@ -0,0 +1,67 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/server/info'
+require 'launchy'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class Info < ClusterTaskBase
+
+        attr_reader :launch, :cluster_pwds_file, :cluster_passwords
+
+        def initialize(options)
+          super
+          @launch = options[:launch]
+          unless @cluster_passwords
+            @cluster_passwords = {}
+            cluster_environments.each do |env|
+              @cluster_passwords[env.to_sym] = {}
+              @cluster_pwds_file = find_cluster_pwds(env)
+              if @cluster_pwds_file
+                @cluster_passwords[env.to_sym] = JSON.parse(IO.read(@cluster_pwds_file), {:symbolize_names => true})
+              end
+            end
+          end
+        end
+
+        def run
+          thor.say "Cluster::Info: name = #{@name}", :yellow
+          info_task = Chef::Server::Info.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]}))
+          info_task.run
+          cluster_environments.each do |env|
+            passwords(env) unless options[:only] && options[:only] != 'passwords'
+          end
+
+          if launch
+            info_task.urls.each do |env, urls|
+              urls.each do |service, url|
+                service = service.to_s
+                if %w{nagios munin}.include? service
+                  user = 'team.eng'
+                  pwd = cluster_passwords[env.to_sym][:'henry_users.teameng']
+                  if user and pwd
+                    proto, host = url.split('://')
+                    url = "#{proto}://#{user}:#{pwd}@#{host}"
+                  end
+                end
+                thor.say_status 'launch', url
+                Launchy.open(url)
+              end
+            end
+          end
+
+        end
+
+        private
+
+        def passwords(env)
+          thor.say "[#{env}] Passwords", :green
+          cluster_passwords[env.to_sym].each do |user, pwd|
+            thor.say_status "[#{env}] #{user}:", "#{pwd}", :cyan
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+require 'fhcap/tasks/task_base'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class List < TaskBase
+
+        def run
+          thor.say "Cluster::List", :yellow
+
+          table_contents = [table_header('Name', 'Repo', 'Template', 'Driver', 'Chef Server', 'Provider ID', 'Environments', 'Domains', 'No. Instances')]
+
+          repos_config.each do |repo_name, cfg|
+            clusters_dir = File.join(repo_dir(repo_name), repo_clusters_dir(repo_name))
+            if Dir.exists?(clusters_dir)
+              Dir.glob("#{clusters_dir}/*.json").reject { |f| f =~ /passwords/ }.each do |json_file|
+                conf = JSON.parse(IO.read(json_file), {:symbolize_names => true})
+                environments = {}
+                if conf[:environments]
+                  conf[:environments].each do |env_name, env_cfg|
+                    env_name = [conf[:id].to_s, env_name.to_s].uniq.join('-')
+                    environments[env_name] = {}
+                    environments[env_name][:domain] = env_cfg[:domain]
+                    environments[env_name][:instances] = (env_cfg[:instances] || {}).keys.collect { |e| "#{env_name}-#{e}" }
+                  end
+                end
+                environment_names = environments.keys.join(',')
+                domain_names = environments.values.collect { |env| env[:domain] }.compact.join(',')
+                instance_names = environments.values.collect { |env| env[:instances] }.flatten
+                table_contents << table_row(conf[:id], conf[:repo], conf[:template], conf[:driver], conf[:chef_server], conf[:provider_id], environment_names, domain_names, instance_names.count)
+              end
+            end
+          end
+          thor.print_table table_contents
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/provision.rb

@@ -0,0 +1,46 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/server/bootstrap'
+require 'fhcap/tasks/chef/server/provision'
+require 'fhcap/tasks/chef/provisioning/provision'
+require 'fhcap/tasks/chef/environments/promote_cookbooks'
+require 'fhcap/tasks/repo/checkout'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class Provision < ClusterTaskBase
+
+        attr_reader :gitref, :strategy, :node_names, :roles
+
+        def initialize(options)
+          super
+          @gitref = options[:"git-ref"]
+          @node_names = options[:nodes]
+          @roles = options[:roles]
+          @skip_repo_checkout = options[:'skip-repo-checkout']
+          @skip_cookbook_promote = options[:'skip-cookbook-promote']
+          @skip_server_bootstrap = options[:'skip-server-bootstrap']
+          @skip_provision = options[:'skip-provision']
+          @strategy = ('knife' unless provider_names.include?(@cluster_config[:provider_id])) || options[:strategy]
+        end
+
+        def run
+          thor.say "Cluster::Provision: name = #{name}, strategy = #{strategy}", :yellow
+          checkout_repos unless @skip_repo_checkout
+          Chef::Environments::PromoteCookbooks.new(@options.dup.merge({:environments => cluster_environments})).run unless @skip_cookbook_promote
+          Chef::Server::Bootstrap.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]})).run unless @skip_server_bootstrap
+          unless @skip_provision
+            if strategy == 'chef'
+              Chef::Provisioning::Provision.new(@options).run
+            elsif strategy == 'knife'
+              Chef::Server::Provision.new(@options.dup.merge({:environments => cluster_environments, :chef_server => cluster_config[:chef_server]})).run
+            else
+              thor.say_status :error, "Unsupported provision strategy #{strategy}"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/status.rb

@@ -0,0 +1,17 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+require 'fhcap/tasks/chef/provisioning/chef_provisioning_task'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class Status < ClusterTaskBase
+
+        def run
+          thor.say "Cluster::Status: name = #{@name}", :yellow
+          Tasks::Chef::Provisioning::ChefProvisioningTask.new(@options.dup.merge({:'run-list' => 'recipe[provision::cluster_status]'})).run
+        end
+
+      end
+    end
+  end
+end

data/lib/fhcap/tasks/cluster/test.rb

@@ -0,0 +1,15 @@
+require 'fhcap/tasks/cluster/cluster_task_base'
+
+module Fhcap
+  module Tasks
+    module Cluster
+      class Test < ClusterTaskBase
+
+        def run
+          thor.say "Cluster::Test: name = #{@name}", :yellow
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+require 'fhcap/tasks/task_base'
+require 'etc'
+require 'chef/config'
+
+module Fhcap
+  module Tasks
+    module Knife
+      class Add < TaskBase
+
+        attr_reader :name, :private_key, :validation_key, :import_file, :knife_config
+
+        def initialize(options)
+          super
+          @name = options[:name]
+          @chef_server_url = options[:url]
+          @node_name = options[:'node-name'] || Etc.getlogin
+          @validation_client_name = options[:'validation-client-name'] || 'chef-validator'
+          @import_file = options[:'import-file']
+          @private_key = nil
+          @validation_key = nil
+
+          if @import_file
+            import_cfg = JSON.parse(IO.read(@import_file), {:symbolize_names => true})
+            @name = import_cfg[:name] || @name
+            @chef_server_url = import_cfg[:chef_server_url]
+            @node_name = import_cfg[:node_name]
+            @validation_client_name = import_cfg[:validation_client_name]
+            @private_key = import_cfg[:private_key]
+            @validation_key = import_cfg[:validation_key]
+          end
+
+          @knife_config = config[:knife][@name.to_sym] || {}
+          @knife_config = {
+              chef_server_url: @chef_server_url,
+              node_name: @node_name,
+              validation_client_name: @validation_client_name,
+          }.merge(@knife_config)
+
+        end
+
+        def run
+          thor.say "Knife::Add: name = #{name}", :yellow
+
+          ask_config(required_config, @knife_config)
+
+          config[:knife][name.to_sym] = @knife_config
+
+          thor.create_file(config.default_config_file, JSON.pretty_generate(config.data), :force => true)
+          config.reload
+          create_knife_config
+        end
+
+        private
+
+        def required_config
+          {
+              chef_server_url: {
+              },
+              node_name: {
+              },
+              validation_client_name: {
+              }
+          }
+        end
+
+        def create_knife_config
+          knife_config_file = File.join(config.knife_dir, "knife-#{name}.rb")
+          cookbook_path = repo_cookbook_paths
+          cookbook_path << File.join(Fhcap.source_root, 'lib', 'cookbooks')
+
+          thor.template(File.join("templates", "init", "knife.rb.erb"), knife_config_file,
+                        :name => name,
+                        :validation_client_name => knife_config[:validation_client_name],
+                        :chef_server_url => knife_config[:chef_server_url],
+                        :node_name => knife_config[:node_name],
+                        :cookbook_path => cookbook_path
+          )
+
+          thor.empty_directory File.join(knife_config_dir, name)
+          thor.empty_directory File.join(knife_config_dir, 'keys')
+
+          thor.create_file(File.join(knife_config_dir, name, "#{knife_config[:node_name]}.pem"), private_key, :force => true) if private_key
+          thor.create_file(File.join(knife_config_dir, name, "#{knife_config[:validation_client_name]}.pem"), private_key, :force => true) if validation_key
+
+          validate_knife_config(knife_config_file)
+
+          unless File.exists? File.join(knife_config_dir, "knife.rb")
+            thor.create_link File.join(knife_config_dir, "knife.rb"), knife_config_file
+          end
+
+        end
+
+        def validate_knife_config(knife_config_file)
+          if File.exists? knife_config_file
+            Chef::Config.from_file(knife_config_file)
+            unless File.exists? Chef::Config[:validation_key]
+              thor.say_status 'missing', Chef::Config[:validation_key], :red
+            end
+
+            unless File.exists? Chef::Config[:client_key]
+              thor.say_status 'missing', Chef::Config[:client_key], :red
+            end
+          else
+            thor.say_status 'missing', knife_config_file, :red
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'fhcap/tasks/task_base'
+
+module Fhcap
+  module Tasks
+    module Knife
+      class List < TaskBase
+
+        def run
+          thor.say "Knife::List", :yellow
+
+          table_contents = [table_header('ID', 'Chef Server Url', 'Node Name')]
+
+          knife_config.each do |id, cfg|
+            table_contents << table_row(id, cfg[:chef_server_url], cfg[:node_name])
+          end
+          thor.print_table table_contents
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+require 'fhcap/tasks/task_base'
+
+module Fhcap
+  module Tasks
+    module Knife
+      class Remove < TaskBase
+
+        attr_reader :name
+
+        def initialize(options)
+          super
+          @name = options[:name]
+        end
+
+        def run
+          thor.say "Knife::Remove: name = #{name}", :yellow
+          if thor.yes? "Remove knife #{name}? (y/n)"
+            config[:knife].delete(name.to_sym)
+            thor.create_file(config.default_config_file, JSON.pretty_generate(config.data), :force => true)
+            config.reload
+            if thor.yes?("Remove local knife config? (y/n)")
+              remove_knife_config
+            end
+          end
+        end
+
+        private
+
+        def remove_knife_config
+          knife_config_dir = config[:knife_dir] || File.join(config.default_dir, '.chef')
+          knife_config_file = File.join(knife_config_dir, "knife-#{name}.rb")
+          thor.remove_file knife_config_file
+          thor.remove_file File.join(knife_config_dir, name)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'fhcap/tasks/task_base'
+require 'aws-sdk'
+require 'public_suffix'
+
+# fhcap misc create_dns_record --domain *.test.skunkhenry.com --ipaddress 192.168.33.10
+# fhcap misc create_dns_record --domain *.test2.skunkhenry.com --alias-target dns_name:fh-lb-eng2-core-studio-584044547.eu-central-1.elb.amazonaws.com hosted_zone_id:Z215JYRZR1TBD5
+
+module Fhcap
+  module Tasks
+    module Misc
+      class CreateDNSRecord < TaskBase
+
+        attr_reader :domain, :ipaddress, :alias_target, :ttl
+
+        def initialize(options)
+          super
+          @domain = options[:domain]
+          @alias_target = options[:'alias-target']
+          @ipaddress = options[:ipaddress]
+          @ttl = options[:ttl] || 300
+        end
+
+        def run
+          thor.say "CreateDNSRecord: name = #{domain}, ipaddress = #{ipaddress}, ttl = #{ttl}", :yellow
+
+          host_domain = PublicSuffix.parse(domain).domain
+          provider = provider_for(host_domain)
+
+          if provider
+            begin
+              cfg = provider_config(provider)
+              region = provider_regions(provider).keys.first
+              creds = cfg[:credentials]
+              client = Aws::Route53::Client.new(
+                  region: region,
+                  access_key_id: creds[:'aws-access-key'],
+                  secret_access_key: creds[:'aws-secret-key']
+              )
+              resp = client.list_hosted_zones
+              zone = resp.hosted_zones.reject { |z| !(z.name =~ /#{host_domain}/) }.first
+
+              if zone
+                thor.say "Found zone id: #{zone.id}, name: #{zone.name}"
+                resp = client.list_resource_record_sets({
+                                                            hosted_zone_id: zone.id,
+                                                            start_record_name: domain,
+                                                            start_record_type: "A",
+                                                            max_items: 1
+                                                        })
+                record_set = resp.resource_record_sets.reject { |z| !(z.name =~ /^#{domain}/) }.first
+                if record_set
+                  thor.say "Found existing record set, id: name: #{record_set.name}, type: #{record_set.type}, record_set: #{record_set.resource_records || 'None'}, alias_target: #{record_set.alias_target || 'None'}\n"
+                else
+                  change_request = {
+                      :action => 'CREATE',
+                      :resource_record_set => {
+                          :name => domain,
+                          :type => "A"
+                      }
+                  }
+
+                  if @alias_target
+                    change_request[:resource_record_set].merge!(
+                        {
+                            alias_target: {
+                                evaluate_target_health: false
+                            }.merge!(@alias_target)
+                        }
+                    )
+                  else
+                    change_request[:resource_record_set].merge!(
+                        {
+                            :ttl => ttl,
+                            :resource_records => [{:value => ipaddress}]
+                        }
+                    )
+                  end
+
+                  client.change_resource_record_sets({
+                                                         :hosted_zone_id => zone.id,
+                                                         :change_batch => {
+                                                             :changes => [change_request]
+                                                         }
+                                                     })
+                end
+              else
+                thor.say_status 'error', "Can't get hosted zone for '#{host_domain}'", :red
+              end
+            rescue Aws::Route53::Errors::ServiceError => e
+              thor.say_status 'error', e.message, :red
+            end
+          else
+            thor.say_status 'error', "No DNS provider configured for '#{domain}'", :red
+          end
+        end
+
+      end
+    end
+  end
+end