fhcap-cli 0.3.0

data/lib/fhcap/dummy_node.rb

@@ -0,0 +1,80 @@
+require 'chef/node'
+
+module Fhcap
+  class DummyNode < Chef::Node
+
+
+    attr_accessor :included_recipe_attributes
+
+    def initialize
+      super
+      @included_recipe_attributes = []
+    end
+
+    def include_attribute(recipe)
+      @included_recipe_attributes << recipe
+    end
+
+    def from_file(filename)
+      if File.exists?(filename) && File.readable?(filename)
+        #Convert any references to node['blah'] to a string so instance_eval doesn't try to evaluate it
+        text = ""
+        ignore_lines = false
+        File.open(filename).each_line do |line|
+          key, value = line.split(/ = /, 2)
+          if key && value
+            ignore_lines = false
+            if ignore_key? key
+              value = "\"Ignored\""
+              ignore_lines = true
+            else
+              value.gsub!(/node(\[['a-zA-Z0-9_-]*\])+/, '"\&"')
+              value.gsub!(/node.chef_environment/, '"\&"')
+              if value =~ /\.* \| "node\[/
+                value.gsub!(/"/, '')
+                value = "\"#{value.chomp}\"\n"
+              end
+            end
+            line = "#{key} = #{value}"
+          end
+          text += line unless ignore_lines
+        end
+        self.instance_eval(text, filename, 1)
+      else
+        raise IOError, "Cannot open or read #{filename}!"
+      end
+    end
+
+    def ignore_key?(key)
+      key =~ /\['cron_jobs'\]/
+    end
+
+    def metadata_attributes
+      self.get_attributes(node.default_attrs)
+    end
+
+    def get_attributes(hash, attrs=nil, keys=nil)
+      keys ||= []
+      attrs ||= {}
+      hash.sort.each() do |k, v|
+        keys << k.to_s
+        if v.is_a? Hash
+          self.get_attributes(v, attrs, keys)
+        else
+          attrs[keys.join("/")] = {:default => parse_value(v)}
+        end
+        keys.pop
+      end
+      attrs
+    end
+
+    def parse_value(value)
+      if value.is_a? Array
+        value
+      else
+        value.to_s
+      end
+    end
+
+  end
+end

data/lib/fhcap/fhcap_helper.rb

@@ -0,0 +1,9 @@
+module Fhcap
+  module FhcapHelper
+
+    def cluster_template_names
+      Fhcap::TEMPLATE_NAMES
+    end
+
+  end
+end

data/lib/fhcap/kitchen.rb

@@ -0,0 +1,235 @@
+require 'thor'
+require 'fhcap/thor_base'
+
+require 'pathname'
+require 'yaml'
+
+module Fhcap
+  module CLI
+    class Kitchen < Fhcap::ThorBase
+
+      TEST_SUITE_NAME='default'
+      DEFAULT_INSTANCE='default'
+
+      add_shared_option :cookbooks, :aliases => "-c", :desc => "Apply to these Cookbooks", :type => :array
+      add_shared_option :roles, :aliases => "-r", :desc => "Roles to generate kitchen for", :type => :array
+      add_shared_option :driver, :aliases => "-d", :desc => "Kitchen Driver", :type => :string, :default => 'openstack', :enum => %w{aws openstack docker}
+      add_shared_option :modified, :aliases => "-m", :desc => "Apply only to modified Cookbooks", :type => :boolean, :required => false, :default => false
+      add_shared_option :provisioner, :aliases => "-p", :desc => "Kitchen Provisioner", :type => :string, :default => 'chef_solo', :enum => %w{chef_solo chef_zero}
+
+
+      desc "generate", "Generate"
+
+      shared_options :cookbooks, :roles, :modified, :driver, :provisioner
+      method_option 'only', :type => :array, :default => nil, :desc => "Only include tests for cookbooks matching these names."
+      method_option 'exclude', :type => :array, :default => nil, :desc => "Exclude tests for cookbooks matching these names, takes precedence over 'only' option."
+      method_option 'clean', :type => :boolean, :default => true, :desc => "Clean the current generated kitchen prior to creating the new one"
+
+      def generate
+        require 'chef'
+        cookbooks = get_cookbooks(options, nil, repo_cookbook_paths('-cookbooks'))
+        roles = options[:roles] || []
+        driver = options[:driver]
+        provisioner = options[:provisioner]
+        say("Kitchen Generate: Cookbooks = #{cookbooks} : Roles = #{roles}: Driver = #{driver} : Provisioner = #{provisioner}", :yellow)
+
+        Fhcap::CLI::Kitchen.new.invoke(:clean, [], {}) if is_kitchen_generated? && options[:clean]
+        empty_directory test_suite_dir
+
+        kitchen_config = YAML.load_file(File.join(Fhcap.source_root, "templates", "kitchen", "kitchen.#{driver}.yml.erb"))
+        kitchen_config['suites'] = []
+        kitchen_config['provisioner']['name'] = provisioner
+        kitchen_config['provisioner']['data_bags_path'] = File.join(repo_dir(:fhcap), 'data_bags')
+        kitchen_config['provisioner']['environments_path'] = File.join(repo_dir(:fhcap), 'environments')
+        kitchen_config['provisioner']['roles_path'] = File.join(repo_dir(:fhcap), 'roles')
+
+        cookbook_dependencies = {}
+
+        cookbooks.each do |cookbook|
+          meta = cookbook_loader.cookbooks_by_name[cookbook]
+          if meta
+            cookbook_kitchen_yaml = File.join(meta.root_dir, ".kitchen.yml")
+            if File.exists? cookbook_kitchen_yaml
+              cookbook_kitchen_config = YAML.load_file(cookbook_kitchen_yaml)
+              cookbook_kitchen_config['suites'].each do |suite|
+                suite['name'] = "#{suite['name']}_#{cookbook}"
+                suite['run_list'].unshift 'recipe[feedhenry_utils::kitchen_docker]' if driver == 'docker'
+                suite['run_list'].unshift 'recipe[apt::default]'
+                suite['run_list'].unshift 'recipe[chef-solo-search]' if provisioner == 'chef_solo'
+                suite['run_list'].unshift 'role[test-kitchen_server]'
+                suite['run_list'].uniq!
+
+                suite_cookbooks = [cookbook] | suite['run_list'].collect do |item|
+                  recipe_match = /recipe\[(.+?(?=::)|.+?(?=\]))/.match item
+                  recipe_match ? recipe_match[1] : nil
+                end.compact.uniq
+
+                kitchen_config['suites'] << suite
+
+                suite_cookbooks.each do |c|
+                  get_cookbook_deps(c, cookbook_dependencies, {cwd: test_suite_dir})
+                end
+
+              end
+            else
+              say_status("ERROR", "No test suites found for #{cookbook}", :red)
+            end
+
+          else
+            say_status("ERROR", "No cookbook found for #{cookbook}", :red)
+          end
+        end
+
+        roles.each do |r|
+          role_file = find_role(r)
+          if File.exists? role_file
+            ::Chef::Config[:role_path] = File.join(repo_dir(:fhcap), 'roles')
+            role = ::Chef::Role.from_disk r
+            run_list = role.run_list.expand('development')
+
+            role_cookbooks = run_list.recipes.collect do |recipe|
+              recipe.split('::').first
+            end.compact.uniq
+
+            suite = {}
+            suite['name'] = "default_#{r}"
+            suite['run_list'] = ["role[#{r}]"]
+            kitchen_config['suites'] << suite
+
+            role_cookbooks.each do |c|
+              get_cookbook_deps(c, cookbook_dependencies, {cwd: test_suite_dir})
+            end
+
+            link_cookbook_tests(role_cookbooks, options, r)
+
+          else
+            say "Unknown Role #{role_file}"
+          end
+        end
+
+        # 1. Create kitchen.yml
+        template(File.join("templates", "kitchen", "kitchen.generate.yml.erb"), test_suite_kitchen_yml, :kitchen_yaml => kitchen_config.to_yaml, :force => true)
+
+        #2. Create Cheffile
+        template(File.join("templates", "kitchen", "Cheffile.erb"), File.join(test_suite_dir, "Cheffile"), :cookbooks => cookbook_dependencies.to_h, :name => "Combined Cheffile for #{cookbooks}", :force => true)
+
+        #3. Configure tests
+        link_cookbook_tests(cookbooks, options)
+      end
+
+      desc "clean", "Clean"
+
+      def clean
+        say("Clean Test Suite", :yellow)
+        Fhcap::CLI::Kitchen.new.invoke(:destroy, ['all'], {}) if is_kitchen_generated?
+        remove_file test_suite_dir
+      end
+
+      %w{create converge setup verify test list login destroy diagnose}.each do |cmd|
+
+        desc "#{cmd} [INSTANCE|REGEXP|all]", "Run '#{cmd}' command against current kitchen instances."
+        shared_options :cookbooks, :roles, :modified, :driver, :provisioner if %w{create converge setup verify test}.include? cmd
+
+        define_method(cmd) do |instance='all'|
+          Fhcap::CLI::Kitchen.new.invoke(:generate, [], options) if options[:cookbooks] || options[:modified] || options[:roles]
+          if is_kitchen_generated?
+            Dir.chdir test_suite_dir do
+              cmd_options = options.dup
+              cmd_options['instance'] = instance
+              cmd_options['kitchen-yaml'] = test_suite_kitchen_yml
+              cmd_options['kitchen-options'] = '--concurrency=10'
+              run_kitchen_cmd(cmd, cmd_options)
+            end
+          else
+            say "Please generate a test kitchen first! i.e fhcap kitchen generate -c <cookbooks>", :yellow
+          end
+        end
+
+      end
+
+      protected
+
+      def test_suite_dir
+        File.join(config.default_dir, 'tmp', 'kitchen')
+      end
+
+      def test_suite_kitchen_yml
+        File.join(test_suite_dir, 'kitchen.yml')
+      end
+
+      def is_kitchen_generated?
+        File.exists? test_suite_kitchen_yml
+      end
+
+      def include_cookbook_tests?(cookbook, options)
+        if options['exclude']
+          !options['exclude'].include?(cookbook)
+        elsif options['only']
+          options['only'].include?(cookbook)
+        else
+          true
+        end
+      end
+
+      def link_cookbook_tests(cookbooks, options, role=nil)
+        tests_parent_dir = File.join(test_suite_dir, 'test', 'integration')
+        test_helpers_dir = File.join(repo_dir(:fhcap), 'test', 'helpers')
+
+        cookbooks.each do |cookbook|
+          if include_cookbook_tests?(cookbook, options)
+            meta = cookbook_loader.cookbooks_by_name[cookbook]
+            cookbook_dir = File.dirname(meta.root_filenames.first)
+            cookbook_test_suite_dir = File.join(cookbook_dir, '/test/integration')
+
+            if Dir.exists? cookbook_test_suite_dir
+              Dir.entries(cookbook_test_suite_dir).select { |f| !File.directory? f }.each() do |test_suite|
+
+                cookbook_test_dir = File.join(cookbook_test_suite_dir, test_suite)
+                Dir.entries(cookbook_test_dir).select { |f| !File.directory? f }.each() do |test_type|
+                  tests_dir = File.join(tests_parent_dir, "#{test_suite}_#{role || cookbook}")
+
+                  test_type_dir = "#{tests_dir}/#{test_type}"
+                  empty_directory test_type_dir
+
+                  if Dir.exists? "#{test_helpers_dir}/#{test_type}"
+                    FileUtils.cp_r(Dir["#{test_helpers_dir}/#{test_type}/*"], test_type_dir)
+                  end
+
+                  Dir.chdir("#{cookbook_test_dir}/#{test_type}") do
+                    Dir["*_spec.rb"].each do |test|
+                      link_src = "#{cookbook_test_dir}/#{test_type}/#{test}"
+                      link_dest = "#{test_type_dir}/#{cookbook}_#{test}"
+                      create_link link_dest, link_src
+                    end
+                  end
+                end
+              end
+            else
+              say_status("warning", "No tests suites found for #{cookbook}", :yellow)
+            end
+          else
+            say_status("exclude", "Excluding tests for #{cookbook}", :yellow)
+          end
+        end
+      end
+
+      def _get_config(options)
+        opts = []
+        opts << "KITCHEN_YAML=#{options['kitchen-yaml']}" if options['kitchen-yaml']
+        opts.join(' ')
+      end
+
+      def run_kitchen_cmd(cmd, options)
+        suite = options['instance'] || DEFAULT_INSTANCE
+        kitchen_cmd_options = [options['kitchen-options']] || []
+        cmd = ([_get_config(options), 'kitchen', cmd, suite] + kitchen_cmd_options).join(' ')
+        run_cmd(cmd, options)
+      end
+
+      def run_cmd(cmd, options)
+        run(cmd)
+      end
+
+    end
+  end
+end

data/lib/fhcap/knife.rb

@@ -0,0 +1,74 @@
+require 'thor'
+require 'fhcap/thor_base'
+
+module Fhcap
+  module CLI
+    class Knife < Fhcap::ThorBase
+
+      add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
+      add_shared_option :name, :type => :string, :required => true, :desc => "Chef Server name i.e. bob"
+      add_shared_option :interactive, :aliases => "-i", :desc => "Interactive mode (Stops for input)", :type => :boolean, :required => false, :default => false
+
+      desc "add", "Add a chef server"
+
+      shared_options :verbose, :name, :interactive
+      method_option 'url', :type => :string, :required => false, :desc => "Chef Server url i.e. https://bob.feedhenry.net:8443"
+      method_option 'node-name', :type => :string, :desc => "Node name, defaults to current users ID i.e. echo $USER"
+      method_option 'validation-client-name', :type => :string, :desc => "Validation client name, defaults to 'chef-validator'"
+      method_option 'import-file', :type => :string, :desc => "Path to import file"
+      long_desc <<-LONGDESC
+      Add a chef server to your local fhcap configuration.
+
+      With --import-file option, if an admin sent you an import-file you can pass this in here and all config, keys etc.. will be created for you
+      LONGDESC
+
+      def add
+        require "fhcap/tasks/knife/add"
+        Tasks::Knife::Add.new(task_options(options.dup)).run
+      end
+
+      desc "remove", "Remove a chef server"
+
+      shared_options :verbose, :name
+
+      def remove
+        require "fhcap/tasks/knife/remove"
+        Tasks::Knife::Remove.new(task_options(options.dup)).run
+      end
+
+      desc "list", "List configured chef servers"
+
+      def list
+        require "fhcap/tasks/knife/list"
+        Tasks::Knife::List.new(task_options(options.dup)).run
+      end
+
+      desc "create_user", "Create a new user on a given chef server."
+      long_desc <<-LONGDESC
+      Create a new user on a given chef server.
+
+      To create users on a chef server the user running this command must have the appropriate permissions to do so i.e. admin
+
+      By default an import-file is generated that can be sent to the new user to make there local setup easier by passing it directly into the add command
+
+      i.e. fhcap knife add --name <NAME> --import-file <IMPORT_FILE>
+      LONGDESC
+
+      shared_options :verbose, :interactive
+      method_option 'chef-server', :type => :string, :desc => "Chef Server", :required => false, :enum => chef_server_names
+      method_option :username, :type => :string, :desc => "Username", :required => true
+      method_option 'display-name', :type => :string, :desc => "Display Name", :required => false
+      method_option 'first-name', :type => :string, :desc => "First Name", :required => false
+      method_option 'last-name', :type => :string, :desc => "Last Name", :required => false
+      method_option :email, :type => :string, :desc => "Email", :required => false
+      method_option :password, :type => :string, :desc => "Password", :required => false
+
+      def create_user
+        require "fhcap/tasks/chef/server/create_user"
+        Tasks::Chef::Server::CreateUser.new(task_options(options.dup)).run
+
+      end
+
+    end
+  end
+end

data/lib/fhcap/knife_helper.rb

@@ -0,0 +1,38 @@
+require 'chef/config'
+
+module Fhcap
+  module KnifeHelper
+
+    def knife_config
+      config.exists? && config[:knife] ? config[:knife] : {}
+    end
+
+    def knife_config_dir
+      config[:knife_dir] || File.join(config.default_dir, '.chef')
+    end
+
+    def knife_config_file_for(name)
+      File.join(knife_config_dir, "knife-#{name}.rb")
+    end
+
+    def chef_server_names
+      knife_config.collect do |server_name, cfg|
+        server_name.to_s
+      end
+    end
+
+    def chef_server_config_for(name)
+      Chef::Config.from_file(knife_config_file_for(name))
+    end
+
+    def chef_server_config_hash_for(name)
+      chef_server_config_for(name)
+      chef_server_config = {
+          chef_server_url: Chef::Config[:chef_server_url],
+          node_name: Chef::Config[:node_name],
+          client_key: Chef::Config[:client_key],
+      }
+    end
+
+  end
+end

data/lib/fhcap/misc.rb

@@ -0,0 +1,103 @@
+require 'thor'
+require 'fhcap/thor_base'
+
+module Fhcap
+  module CLI
+    class Misc < Fhcap::ThorBase
+
+      add_shared_option :verbose, :aliases => "-v", :desc => "Verbose output", :type => :boolean, :required => false, :default => false
+
+      desc "create_ssl_cert", "Create an SSL Cert"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => "SSL Cert name"
+      method_option 'domain', :type => :string, :required => true, :desc => "SSL Cert Domain i.e. *.feedhenry.me"
+      method_option 'directory', :type => :string, :required => true, :desc => "Destination directory"
+      method_option 'format', :type => :string, :required => true, :default => 'pem', :desc => "Format to save cert in", :enum => %w{pem json}
+
+      def create_ssl_cert
+        require "fhcap/tasks/misc/create_ssl_cert"
+        Tasks::Misc::CreateSslCert.new(task_options(options.dup)).run
+      end
+
+      desc "create_chef_environment", "Create a Chef Environment"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => 'Environment name'
+      method_option 'type', :type => :string, :required => true, :enum => %w{core mbaas}, :desc => 'Environment type'
+      method_option 'domain', :type => :string, :required => true, :desc => 'Environment domain'
+      method_option 'repo', :type => :string, :required => true, :desc => "Fhcap Repo where environment should be saved", :enum => repo_names
+
+      def create_chef_environment
+        require "fhcap/tasks/chef/environments/create"
+        Tasks::Chef::Environments::Create.new(task_options(options.dup)).run
+      end
+
+      desc "destroy_chef_environment", "Create a Chef Environment"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => 'Environment name'
+
+      def destroy_chef_environment
+        require "fhcap/tasks/chef/environments/destroy"
+        Tasks::Chef::Environments::Destroy.new(task_options(options.dup)).run
+      end
+
+      desc "chef_provision", "Run a chef provisioning task against a particular cluster"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => 'Cluster name'
+      method_option 'run-list', :type => :array, :required => true, :desc => 'Chef Provisioning Run List i.e provision::cluster_provision'
+
+      def chef_provision
+        require 'fhcap/tasks/chef/provisioning/chef_provisioning_task'
+        Tasks::Chef::Provisioning::ChefProvisioningTask.new(task_options(options.dup)).run
+      end
+
+      desc "create_cluster_environment", "Add an environment to a cluster"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => 'Cluster name'
+      method_option 'environment-name', :type => :string, :required => true, :desc => 'Environment name'
+      method_option 'domain', :type => :string, :required => true, :desc => 'Environment domain'
+      method_option 'template', :type => :string, :required => true, :desc => 'Environment template'
+
+      def create_cluster_environment
+        require "fhcap/tasks/cluster/create_environment"
+        Tasks::Cluster::CreateEnvironment.new(task_options(options.dup)).run
+      end
+
+      desc "destroy_cluster_environment", "Add an environment to a cluster"
+
+      shared_options :verbose
+
+      method_option 'name', :type => :string, :required => true, :desc => 'Cluster name'
+      method_option 'environment-name', :type => :string, :required => true, :desc => 'Environment name'
+
+      def destroy_cluster_environment
+        require "fhcap/tasks/cluster/destroy_environment"
+        Tasks::Cluster::DestroyEnvironment.new(task_options(options.dup)).run
+      end
+
+      desc "create_dns_record", "Create a new DNS Record"
+
+      shared_options :verbose
+
+      method_option 'domain', :type => :string, :required => true, :desc => 'Domain'
+      method_option 'ipaddress', :type => :string, :desc => 'IP Address'
+      method_option 'alias-target', :type => :hash, :desc => 'Alias Target'
+      method_option 'ttl', :type => :numeric, :default => 300, :desc => 'Time To Live'
+
+      def create_dns_record
+        require "fhcap/tasks/misc/create_dns_record"
+        Tasks::Misc::CreateDNSRecord.new(task_options(options.dup)).run
+      end
+
+    end
+  end
+end