cookbook-client 0.1.0

data/examples/test-auth-against-erlang.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'opscode/rest'
+
+client = Opscode::REST.new
+
+uri = 'http://localhost:5959/objects/1'
+secret_filename = '/Users/tim/.ssh/secret-timh2-com-stg.txt'
+user_id = 'timh2'
+
+user_secret = OpenSSL::PKey::RSA.new(File.read(secret_filename))
+
+res = client.request(:get,
+                     uri, 
+                     :authenticate => true,
+                     :user_id => user_id,
+                     :user_secret => user_secret)
+puts "res from GET is: #{res}"
+

data/examples/test-hash-find.rb

@@ -0,0 +1,22 @@
+
+#!/usr/bin/env ruby -w
+
+# Test collectino.find
+hash = {
+  'something_else' => 'value',
+  'another_thing' => 'hmm',
+  'tarball' => File.new('/etc/passwd'),
+  'yet_another' => '..',
+}
+
+Hash
+res = hash.find { |k,v| v.is_a?(File) }
+puts "res is #{res[1]}"
+
+
+# test gsub
+str = "my-testing/0_7_0"
+str = str.gsub(/_/, '.')
+puts "str is #{str}"
+
+Hash

data/examples/test-ssl.rb

@@ -0,0 +1,20 @@
+require 'net/https'
+require 'uri'
+
+url = 'https://s3.amazonaws.com/opscode-community/cookbook_versions/tarballs/151/original/teamspeak.tar.gz'
+uri = URI.parse url
+
+http_client = Net::HTTP.new(uri.host, uri.port)
+if uri.scheme == 'https'
+  http_client.use_ssl = true
+  http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+end
+
+res = http_client.request_get(uri.path)
+
+#http = Net::HTTP.new(uri.host, uri.port)
+#http.use_ssl = true if uri.scheme == 'https'
+#res = http.get
+
+puts "res #{res}"
+puts "res.body is #{res.body}"

data/examples/test-using-restclient-multipart.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'rest_client'
+require 'mixlib/authentication/signedheaderauth'
+
+uri = 'http://com-stg.opscode.com/api/v1/cookbooks'
+user_secret_filename = '/Users/tim/.ssh/secret-timh2-com-stg.txt'
+user_secret = OpenSSL::PKey::RSA.new(File.read(user_secret_filename))
+
+args = {
+  :file => File.new('couchdb2.tar.gz'),
+  :user_id => 'timh2',
+  :http_method => :post,
+  :timestamp => Time.now.utc.iso8601
+}
+client = Mixlib::Authentication::SignedHeaderAuth.signing_object(args)
+puts "SignedHeaderAuth client is #{client}"
+
+headers = client.sign(user_secret)
+puts "headers is #{headers}"
+
+res = RestClient.post(uri, 
+        {:tarball => File.read('couchdb2.tar.gz'), :cookbook => '{"category":"good"}'},
+        #File.new('couchdb2.tar.gz'),
+        headers)
+puts "POST res is #{res}"
+

data/examples/test_signature_verification.rb

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby -w
+
+require 'rubygems'
+require 'mixlib/authentication/signatureverification'
+
+sigv = Mixlib::Authentication::SignatureVerification.new
+
+# for timh2:
+# -----BEGIN RSA PUBLIC KEY-----
+# MIIBCgKCAQEA0wqGeC4/OSMQwFCp0/6o21dUlSrbWFFFYdVC1wY/ADgpnAbnZGDO
+# URrrmQ8zw2WBMGpZ2RvhaToj7SOlCUOJmM99W5Ou9E3pOFvjRWgWjW0LAe48SIWP
+# t2WtdtI4YBzyS6Dp9Oxdcm5TGGJa7QMbIgaU9VD0Jr8yFDWE9QdqAsy+NBSwM13c
+# CQuBqHtSoJMk9SgzwQyFSm6GCQcliNh5wupKqhNNYCdYOAeJQqJKn25aK9/4+eLu
+# 8F8bVD1MznOBes089+CoY50sy1N2iZnxwftZklmGLJ1tB5C8+vNwB91Qzp9csUtr
+# prTkgeW/9cqybTwTm30pj5yrW6A271pkVwIDAQAB
+# -----END RSA PUBLIC KEY-----
+
+# for timh3:
+# -----BEGIN RSA PUBLIC KEY-----
+# MIIBCgKCAQEA0wqGeC4/OSMQwFCp0/6o21dUlSrbWFFFYdVC1wY/ADgpnAbnZGDO
+# URrrmQ8zw2WBMGpZ2RvhaToj7SOlCUOJmM99W5Ou9E3pOFvjRWgWjW0LAe48SIWP
+# t2WtdtI4YBzyS6Dp9Oxdcm5TGGJa7QMbIgaU9VD0Jr8yFDWE9QdqAsy+NBSwM13c
+# CQuBqHtSoJMk9SgzwQyFSm6GCQcliNh5wupKqhNNYCdYOAeJQqJKn25aK9/4+eLu
+# 8F8bVD1MznOBes089+CoY50sy1N2iZnxwftZklmGLJ1tB5C8+vNwB91Qzp9csUtr
+# prTkgeW/9cqybTwTm30pj5yrW6A271pkVwIDAQAB
+# -----END RSA PUBLIC KEY-----

data/examples/testrestoc.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby 
+
+$: << File.join(File.dirname(__FILE__), "..", "opscode-chef", "chef", "lib")
+
+require 'rubygems'
+require 'cgi'
+require 'json'
+require 'opscode/rest'
+require 'mixlib/log'
+require 'chef/log'
+require 'streaming_cookbook_uploader'
+
+Opscode::REST::Config[:log_level] = :debug
+
+client = Opscode::REST.new
+
+#uri = 'http://opscode-community.pivotallabs.com/api/v1/cookbooks'
+#user_id = 'timh'
+#secret_key_filename = '/Users/tim/.ssh/pivotallabs-secret.txt'
+
+uri = 'http://com-stg.opscode.com/api/v1/cookbooks'
+user_id = 'timh2'
+secret_key_filename = '/Users/tim/.ssh/secret-timh2-com-stg.txt'
+
+user_secret = OpenSSL::PKey::RSA.new(File.read(secret_key_filename))
+filename_to_upload = 'couchdb3.tar.gz'
+
+if 1
+  ########## streaming cookbook uploader
+  ##########  results in 'invalid authenticity token' exception (pages of rails
+  ##########  exception) from far end:
+  streaming_client = Chef::StreamingCookbookUploader.new
+  res = streaming_client.post(uri, user_id, secret_key_filename, 
+              { 'tarball' => File.new(filename_to_upload), 
+                'cookbook' => '{"category":"good"}' })
+  puts "res is #{res}"
+
+elsif nil
+  ########## nuo's alternative
+  ##########  results in 'unauthorized' from far end
+  headers = {:accept=>"application/json", :content_type=>'application/json'}
+  options = {:authenticate=> true,
+             :user_secret=>user_secret,
+             :user_id=>user_id,
+             :headers=>headers,
+             :payload=>File.read(filename_to_upload)
+            }
+  res = client.request(:post,uri,options)
+  puts "res is #{res}"
+
+elsif 1
+  ########## my original
+  ##########  results in 'unauthorized' from far end
+  res = client.post(uri, 
+                    :payload => File.read(filename_to_upload), 
+                    :authenticate => true,
+                    :user_id => user_id,
+                    :user_secret => user_secret,
+                    :headers => {
+                    :content_type => 'application/octet-stream' })
+  puts "res is #{res}"
+end

data/examples/upload-using-cw_multipart.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+$: << File.join(File.dirname(__FILE__), "..", "opscode-chef", "chef", "lib")
+
+require 'rubygems'
+require 'rest_client'
+require 'mixlib/authentication/signedheaderauth'
+require 'mixlib/log'
+require 'chef/log'
+require 'streaming_cookbook_uploader'
+
+uri = 'http://com-stg.opscode.com/api/v1/cookbooks'
+user_id = 'timh2'
+user_secret_filename = '/Users/tim/.ssh/secret-timh2-com-stg.txt'
+user_secret = OpenSSL::PKey::RSA.new(File.read(user_secret_filename))
+
+# def post(to_url, user_id, secret_key_filename, params = {}, headers = {})
+#   make_request(:post, to_url, user_id, secret_key_filename, params, headers)
+# end
+
+client = Chef::StreamingCookbookUploader.new
+
+res = client.post(uri, user_id, user_secret_filename, {
+  :tarball => File.open('couchdb2.tar.gz'),
+  :cookbook => '{"category":"databases"}'
+})
+puts "POST res is #{res}"
+

data/lib/chef/cookbook_client.rb

@@ -0,0 +1,196 @@
+
+require 'chef/streaming_cookbook_uploader'
+require 'chef/remote_cookbook'
+require 'opscode/rest'
+require 'cgi'
+
+module Chef
+  class CookbookClient
+    def initialize(hostname)
+      @hostname = hostname
+      @client = Opscode::REST.new
+    end
+
+    def do_search(term)
+      uri = make_uri('api/v1/search', {'q' => term})
+      parse_json_cookbook_list @client.get(uri)
+    end
+
+    def do_list()
+      params = {}
+      params['items'] = 999999
+
+      uri = make_uri('api/v1/cookbooks', params)
+
+      parse_json_cookbook_list @client.get(uri)
+    end
+
+    # parse json output back from pivotallabs. assumes a hash comes back, which
+    # contains a key 'items', which itself is an array. that array has cookbook
+    # hashes in it.
+    # e.g. http://opscode-community.pivotallabs.com/api/v1/cookbooks/
+    def parse_json_cookbook_list(json_hash)
+      cookbooks_res = []
+
+      items = json_hash['items']
+      if !items.nil? && items.kind_of?(Array)
+        items.each do |item|
+          cookbook = RemoteCookbook.from_json_list(item)
+
+          cookbooks_res.push cookbook
+        end
+      else
+        raise Exception, "items should be an Array, but it's #{items}"
+      end
+      cookbooks_res
+    end
+
+    # Retrieve details and an enumeration of versions for the given cookbook.
+    def do_details(cookbook_name)
+      cookbook_uri = make_uri "api/v1/cookbooks/#{cookbook_name}"
+
+      json_hash = @client.get(cookbook_uri)
+
+      cookbook_res = RemoteCookbook.from_json_details(cookbook_uri, json_hash)
+      cookbook_res.versions.each do |ver|
+        ver_json_hash = @client.get(ver.uri)
+
+        # populate additional fields of the version object with the result
+        # from the versioned JSON call.
+        ver.set_from_json_hash @hostname, ver_json_hash
+      end
+
+      cookbook_res
+    end
+
+    # Download the tarball for a given cookbook. If the version isn't specified,
+    # grab the latest. Returns the file
+    def do_download(cookbook_name, cookbook_version = nil)
+      # Fetch the details of the cookbook we're about to download, so we can
+      # look at its versions. If there's no such cookbook, rest client will
+      # throw an exception.
+      remote_cookbook = do_details cookbook_name
+
+      # if user specified a version, look it up, otherwise use the latest.
+      found_version = 
+      if cookbook_version
+        remote_cookbook.find_version_by_user_version(cookbook_version)
+      else
+        remote_cookbook.latest_version
+      end
+
+      # Download the cookbook if we were able to find a valid version.
+      if found_version
+        if found_version.tarball_uri =~ /.*\/([^\/]+)$/
+          out_filename = $1
+        end
+        if out_filename.nil?
+          raise ArgumentError, "do_download: can't figure out the filename pattern for #{found_version.tarball_uri}"
+        end
+
+        # TODO: should be using a streaming form, but am using the string all-at-once
+        # version for now.
+        uri = URI.parse found_version.tarball_uri
+        http_client = Net::HTTP.new(uri.host, uri.port)
+        if uri.scheme == 'https'
+          http_client.use_ssl = true
+          http_client.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+
+        http_res = http_client.request_get(uri.path)
+        out = File.open(out_filename, 'wb')
+        out.write(http_res.body)
+        out.close
+
+        out_filename
+      else
+        raise Exception, "No such version of cookbook '#{cookbook_name}': #{cookbook_version}"
+      end
+    end
+
+    def do_upload(cookbook_filename, cookbook_category, user_id, user_secret_filename)
+      cookbook_uploader = StreamingCookbookUploader.new
+      uri = make_uri "api/v1/cookbooks"
+
+      category_string = { 'category'=>cookbook_category }.to_json
+
+      http_resp = cookbook_uploader.post(uri, user_id, user_secret_filename, {
+        :tarball => File.open(cookbook_filename),
+        :cookbook => category_string
+      })
+
+      res = JSON.parse(http_resp.body)
+      if http_resp.code.to_i != 201
+        if !res['error_messages'].nil?
+          if res['error_messages'][0] =~ /Version already exists/
+            raise "Version already exists"
+          else
+            raise Exception, res
+          end
+        else
+          raise Exception, "Error uploading: #{res}"
+        end
+      end
+
+      #puts "do_upload: POST res is #{res}"
+      res
+    end
+
+    # Delete the given cookbook, using the given credentials
+    def do_delete(cookbook_name, user_id, user_secret_filename)
+      cookbook_to_delete = do_details(cookbook_name)
+      if cookbook_to_delete.nil?
+        raise ArgumentError, "No such cookbook to delete #{cookbook_name}"
+      end
+
+      user_secret_rsa = OpenSSL::PKey::RSA.new(File.read(user_secret_filename))
+
+      client_options = {
+        :authenticate => true,
+        :user_id => user_id,
+        :user_secret => user_secret_rsa
+      }
+
+      # delete the whole cookbook
+      @client.request(:delete, cookbook_to_delete.uri, client_options)
+    end
+
+    def do_deprecate(cookbook_name, replacement_cookbook_name, user_id, user_secret_filename)
+      cookbook_to_deprecate = do_details(cookbook_name)
+      if cookbook_to_deprecate.nil?
+        raise ArgumentError, "No such cookbook to deprecate #{cookbook_name}"
+      end
+
+      user_secret_rsa = OpenSSL::PKey::RSA.new(File.read(user_secret_filename))
+
+      deprecate_uri = "#{cookbook_to_deprecate.uri}/deprecation"
+      deprecation_json = { 'replacement_cookbook_name' => replacement_cookbook_name }.to_json
+
+      client_options = {
+        :authenticate => true,
+        :user_id => user_id,
+        :user_secret => user_secret_rsa,
+        :payload => deprecation_json,
+      }
+      
+      # delete the whole cookbook
+      res = @client.post(deprecate_uri, client_options)
+    end
+
+    # make a url given the hostname we were set up with, the base path,
+    # and any parameters that were included.
+    def make_uri(base, params = {})
+      if params && !params.empty?
+        path_components = params.each.collect do |key, value| 
+          key = CGI.escape(key.to_s)
+          value = CGI.escape(value.to_s)
+          "#{key}=#{value}"
+        end
+        path_components_str = '?' + path_components.join('&')
+      end
+      "http://#{@hostname}/#{base}#{path_components_str}"
+    end
+  end
+
+end
+

data/lib/chef/remote_cookbook.rb

@@ -0,0 +1,114 @@
+
+module Chef
+  class RemoteCookbookVersion
+    attr_accessor :uri
+    attr_accessor :tarball_uri
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def version
+      # http://www.example.com/api/v1/cookbooks/apache/versions/1_0
+      version = ""
+      if /.+\/([^\/]+)$/ =~ @uri
+        version = $1
+      end
+      version.gsub(/_/, '.')
+    end
+
+    def set_from_json_hash(hostname, json_hash)
+      tarball_path = json_hash['file']
+
+      if tarball_path =~ /http/
+        # absolute path. use it verbatim.
+        @tarball_uri = tarball_path
+      else
+        # relative path. use the hostname we already have and the path in 'file'
+        # chop off leading slash for relative paths
+        if tarball_path =~ /^\/(.+)$/
+          tarball_path = $1
+        end
+
+        @tarball_uri = "http://#{hostname}/#{tarball_path}"
+      end
+
+      #created_at = Date.parse json_hash['created_at']
+      #updated_at = Date.parse json_hash['updated_at']
+      #average_rating = json_hash['average_rating']
+      #license = json_hash['license']
+    end
+
+  end
+
+  class RemoteCookbook
+    attr_accessor :uri, :maintainer, :name, :description
+    attr_accessor :deprecated
+    attr_accessor :versions, :latest_version
+
+    def initialize(params = {})
+      @uri = params[:uri]
+      @maintainer = params[:maintainer]
+      @name = params[:name]
+      @description = params[:description]
+
+      @versions = Array.new
+    end
+
+    # these kind of responses come back from 'search' and 'list'
+    def self.from_json_list(json_hash)
+      res = new
+
+      res.uri = json_hash['cookbook']
+      res.maintainer = json_hash['cookbook_maintainer']
+      res.name = json_hash['cookbook_name']
+      res.description = json_hash['cookbook_description']
+
+      res
+    end
+
+    # this type of response comes back from directly looking up a cookbook
+    def self.from_json_details(uri, json_hash)
+      unless json_hash.kind_of?(Hash)
+        raise "from_json_show needs a hash"
+      end
+
+      res = new
+
+      res.uri = uri
+      res.name = json_hash['name']
+      res.maintainer = json_hash['maintainer']
+      res.description = json_hash['description']
+      res.deprecated = json_hash['deprecated'] == 'true'
+      # res.external_url = json_hash['external_url']
+      # res.category = json_hash['category']
+      # res.average_rating = json_hash['average_rating']
+      # res.created_at = Date.parse json_hash['created_at']
+      # res.updated_at = Date.parse json_hash['updated_at']
+
+      versions = json_hash['versions']
+      if (!versions.nil?) && (versions.kind_of? Array)
+        versions.each do |ver|
+          res.versions.push(RemoteCookbookVersion.new ver)
+        end
+        res.latest_version = res.find_version_by_uri json_hash['latest_version']
+      end
+
+      res
+    end
+
+    def find_version_by_uri(uri)
+      @versions.find { |ver| ver.uri == uri }
+    end
+
+    def find_version_by_user_version(version)
+      @versions.find { |ver| ver.version == version }
+    end
+
+    def to_s
+      "RemoteCookbook #{@name}: description '#{@description}', maint #{@maintainer}, uri #{@uri}"
+    end
+
+  end
+  
+end

data/lib/chef/streaming_cookbook_uploader.rb

@@ -0,0 +1,177 @@
+require 'rubygems'
+require 'net/http'
+require 'mixlib/authentication/signedheaderauth'
+require 'openssl'
+
+# inspired by/cargo-culted from http://stanislavvitvitskiy.blogspot.com/2008/12/multipart-post-in-ruby.html
+module Chef
+  class StreamingCookbookUploader
+    DefaultHeaders = { 'accept' => 'application/json' }
+
+    def post(to_url, user_id, secret_key_filename, params = {}, headers = {})
+      make_request(:post, to_url, user_id, secret_key_filename, params, headers)
+    end
+
+    def put(to_url, user_id, secret_key_filename, params = {}, headers = {})
+      make_request(:put, to_url, user_id, secret_key_filename, params, headers)
+    end
+
+    def make_request(http_verb, to_url, user_id, secret_key_filename, params = {}, headers = {})
+      boundary = '----RubyMultipartClient' + rand(1000000).to_s + 'ZZZZZ'
+      parts = []
+      content_file = nil
+      content_body = nil
+
+      timestamp = Time.now.utc.iso8601
+      secret_key = OpenSSL::PKey::RSA.new(File.read(secret_key_filename))
+
+      unless params.nil? || params.empty?
+        params.each do |key, value|
+          if value.kind_of?(File)
+            content_file = value
+            filepath = value.path
+            filename = File.basename(filepath)
+            parts << StringPart.new( "--" + boundary + "\r\n" +
+            "Content-Disposition: form-data; name=\"" + key.to_s + "\"; filename=\"" + filename + "\"\r\n" +
+            "Content-Type: application/octet-stream\r\n\r\n")
+            parts << StreamPart.new(value, File.size(filepath))
+            parts << StringPart.new("\r\n")
+          else
+            content_body = value.to_s
+            parts << StringPart.new( "--" + boundary + "\r\n" +
+            "Content-Disposition: form-data; name=\"" + key.to_s + "\"\r\n\r\n")
+            parts << StringPart.new(content_body + "\r\n")
+          end
+        end
+        parts << StringPart.new("--" + boundary + "--\r\n")
+      end
+
+      body_stream = MultipartStream.new(parts)
+
+      timestamp = Time.now.utc.iso8601
+
+      signing_options = {
+        :http_method=>http_verb,
+        :user_id=>user_id,
+        :timestamp=>timestamp
+      }
+      (content_file && signing_options[:file] = content_file) || (signing_options[:body] = (content_body || ""))
+
+      headers.merge!(Mixlib::Authentication::SignedHeaderAuth.signing_object(signing_options).sign(secret_key))
+
+      content_file.rewind if content_file
+
+      # net/http doesn't like symbols for header keys, so we'll to_s each one just in case
+      headers = DefaultHeaders.merge(Hash[*headers.map{ |k,v| [k.to_s, v] }.flatten])
+
+      url = URI.parse(to_url)
+      req = case http_verb
+      when :put
+        Net::HTTP::Put.new(url.path, headers)
+      when :post
+        Net::HTTP::Post.new(url.path, headers)
+      end              
+      req.content_length = body_stream.size
+      req.content_type = 'multipart/form-data; boundary=' + boundary unless parts.empty?
+      req.body_stream = body_stream
+
+      http = Net::HTTP.new(url.host, url.port)
+      if url.scheme == "https"
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      res = http.request(req)
+      #res = http.start {|http_proc| http_proc.request(req) }
+
+      # alias status to code and to_s to body for test purposes
+      # TODO: stop the following madness!
+      class << res
+        alias :to_s :body
+
+        # BUGBUG this makes the response compatible with what respsonse_steps expects to test headers (response.headers[] -> response[])
+        def headers
+          self
+        end
+
+        def status
+          code.to_i
+        end
+      end
+      res
+    end
+  end
+
+  class StreamPart
+    def initialize(stream, size)
+      @stream, @size = stream, size
+    end
+
+    def size
+      @size
+    end
+
+    # read the specified amount from the stream
+    def read(offset, how_much)
+      @stream.read(how_much)
+    end
+  end
+
+  class StringPart
+    def initialize(str)
+      @str = str
+    end
+
+    def size
+      @str.length
+    end
+
+    # read the specified amount from the string startiung at the offset
+    def read(offset, how_much)
+      @str[offset, how_much]
+    end
+  end
+
+  class MultipartStream
+    def initialize(parts)
+      @parts = parts
+      @part_no = 0
+      @part_offset = 0
+    end
+
+    def size
+      @parts.inject(0) {|size, part| size + part.size}
+    end
+
+    def read(how_much)
+      return nil if @part_no >= @parts.size
+
+      how_much_current_part = @parts[@part_no].size - @part_offset
+
+      how_much_current_part = if how_much_current_part > how_much
+        how_much
+      else
+        how_much_current_part
+      end
+
+      how_much_next_part = how_much - how_much_current_part
+
+      current_part = @parts[@part_no].read(@part_offset, how_much_current_part)
+
+      # recurse into the next part if the current one was not large enough
+      if how_much_next_part > 0
+        @part_no += 1
+        @part_offset = 0
+        next_part = read(how_much_next_part)
+        current_part + if next_part
+          next_part
+        else
+          ''
+        end
+      else
+        @part_offset += how_much_current_part
+        current_part
+      end
+    end
+  end
+
+end