knife-github 0.0.7 → 0.0.8

data/lib/chef/knife/github_cleanup.rb

@@ -90,8 +90,8 @@ module KnifeGithubCleanup
       cookbook = File.join(cookbook_path.first,repo)
       if File.exists?(cookbook)
         if repo_status_clean?(repo, cookbook)
-          # delete the repo
-          ui.info("Processing [D] #{repo}")
+          # delete the repo 
+          ui.info("Processing [ DELETE  ] #{repo}")
           FileUtils.remove_entry(cookbook) 
         end
       else
@@ -103,13 +103,13 @@ module KnifeGithubCleanup
       shell_out!("git fetch", :cwd => cookbook)
       status = shell_out!("git status", :cwd => cookbook)
       unless status.stdout == "# On branch master\nnothing to commit (working directory clean)\n"
-        ui.info("Processing [C] #{repo} (Action needed!)")
+        ui.info("Processing [ COMMIT  ] #{repo} (Action needed!)")
         status.stdout.lines.each { |l| puts l.sub( /^/, "    ") }
         return false   
       end
       log = shell_out!("git log --branches --not --remotes --simplify-by-decoration --decorate --oneline", :cwd => cookbook)
       unless log.stdout.empty?
-        ui.info("Processing [B] #{repo} (Action needed!)")
+        ui.info("Processing [ BRANCH  ] #{repo} (Action needed!)")
         ui.info("    Please check your branches, one of them has unsaved changes")
         log.stdout.lines.each { |l| puts l.sub( /^/, "    ") }
         return false   

data/lib/chef/knife/github_clone.rb

@@ -75,29 +75,31 @@ class Chef
         end
       end
 
-      def repo_clone(repo, cookbook)
+      def repo_clone(repo, cookbook_name)
         if repo.nil? || repo.empty?
-          ui.info("Processing [?] #{cookbook}")
-          Chef::Log.info("Cannot find the repository: #{cookbook} within github")
+          ui.info("Processing [ UNKNOWN ] #{cookbook_name}")
+          Chef::Log.info("Cannot find the repository: #{cookbook_name} within github")
           return nil
         end
 
         repo_link = get_repo_clone_link()
-        if repo[cookbook].nil? || repo[cookbook][repo_link].nil? || repo[cookbook][repo_link].empty?
-          ui.info("Processing [?] #{cookbook}")
-          Chef::Log.info("Cannot find the link for the repository with the name: #{cookbook}")
+        if repo[cookbook_name].nil? || repo[cookbook_name][repo_link].nil? || repo[cookbook_name][repo_link].empty?
+          ui.info("Processing [ UNKNOWN ] #{cookbook_name}")
+          Chef::Log.info("Cannot find the link for the repository with the name: #{cookbook_name}")
           return nil
         end
 
- 	github_url = repo[cookbook][repo_link]
-        cookbook_path = cookbook_path_valid?(cookbook, true)
-        unless cookbook_path.nil?
-          ui.info("Processing [C] #{cookbook}")
+ 	github_url = repo[cookbook_name][repo_link]
+        cookbook_path = get_cookbook_path(cookbook_name)
+        if File.exists?(cookbook_path)
+          ui.info("Processing [ SKIP    ] #{cookbook_name}")
+          Chef::Log.info("Path to #{cookbook_path} already exists, skipping.")
+        else
+          ui.info("Processing [ CLONE   ] #{cookbook_name}")
           Chef::Log.info("Cloning repository to: #{cookbook_path}")
           shell_out!("git clone #{github_url} #{cookbook_path}") 
         end
       end
-  
 
     end
   end

data/lib/chef/knife/github_config.rb

@@ -0,0 +1,11 @@
+require 'mixlib/config'
+module Github
+    module Config
+      extend Mixlib::Config
+      config_strict_mode true
+      config_context :knife do
+        configurable :github_url
+        configurable :github_organizations
+      end
+  end
+end

data/lib/chef/knife/github_create.rb

@@ -0,0 +1,236 @@
+#
+# 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.
+#
+
+
+#
+#
+#  BE AWARE THIS COMMAND IS STILL UNDER HEAVY DEVELOPMENT!
+#
+#
+require 'chef/knife'
+
+module KnifeGithubCreate
+  class GithubCreate < Chef::Knife
+
+    deps do
+      require 'chef/knife/github_base'
+      include Chef::Knife::GithubBase
+      require 'chef/mixin/shell_out'
+    end
+      
+    banner "knife github create STRING (options)"
+    category "github"
+
+    option :github_token,
+           :short => "-t",
+           :long => "--github_token",
+           :description => "Your github token for OAuth authentication"
+
+    option :github_user_repo,
+           :short => "-U",
+           :long => "--github_user_repo",
+           :description => "Create the repo within your user environment",
+           :boolean => true
+
+    def run
+      extend Chef::Mixin::ShellOut
+
+      # validate base options from base module.
+      validate_base_options      
+
+      # Display information if debug mode is on.
+      display_debug_info
+
+      # Get the name_args from the command line
+      name = name_args.first
+
+      # Get the organization name from config
+      org = locate_config_value('github_organizations').first
+
+      if name.nil? || name.empty? 
+        Chef::Log.error("Please specify a repository name")
+        exit 1
+      end 
+      
+      if config[:github_user_repo]
+        url = @github_url + "/api/" + @github_api_version + "/user/repos"
+        Chef::Log.debug("Creating repository in user environment")
+      else
+        url = @github_url + "/api/" + @github_api_version + "/orgs/#{org}/repos"
+        Chef::Log.debug("Creating repository in organization: #{org}")
+      end
+
+      # Get token information
+      token = get_github_token()
+
+      # Get body data for post
+      body = get_body_json(name)
+
+      # Creating the repository 
+      Chef::Log.debug("Creating the github repository")
+      repo = post_request(url, body, token)
+
+      Chef::Log.debug("Creating the local repository based on template")
+      create_cookbook(name)
+
+      cookbook_path = get_cookbook_path(name)
+
+      # Updating README.md if needed.
+      update_readme(cookbook_path)
+ 
+      # Updateing metadata.rb if needed.
+      update_metadata(cookbook_path)
+
+      github_ssh_url = repo['ssh_url']
+       
+      shell_out!("git init", :cwd => cookbook_path )
+      shell_out!("git add .", :cwd => cookbook_path ) 
+      shell_out!("git commit -m 'creating initial cookbook structure from the knife-github plugin' ", :cwd => cookbook_path ) 
+      shell_out!("git remote add origin #{github_ssh_url} ", :cwd => cookbook_path ) 
+      shell_out!("git push -u origin master", :cwd => cookbook_path ) 
+    end
+
+    # Set the username in README.md
+    # @param name [String] cookbook path    
+    def update_readme(cookbook_path)
+      contents = ''
+      username = get_username
+      readme = File.join(cookbook_path, "README.md")
+      File.foreach(readme) do |line|
+        line.gsub!(/TODO: List authors/,"#{username}\n")
+        contents = contents << line
+      end
+      File.open(readme, 'w') {|f| f.write(contents) }
+      return nil
+    end
+
+    # Set the username and email in metadata.rb
+    # @param name [String] cookbook path 
+    def update_metadata(cookbook_path)
+      contents = ''
+      username = get_username
+      email    = get_useremail
+      metadata = File.join(cookbook_path, "metadata.rb")
+      File.foreach(metadata) do |line|
+        line.gsub!(/YOUR_COMPANY_NAME/,username) if username
+        line.gsub!(/YOUR_EMAIL/,email) if email
+        contents = contents << line
+      end
+      File.open(metadata, 'w') {|f| f.write(contents) }
+      return nil
+    end
+
+    # Get the username from passwd file or git config
+    # @param nil
+    def get_username()
+      username = ENV['USER']
+      passwd_user = %x(getent passwd #{username} | cut -d ':' -f 5).chomp
+      username = passwd_user if passwd_user
+      git_user_name = %x(git config user.name).strip
+      username = git_user_name if git_user_name
+      username
+    end
+
+    # Get the email from passwd file or git config
+    # @param nil
+    def get_useremail()
+      email = nil
+      git_user_email = %x(git config user.email).strip
+      email = git_user_email if git_user_email
+      email
+    end
+
+    # Create the cookbook template for upload
+    # @param name [String] cookbook name
+    def create_cookbook(cookbook_name)
+      args = [ cookbook_name ]
+      create = Chef::Knife::CookbookCreate.new(args)
+      create.run
+    end
+
+    # Create the json body with repo config for POST information
+    # @param name [String] cookbook name  
+    def get_body_json(cookbook_name)
+      body = {
+        "name" => cookbook_name,
+        "description" => "We should ask for an description",
+        "private" => false,
+        "has_issues" => true,
+        "has_wiki" => true,
+        "has_downloads" => true
+      }.to_json
+    end
+
+    # Get the OAuth authentication token from config or command line
+    # @param nil
+    def get_github_token()
+      token = locate_config_value('github_token')
+      if token.nil? || token.empty?
+        Chef::Log.error("Please specify a github token")
+        exit 1
+      end
+      token
+    end
+
+    # Post Get the OAuth authentication token from config or command line
+    # @param url   [String] target url (organization or user) 
+    #        body  [JSON]   json data with repo configuration
+    #        token [String] token sring
+    def post_request(url, body, token)
+
+      if @github_ssl_verify_mode == "verify_none"
+        config[:ssl_verify_mode] = :verify_none
+      elsif @github_ssl_verify_mode == "verify_peer"
+        config[:ssl_verify_mode] = :verify_peer
+      end
+
+      Chef::Log.debug("URL: " + url.to_s)
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host,uri.port)
+      if uri.scheme == "https"
+        http.use_ssl = true
+        if  @github_ssl_verify_mode == "verify_none"
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+      end
+       
+      req = Net::HTTP::Post.new(uri.path, initheader = {"Authorization" => "token #{token}"})
+      req.body = body        
+      response = http.request(req)
+      
+      unless response.code == "201" then
+        puts "Error #{response.code}: #{response.message}"
+        puts JSON.pretty_generate(JSON.parse(response.body))
+        puts "URL: #{url}"
+        exit 1
+      end
+
+      begin
+        json = JSON.parse(response.body)
+      rescue
+        ui.warn "The result on the RESTRequest is not in json format"
+        ui.warn "Output: " + response.body
+        exit 1
+      end
+      json
+    end
+  end
+end

data/lib/chef/knife/github_deploy.rb

@@ -122,9 +122,9 @@ class Chef
         end
 
         # is the cookbook in the cookbook_path?
-        if cookbook_path_valid?(@cookbook_name, false).nil?
+        if get_cookbook_path(@cookbook_name).nil?
           Chef::Log.error("Cookbook is not in cookbook path")
-          ui.info("HINT:  knife github clone #{@cookbook_name}")
+          ui.info("HINT: knife github clone #{@cookbook_name}")
           exit 1
         end
 
@@ -236,13 +236,20 @@ class Chef
              major = $1
              minor = $2
              patch = $3
-             major = major.to_i + 1 if config[:major]
-             minor = minor.to_i + 1 if config[:minor]
+             if config[:major]
+               major = major.to_i + 1 
+               minor = 0 
+               patch = 0 
+             end
+             if config[:minor] 
+              minor = minor.to_i + 1 
+              patch = 0 
+             end
              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")
+             Chef::Log.error("Version is in a format I cannot auto-update")
              exit 1
           end
           version
@@ -258,7 +265,7 @@ class Chef
               args.push "--freeze"
           end
           upload = Chef::Knife::CookbookUpload.new(args)
-          #upload.config[:cookbook_path] = "#{@github_tmp}/git"
+          # upload.config[:cookbook_path] = "#{@github_tmp}/git"
           # plugin will throw its own errors
           upload.run
       end
@@ -269,8 +276,8 @@ class Chef
       # @param version [String] Version
       def checkout_tag(version)
           ui.info "Checking out tag #{version}"
-          cpath = get_cookbook_path(@cookbook_name)
-          Dir.chdir(cpath);
+          cookbook_path = get_cookbook_path(@cookbook_name)
+          Dir.chdir(cookbook_path);
 		  `git checkout -b #{version}`
 		  if !$?.exitstatus == 0
 		     ui.error("Failed to checkout branch #{version} of #{@cookbook_name}")
@@ -286,39 +293,13 @@ class Chef
           end
       end
 
-      # Get the version number in the git version of the cookbook
-      # @param version [String] Version
-      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
-
-      # Determine if the current cookbook path is valid and that there
-      # is a cookbook of the correct name in there
-      # @param cookbook [String] cookbook name
-      # @return [String] Path to cookbook
-      def get_cookbook_path(cookbook) 
-          return cookbook_path_valid?(cookbook, false)
-      end
 
       # Commit changes in git
       # @param version [String] cookbook version
       # @param push [Bool] true is the cookbook should also be pushed
       def do_commit(version, push)
-          cpath = get_cookbook_path(@cookbook_name)
-          Dir.chdir("#{cpath}")
-          puts cpath
+          cookbook_path = get_cookbook_path(@cookbook_path)
+          Dir.chdir("#{cookbook_path}")
           output = `git commit -a -m "Deploy #{version}" 2>&1`
           if $?.exitstatus != 0
              if output !~ /nothing to commit/
@@ -343,12 +324,12 @@ class Chef
       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|
+          cookbook_path = get_cookbook_path(@cookbook_name)
+          File.foreach("#{cookbook_path}/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) }
+          File.open("#{cookbook_path}/metadata.rb", 'w') {|f| f.write(contents) }
           return true
       end
 

data/lib/chef/knife/github_diff.rb

@@ -88,8 +88,8 @@ class Chef
         if config[:github]
 	        get_clone(github_link, @cookbook_name)
         else # Copy downloaded version to #{@github_tmp}/git
-            cpath = cookbook_path_valid?(@cookbook_name, false)
-            if cpath.nil?
+            cookbook_path = get_cookbook_path(@cookbook_name)
+            if cookbook_path.nil?
               Chef::Log.error("Cannot find any local repository with the name: #{@cookbook_name}")
               Chef::Log.error("Please use the option -g if you want to diff the github repository")
               exit 1
@@ -98,7 +98,7 @@ class Chef
             if ! File.exists?(tpath)
                 FileUtils.makedirs(tpath)
             end
-            FileUtils.cp_r cpath, tpath
+            FileUtils.cp_r cookbook_path, tpath
         end
 
 	    version = get_cookbook_copy(@cookbook_name, cookbook_version)