knife-github 0.1.4 → 0.1.6

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDViMjMxNGQzYTkxODBmMzM2MTI2ZjVkYmFkNmRmNjMyNjEzZjE2MA==
+    MjM5M2RiM2MwOWRlY2U1YmUxMjMwYjk5NTgwOWNiZGQ3ODk3N2JmOA==
   data.tar.gz: !binary |-
-    NDk3NTRkOTc1MjYxMzZiZDhlNWJmZThlM2ZlNDNiZDg2MzcxZDBkMw==
+    MWQyMjFiNTliYWNkZTcyYjFhY2QzOWVjM2QyNjlkMGE0ZDI5NjgzMw==
 SHA512:
   metadata.gz: !binary |-
-    N2ZkMTM5OGIxNTRiNDkyMGY2YWMyY2E4NjYxYmU3ZGMyN2FkZWI5YThhYmE3
-    MGE4YjhiODIzYTg4ZWE4OTM0NGIzOGY1MGI0NWQ0MjY1MzkwZWM4N2NmMjFk
-    YWIzY2Y3ODY2ZjhhNDNlMjQzMzRmYjc3Mzg4ZGU3ZGRiODEwMzI=
+    ZDE3NDk2NTBkODgzNzRlZTIxNzI1ZjI5YzRjYjhiYTQxZDQ2NWZiMWU3OGY2
+    ZWU0N2Y4YTE0NGNkYTE2ZDY1Y2M2NjdiODM1MzlmMjgxMzliMjlkYTUyMThj
+    MDM5NDQ1ZTk1NzA5YmMzOTdjN2FmNTM0OGVhYjJlNzNlNzQ4MzE=
   data.tar.gz: !binary |-
-    ODllMmI5OTRhNDlhYTNkM2MwNmQ5ODIwNmJjZGZiYjE5MThmY2EwMmRkMDIy
-    NzJjNDVkNDk3MGM5YjIzYjZmN2I3ZTdiMjQ4N2JmNjIwMTdhMjliZTllZjFm
-    Y2EwZDNkMDJhMzk4NTQ2MWI4YjdjMGRiMTcyNjMwY2JkOWVkOTY=
+    MmRhYTdiZTA3ODAzNWUzMDA4NjRmZDE4MDhmYjFjN2Y2YjlhNGYzOGYyMGM1
+    OWVlMmRiZDliMDlkMzdmYmMwMjNmZDhmYWEwNTc0ZjE0MzA5ZWIyZWQ3NDlm
+    OWUxODRlODNkNWYyMDE4MjhmZjVhNzg5MjQ5NTM0Mjk1MGM1OWY=

data/README.md

@@ -52,6 +52,8 @@ Currently the options are: <tt>verify_peer</tt> <tt>verify_none</tt>
 Token information is required when creating and deleting github repositories.  
 With the command <tt>knife github token create</tt> you are able to create token information.
 
+###### github_proxy \<optional\>
+Used for HTTP communication over a proxy. 
 
 Other
 =====

data/knife-github.gemspec

@@ -21,5 +21,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'mixlib-versioning', '>= 1.0.0'
   s.add_dependency 'highline', '>= 1.6.19'
   s.add_dependency 'rb-readline', '~> 0.5.1'
-  s.add_dependency 'chef', '>= 10.0.0'
+  s.add_dependency 'chef', '~> 11.0'
 end

data/lib/chef/knife/github_base.rb

@@ -21,6 +21,7 @@ require 'knife-github/config'
 require 'knife-github/version'
 require 'knife-github/connection'
 require 'mixlib/versioning'
+require 'chef/mixin/shell_out'
 
 class Chef
   class Knife
@@ -59,6 +60,15 @@ class Chef
                  :long => "--github_no_update",
                  :description => "Turn github update checking off",
                  :boolean => true
+
+          option :github_proxy,
+                 :long => "--github_proxy",
+                 :description => "Enable proxy configuration for github api"
+ 
+          option :github_token,
+                 :short => "-t",
+                 :long => "--github_token",
+                 :description => "Your github token for OAuth authentication"
  
           def validate_base_options
             unless locate_config_value('github_url')
@@ -69,22 +79,37 @@ class Chef
               ui.error "Github organization(s) not specified"
               exit 1
             end
-            unless locate_config_value('github_no_update')
-              check_gem_version
-            end
 
             @github_url             = locate_config_value("github_url")
             @github_organizations   = locate_config_value("github_organizations")
             @github_link            = locate_config_value("github_link") || 'ssh'
             @github_api_version     = locate_config_value("github_api_version") || 'v3'
             @github_ssl_verify_mode = locate_config_value("github_ssl_verify_mode") || 'verify_peer'
+            @github_proxy           = locate_config_value("github_proxy")
+            @github_token           = locate_config_value("github_token")
             @github_tmp             = locate_config_value("github_tmp") || '/var/tmp/gitdiff'
             @github_tmp             = "#{@github_tmp}#{Process.pid}"
+
+            unless locate_config_value('github_no_update')
+              check_gem_version
+            end
           end
 
           def check_gem_version
-            url  = 'http://rubygems.org/api/v1/gems/knife-github.json'
-            result = `curl -L -s #{url}`
+            extend Chef::Mixin::ShellOut
+            url   = 'http://rubygems.org/api/v1/gems/knife-github.json'
+            proxy = @github_proxy
+            if proxy.nil?
+              result = `curl -L -s #{url}`
+              Chef::Log.debug("removing proxy in glogal git config")
+              shell_out!("git config --global --unset http.proxy")
+              shell_out!("git config --global --unset https.proxy")
+            else
+              Chef::Log.debug("Putting proxy in glogal git config")
+              shell_out!("git config --global http.proxy #{proxy}")
+              shell_out!("git config --global https.proxy #{proxy}")
+              result = `curl --proxy #{proxy} -L -s #{url}`
+            end
             begin
               json = JSON.parse(result)
               webversion = Mixlib::Versioning.parse(json['version'])
@@ -110,6 +135,8 @@ class Chef
             Chef::Log.debug("github_api           : " + @github_api_version.to_s)
             Chef::Log.debug("github_link          : " + @github_link.to_s)
             Chef::Log.debug("github_ssl_mode      : " + @github_ssl_verify_mode.to_s)
+            Chef::Log.debug("github_proxy         : " + @github_proxy.to_s)
+            Chef::Log.debug("github_token         : " + @github_token.to_s)
           end
 
           def locate_config_value(key)
@@ -199,12 +226,16 @@ class Chef
           end
       
           def get_github_repo_data(org)
+            params = {}
             arr  = []
-            page = 1
             url  = @github_url + "/api/" + @github_api_version + "/orgs/" + org + "/repos"
+            params[:token] = @github_token
+            params[:action] = "GET"
+            params[:url] = url
+            page = 1
             while true
-              params = {'response' => 'json', 'page' => page }
-              result = connection.send_get_request(url, params)
+              params[:request_uri] = "?response=json&page=#{page}"
+              result = connection.request(params)
               break if result.nil? || result.count < 1
               result.each { |key| arr << Github::Repo.new(key) }
               page = page + 1
@@ -280,6 +311,23 @@ class Chef
               version
           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?
+               return nil
+            end
+            token
+          end
+
+          # Create the json body with repo config for POST information
+          # @param name [String] cookbook name
+          def get_body_json()
+            body = {
+              "scopes" => ["public_repo"]
+            }.to_json
+          end
         end
       end
     end

data/lib/chef/knife/github_cleanup.rb

@@ -82,7 +82,7 @@ module KnifeGithubCleanup
 
     def repo_cleanup(repo)
       cookbook_path = config[:cookbook_path] || Chef::Config[:cookbook_path]
-      cookbook = File.join(cookbook_path.first,repo)
+      cookbook = File.join(cookbook_path,repo)
       if File.exists?(cookbook)
         if repo_status_clean?(repo, cookbook)
           # delete the repo 

data/lib/chef/knife/github_repo_create.rb

@@ -47,11 +47,6 @@ module KnifeGithubRepoCreate
     banner "knife github repo create <name> <description> (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",
@@ -60,6 +55,7 @@ module KnifeGithubRepoCreate
 
     def run
       extend Chef::Mixin::ShellOut
+      params = {}
 
       # validate base options from base module.
       validate_base_options      
@@ -83,31 +79,29 @@ module KnifeGithubRepoCreate
       type = get_repo_type
 
       if config[:github_user_repo]
-        url = @github_url + "/api/" + @github_api_version + "/user/repos"
+        params[: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"
+        params[:url] = @github_url + "/api/" + @github_api_version + "/orgs/#{org}/repos"
         Chef::Log.debug("Creating repository in organization: #{org}")
       end
 
       @github_tmp = locate_config_value("github_tmp") || '/var/tmp/gitcreate'
       @github_tmp = "#{@github_tmp}#{Process.pid}"
 
-      # Get token information
-      token = get_github_token()
-
-      # Get body data for post
-      body = get_body_json(name, desc)
 
       # Creating the local repository or using existing one.
       cookbook_dir = get_cookbook_path(name) || ""
 
+      params[:body] = lget_body_json(name, desc)
+      params[:token] = get_github_token()
+      params[:action] = "POST" 
       if File.exists?(cookbook_dir)
         Chef::Log.debug("Using local repository from #{cookbook_dir}")
 
         # Creating the github repository
         Chef::Log.debug("Creating the github repository")
-        repo = post_request(url, body, token)
+        repo = connection.request(params)
         github_ssh_url = repo['ssh_url']
     
         Chef::Log.debug("Commit and push local repository")
@@ -126,7 +120,7 @@ module KnifeGithubRepoCreate
   
         # Creating the github repository
         Chef::Log.debug("Creating the github repository")
-        repo = post_request(url, body, token)
+        repo = connection.request(params)
         github_ssh_url = repo['ssh_url']
   
         Chef::Log.debug("Commit and push local repository")      
@@ -271,7 +265,7 @@ module KnifeGithubRepoCreate
 
     # Create the json body with repo config for POST information
     # @param name [String] cookbook name  
-    def get_body_json(cookbook_name, description="Please fill in the description.")
+    def lget_body_json(cookbook_name, description="Please fill in the description.")
       body = {
         "name" => cookbook_name,
         "description" => description,
@@ -282,61 +276,5 @@ module KnifeGithubRepoCreate
       }.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_repo_destroy.rb

@@ -106,7 +106,11 @@ module KnifeGithubRepoDestroy
       # update_metadata(cookbook_path)
 
       # Creating the github repository
-      repo = delete_request(url, token)
+      params = {}
+      params[:url] = url
+      params[:token] = token
+      params[:action] = "DELETE"
+      repo = connection.request(params)
       puts "Repo: #{name} is deleted" if repo.nil?
 
       # github_ssh_url = repo['ssh_url']
@@ -202,72 +206,5 @@ module KnifeGithubRepoDestroy
       create.run
     end
 
-    # Create the json body with repo config for POST information
-    # @param name [String] cookbook name  
-    def get_body_json()
-      body = {
-        "scopes" => ["public_repo"]
-      }.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("Cannot find any token information!")
-        Chef::Log.error("Please use: knife github token create")
-        exit 1
-      end
-      token
-    end
-
-    # Send DELETE command to API 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 delete_request(url, 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::Delete.new(uri.path, initheader = {"Authorization" => "token #{token}"}) 
-      req.body = get_body_json()        
-      response = http.request(req)
-      
-      return nil if response.code == "204"
-
-      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_repo_fork.rb

@@ -29,9 +29,6 @@ module KnifeGithubRepoFork
     # Fork a new cookbook:
     #    knife github repo fork <name>
     #
-    # === Options
-    # -t --github_token		Authentication token for the github.
-    #
     
     deps do
       require 'chef/knife/github_base'
@@ -41,13 +38,7 @@ module KnifeGithubRepoFork
     banner "knife github repo fork <name> [owner] [target] (options)"
     category "github"
 
-    option :github_token,
-           :short => "-t",
-           :long => "--github_token",
-           :description => "Your github token for OAuth authentication"
-
     def run
-      params = {}
       # validate base options from base module.
       validate_base_options      
 
@@ -65,15 +56,17 @@ module KnifeGithubRepoFork
       end 
 
       # Set params for the rest request
-      params['url'] = @github_url + "/api/" + @github_api_version + "/repos/#{owner}/#{name}/forks"
-      params['body'] = get_body_json(target) unless target.nil?
-      params['token'] = get_github_token()
-      params['response_code']  = 202
+      params = {}
+      params[:url] = @github_url + "/api/" + @github_api_version + "/repos/#{owner}/#{name}/forks"
+      params[:body] = get_body_json(target) unless target.nil?
+      params[:token] = get_github_token()
+      #params[:response_code]  = 202
+      params[:action]  = "POST"
 
       # Execute the rest request
       username = ENV['USER']
 
-      rest_request(params)
+      connection.request(params)
       if target
         puts "Fork of #{name} is created in #{target}"
       else
@@ -81,74 +74,5 @@ module KnifeGithubRepoFork
       end
     end
  
-    # Create the json body with repo config for POST information
-    # @param target [String] oragnization target name  
-    def get_body_json(target)
-      body = {
-        "organization" => target,
-      }.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 rest_request(params = {})
-      url    = params['url'].to_s
-      token  = params['token'].to_s
-      code   = params['response_code'] || 200
-      body   = params['body'] || nil
-      action = params['action'] || 'POST'
-
-      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)
-
-      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 unless body.nil?
-      response = http.request(req)
-      
-      unless response.code.to_s == code.to_s 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_search.rb

@@ -71,16 +71,22 @@ module KnifeGithubSearch
       end
     end
 
-    def github_search_repos(query, params ={})
+    def github_search_repos(query, request = {})
       # once the new search function is available, we can use these params
-      params['q'] = query
-      params['sort'] = 'stars'
-      params['order'] = 'desc'
-      params['response'] = 'json'
-
-      url  = @github_url + "/api/" + @github_api_version + "/legacy/repos/search/" + query
-      Chef::Log.debug("URL: #{url}")
-      connection.send_get_request(url, params = {}) 
+      request['sort'] = 'stars'
+      request['order'] = 'desc'
+      request['response'] = 'json'
+      request_arr = []
+      request.sort.each { |elem|
+        request_arr << elem[0].to_s + '=' + CGI.escape(elem[1].to_s).gsub('+', '%20').gsub(' ','%20')
+      }
+      data = request_arr.join('&')
+      params = {}
+      params[:url]  = @github_url + "/api/" + @github_api_version + "/legacy/repos/search/" + query
+      params[:action] = "GET"
+      params[:token] = get_github_token
+      params[:request_uri] = "?#{data}"
+      connection.request(params) 
     end
 
   end

data/lib/chef/knife/github_token_create.rb

@@ -107,17 +107,6 @@ module KnifeGithubTokenCreate
       return true
     end
 
-    # Get the OAuth authentication token from config or command line
-    # @param none
-    def get_github_token()
-      token = locate_config_value('github_token')
-      if token.nil? || token.empty? 
-        return nil
-      else
-        return token
-      end
-    end
-
     # Validate the OAuth authentication token for the knife-github application.
     # @param username   [String]        validates the token for specific user. (default is ENV['USER'])
     #
@@ -134,7 +123,7 @@ module KnifeGithubTokenCreate
 
       token_key = nil
 
-      result = send_request(params)
+      result = connection.request(params)
       result.each do |token|
         if token['app'] && token['app']['name'] == "knife-github (API)"
           if token['scopes'].include?("delete_repo")
@@ -167,73 +156,15 @@ module KnifeGithubTokenCreate
       params[:url]    = @github_url + "/api/" + @github_api_version + "/authorizations"
       params[:body]   = '{"note":"knife-github","scopes":["delete_repo", "user", "public_repo", "repo", "gist"]"}'
       params[:action] = "POST"
-      send_request(params)
+      connection.request(params)
     end
 
     def delete_github_token(params)
       Chef::Log.debug("Deleting token id: #{params[':id']}")
       params[:url]    = @github_url + "/api/" + @github_api_version + "/authorizations/#{params[:id]}"
       params[:action] = "DELETE"
-      send_request(params)
+      connection.request(params)
     end
 
-    # Post Get the OAuth authentication token from config or command line
-    # @param params		[Hash] 		Hash containing all options 
-    #        params[:url]	[String]	Url to target
-    #        params[:body]  	[JSON]   	json data for the request
-    #        params[:token]	[String] 	OAuth token
-    #        params[:username]	[String]	Username if no token specified
-    #        params[:password]  [String]	Password if no token specified
-    #
-    def send_request(params)
-      url = params[:url]
-      
-      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
-
-      if params[:action] == "GET"
-        req = Net::HTTP::Get.new(uri.path)
-      elsif params[:action] == "POST"
-        req = Net::HTTP::Post.new(uri.path)
-      elsif params[:action] == "DELETE" 
-        req = Net::HTTP::Delete.new(uri.path)
-      end
-      
-      if params[:token].nil?
-        req.basic_auth params[:username], params[:password]
-      else
-        req.initheader = ({"Authorization" => "token #{params[:token]}"})
-      end
-      req.body = params[:body] if params[:body]
-      response = http.request(req)
-      
-      unless response.code =~ /^2../ then
-        puts "Error #{response.code}: #{response.message}"
-        puts JSON.pretty_generate(JSON.parse(response.body))
-        puts "URL: #{url}"
-        exit 1
-      end
-
-      return nil if response.body.nil? || response.body.empty?
-
-      begin
-        json = JSON.parse(response.body)
-      rescue
-        ui.warn "The result on the REST Request is not in json format"
-        ui.warn "Output: " + response.body
-        exit 1
-      end
-      json
-    end
   end
 end

data/lib/knife-github/config.rb

@@ -8,6 +8,7 @@ module Github
         configurable :github_link
         configurable :github_api_version
         configurable :github_ssl_verify_mode
+        configurable :github_proxy
       end
   end
 end

data/lib/knife-github/connection.rb

@@ -6,39 +6,80 @@ require 'net/http'
 
 module GithubClient
  class Connection
-    def send_get_request(url, params = {})
-      unless params.empty?
-        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('&')
-        url = "#{url}?#{data}"
-      end
 
-      #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
+    def request(params)
+      ssl_verify_mode = Chef::Config[:knife][:github_ssl_verify_mode]
+      # @param params                [Hash]          Hash containing all options
+      #        params[:url]          [String]        Url to target
+      #        params[:body]         [JSON]          json data for the request
+      #        params[:token]        [String]        OAuth token
+      #        params[:username]     [String]        Username if no token specified
+      #        params[:password]     [String]        Password if no token specified
+      #        params[:request_uri]  [String]        Some request, only need an URI....
+      #        params[:action]       [String]        The HTTP action
+      #
+      url = params[:url]
+      action = params[:action]
+      token = params[:token]
+      username = params[:username]
+      password = params[:password]
+      body = params[:body]
+      request_uri = params[:request_uri] || ''
+
+      unless url || action then
+        puts "URL and ACTION not defined!"
+        exit 1
+      end
 
       Chef::Log.debug("URL: " + url.to_s)
 
+      url = "#{url}#{request_uri}"
       uri = URI.parse(url)
-      http = http_client_builder.new(uri.host, uri.port)
-
+      http = http_builder.new(uri.host,uri.port)
       if uri.scheme == "https"
         http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        if  @ssl_verify_mode == "verify_none"
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        else
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        end
+      end
+      
+      initheader = {}
+      if token
+        initheader = {"Authorization" => "token #{token}"}
+        Chef::Log.debug("Using token: #{token} for action: #{action} on URL: #{url}")
       end
-  
-      request = Net::HTTP::Get.new(uri.request_uri)
-      response = http.request(request)
 
-      unless response.is_a?(Net::HTTPOK) then
+      case action
+      when "GET"
+        if uri.request_uri.nil?
+          req = Net::HTTP::Get.new(uri.path, initheader)
+        else
+          req = Net::HTTP::Get.new(uri.request_uri, initheader)
+        end
+      when "POST"
+        req = Net::HTTP::Post.new(uri.path, initheader)
+      when "DELETE"
+        req = Net::HTTP::Delete.new(uri.path, initheader)
+      else
+        puts "Error, undefined action #{action}"
+        exit 1
+      end
+      if username && password
+        req.basic_auth username, password
+        Chef::Log.debug("Using basic_auth #{username}, #{password} for action: #{action} on URL: #{url}")
+      end
+
+      req.body = body if body
+      response = http.request(req)
+      validate = response_validator(response)
+    end
+
+    def response_validator(response)
+      unless response.code =~ /^2../ then
         puts "Error #{response.code}: #{response.message}"
         puts JSON.pretty_generate(JSON.parse(response.body))
-        puts "URL: #{url}"
         exit 1
       end
 
@@ -52,11 +93,12 @@ module GithubClient
       return json
     end
 
-    def http_client_builder
-      http_proxy = proxy_uri
-      if http_proxy.nil?
+    def http_builder
+      proxy = Chef::Config[:knife][:github_proxy]
+      if proxy.nil?
         Net::HTTP
       else
+        http_proxy = URI.parse(proxy)
         Chef::Log.debug("Using #{http_proxy.host}:#{http_proxy.port} for proxy")
         user = http_proxy.user if http_proxy.user
         pass = http_proxy.password if http_proxy.password
@@ -64,11 +106,6 @@ module GithubClient
       end
     end
 
-    def proxy_uri
-      return nil if @api_proxy.nil?
-      result = URI.parse(@api_proxy)
-      return result unless result.host.nil? || result.host.empty?
-      nil
-    end
   end
 end
+

data/lib/knife-github/repo.rb

@@ -76,7 +76,11 @@ module Github
 
     def get_tags(url)
       tags = []
-      result = connection.send_get_request(url)
+      params = {}
+      params[:url] = url
+      params[:action] = "GET"
+      params[:token] = Chef::Config[:knife][:github_token] 
+      result = connection.request(params)
       result.each { |tag| tags.push(tag['name']) if tag['name'] =~ /^(\d*)\.(\d*)\.(\d*)$/ }
       tags || nil
     end

data/lib/knife-github/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Github
-    VERSION = "0.1.4"
+    VERSION = "0.1.6"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: knife-github
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Sander Botman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-03 00:00:00.000000000 Z
+date: 2014-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-versioning
@@ -57,16 +57,16 @@ dependencies:
   name: chef
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: '11.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 10.0.0
+        version: '11.0'
 description: Github interaction support for chef's knife cli tool
 email:
 - sbotman@schubergphilis.com