sambot 0.1.158 → 0.1.159

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 139b18279e241ac46116915b26deb81f1580d678
-  data.tar.gz: b52f85c301c1fd55f479f8bc0c9a1faa16f53461
+  metadata.gz: f27feb0c87f9680b1441083a5226c3c45f34949d
+  data.tar.gz: 137d801be27d2a4331845631e71e4f7d2cdaf052
 SHA512:
-  metadata.gz: 5cf99d7d524a275da20dcf8a185243da2fe8a6f11a234190dcdf2b54adec6e40c53cdf97b957cbaca6b5260c8b7f402c18702fb77c795348cf097059a52444ce
-  data.tar.gz: 3e38b01a1a55544203a6e83953523a17ba6634c0946aedca87becc807d22838be3e2b6aa550ca42f6476e064a1af7de6263174748f147c1af482deb0a70ab1b2
+  metadata.gz: 49a6f7111b10455d4067fde52cabf814912f5ede523ccc9226d81a92892dbc846c7ea62c513e496aff3b533a2dfc5e1b769506f21f64a153018304858bf5835d
+  data.tar.gz: c7197211b5b94c3d0d8dd2898525d7f10738d8f6583523a685f728b16fde7d15860d1ecd5d46128903bc3730fa8b3f1d637a4190a976b8f01082def49ad8d480

data/lib/sambot.rb

@@ -6,6 +6,7 @@ require_relative 'sambot/ui'
 require_relative 'sambot/runtime'
 require_relative 'sambot/version'
 require_relative 'sambot/template'
+require_relative 'sambot/fs'
 
 require_relative 'sambot/chef/kitchen'
 require_relative 'sambot/chef/metadata'

data/lib/sambot/base_command.rb

@@ -62,36 +62,13 @@ module Sambot
 
       no_commands do
 
-        def missing_credentials(need_dev_credentials, need_sudo_password)
-          return true if need_dev_credentials && (!ENV['SAMBOT_DEV_USERNAME'] && !ENV['SAMBOT_DEV_PASSWORD'])
-          return need_sudo_password && !ENV['SAMBOT_SUDO_PASSWORD']
-        end
-
-        def execute(need_dev_credentials: false, need_sudo_password: false)
-          if missing_credentials(need_dev_credentials, need_sudo_password)
-            UI.info("Sambot will need to make some secure operations on your behalf. You can provide your credentials below or set them as environment variables:")
-          end
-          if need_dev_credentials && !ENV['SAMBOT_DEV_USERNAME']
-            ENV['SAMBOT_DEV_USERNAME'] = UI.ask("No environment variable SAMBOT_DEV_USERNAME found. Please provide your DEV/QE AD username: ")
-          end
-          if need_dev_credentials && !ENV['SAMBOT_DEV_PASSWORD']
-            ENV['SAMBOT_DEV_PASSWORD'] = UI.ask_password("No environment variable SAMBOT_DEV_PASSWORD found. Please provide your DEV/QE AD password: ")
-            puts "\n"
-          end
-          if need_sudo_password && !ENV['SAMBOT_SUDO_PASSWORD']
-            ENV['SAMBOT_SUDO_PASSWORD'] = UI.ask_password("No environment variable SAMBOT_SUDO_PASSWORD found. Please provide your sudo password - this is required for operations such as setting up your local SSH tunnels: ")
-            puts "\n"
-          end
+        def execute()
           Runtime.ensure_latest
           yield
         rescue ApplicationError => e
           UI.error(e.message)
         end
 
-        def config
-           Config.new.read
-        end
-
         def self.docs(path)
           File.read(File.join(File.dirname(__FILE__), '/docs', path + '.txt'))
         end

data/lib/sambot/chef/cookbook.rb

@@ -7,87 +7,65 @@ module Sambot
   module Chef
     class Cookbook
 
-      ESSENTIAL_FILES = [
-        '.config.yml',
-        'recipes',
-        'README.md'
-      ].freeze
-
       GENERATED_FILES = {
         'teamcity.sh.erb': {eruby: true, dest: 'teamcity.sh', platform: [:windows, :centos]},
         'chefignore': {eruby: false, dest: 'chefignore', platform: [:windows, :centos]},
         'Berksfile': {eruby: false, dest: 'Berksfile', platform: [:windows, :centos]},
         '.rubocop.yml': {eruby: false, dest: '.rubocop.yml', platform: [:windows, :centos]},
         '.gitignore.sample': {eruby: false, dest: '.gitignore', platform: [:windows, :centos]},
-        'local_bootstrap.sh': {eruby: false, dest: 'local_bootstrap.sh', platform: [:centos]},
-        'local_bootstrap.ps1': {eruby: false, dest: 'local_bootstrap.ps1', platform: [:windows]},
-        'gcp_bootstrap.sh.erb': {eruby: true, dest: 'gcp_bootstrap.sh', platform: [:centos]},
-        'gcp_bootstrap.ps1.erb': {eruby: true, dest: 'gcp_bootstrap.ps1', platform: [:windows]},
         'Vagrantfile.erb': {eruby: false, dest: 'Vagrantfile.erb', platform: [:windows, :centos]},
         'winrm_config': {eruby: false, dest: 'winrm_config', platform: [:windows]}
       }
 
-      CHEF_ARTEFACTS = ['Berksfile.lock']
-
-      KITCHEN_FILES_PATTERN = '\.kitchen*\.yml'
-
       class << self
 
-        def build(config)
-          Generator.from_templates(config, ESSENTIAL_FILES, GENERATED_FILES)
-          Kitchen.setup(config)
+        def build(config, cloud, vault_setup = nil)
+          create_files(config)
+          Generator.from_templates(config, cloud, vault_setup, GENERATED_FILES)
+          Kitchen.setup(cloud, config)
           Metadata.generate(config)
           Hooks.copy()
           UI.info('The cookbook has been successfully built.')
         end
 
+        def bump()
+          new_version = Config.bump_version
+          UI.info("You have bumped the version of this cookbook to #{new_version}.")
+        end
+
         def clean()
           UI.info('Removing all generated files from this cookbook.')
-          targets = ['metadata.rb', 'Berksfile.lock'] + GENERATED_FILES.map{ |key, val| val[:dest]} + Dir.glob(KITCHEN_FILES_PATTERN) - ['.gitignore']
-          targets.each { |file| delete(file) }
+          targets = GENERATED_FILES.map{ |key, val| val[:dest]} - ['.gitignore']
+          targets.each { |file| Sambot::FS.delete(file) }
+          Sambot::FS.delete('bootstrap.sh')
+          Sambot::FS.delete('bootstrap.ps1')
+          Metadata.clean
+          Kitchen.clean
           UI.info('The cookbook has been successfully cleaned.')
         end
 
-        def bump()
-          new_version = Config.new.bump_version
-          UI.info("You have bumped the version of this cookbook to #{new_version}.")
-        end
-
-        def generate(config)
-          Git.init(config[:name])
-          Dir.chdir(config[:name]) do
-            ['test', 'spec', 'recipes', 'attributes'].each {|target| FileUtils.mkdir(target) }
-            Dir.chdir('attributes') do
-              FileUtils.touch('default.rb')
-            end
-            Dir.chdir('recipes') do
-              FileUtils.touch('install.rb')
-              FileUtils.touch('configure.rb')
-              FileUtils.touch('default.rb')
-            end
-            Dir.chdir('test') do
-              FileUtils.touch('default_test.rb')
-            end
-            Dir.chdir('spec') do
-              File.write('spec_helper.rb', <<-EOT)
-              require 'chefspec'
-              require 'chefspec/berkshelf'
-              EOT
-              FileUtils.touch('default_spec.rb')
-            end
-            FileUtils.touch('README.md')
-            Template.new('.config.yml.erb').write(config, '.config.yml')
-            UI.debug("./.config.yml has been added to the cookbook.")
+        def create(config)
+          Git.init(config.name)
+          Dir.chdir(config.name) do
+            create_files(config)
           end
-          UI.info('The cookbook has been successfully generated.')
+          UI.info('The cookbook has been successfully created.')
         end
 
         private
 
-        def delete(filename)
-          return unless File.exist?(filename)
-          File.delete(filename)
-          UI.debug("./#{filename} has been removed.")
+        def create_files(config)
+          ['spec', 'test', 'attributes', '.vault.yml', '.consul.yml', 'local', 'README.md'].each { |resource| FS.copy(resource) }
+          ['recipes', 'libraries', 'resources', 'files', 'templates'].each { |target| FS.mkdir(target) }
+          Dir.chdir('recipes') do
+            Template.new('recipes/install.rb.erb').write({config: config}, 'install.rb') unless FS.exist?('install.rb')
+            Template.new('recipes/configure.rb.erb').write({config: config}, 'configure.rb') unless FS.exist?('configure.rb')
+            Template.new('recipes/default.rb.erb').write({config: config}, 'default.rb') unless FS.exist?('default.rb')
+          end
+          unless FS.exist?('.config.yml')
+            Template.new('.config.yml.erb').write({config: config}, '.config.yml')
+            UI.debug("./.config.yml has been added to the cookbook.")
+          end
         end
 
       end

data/lib/sambot/chef/generator.rb

@@ -5,27 +5,32 @@ module Sambot
     module Chef
       class Generator
 
-        def self.from_templates(config, cookbook_essentials, cookbook_generated_files)
-          platforms = config[:platforms] if config.has_key?(:platforms)
-          platforms = config['platforms'] if config.has_key?('platforms')
-          cookbook_essentials.each { |path| exists!(path) } if cookbook_essentials
-          cookbook_generated_files.each do |template_name, opts|
-            generate_from_template(template_name.to_s, opts, platforms)
-          end
-          override_bootstrap_mechanism(config['bootstrap']) if config['bootstrap']
+        def self.from_templates(config, cloud, vault_setup, generated_files)
+          generated_files.each { |template_name, opts| generate_from_template(template_name.to_s, opts, config) }
+          generate_bootstrap_scripts(config, cloud, vault_setup)
         end
 
         private
 
-        def self.override_bootstrap_mechanism(config)
-          if config['centos']
-            raise ApplicationError, "The file #{config['centos']} does not exist" unless File.exist?(config['centos'])
-            FileUtils.cp(config['centos'], 'bootstrap.sh')
-          end
-          if config['windows']
-            raise ApplicationError, "The file #{config['centos']} does not exist" unless File.exist?(config['windows'])
-            FileUtils.cp(config['windows'], 'bootstrap.ps1')
-          end
+        def self.bootstrap_centos(path)
+          generate_bootstrap_from_template('bootstrap.sh', path, 'sh')
+        end
+
+        def self.bootstrap_windows(path)
+          generate_bootstrap_from_template('bootstrap.ps1', path, 'ps1')
+        end
+
+        def self.bootstrap(config, path)
+          bootstrap_centos(path) if config.runs_on_centos?
+          bootstrap_windows(path) if config.runs_on_windows?
+        end
+
+        def self.generate_bootstrap_from_template(dest, path, suffix)
+          Template.new("bootstrap_scripts/#{path}/bootstrap.#{suffix}.erb").process({eruby: true, dest: "bootstrap.#{suffix}"})
+        end
+
+        def self.generate_bootstrap_scripts(config, cloud, vault_setup)
+          cloud != 'local'? bootstrap(config, cloud) : bootstrap(config, "local/#{vault_setup}_vault")
         end
 
         def self.exists!(path)
@@ -33,36 +38,21 @@ module Sambot
           raise ApplicationError, "The file or directory #{path} was not found in the current directory."
         end
 
-        def self.generate_from_template(template_file, opts, platforms)
-          UI.debug("Processing #{template_file} with opts #{opts.inspect} on platform #{platforms}")
+        def self.generate_from_template(template_file, opts, config)
+          UI.debug("Processing #{template_file} with opts #{opts.inspect} on platform #{config.available_platforms}")
           template = Template.new(template_file)
-          if valid_platform?(opts, platforms)
-            File.delete(opts[:dest]) if File.exist?(opts[:dest])
-            if opts[:eruby]
-              UI.debug("Parsing #{template.path} using Erubis")
-              template.write({}, opts[:dest])
-            else
-              FileUtils.cp(template.path, opts[:dest].to_s)
-            end
-            if File.executable?(template.path)
-              UI.debug("Making #{opts[:dest]} executable")
-              make_executable(template.path, opts[:dest])
-            end
+          if valid_platform?(opts, config)
+            template.process(opts)
             UI.debug("#{opts[:dest]} has been added to the cookbook.")
           end
         end
 
-        def self.valid_platform?(opts, platforms)
+        def self.valid_platform?(opts, config)
           targets = opts[:platform].map { |x| x.to_s}
-          result = targets & platforms
+          result = targets & config.available_platforms
           result.size > 0
         end
 
-        def self.make_executable(file, working_path)
-          current_mask = File.stat(file).mode
-          new_mask = current_mask | '0000000000000001'.to_i(2)
-          File.chmod(new_mask, working_path)
-        end
       end
   end
 end

data/lib/sambot/chef/hooks.rb

@@ -4,10 +4,12 @@ module Sambot
     module Chef
       class Hooks
 
+        SCRIPTS = ['pre-push', 'pre-commit']
+
         def self.copy
-          ['pre-push', 'pre-commit'].each do |hook|
+          SCRIPTS.each do |hook|
             working_path = ".git/hooks/#{hook}"
-            template_path = Template.new(hook).path
+            template_path = Template.new("git_hooks/#{hook}").path
             File.delete(working_path) if File.exist?(working_path)
             FileUtils.cp(template_path, working_path)
             UI.debug("The #{hook} Git hook has been added to the cookbook.")

data/lib/sambot/chef/kitchen.rb

@@ -4,68 +4,59 @@ module Sambot
     module Chef
       class Kitchen
 
-        LOCAL = '.kitchen.yml'
-        GCP = '.kitchen.gcp.yml'
-        RACKSPACE = '.kitchen.rackspace.yml'
-
         class << self
 
-          def setup(config)
-            files = generate_yml(config['name'], config['platforms'], config['suites'])
-            files.each do |filename, contents|
-              File.write(filename.to_s, contents)
-              UI.debug("#{filename.to_s} has been added to the cookbook.")
-            end
+          GENERATED_FILE = '.kitchen.yml'
+
+          def setup(cloud, config)
+            contents = generate_yml(cloud, config.name, config.available_platforms, config.suites)
+            File.write(GENERATED_FILE, contents)
+            UI.debug("#{GENERATED_FILE} has been added to the cookbook.")
           end
 
-          def generate_yml(cookbook_name, platforms, suites = nil)
+          def clean
+            FS.delete(GENERATED_FILE)
+          end
+
+          def generate_yml(cloud, cookbook_name, platforms, suites = nil)
             raise ApplicationError, 'Missing platforms when trying to generate Test-Kitchen YAML.' unless platforms
             raise ApplicationError, 'Missing cookbook name when trying to generate Test-Kitchen YAML.' unless cookbook_name
-            test_kitchen_configs = {
-              "#{LOCAL}": read_template(LOCAL, cookbook_name, platforms),
-              "#{GCP}": read_template(GCP, cookbook_name, platforms),
-              "#{RACKSPACE}": read_template(RACKSPACE, cookbook_name, platforms)
-            }
-            test_kitchen_configs.each do |key, value|
-              if suites
-                value['suites'] = Marshal.load(Marshal.dump(suites))
-                case key.to_s
-                when LOCAL
-                  add_platform_identifier(value, 'LOCAL')
-                when GCP
-                  add_platform_identifier(value, 'GCP')
-                when RACKSPACE
-                  add_platform_identifier(value, 'RACKSPACE')
-                end
-              end
-              test_kitchen_configs[key] = value.to_yaml
+            template = read_template(cloud, cookbook_name, platforms)
+            if suites
+              template['suites'] = Marshal.load(Marshal.dump(suites))
+              add_platform_identifier(template, cloud)
             end
-            test_kitchen_configs
+            template.to_yaml
           end
 
           private
 
+          # Adds attributes to each test suite that is only applicable to testing
+          # environments. These are things like controlling how Vault token
+          # renewal works and specifying the cloud platform.
           def add_platform_identifier(value, platform)
-            value['suites'].each do |config|
-              config['run_list'] = handle_customized_runlists(config, platform)
-              config['attributes'] = config['attributes'] || {}
-              config['attributes']['cloud_platform'] = platform
-              config['attributes']['vault'] = config['attributes']['vault'] || {}
-              config['attributes']['vault']['exec_renew'] = false
+            value['suites'].each do |suite|
+              suite['run_list'] = handle_customized_runlists(suite, platform)
+              suite['attributes'] = suite['attributes'] || {}
+              suite['attributes']['cloud_platform'] = platform
+              suite['attributes']['vault'] = suite['attributes']['vault'] || {}
+              suite['attributes']['vault']['exec_renew'] = false
             end
           end
 
+          # Provides the ability to have a different run-list for different clouds.
+          # This only works for the 'local' cloud and the 'dev' clouds i.e. Rackspace
+          # and Google.
           def handle_customized_runlists(config, platform)
             runlist = config['run_list']
             return runlist if runlist.is_a?(Array)
-            platform == 'LOCAL' ? runlist['local'] : runlist['dev']
+            platform == 'local' ? runlist['local'] : runlist['dev']
           end
 
-          def read_template(template, cookbook_name, platforms)
-            result = Template.new("#{template}.erb").evaluate({platforms: platforms}, {:pattern => '<!--% %-->'}) do |contents|
-              contents.gsub(/@@cookbook_name@@/, cookbook_name)
-            end
-            YAML.load(result.gsub(/\_@/, '<%=').gsub(/@\_/, '%>'))
+          def read_template(cloud, cookbook_name, platforms)
+            ctx = {platforms: platforms, name: cookbook_name}
+            result = Template.new("test_kitchen/#{cloud}.yml.erb").evaluate(ctx, {:pattern => '<!--% %-->'})
+            YAML.load(result)
           end
 
       end

data/lib/sambot/chef/metadata.rb

@@ -8,27 +8,27 @@ module Sambot
 
       class << self
 
+        GENERATED_FILES = ['metadata.rb', 'Berksfile.lock']
+
+        def clean
+          GENERATED_FILES.each do |filename|
+            FS.delete(filename)
+          end
+        end
+
         def generate(config, dest = 'metadata.rb')
           write({
-            'cookbook_name' => config['name'],
-            'cookbook_platforms' => config['platforms'],
-            'cookbook_version' => config['version'],
-            'cookbook_description' => config['description'],
-            'cookbook_dependencies' => map_dependencies(config),
-            'cookbook_gems' => config['gems'] || [],
+            'cookbook_name' => config.name,
+            'cookbook_platforms' => config.available_platforms,
+            'cookbook_version' => config.version,
+            'cookbook_description' => config.description,
+            'cookbook_dependencies' => config.dependencies,
+            'cookbook_gems' => config.gems,
           }, dest)
         end
 
         private
 
-        def map_dependencies(config)
-          config['dependencies'] ? config['dependencies'].map { |x| transform_hashes(x) } : []
-        end
-
-        def transform_hashes(obj)
-          obj.is_a?(Hash) ? "#{obj.keys.first}', '#{obj.values.first}" : obj
-        end
-
         def write(ctx, dest)
           template = Sambot::Template.new('metadata.rb.erb').write(ctx, dest)
           UI.debug("A new metadata.rb file has been generated.")

data/lib/sambot/cli.rb

@@ -1,41 +1,51 @@
 # frozen_string_literal: true
 
 require_relative 'base_command'
-require_relative 'commands/cookbook_cmd'
 
 module Sambot
   class CLI < BaseCommand
 
-    desc 'cookbook', 'Manage Chef cookbooks'
-    subcommand 'cookbook', Sambot::Commands::CookbookCmd
-
     desc 'clean', 'Remove all generated build files from a Chef cookbook'
     def clean
       execute { Chef::Cookbook.clean() }
     end
 
-    desc 'clean', 'Bump the patch version of a cookbook'
+    desc 'bump', 'Bump the patch version of a cookbook'
     def bump
       execute { Chef::Cookbook.bump() }
     end
 
     desc 'build', 'Builds a Chef cookbook from its configuration file'
+    option :local, :type => :boolean
+    option :google, :type => :boolean
+    option :rackspace, :type => :boolean
+    option :vault, :type => :string, :default => 'standalone'
     def build
-      execute { Chef::Cookbook.build(config) }
+      execute do
+        cloud = nil
+        cloud = 'local' if options[:local]
+        cloud = 'google' if options[:google]
+        cloud = 'rackspace' if options[:rackspace]
+        unless cloud
+          UI.error('Please select which environment this is building for using one of the following flags: --local, --rackspace or --google')
+          exit
+        end
+        Chef::Cookbook.build(Config.read, cloud, options[:vault])
+      end
     end
 
-    desc 'generate', 'Creates a new Chef cookbook'
-    def generate
+    desc 'create', 'Creates a new Chef cookbook'
+    def create
       execute do
-        config = {
+        opts = {
           name: ask(' What is the name of this cookbook?'),
           type: ask(' What type of cookbook will this be?', :limited_to => ['wrapper', 'role']),
           platforms: ask(' What operating system will this cookbook run on?', :limited_to => ['windows', 'centos', 'both']),
           description: ask(' What does this cookbook do?')
         }
-        config[:identifier] = ask(' What will be the unique machiner identifier for this role cookbook?') if config[:type] == 'role'
-        config[:platforms] = config[:platforms] == 'both' ? ['centos', 'windows'] : [config[:platforms]]
-        Chef::Cookbook.generate(config)
+        opts[:identifier] = ask(' What will be the unique machiner identifier for this role cookbook?') if opts[:type] == 'role'
+        opts[:platforms] = opts[:platforms] == 'both' ? ['centos', 'windows'] : [opts[:platforms]]
+        Chef::Cookbook.create(Config.new(opts))
       end
     end
 
@@ -44,12 +54,5 @@ module Sambot
       execute { puts "##teamcity[buildNumber '#{config['version'].to_s}']" }
     end
 
-    desc 'configure', 'Sets up an engineering workstation'
-    def configure
-      execute(need_dev_credentials: true, need_sudo_password: true) do
-        Workflow::Workstation.configure(ENV['SAMBOT_DEV_PASSWORD'])
-      end
-    end
-
   end
 end