knife-github 0.0.3 → 0.0.6

data/lib/chef/knife/github_compare.rb

@@ -25,28 +25,14 @@ class Chef
 
       deps do
         require 'chef/knife/github_base'
-
         include Chef::Knife::GithubBase
+        require 'chef/knife/github_baselist'
+        include Chef::Knife::GithubBaseList
       end
       
       banner "knife github compare [COOKBOOK] (options)"
       category "github"
 
-      option :fields,
-             :long => "--fields 'NAME, NAME'",
-             :description => "The fields to output, comma-separated"
-
-      option :noheader,
-             :long => "--noheader",
-             :description => "Removes header from output",
-             :boolean => true
-
-      option :all,
-             :short => "-a",
-             :long => "--all",
-             :description => "Get all cookbooks from github.",
-             :boolean => true
-
       option :mismatch,
              :short => "-m",
              :long => "--mismatch",
@@ -54,7 +40,6 @@ class Chef
              :boolean => true
 
       def run
-#         extend Chef::Mixin::ShellOut
         # validate base options from base module.
         validate_base_options      
 
@@ -64,31 +49,31 @@ class Chef
         # Gather all repo information from github.
         get_all_repos = get_all_repos(@github_organizations.reverse)
 
+        # Get all chef cookbooks and versions.
+        cookbooks = rest.get_rest("/cookbooks?num_version=1")
 
-        # Get all chef cookbooks and versions (hopefully chef does the error handeling).
-        cb_and_ver = rest.get_rest("/cookbooks?num_version=1")
-
+        #Get the github link
+        git_link = get_repo_clone_link
 
         # Filter all repo information based on the tags that we can find
-        all_repos = {}
-        if config[:all]
-          get_all_repos.each { |k,v|
-            cookbook = k
-            cb_and_ver[k].nil? || cb_and_ver[k]['versions'].nil? ? version = "" : version = cb_and_ver[k]['versions'][0]['version']
-            ssh_url = v['ssh_url']
-            gh_tag  = v['latest_tag']
-            all_repos[cookbook] = { 'name' => cookbook, 'latest_cb_tag' => version, 'ssh_url' => ssh_url, 'latest_gh_tag' => gh_tag }
-          } 
+        if config[:fields] || config[:fieldlist]
+          all_repos = get_all_repos
+          config[:fields] = "name" if config[:fields].nil? || config[:fields].empty?
         else
-          cb_and_ver.each { |k,v|
-            cookbook = k
-            version  = v['versions'][0]['version']
-            get_all_repos[k].nil? || get_all_repos[k]['ssh_url'].nil? ? ssh_url = ui.color("ERROR: Cannot find cookbook!", :red) : ssh_url = get_all_repos[k]['ssh_url']
-            get_all_repos[k].nil? || get_all_repos[k]['latest_tag'].nil? ? gh_tag = ui.color("ERROR: No tags!", :red) : gh_tag = get_all_repos[k]['latest_tag']
-            all_repos[cookbook] = { 'name' => cookbook, 'latest_cb_tag' => version, 'ssh_url' => ssh_url, 'latest_gh_tag' => gh_tag } 
-          }
+          all_repos = {}
+          if config[:all]
+            get_all_repos.each { |k,v|
+              cookbooks[k].nil? || cookbooks[k]['versions'].nil? ? version = "" : version = cookbooks[k]['versions'][0]['version']
+              all_repos[k] = { 'name' => k, 'latest_cb_tag' => version, 'git_url' => v[git_link], 'latest_gh_tag' => v['latest_tag'] }
+            }
+          else
+            cookbooks.each { |k,v|
+              get_all_repos[k].nil? || get_all_repos[k][git_link].nil? ? gh_url = ui.color("ERROR: Cannot find cookbook!", :red) : gh_url = get_all_repos[k][git_link]
+              get_all_repos[k].nil? || get_all_repos[k]['latest_tag'].nil? ? gh_tag = ui.color("ERROR: No tags!", :red) : gh_tag = get_all_repos[k]['latest_tag']
+              all_repos[k] = { 'name' => k, 'latest_cb_tag' => v['versions'][0]['version'], 'git_url' => gh_url, 'latest_gh_tag' => gh_tag }
+            }
+          end
         end
- 
 
         # Filter only on the cookbook name if its given on the command line
         @cookbook_name = name_args.first unless name_args.empty?
@@ -98,145 +83,15 @@ class Chef
           repos = all_repos 
         end
 
+        columns = [ 'name,Name', 'latest_cb_tag,Tag', 'git_url,Link', 'latest_gh_tag,Tag' ]
+        match = [ 'latest_cb_tag', 'latest_gh_tag' ]
 
-        # Displaying information based on the fields and repos
-        if config[:fields]
-          object_list = []
-          config[:fields].split(',').each { |n| object_list << ui.color(("#{n}").strip, :bold) }
+        if repos.nil? || repos.empty?
+          Chef::Log.error("No repositories found.")
         else
-          object_list = [
-            ui.color('Cookbook', :bold),
-            ui.color('Tag', :bold),
-            ui.color('Github', :bold),
-            ui.color('Tag', :bold)
-          ]
-        end
-
-        columns = object_list.count
-        object_list = [] if config[:noheader]
-
-        repos.each do |k,r|
-          if config[:fields]
-             config[:fields].downcase.split(',').each { |n| object_list << ((r[("#{n}").strip]).to_s || 'n/a') }
-          else
-            next if config[:mismatch] && (r['latest_gh_tag'] == r['latest_cb_tag'])
-            r['latest_gh_tag'] == r['latest_cb_tag'] ? color = :white : color = :yellow
-            color = :white if config[:all]
- 
-            object_list << ui.color((r['name'] || 'n/a'), color)
-            object_list << ui.color((r['latest_cb_tag'] || 'n/a'), color)
-            object_list << ui.color((r['ssh_url'] || 'n/a'), color)
-            object_list << ui.color((r['latest_gh_tag'] || 'n/a'), color)
-          end
-        end
-
-        puts ui.list(object_list, :uneven_columns_across, columns)
-
-      end
-    
-      def get_all_repos(orgs)
-        # Parse every org and merge all into one hash
-        repos = {}
-        orgs.each do |org|
-          get_repos(org).each { |repo| name = repo['name'] ; repos["#{name}"] = repo } 
+          display_info(repos, columns, match)
         end
-        repos
-      end
-
-
 
-      def get_repos(org)
-        dns_name  = get_dns_name(@github_url)
-        file_cache = "#{ENV['HOME']}/.chef/.#{dns_name.downcase}_#{org.downcase}.cache" 
-        if File.exists?(file_cache)
-          Chef::Log.debug("#{org} cache is created: " + (Time.now - File.ctime(file_cache)).to_i.to_s  + " seconds ago.")
-          if Time.now - File.ctime(file_cache) > @github_cache
-            # update cache file
-            create_cache_file(file_cache, org)
-          end
-        else
-          create_cache_file(file_cache, org)
-        end
-        # use cache files
-        JSON.parse(File.read(file_cache))
-      end
-
-      def create_cache_file(file_cache, org)
-        Chef::Log.debug("Updating the cache file: #{file_cache}")
-        result = get_repos_github(org)
-        File.open(file_cache, 'w') { |file| file.write(JSON.pretty_generate(result)) }
-      end
-
-
- 
-      def get_repos_github(org)
-        # Get all repo's for the org from github
-        arr  = []
-        page = 1
-        url  = @github_url + "/api/" + @github_api_version + "/orgs/" + org + "/repos" 
-        while true
-          params = { 'page' => page }
-          result = send_request(url, params)
-          break if result.nil? || result.count < 1
-          result.each { |key|
-            if key['tags_url']
-              tags = get_tags(key)
-              key['tags'] = tags unless tags.nil? || tags.empty?
-              key['latest_tag'] = tags.first['name'] unless tags.nil? || tags.empty?
-              arr << key
-            else 
-              arr << key 
-            end
-          }
-          page = page + 1
-        end
-        arr
-      end
-
-
-      def get_tags(repo)
-        tags = send_request(repo['tags_url'])
-        tags
-      end
-
-
-      def get_dns_name(url)
-        url = url.downcase.gsub("http://","") if url.downcase.start_with?("http://")
-        url = url.downcase.gsub("https://","") if url.downcase.start_with?("https://")
-        url
-      end
-
-
-      def send_request(url, params = {})
-        params['response'] = 'json'
-
-        params_arr = []
-        params.sort.each { |elem|
-          params_arr << elem[0].to_s + '=' + CGI.escape(elem[1].to_s).gsub('+', '%20').gsub(' ','%20')
-        }
-        data = params_arr.join('&')
-
-        if url.nil? || url.empty?
-          puts "Error: Please specify a valid Github URL."
-          exit 1
-        end
-
-        github_url = "#{url}?#{data}" 
-        # Chef::Log.debug("URL: #{github_url}")
-
-        uri = URI.parse(github_url)
-        req_body = Net::HTTP::Get.new(uri.request_uri)
-        request = Chef::REST::RESTRequest.new("GET", uri, req_body, headers={})
-      
-        response = request.call
-      
-        if !response.is_a?(Net::HTTPOK) then
-          puts "Error #{response.code}: #{response.message}"
-          puts JSON.pretty_generate(JSON.parse(response.body))
-          puts "URL: #{url}"
-          exit 1
-        end
-        json = JSON.parse(response.body)
       end
 
     end

data/lib/chef/knife/github_deploy.rb

@@ -0,0 +1,335 @@
+#
+# Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# ---------------------------------------------------------------------------- #
+# Abstract
+# ---------------------------------------------------------------------------- #
+# This code is specific to our company workflow
+# When a cookbook is released it is tagged to a specific version
+# This version should match the cookbook version (from the metadata)
+# This version is then pinned against specific environments
+#
+# This class expects you to have pushed all your changes to github
+# It will then do the rest
+#
+# All modes presume you have used github download to download a cookbook or
+# are creating a new cookbook
+#
+# There are two modes of operation
+# Development (default)
+#
+# This will take a cookbook name
+# Do some basic version checks (if the current cookbook is frozen) and
+# upload it
+#
+# If the cookbook is frozen it will force you to choose a new version
+# and update the metadata accordingly
+#
+# Final (-f)
+#
+# You will be forced to select a new version.
+# You can choose via the options whether to increment the Major/minor or patch
+# revision numbers
+# The version will be tagged
+# Uploaded to the Chef server and frozen
+#
+# Version numbers
+#
+# You can choose a specific version number by specifying it on the command
+# line.
+#
+# If you do not specify a version, the version will be the version in your
+# cookbook's metadata
+#
+# A warning is issued if the version is lower than the version in github
+# ---------------------------------------------------------------------------- #
+require 'chef/knife'
+
+class Chef
+  class Knife
+
+    class GithubDeploy < Knife
+      deps do
+        require 'chef/knife/github_base'
+        include Chef::Knife::GithubBase
+        require 'chef/cookbook_loader'
+        require 'chef/cookbook_uploader'
+      end
+      
+      banner "knife github deploy COOKBOOK [VERSION] (options)"
+      category "github"
+
+      option :final,
+             :short => "-f",
+             :long => "--final",
+             :description => "Bump version, make git tag and freeze",
+             :boolean => true,
+             :default => false
+
+      option :major,
+             :short => "-M",
+             :long => "--major",
+             :description => "In final mode, increase the major version ie. X.x.x",
+             :boolean => true,
+             :default => false
+
+      option :minor,
+             :short => "-m",
+             :long => "--minor",
+             :description => "In final mode, increase the minor version ie. x.X.x",
+             :boolean => true,
+             :default => false
+
+      option :patch,
+             :short => "-p",
+             :long => "--patch",
+             :description => "In final mode, increase the minor version ie. x.x.X (Default)",
+             :boolean => true,
+             :default => true
+
+      def run
+
+        # validate base options from base module.
+        validate_base_options      
+
+        # Display information if debug mode is on.
+        display_debug_info
+
+        # Gather all repo information from github.
+        get_all_repos = get_all_repos(@github_organizations.reverse)
+
+        # Get all chef cookbooks and versions (hopefully chef does the error handeling).
+        cookbooks = rest.get_rest("/cookbooks?num_version=1")
+
+        @versions = []
+        cookbook_version = nil
+        @cookbook_name = name_args.first unless name_args.empty?
+        cookbook_version = name_args[1] unless name_args[1].nil?
+
+        if @cookbook_name
+          repo = get_all_repos.select { |k,v| v["name"] == @cookbook_name }
+        else
+          Chef::Log.error("Cookbook not in git.  You must add it to git to use deploy")
+          exit 1
+        end
+
+        if repo.empty?
+          Chef::Log.error("Cookbook not in git.  You must add it to git to use deploy")
+          exit 1
+        end
+
+        # is the cookbook in the cookbook_path?
+        if cookbook_path_valid?(@cookbook_name, false).nil?
+          Chef::Log.error("Cookbook is not in cookbook path")
+          ui.info("HINT:  knife github download #{@cookbook_name}")
+          exit 1
+        end
+
+        # ----------------------------- #
+        # The version can come
+        # 1.  From the command line
+        # 2.  From the cookbook
+        # ----------------------------- #
+        if cookbook_version.nil?
+           cookbook_version = get_cookbook_version()
+        end
+        # Next check to see if the version in git is way ahead
+        if ! get_all_repos[@cookbook_name]['latest_tag'].nil?
+            cb1 = Mixlib::Versioning.parse(cookbook_version)
+            cb2 = Mixlib::Versioning.parse(get_all_repos[@cookbook_name]['latest_tag'])
+            if(cb2 > cb1)
+                ui.confirm "Version in github #{cb2} is greater than the version you want to deploy #{cb1} - Continue"
+            end
+        end
+
+        inChef = true
+        isFrozen = false
+        if (config[:major] || config[:minor])
+            config[:patch] = false
+        end
+
+        begin
+            isFrozen = rest.get_rest("cookbooks/#{@cookbook_name}/#{cookbook_version}").frozen_version?
+        rescue
+            ui.warn "#{@cookbook_name} is not yet in chef"
+            inChef = false
+        end
+
+        
+        if config[:final]
+            ui.info "Using Final mode"
+
+        else
+            ui.info "Using Development mode"
+        end
+        ui.info "Cookbook is frozen" if isFrozen
+
+        # Might be first upload so need to catch that cookbook does not exist!
+        get_cookbook_chef_versions()  unless ! inChef
+
+        if config[:final]
+            cookbook_version = up_version(cookbook_version)
+
+            if repo[@cookbook_name]['tags'].select { |k| k['name'] == cookbook_version }.empty?
+                ui.info("Cookbook #{cookbook_version} has no tag in Git")
+                ui.confirm("Shall I add a tag for you?")
+                set_cookbook_version(cookbook_version)
+                add_tag(cookbook_version)
+            else
+                checkout_tag(cookbook_version)
+                set_cookbook_version(cookbook_version)
+            end
+
+            do_commit(cookbook_version, true)
+        end
+
+        # In Dev mode the version of the cookbook does not need to change
+        # If however the cookbook is frozen, then the version has to change
+        if ! config[:final] && isFrozen
+            cookbook_version = up_version(cookbook_version)
+            set_cookbook_version(cookbook_version)
+            do_commit(cookbook_version, false)
+        end
+
+        # If we have gotten this far we can just upload the cookbook
+        cookbook_upload()
+
+      end
+
+      def up_version(version)
+          while true do
+                ui.info("Trying to deploy version #{version}")
+                if @versions.include?(version)
+                   ui.info("Version #{version} is already in chef")
+                   ui.confirm("Shall I bump the version (No to Cancel)")
+                   version = choose_version(version)
+                else
+                   break
+                end
+          end
+          version
+      end
+
+      def choose_version(version)
+          if version =~ /(\d+)\.(\d+)\.(\d+)/
+             major = $1
+             minor = $1
+             patch = $3
+             major = major.to_i + 1 if config[:major]
+             minor = minor.to_i + 1 if config[:minor]
+             patch = patch.to_i + 1 if config[:patch]
+             version = "#{major}.#{minor}.#{patch}"
+             Chef::Log.debug("New version is #{version}")
+          else
+             Chef::Log.error("Version is in a format I cannot auto auto-update")
+             exit 1
+          end
+          version
+      end
+
+      def cookbook_upload() 
+          # Git meuk should not be uploaded use chefignore file instead
+          # FileUtils.remove_entry("#{@github_tmp}/git/#{@cookbook_name}/.git")
+		  args = ['cookbook', 'upload',  @cookbook_name ]
+          if config[:final]
+              args.push "--freeze"
+          end
+          upload = Chef::Knife::CookbookUpload.new(args)
+          #upload.config[:cookbook_path] = "#{@github_tmp}/git"
+          # plugin will throw its own errors
+          upload.run
+      end
+
+      def checkout_tag(version)
+          ui.info "Checking out tag #{version}"
+          cpath = get_cookbook_path(@cookbook_name)
+          Dir.chdir(cpath);
+		  `git checkout -b #{version}`
+		  if !$?.exitstatus == 0
+		     ui.error("Failed to checkout branch #{version} of #{@cookbook_name}")
+		     exit 1
+          end
+      end
+
+      def get_cookbook_chef_versions ()
+          cookbooks = rest.get_rest("/cookbooks/#{@cookbook_name}?num_version=all")
+          cookbooks[@cookbook_name]['versions'].each do |v|
+              @versions.push v['version']
+          end
+      end
+
+      # ---------------------------------------------------------------------- #
+      # Get the version number in the git version of the cookbook
+      # ---------------------------------------------------------------------- #
+      def get_cookbook_version()
+          version = nil
+          cpath = get_cookbook_path(@cookbook_name)
+          File.foreach("#{cpath}/metadata.rb") do |line|
+              if line =~ /version.*"(.*)"/i
+                 version = $1
+                 break
+              end
+          end
+          if version.nil?
+             Chef::Log.error("Cannot get the version for cookbook #{@cookbook_name}")
+             exit 1
+          end
+          version
+      end
+
+      def get_cookbook_path(cookbook) 
+          return cookbook_path_valid?(cookbook, false)
+      end
+
+      def do_commit(version, push)
+          cpath = get_cookbook_path(@cookbook_name)
+          Dir.chdir("#{cpath}")
+          puts cpath
+          output = `git commit -a -m "Deploy #{version}" 2>&1`
+          if $?.exitstatus != 0
+             if output !~ /nothing to commit/
+                Chef::Log.error("Could not commit #{@cookbook_name}")
+                puts output
+                exit 1
+             end
+          end
+          if push
+              output = `git push --tags 2>&1`
+              if $?.exitstatus != 0
+                 Chef::Log.error("Could not push tag for: #{@cookbook_name}")
+                 exit 1
+              end
+              output = `git push 2>&1`
+          end
+      end
+
+
+      def set_cookbook_version(version)
+          return  unless get_cookbook_version() != version
+          contents = ''
+          cpath = get_cookbook_path(@cookbook_name)
+          File.foreach("#{cpath}/metadata.rb") do |line|
+              line.gsub!(/(version[\t\s]+)(.*)/i,"\\1 \"#{version}\"\n")
+              contents = contents << line
+          end
+          File.open("#{cpath}/metadata.rb", 'w') {|f| f.write(contents) }
+          return true
+      end
+
+    end
+  end
+end

data/lib/chef/knife/github_diff.rb

@@ -0,0 +1,126 @@
+#
+# Author:: Sander Botman (<sbotman@schubergphilis.com>)
+# Copyright:: Copyright (c) 2013 Sander Botman.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'chef/knife'
+
+class Chef
+  class Knife
+
+    class GithubDiff < Knife
+
+      deps do
+        require 'chef/knife/github_base'
+
+        include Chef::Knife::GithubBase
+      end
+      
+      banner "knife github diff COOKBOOK [version] (options)"
+      category "github"
+
+      option :all,
+             :short => "-a",
+             :long => "--all",
+             :description => "Diff all cookbooks from chef against github.",
+             :boolean => true
+
+      def run
+
+        # validate base options from base module.
+        validate_base_options      
+
+        # Display information if debug mode is on.
+        display_debug_info
+
+        # Gather all repo information from github.
+        get_all_repos = get_all_repos(@github_organizations.reverse)
+
+        # Get all chef cookbooks and versions (hopefully chef does the error handeling).
+        cookbooks = rest.get_rest("/cookbooks?num_version=1")
+
+        # Get the cookbook name from the command line
+        @cookbook_name = name_args.first unless name_args.empty?
+        cookbook_version = name_args[1] unless name_args[1].nil?
+        if @cookbook_name
+          repo = get_all_repos.select { |k,v| v["name"] == @cookbook_name }
+        else
+          #repos = all_repos 
+          Chef::Log.error("Please specify a cookbook name")
+          exit 1
+        end
+        
+        if repo.empty?
+          Chef::Log.error("Cannot find the repository: #{} within github")
+          exit 1
+        end
+
+        github_link = (repo[@cookbook_name][(get_repo_clone_link)])
+        if github_link.nil? || github_link.empty?
+          Chef::Log.error("Cannot find the link for the repository with the name: #{@cookbook_name}")
+          exit 1
+        end
+        puts github_link
+	get_clone(github_link, @cookbook_name)
+	version = get_cookbook_copy(@cookbook_name, cookbook_version)
+	do_diff(@cookbook_name, version)
+        FileUtils.remove_entry(@github_tmp)
+      end
+
+      def do_diff(name, version)
+        # Check to see if there is a tag matching the version
+        Dir.chdir("#{@github_tmp}/git/#{name}")
+        if `git tag`.split("\n").include?(version)
+          ui.info("Tag version #{version} found, checking that out for diff")
+          # Tag found so checkout that tag
+          `git checkout -b #{version}`
+          if !$?.exitstatus == 0
+            ui.error("Failed to checkout branch #{version}")
+            exit 1
+          end
+        else
+          ui.info("Version #{version} of #{name} has no tag, using latest for diff")
+	end
+
+        FileUtils.remove_entry("#{@github_tmp}/git/#{name}/.git")
+        output = `git diff --color #{@github_tmp}/git/#{name} #{@github_tmp}/cb/#{name}-#{version} 2>&1`
+        if output.length == 0
+          ui.info("No differences found")
+        else
+          ui.msg(output)
+        end
+      end
+
+      def get_cookbook_copy(name, version)
+        Dir.mkdir("#{@github_tmp}/cb")
+        args = ['cookbook', 'download',  name ]
+        args.push version if version
+        Dir.chdir("#{@github_tmp}/cb")
+        download = Chef::Knife::CookbookDownload.new(args)
+        download.config[:download_directory] = "#{@github_tmp}/cb"
+        download.run
+
+        Dir.entries("#{@github_tmp}/cb").each do |d|
+          if d =~ /#{name}-(.*)/
+            version = $1
+          end
+        end
+        return version
+      end 
+
+    end
+  end
+end