between_meals 0.0.1 → 0.0.2

data/lib/between_meals/knife.rb

@@ -0,0 +1,197 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'json'
+require 'fileutils'
+require 'digest/md5'
+require 'between_meals/util'
+
+module BetweenMeals
+  # Knife does not have a usable API for using it as a lib
+  # This could be possibly refactored to touch its internals
+  # instead of shelling out
+  class Knife
+    include BetweenMeals::Util
+
+    def initialize(opts = {})
+      @logger = opts[:logger] || nil
+      @user = opts[:user] || ENV['USER']
+      @home = opts[:home] || ENV['HOME']
+      @host = opts[:host] || 'localhost'
+      @port = opts[:port] || 4000
+      @config = opts[:config] ||
+        "#{@home}/.chef/knife-#{@user}-taste-tester.rb"
+      @knife = opts[:bin] || 'knife'
+      @pem = opts[:pem] ||
+        "#{@home}/.chef/#{@user}-taste-tester.pem"
+      @role_dir = opts[:role_dir]
+      @cookbook_dirs = opts[:cookbook_dirs]
+      @databag_dir = opts[:databag_dir]
+      @checksum_dir = opts[:checksum_dir]
+      @client_key =
+        File.expand_path("#{@home}/.chef/#{@user}-taste-tester.pem")
+    end
+
+    def role_upload_all
+      roles = File.join(@role_dir, '*.rb')
+      exec!("#{@knife} role from file #{roles} -c #{@config}", @logger)
+    end
+
+    def role_upload(roles)
+      if roles.any?
+        roles = roles.map { |x| File.join(@role_dir, "#{x.name}.rb") }.join(' ')
+        exec!("#{@knife} role from file #{roles} -c #{@config}", @logger)
+      end
+    end
+
+    def role_delete(roles)
+      if roles.any?
+        roles.each do |role|
+          exec!(
+            "#{@knife} role delete #{role.name} --yes -c #{@config}", @logger
+          )
+        end
+      end
+    end
+
+    def cookbook_upload_all
+      exec!("#{@knife} cookbook upload -a -c #{@config}", @logger)
+    end
+
+    def cookbook_upload(cookbooks)
+      if cookbooks.any?
+        cookbooks = cookbooks.map { |x| x.name }.join(' ')
+        exec!("#{@knife} cookbook upload #{cookbooks} -c #{@config}", @logger)
+      end
+    end
+
+    def cookbook_delete(cookbooks)
+      if cookbooks.any?
+        cookbooks.each do |cookbook|
+          exec!("#{@knife} cookbook delete #{cookbook.name}" +
+                  " --purge --yes -c #{@config}", @logger)
+        end
+      end
+    end
+
+    def databag_upload_all
+      glob = File.join(@databag_dir, '*', '*.json')
+      items = Dir.glob(glob).map do |file|
+        BetweenMeals::Changes::Databag.new(
+          { :status => :modified, :path => file }, @databag_dir
+        )
+      end
+      databag_upload(items)
+    end
+
+    def databag_upload(databags)
+      if databags.any?
+        databags.group_by { |x| x.name }.each do |dbname, dbs|
+          create_databag_if_missing(dbname)
+          dbitems = dbs.map do |x|
+            File.join(@databag_dir, dbname, "#{x.item}.json")
+          end.join(' ')
+          exec!("#{@knife} data bag from file #{dbname} #{dbitems}", @logger)
+        end
+      end
+    end
+
+    def databag_delete(databags)
+      if databags.any?
+        databags.group_by { |x| x.name }.each do |dbname, dbs|
+          dbs.each do |db|
+            exec!("#{@knife} data bag delete #{dbname} #{db.item}" +
+                    " --yes -c #{@config}", @logger)
+          end
+          delete_databag_if_empty(dbname)
+        end
+      end
+    end
+
+    def write_user_config
+      cfg = <<-BLOCK
+user = ENV['USER']
+log_level :info
+log_location STDOUT
+node_name user
+chef_server_url "http://#{@host}:#{@port}"
+cache_type 'BasicFile'
+client_key '#{@client_key}'
+cache_options(:path => File.expand_path("#{@checksum_dir}"))
+cookbook_path [
+BLOCK
+      @cookbook_dirs.each do |dir|
+        cfg << "  \"#{dir}\",\n"
+      end
+      cfg << "]\n"
+      unless File.directory?(File.dirname(@config))
+        Dir.mkdir(File.dirname(@config), 0755)
+      end
+      if !File.exists?(@config) ||
+         ::Digest::MD5.hexdigest(cfg) !=
+          ::Digest::MD5.hexdigest(File.read(@config))
+        @logger.info("Generating #{@config}")
+        File.write(@config, cfg)
+      end
+
+      # Won't work with shorter keys
+      pem = <<-BLOCK
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCs4Ih8+R/2hcYS
+tccwJHd0cXHcUibC2wGYmRwf1fKxXLADvfuLRVBHOI5Hgd/ZXF70dowC5mDQ03gr
+ouk8e7RL72MCKzPuG2V92sh/FnyKhkNsHCOEKaRRiP9lHVbZkS9LEotCKF7eOkL0
+SVkGWx8pVZzrOFmhZgHaOFJ2/2t1irUTRFqTikrRsP2KvnhHdDlnnbUumZWxSuEN
+oN6aSAQEOkKbEOLSn/EIMzEb2jtks7L7wkRErajH094jGoZbQvLiwRHDeM0C9uG7
+2sdQ45BG9EQOCdBzy1We5keqtJbXBcpwuBa0d1nQZIsGxnDb88+Kmh9h6k9/WmYN
+zEQEeSSdAgMBAAECggEATFWQru4p6ObEwTo2y9EuVeJJzmkP6HZfzAu/WWdVFG/C
+4MQgsCxY+DnGyVhViVq6KuO1iwpCsbLOmyYCKszMncMESs7czUSXmezjHwrEzz3d
+w3zhSdhBUCdX7kP4N3VeFp4Hk5zT1viO2+MPRjkyF0RQV6S4HwY1xy+baiP6RRnS
+dGhUYsdz6fjxSkYEQy3/xHm9VLT6ZDV4pN2aA+LOFeveHKcnOjKFCBy4WzkO6fvj
+6H3jghxsHXoL7loCHfi9WX3xKjeXG/NjGbUfTH8P7IldUPha+ru/e8W/P+jjE1os
+VkScWt08Vu6iTl1EkYeFxOMtSDZxeXNnDkPI0iDQgQKBgQDUMFYncQcZ4uLIfoZq
+B+Lx7WJGlIwulOdobnraTd5lsrBHj1sC1+/f4cBSpJwUij2l3GdmmnOpuFAof5eu
+mrBGu++5jy+0eIeT5O2d30O8GOBryJ+oAKI2/BPVCmM8d986wl5Esauycb++O7UO
+RhpZFOCKbFvlNjhg+CdlvHSl7QKBgQDQkkvpnE//yWmhCPg27n7w3bTg5QPNrzTO
+pF2iwvLK4XjRceTeW3P4f42HONzJNnmt5TexM9NbdE9g/exA5uNt59ZB5FeFiKAu
+NmVXbmswPX6R/dlyidqzz1guGrL04e0dZehHZBNDr5Sio8IBjMWrpDIxjDJqEwUa
+4qCu4e6jcQKBgQDN0FTAzRFmOnxenNsj3aJzpx27+DpAtI4A7aicNwuQ+VGjF5nf
+mDRDpGU3xBLgmXZSewaQrx+hb/XQUnJ+Ge0BrylHg2tyUbav7U3N49F/kWGdKmwy
+OOsfCkLyUbEP5fXQuNdXKj6wR0UE8EUeI0FLRsTFf3VjTsRAynLsa295wQKBgAo3
+QDSfDWQP73aNw+qc3+bYVSW20erfLAz7DAMO3WmGha5sj7M8c3+2b64x4M6SNn+H
+/KRXT4DpP4IWrd238WfOtTXhA1BtErtwuqH/rIxeVra74kyz59xqyXzond9UuZJ5
+DVmB01e7X+Jfdv8wb/YqQrMelNGRQOzCMPCf7FphAoGAbUh5HzNF2aciQJGA6Qk8
+zvgEHqbS0/QkJGOZ+UifPRanTDuGYQkPdHHOER4UghbM+Kz5rZbBicJ3bCyNOsah
+IAMAEpsWX2s2A6phgMCx7kH6wMmoZn3hb7Thh9+PfR8Jtp2/7k+ibCeF4gEWUCs5
+6wX4GR84dwyhG80yd4TP8Qo=
+-----END PRIVATE KEY-----
+    BLOCK
+
+      unless File.exists?(@pem)
+        @logger.info("Generating #{@pem}")
+        File.write(@pem, pem)
+      end
+    end
+
+    private
+
+    def create_databag_if_missing(databag)
+      s = Mixlib::ShellOut.new("#{@knife} data bag list" +
+                               " --format json -c #{@config}").run_command
+      s.error!
+      db = JSON.load(s.stdout)
+      unless db.include?(databag)
+        exec!("#{@knife} data bag create #{databag} -c #{@config}", @logger)
+      end
+    end
+
+    def delete_databag_if_empty(databag)
+      s = Mixlib::ShellOut.new("#{@knife} data bag show #{databag}" +
+                               " --format json -c #{@config}").run_command
+      s.error!
+      db = JSON.load(s.stdout)
+      if db.empty?
+        exec!("#{@knife} data bag delete #{databag} --yes -c #{@config}",
+              @logger)
+      end
+    end
+  end
+end

data/lib/between_meals/repo/git.rb

@@ -0,0 +1,204 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'rugged'
+require 'mixlib/shellout'
+require 'between_meals/changeset'
+
+module BetweenMeals
+  # Local checkout wrapper
+  class Repo
+    # Git provider
+    class Git < BetweenMeals::Repo
+      def setup
+        if File.exists?(File.expand_path(@repo_path))
+          @repo = Rugged::Repository.new(File.expand_path(@repo_path))
+        else
+          @repo = nil
+        end
+        @bin = 'git'
+      end
+
+      def exists?
+        @repo && !@repo.empty?
+      end
+
+      def head_rev
+        @repo.head.target.oid
+      end
+
+      def last_msg
+        @repo.head.target.message
+      end
+
+      def last_msg=(msg)
+        @repo.head.target.amend(
+          {
+            :message => msg,
+            :update_ref => 'HEAD',
+          }
+        )
+      end
+
+      def last_author
+        @repo.head.target.to_hash[:author]
+      end
+
+      def head_parents
+        @repo.head.target.parents
+      end
+
+      def checkout(url)
+        s = Mixlib::ShellOut.new(
+          "#{@bin} clone #{url} #{@repo} #{@repo_path}"
+        ).run_command
+        s.error!
+        @repo = Rugged::Repository.new(File.expand_path(@repo_path))
+      end
+
+      # Return files changed between two revisions
+      def changes(start_ref, end_ref)
+        check_refs(start_ref, end_ref)
+        s = Mixlib::ShellOut.new(
+          "#{@bin} diff --name-status #{start_ref} #{end_ref}",
+          :cwd => File.expand_path(@repo_path)
+        )
+        s.run_command.error!
+        begin
+          parse_status(s.stdout).compact
+        rescue => e
+          # We've seen some weird non-reproducible failures here
+          @logger.error(
+            'Something went wrong. Please please report this output.'
+          )
+          @logger.error(e)
+          s.stdout.lines.each do |line|
+            @logger.error(line.strip)
+          end
+          exit(1)
+        end
+      end
+
+      def update
+        cmd = Mixlib::ShellOut.new(
+          "#{@bin} pull --rebase", :cwd => File.expand_path(@repo_path)
+        )
+        cmd.run_command
+        if cmd.exitstatus != 0
+          @logger.error('Something went wrong with git!')
+          @logger.error(cmd.stdout)
+          fail
+        end
+        cmd.stdout
+      end
+
+      # Return all files
+      def files
+        @repo.index.map { |x| { :path => x[:path], :status => :created } }
+      end
+
+      def status
+        cmd = Mixlib::ShellOut.new(
+          "#{@bin} status --porcelain 2>&1",
+          :cwd => File.expand_path(@repo_path)
+        )
+        cmd.run_command
+        if cmd.exitstatus != 0
+          @logger.error('Something went wrong with git!')
+          @logger.error(cmd.stdout)
+          fail
+        end
+        cmd.stdout
+      end
+
+      private
+
+      def check_refs(start_ref, end_ref)
+        unless @repo.exists?(start_ref)
+          fail Changeset::ReferenceError
+        end
+        unless end_ref.nil?
+          unless @repo.exists?(end_ref)
+            fail Changeset::ReferenceError
+          end
+        end
+      end
+
+      def parse_status(changes)
+        # man git-diff-files
+        # Possible status letters are:
+        #
+        # A: addition of a file
+        # C: copy of a file into a new one
+        # D: deletion of a file
+        # M: modification of the contents or mode of a file
+        # R: renaming of a file
+        # T: change in the type of the file
+        # U: file is unmerged (you must complete the merge before it can
+        #    be committed)
+        # X: "unknown" change type (most probably a bug, please report it)
+
+        # rubocop:disable MultilineBlockChain
+        changes.lines.map do |line|
+          case line
+          when /^A\s+(\S+)$/
+            # A path
+            {
+              :status => :modified,
+              :path => Regexp.last_match(1)
+            }
+          when /^C(?:\d*)\s+(\S+)\s+(\S+)/
+            # C<numbers> path1 path2
+            {
+              :status => :modified,
+              :path => Regexp.last_match(2)
+            }
+          when /^D\s+(\S+)$/
+            # D path
+            {
+              :status => :deleted,
+              :path => Regexp.last_match(1)
+            }
+          when /^M(?:\d*)\s+(\S+)$/
+            # M<numbers> path
+            {
+              :status => :modified,
+              :path => Regexp.last_match(1)
+            }
+          when /^R(?:\d*)\s+(\S+)\s+(\S+)/
+            # R<numbers> path1 path2
+            [
+              {
+                :status => :deleted,
+                :path => Regexp.last_match(1)
+              },
+              {
+                :status => :modified,
+                :path => Regexp.last_match(2)
+              }
+            ]
+          when /^T\s+(\S+)$/
+            # T path
+            [
+              {
+                :status => :deleted,
+                :path => Regexp.last_match(1)
+              },
+              {
+                :status => :modified,
+                :path => Regexp.last_match(1)
+              }
+            ]
+          else
+            fail 'No match'
+          end
+        end.flatten.map do |x|
+          {
+            :status => x[:status],
+            :path => x[:path].sub("#{@repo_path}/", '')
+          }
+        end
+        # rubocop:enable MultilineBlockChain
+      end
+    end
+  end
+end

data/lib/between_meals/repo/svn.rb

@@ -0,0 +1,121 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'between_meals/repo'
+require 'between_meals/changeset'
+require 'mixlib/shellout'
+
+module BetweenMeals
+  # Local checkout wrapper
+  class Repo
+    # SVN implementation
+    class Svn < BetweenMeals::Repo
+      def setup
+        @bin = 'svn'
+      end
+
+      def exists?
+        # this shuold be better
+        Dir.exists?(@repo_path)
+      end
+
+      def head_rev
+        s = Mixlib::ShellOut.new("#{@bin} info #{@repo_path}").run_command
+        s.error!
+        s.stdout.each_line do |line|
+          m = line.match(/Last Changed Rev: (\d+)$/)
+          return m[1] if m
+        end
+      end
+
+      def latest_revision
+        s = Mixlib::ShellOut.new("#{@bin} info #{@repo_path}").run_command
+        s.error!
+        s.stdout.each do |line|
+          m = line.match(/Revision: (\d+)$/)
+          return m[1] if m
+        end
+      end
+
+      def checkout(url)
+        s = Mixlib::ShellOut.new(
+          "#{@bin} co --ignore-externals #{url} #{@repo_path}").run_command
+        s.error!
+      end
+
+      # Return files changed between two revisions
+      def changes(start_ref, end_ref)
+        check_refs(start_ref, end_ref)
+        s = Mixlib::ShellOut.new(
+          "#{@bin} diff -r #{start_ref}:#{end_ref} --summarize #{@repo_path}")
+        s.run_command.error!
+        @logger.info("Diff between #{start_ref} and #{end_ref}")
+        s.stdout.lines.map do |line|
+          m = line.match(/^(\w)\w?\s+(\S+)$/)
+          fail "Could not parse line: #{line}" unless m
+
+          {
+            :status => m[1] == 'D' ? :deleted : :modified,
+            :path => m[2].sub("#{@repo_path}/", '')
+          }
+        end
+      end
+
+      def update
+        cleanup
+        revert
+        up
+      end
+
+      # Return all files
+      def files
+        s = Mixlib::ShellOut.new("#{@bin} ls --depth infinity #{@repo_path}")
+        s.run_command
+        s.error!
+        s.stdout.split("\n").map do |x|
+          { :path => x, :status => :created }
+        end
+      end
+
+      private
+
+      def run(cmd)
+        Mixlib::ShellOut.new(cmd).run_command.error!
+      end
+
+      def revert
+        run("#{@bin} revert -R #{@repo_path}")
+      end
+
+      def up
+        run("#{@bin} update #{@repo_path}")
+      end
+
+      def cleanup
+        run("#{@bin} cleanup #{@repo_path}")
+      end
+
+      def first_revision
+        0
+      end
+
+      private
+
+      def check_refs(start_ref, end_ref)
+        s = Mixlib::ShellOut.new(
+              "#{@bin} info -r #{start_ref}",
+              :cwd => @repo_path
+            ).run_command
+        s.error!
+        if end_ref
+          s = Mixlib::ShellOut.new(
+                "#{@bin} info -r #{end_ref}",
+                :cwd => @repo_path
+              ).run_command
+          s.error!
+        end
+      rescue
+        raise Changeset::ReferenceError
+      end
+    end
+  end
+end

data/lib/between_meals/repo.rb

@@ -0,0 +1,113 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'mixlib/shellout'
+
+module BetweenMeals
+  # Local checkout wrapper
+  class Repo
+    attr_reader :repo_path
+    attr_writer :bin
+
+    def initialize(repo_path, logger)
+      @repo_path = repo_path
+      @logger = logger
+      @repo = nil
+      @bin = nil
+      setup
+    rescue
+      @logger.warn("Unable to read repo from #{File.expand_path(repo_path)}")
+      exit(1)
+    end
+
+    def self.get(type, repo_path, logger)
+      case type
+      when 'svn'
+        require 'between_meals/repo/svn'
+        BetweenMeals::Repo::Svn.new(repo_path, logger)
+      when 'git'
+        require 'between_meals/repo/git'
+        BetweenMeals::Repo::Git.new(repo_path, logger)
+      else
+        fail "Do not know repo type #{type}"
+      end
+    end
+
+    def exists?
+      fail 'Not implemented'
+    end
+
+    def status
+      fail 'Not implemented'
+    end
+
+    def setup
+      fail 'Not implemented'
+    end
+
+    def head_rev
+      fail 'Not implemented'
+    end
+
+    def head_msg
+      fail 'Not implemented'
+    end
+
+    def head_msg=
+      fail 'Not implemented'
+    end
+
+    def head_parents
+      fail 'Not implemented'
+    end
+
+    def latest_revision
+      fail 'Not implemented'
+    end
+
+    def create(_url)
+      fail 'Not implemented'
+    end
+
+    # Return files changed between two revisions
+    def changes(_start_ref, _end_ref)
+      fail 'Not implemented'
+    end
+
+    def update
+      fail 'Not implemented'
+    end
+
+    # Return all files
+    def files
+      fail 'Not implemented'
+    end
+
+    def latest_revision
+      fail 'Not implemented'
+    end
+
+    def head
+      fail 'Not implemented'
+    end
+
+    def checkout
+      fail 'Not implemented'
+    end
+
+    def update
+      fail 'Not implemented'
+    end
+
+    def last_author
+      fail 'Not implemented'
+    end
+
+    def last_msg
+      fail 'Not implemented'
+    end
+
+    def last_msg=
+      fail 'Not implemented'
+    end
+  end
+end

data/lib/between_meals/util.rb

@@ -0,0 +1,74 @@
+# vim: syntax=ruby:expandtab:shiftwidth=2:softtabstop=2:tabstop=2
+
+require 'colorize'
+require 'socket'
+require 'timeout'
+
+module BetweenMeals
+  # A set of simple utility functions used throughout BetweenMeals
+  #
+  # Feel freeo to use... note that if you pass in a logger once
+  # you don't need to again, but be safe and always pass one in. :)
+
+  # Util classes need class vars :)
+  # rubocop:disable ClassVars
+  module Util
+    @@logger = nil
+
+    def time(logger = nil)
+      @@logger = logger if logger
+      t0 = Time.now
+      yield
+      info("Executed in #{format('%.2f', Time.now - t0)}s")
+    end
+
+    def exec!(command, logger = nil)
+      @@logger = logger if logger
+      c = execute(command)
+      c.error!
+      return c.status.exitstatus, c.stdout
+    end
+
+    def exec(command, logger = nil)
+      @@logger = logger if logger
+      c = execute(command)
+      return c.status.exitstatus, c.stdout
+    end
+
+    private
+
+    def info(msg)
+      @@logger.info(msg) if @@logger
+    end
+
+    def execute(command)
+      info("Running: #{command}")
+      c = Mixlib::ShellOut.new(command)
+      c.run_command
+      c.stdout.lines.each do |line|
+        info("STDOUT: #{line.strip}")
+      end
+      c.stderr.lines.each do |line|
+        info("STDERR: #{line.strip.red}")
+      end
+      return c
+    end
+
+    def port_open?(port)
+      begin
+        Timeout.timeout(1) do
+          begin
+            s = TCPSocket.new('localhost', port)
+            s.close
+            return true
+          rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            return false
+          end
+        end
+      rescue Timeout::Error
+        return false
+      end
+      return false
+    end
+  end
+end