knife-table 0.0.1

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.0.1
+* Initial commit

data/README.md

@@ -0,0 +1,54 @@
+# ChefTable
+
+ChefTable is a knife plugin to aid in cookbook development
+workflow. Its intention is to help automate versioning
+within environments and cookbook freezing based on a stable
+branch. Building off of the knife-spork plugin ChefTable
+helps to provide consistency within the environment.
+
+
+## Usage
+
+Currently, two helpers are available:
+
+`knife table set`
+
+and 
+
+`knife table serve`
+
+### Setting the table
+
+First, we set the table either by adding new or modifying
+existing features. To do this, we set the table with a basic description
+of what is being added:
+
+`knife table set new feature`
+
+This will create a new working branch named 'WIP-new_feature'. The prefix
+for the branch defaults to 'WIP-' but can be modified using the `-p` option.
+If it is known what cookbooks will be modified, you can provide them while
+setting:
+
+`knife table set -c iptables,mysql new feature`
+
+### Service
+
+Service works on the assumption that any new code into the stable branch (master
+by default) will arrive via pull requests. By default, it will find the last
+pull request in the log and update based on changes within that merge. The default
+behavior of the `serve` command will upload and freeze any changed cookbooks. Optionally,
+environments can be provided to have the cookbook versions automatically pegged. Also,
+roles and data bags can be automatically uploaded as well.
+
+Options for serve:
+
+* `--environments ENV[,ENV...]` 'Update versions in given environments'
+* `--git-autopush` 'Automatically commit and push any changes to master'
+* `--git-tag` 'Automatically create tag for frozen cookbook'
+* `--git-branch BRANCH` 'Set working branch'
+* `--git-remote-name NAME` 'Remote repo name'
+* `--git-autocommit` 'Automatically commit changes'
+* `--autoproceed` 'Answer yes to any prompts'
+* `--roles` 'Upload any changed roles'
+* `--data-bags` 'Upload any changed data bags'

data/knife-table.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name = 'knife-table'
+  s.version = '0.0.1'
+  s.summary = 'Help chef set and serve the table'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/heavywater/knife-table'
+  s.description = "Chef's table"
+  s.require_path = 'lib'
+  s.files = Dir.glob('**/*')
+  s.add_dependency 'knife-spork'
+end

data/lib/chef/knife/data_holder.rb

@@ -0,0 +1,54 @@
+require 'pp'
+
+class DataHolder
+
+  def initialize
+    @holder = {}
+    @path = nil
+  end
+
+  def method_missing(name, *args)
+    @holder[name] = args
+  end
+
+  def ==(holder)
+    raise TypeError.new('Comparisons only allowed between DataHolder instances')
+    self._holder == holder._holder
+  end
+
+  def _holder
+    @holder
+  end
+
+  def _load(path)
+    @path = path
+    self.instance_eval(
+      File.read(path)
+    )
+    self
+  end
+
+  def _output
+    output = ''
+    @holder.each_pair do |k,v|
+      output << "#{k}(\n"
+      inards = []
+      v.each do |item|
+        s = ''
+        PP.pp(item, s)
+        inards << s
+      end
+      output << inards.join(",\n")
+      output << ")\n"
+    end
+    output
+    File.open(@path, 'w') do |file|
+      file.write(output)
+    end
+    output
+  end
+
+  def _path
+    @path
+  end
+end

data/lib/chef/knife/table_clear.rb

@@ -0,0 +1,21 @@
+require 'knife-table/helpers'
+
+module KnifeTable
+  class TableClear < Chef::Knife
+
+    include KnifeTable::Helpers
+
+    deps do
+      require 'git'
+      require 'chef/knife/core/object_loader'
+    end
+
+    banner 'knife table clear'
+
+    def run
+
+    end
+
+  end
+end
+

data/lib/chef/knife/table_serve.rb

@@ -0,0 +1,332 @@
+require 'knife-table/helpers'
+
+module KnifeTable
+  class TableServe < Chef::Knife
+
+    include KnifeTable::Helpers
+
+    deps do
+      require 'git'
+      require 'chef/knife/core/object_loader'
+    end
+
+    banner "knife table serve [#PULLREQ|COMMITSHA[..COMMITSHA]]"
+
+    option :environments,
+      :short => '-e ENV[,ENV...]',
+      :long => '--environments ENV[,ENV...]',
+      :description => 'Update versions in given environments'
+
+    option :git_autopush,
+      :short => '-g',
+      :long => '--git-autopush',
+      :boolean => true,
+      :description => 'Automatically commit and push any changes to master'
+
+    option :git_tag,
+      :short => '-t',
+      :long => '--git-tag',
+      :boolean => true,
+      :description => 'Automatically create tag for frozen cookbook'
+
+    option :git_branch,
+      :short => '-b BRANCH',
+      :long => '--git-branch BRANCH',
+      :default => 'master',
+      :description => 'Set working branch'
+
+    option :git_remote_name,
+      :short => '-r NAME',
+      :long => '--git-remote-name NAME',
+      :default => 'origin',
+      :description => 'Remote repo name'
+
+    option :git_autocommit,
+      :short => '-c',
+      :long => '--git-autocommit',
+      :boolean => true,
+      :description => 'Automatically commit changes'
+
+    option :autoproceed,
+      :short => '-a',
+      :long => '--autoproceed',
+      :boolean => true,
+      :description => 'Answer yes to any prompts'
+
+    option :upload_roles,
+      :short => '-r',
+      :long => '--roles',
+      :boolean => true,
+      :description => 'Upload any changed roles'
+
+    option :upload_data_bags,
+      :short => '-d',
+      :long => '--data-bags',
+      :boolean => true,
+      :description => 'Upload any changed data bags'
+
+    def initialize(*args)
+      super
+      @environments = config[:environments].to_s.split(",").map(&:strip)
+    end
+
+    def run
+      sanity_checks
+      cookbooks = discover_changed(:cookbooks, *determine_commit_span).map{|c|c.split('/').first}
+      roles = discover_changed(:roles, *determine_commit_span) if config[:upload_roles]
+      data_bags = discover_changed(:data_bags, *determine_commit_span) if config[:upload_data_bags]
+
+      ui.msg ui.highline.color("#{' ' * 10}** Knife Table: Service started  **", [HighLine::GREEN, HighLine::BOLD])
+      ui.highline.say ui.highline.color("Discovered cookbooks staged for freeze: #{cookbooks.join(', ')}", HighLine::CYAN)
+      ui.highline.say ui.highline.color("Environments staged to be updated: #{@environments.join(', ')}", HighLine::CYAN) unless @environments.empty?
+      ui.highline.say ui.highline.color("Roles staged to be uploaded: #{roles.sort.map{|r|r.sub(/\.(rb|json)/, '')}.join(', ')}", HighLine::CYAN) unless roles.nil? || roles.empty?
+      ui.highline.say ui.highline.color("Data Bags staged to be uploaded: #{data_bags.sort.join(', ')}", HighLine::CYAN) unless data_bags.nil? || data_bags.empty?
+
+      ui.highline.say "\n"
+
+      if(config[:autoproceed])
+        ui.warn "Autoproceeding based on config (ctrl+c to halt)"
+        sleep(3)
+      else
+        ui.confirm "Proceed"
+      end
+      
+      ui.highline.say "\n"
+
+      ui.highline.say "#{ui.highline.color("Freezing cookbooks:", HighLine::GREEN)} "
+      cookbooks.each{|c| freeze_cookbook(c) }
+      ui.highline.say "\n"
+
+      unless(@environments.empty?)
+        ui.msg ui.highline.color("Updating environments:", HighLine::GREEN)
+        @environments.each do |env|
+          ui.highline.say "  #{ui.highline.color(env, HighLine::BLUE)}: "
+          cookbooks.each{|c| update_environments(env, c) }
+          ui.highline.say "\n"
+        end
+
+        ui.highline.say "#{ui.highline.color("Uploading environments:", HighLine::GREEN)} "
+        upload_environments
+        ui.highline.say "\n"
+      end
+
+      upload_changes(:roles, roles) if roles && !roles.empty?
+      upload_changes(:data_bags, data_bags) if data_bags && !data_bags.empty?
+
+      if(config[:git_autocommit])
+        ui.highline.say "#{ui.highline.color("Committing environments:", HighLine::GREEN)} "
+        git_commit_environments(cookbooks)
+        ui.highline.say "\n"
+      end
+
+      if(config[:git_tag])
+        ui.highline.say "#{ui.highline.color("Tagging cookbooks:", HighLine::GREEN)} "
+        git_tag(cookbooks)
+        ui.highline.say "\n"
+      end
+
+      if(config[:git_autopush])
+        ui.highline.say "#{ui.highline.color("Pushing changes to remote repo:", HighLine::GREEN)} "
+        git_push
+        ui.highline.say "\n"
+      end
+
+      ui.msg ui.highline.color("#{' ' * 10}** Knife Table: Service complete **", [HighLine::GREEN, HighLine::BOLD])
+    end
+
+    def frozen_cookbook?(cookbook)
+      begin
+        spork_check = KnifeSpork::SporkCheck.new
+        spork_check.check_frozen(
+          cookbook,
+          spork_check.get_version(
+            cookbook_path,
+            cookbook
+          )
+        )
+      rescue  Net::HTTPServerException => e
+        if(e.response.is_a?(Net::HTTPNotFound))
+          false
+        else
+          raise
+        end
+      end
+    end
+
+    def freeze_cookbook(cookbook)
+      unless(frozen_cookbook?(cookbook))
+        spork_upload = KnifeSpork::SporkUpload.new
+        spork_upload.config[:freeze] = true
+        spork_upload.config[:cookbook_path] = cookbook_path
+        repo_cookbook = spork_upload.cookbook_repo[cookbook]
+        repo_cookbook.freeze_version
+        Chef::CookbookUploader.new(repo_cookbook, cookbook_path).upload_cookbook
+        ui.highline.say "#{cookbook} "
+      else
+        ui.highline.say "#{ui.highline.color("#{cookbook} (already frozen)", HighLine::RED)} "
+      end
+    end
+
+    def update_environments(environment, cookbook)
+      promote_environment(environment, cookbook)
+      ui.highline.say "#{cookbook} "
+    end
+
+    def upload_environments
+      @environments.each do |environment|
+        spork_promote.config[:cookbook_path] = [cookbook_path]
+        spork_promote.save_environment_changes_remote(environment)
+        ui.highline.say "#{environment} "
+      end
+    end
+
+    def git_commit_environments(cookbooks)
+      commit = false
+      @environments.each do |environment|
+        status = git.status.changed[::File.join('environments', "#{environment}.json")]
+        if(status && !git.diff('HEAD', status.path).none?)
+          git.add(status.path)
+          commit_message = "Environment #{environment} cookbook version updates\n"
+          cookbooks.sort.each do |cookbook|
+            commit_message << "\n#{cookbook}: #{spork_promote.get_version(cookbook_path, cookbook)}"
+          end
+          git.commit(commit_message)
+          ui.highline.say "#{environment} "
+          @git_changed = true
+          commit = true
+        end
+      end
+      ui.highline.say "nothing to commit " unless commit
+    end
+
+    def git_tag(cookbooks)
+      cookbooks.each do |cookbook|
+        tag_string = "#{cookbook}-v#{spork_promote.get_version(cookbook_path, cookbook)}"
+        unless(git.tags.map(&:name).include?(tag_string))
+          git.add_tag(tag_string)
+          ui.highline.say "#{tag_string} "
+          @git_changed = true
+        else
+          ui.highline.say "#{ui.highline.color("#{tag_string} (exists)", HighLine::RED)} "
+        end
+      end
+    end
+
+    def git_push
+      if(@git_changed)
+        git.push(config[:git_remote_name], config[:git_branch], true)
+        ui.highline.say "pushed #{config[:git_branch]} to #{config[:git_remote_name]} "
+      else
+        ui.highline.say "nothing to push "
+      end
+    end
+
+    def upload_roles(role)
+      role_load = loader(:roles).load_from('roles', role)
+      role_load.save
+    end
+
+    def upload_data_bags(bag)
+      data_bag_load = loader(:data_bags).load_from('data_bags', bag.split.first, bag.split.last)
+      data_bag_load.save
+    end
+
+    private
+
+    def promote_environment(environment, cookbook)
+      version = spork_promote.get_version(cookbook_path, cookbook)
+      env = spork_promote.update_version_constraints(
+        Chef::Environment.load(environment), 
+        cookbook, 
+        version
+      )
+      env_json = spork_promote.pretty_print(env)
+      spork_promote.save_environment_changes(environment, env_json)
+    end
+
+    def spork_promote
+      unless(@spork_promote)
+        @spork_promote = KnifeSpork::SporkPromote.new
+        @spork_promote.config[:cookbook_path] = [cookbook_path]
+        @spork_promote.loader # work around for bad namespacing
+        @spork_promote.instance_variable_set(:@conf, AppConf.new) # configuration isn't isolated to single call so just stub
+      end
+      @spork_promote
+    end
+
+    def sanity_checks
+      unless(git.branches.map(&:name).include?(config[:git_branch]))
+        raise "Requested git branch (#{config[:git_branch]}) does not exist"
+      else
+        ui.warn "Checking out requested working branch: #{config[:git_branch]}"
+        @git.checkout(config[:git_branch]) if config[:git_branch]
+      end
+      unless(git.remotes.map(&:name).include?(config[:git_remote_name]))
+        raise "Specified remote #{config[:git_remote_name]} not found"
+      end
+    end
+
+    def determine_commit_span
+      if(@first_commit.nil? || @last_commit.nil?)
+        if(name_args.size > 0)
+          if(name_args.first.start_with?('#'))
+            @first_commit, @last_commit = discover_commits(name_args.first)
+          elsif(name_args.first.include?(".."))
+            @first_commit, @last_commit = name_args.first.split("..")
+          else
+            @first_commit = "#{name_args.first}^1"
+            @last_commit = name_args.first
+          end
+        else
+          @first_commit, @last_commit = discover_commits
+        end
+      end
+      [@first_commit, @last_commit]
+    end
+
+    def discover_commits(pull_num = nil)
+      match = "pull request #{pull_num}"
+      commit = git.log.detect{|log| log.message.include?(match)}
+      if(commit)
+        ["#{commit}^1",commit]
+      else
+        raise "Unable to locate last pull request"
+      end
+    end
+
+    def discover_changed(type, first_commit, last_commit)
+      changed = []
+      git.diff(first_commit, last_commit).stats[:files].keys.each do |path|
+        if(path.start_with?(type.to_s))
+          changed << path.sub(/^#{type.to_s}\/?/, '')
+        end
+      end
+      changed.uniq
+    end
+
+    def upload_changes(type, changed)
+      raise "Unsupported upload change type: #{type}" unless [:roles, :data_bags].include?(type.to_sym)
+      ui.highline.say "#{ui.highline.color("Uploading #{type.to_s.gsub('_', ' ')}:", HighLine::GREEN)} "
+      unless(changed.empty?)
+        changed.each do |item|
+          send("upload_#{type}", item)
+          ui.highline.say "#{File.basename(item).sub(/\.(rb|json)/, '')} "
+        end
+      else
+        ui.highline.say "no #{type.to_s.gsub('_', ' ').sub(/s$/, '')} changes detected "
+      end
+      ui.highline.say "\n"
+    end
+
+    def loader(type)
+      if(type == :roles)
+        @role_loader ||= Chef::Knife::Core::ObjectLoader.new(Chef::Role, ui)
+      elsif(type == :data_bags)
+        @role_loader ||= Chef::Knife::Core::ObjectLoader.new(Chef::DataBag, ui)
+      else
+        raise 'Unsupported load type'
+      end
+    end
+
+  end
+end

data/lib/chef/knife/table_set.rb

@@ -0,0 +1,54 @@
+require 'knife-table/helpers'
+
+module KnifeTable
+  class TableSet < Chef::Knife
+
+    include KnifeTable::Helpers
+
+    deps do
+      require 'git'
+      require 'chef/knife/core/object_loader'
+    end
+
+    banner 'knife table set NEW_FEATURE_OR_FIX'
+
+    option :cookbooks,
+      :short => '-c [COOKBOOK,COOKBOOK,...]',
+      :long => '--cookbooks [COOKBOOK,COOKBOOK,...]',
+      :description => 'Automatically bump patch version on provided cookbooks'
+
+    option :branch_prefix,
+      :short => '-p PREFIX',
+      :long => '--branch-prefix PREFIX',
+      :description => 'Set prefix for branch name',
+      :default => 'WIP-'
+
+    option :bump_type,
+      :short => '-b TYPE',
+      :long => '--bump-type TYPE',
+      :description => 'Type of version bump (major, minor, patch)',
+      :default => 'patch'
+
+    def initialize(*args)
+      super
+      @cookbooks = config[:cookbooks].to_s.split(',').map(&:strip)
+    end
+
+    def run
+      ui.msg ui.highline.color("#{' ' * 10}** Knife Table: New place setting  **", [HighLine::GREEN, HighLine::BOLD])
+      branch_name = "#{config[:branch_prefix]}#{name_args.join('_').downcase}"
+      ui.highline.say "Creating new work branch (#{branch_name}): "
+      git.branch(branch_name).create
+      ui.highline.say "done"
+      git.checkout(branch_name)
+
+      unless(@cookbooks.empty?)
+        bumper = KnifeSpork::SporkBump.new
+        @cookbooks.each do |cookbook|
+          bumper.patch(cookbook_path, cookbook, config[:bump_type])
+        end
+      end
+    end
+
+  end
+end

data/lib/knife-table.rb

@@ -0,0 +1 @@
+require 'knife-table/version'

data/lib/knife-table/helpers.rb

@@ -0,0 +1,11 @@
+module KnifeTable
+  module Helpers
+    def git
+      @git ||= Git.open(File.dirname(cookbook_path))
+    end
+    
+    def cookbook_path
+      Chef::Config[:cookbook_path].first
+    end
+  end
+end

data/lib/knife-table/version.rb

@@ -0,0 +1,3 @@
+module KnifeTable
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: knife-table
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: knife-spork
+  requirement: &16438040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *16438040
+description: Chef's table
+email: chrisroberts.code@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- knife-table.gemspec
+- lib/knife-table/version.rb
+- lib/knife-table/helpers.rb
+- lib/chef/knife/data_holder.rb
+- lib/chef/knife/table_serve.rb
+- lib/chef/knife/table_clear.rb
+- lib/chef/knife/table_set.rb
+- lib/knife-table.rb
+homepage: http://github.com/heavywater/knife-table
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Help chef set and serve the table
+test_files: []
+has_rdoc: