cfoundry 0.4.21 → 0.5.0

data/Rakefile

@@ -1,41 +1,64 @@
 require "rake"
+require "rspec/core/rake_task"
 
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "cfoundry/version"
 
-task :default => "spec"
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
 
-desc "Run specs"
-task "spec" => ["bundler:install", "test:spec"]
+namespace :deploy do
+  def last_staging_sha
+    `git rev-parse latest-staging`.strip
+  end
 
-task :build do
-  sh "gem build cfoundry.gemspec"
-end
+  def last_release_sha
+    `git rev-parse latest-release`.strip
+  end
 
-task :install => :build do
-  sh "gem install --local cfoundry-#{CFoundry::VERSION}"
-  sh "rm cfoundry-#{CFoundry::VERSION}.gem"
-end
+  def last_staging_ref_was_released?
+    last_staging_sha == last_release_sha
+  end
 
-task :uninstall do
-  sh "gem uninstall cfoundry"
+  task :staging, :version do |_, args|
+    sh "gem bump --push #{"--version #{args.version}" if args.version}" if last_staging_ref_was_released?
+    sh "git tag -f latest-staging"
+    sh "git push origin :latest-staging"
+    sh "git push origin latest-staging"
+  end
+
+  task :gem do
+    sh "git fetch"
+    sh "git checkout #{last_staging_sha}"
+    sh "gem release --tag"
+    sh "git tag -f latest-release"
+    sh "git push origin :latest-release"
+    sh "git push origin latest-release"
+  end
 end
 
-task :reinstall => [:uninstall, :install]
+namespace :release do
+  DEPENDENTS = %w[
+    vmc/vmc.gemspec
+    vmc-plugins/admin/admin-vmc-plugin.gemspec
+    vmc-plugins/console/console-vmc-plugin.gemspec
+    vmc-plugins/manifests/manifests-vmc-plugin.gemspec
+    vmc-plugins/mcf/mcf-vmc-plugin.gemspec
+    vmc-plugins/tunnel/tunnel-vmc-plugin.gemspec
+  ].freeze
 
-task :release => :build do
-  sh "gem push cfoundry-#{CFoundry::VERSION}.gem"
-end
+  def bump_dependent(file, dep, ver)
+    puts "Bumping #{dep} to #{ver} in #{file}"
 
-namespace "bundler" do
-  desc "Install gems"
-  task "install" do
-    sh("bundle install")
+    old = File.read(file)
+    new = old.sub(/(\.add.+#{dep}\D+)[^'"]+(.+)/, "\\1#{ver}\\2")
+
+    File.open(file, "w") { |io| io.print new }
   end
-end
 
-namespace "test" do
-  task "spec" do |t|
-    sh("bundle exec rspec")
+  task :bump_dependents do
+    DEPENDENTS.each do |dep|
+      bump_dependent(File.expand_path("../../#{dep}", __FILE__), "cfoundry", CFoundry::VERSION)
+    end
   end
 end

data/lib/cfoundry/auth_token.rb

@@ -0,0 +1,48 @@
+module CFoundry
+  class AuthToken
+    class << self
+      def from_uaa_token_info(token_info)
+        new(
+          token_info.auth_header,
+          token_info.info[:refresh_token]
+        )
+      end
+
+      def from_hash(hash)
+        new(
+          hash[:token],
+          hash[:refresh_token]
+        )
+      end
+    end
+
+    def initialize(auth_header, refresh_token = nil)
+      @auth_header = auth_header
+      @refresh_token = refresh_token
+    end
+
+    attr_reader :auth_header
+
+    def to_hash
+      {
+        :token => auth_header,
+        :refresh_token => @refresh_token
+      }
+    end
+
+    JSON_HASH = /\{.*?\}/.freeze
+
+    # TODO: rename to #data
+    def token_data
+      return @token_data if @token_data
+
+      json_hashes = Base64.decode64(@auth_header.split(" ", 2).last)
+      data_json = json_hashes.sub(JSON_HASH, "")[JSON_HASH]
+      return {} unless data_json
+
+      @token_data = MultiJson.load data_json, :symbolize_keys => true
+    rescue MultiJson::DecodeError
+      {}
+    end
+  end
+end

data/lib/cfoundry/baseclient.rb

@@ -3,335 +3,154 @@ require "net/https"
 require "net/http/post/multipart"
 require "multi_json"
 require "fileutils"
-require "base64"
+require "forwardable"
 
 module CFoundry
   class BaseClient # :nodoc:
-    include CFoundry::TraceHelpers
+    extend Forwardable
 
-    LOG_LENGTH = 10
+    attr_reader :rest_client
 
-    attr_reader :target
+    def_delegators :rest_client, :target, :target=, :token,
+      :proxy, :proxy=, :trace, :backtrace, :backtrace=,
+      :log, :log=
 
-    attr_accessor :trace, :backtrace, :log
-
-    def initialize(target, token = nil)
-      @target = target
-      @token = token
-      @trace = false
-      @backtrace = false
-      @log = false
-    end
-
-    # grab the metadata from a token that looks like:
-    #
-    # bearer (base64 ...)
-    def token_data
-      return {} unless @token
-
-      tok = Base64.decode64(@token.sub(/^bearer\s+/, ""))
-      tok.sub!(/\{.+?\}/, "") # clear algo
-      MultiJson.load(tok[/\{.+?\}/], :symbolize_keys => true)
-
-    # can't expect all tokens to be the proper format
-    rescue MultiJson::DecodeError
-      {}
-    end
-
-    def request_path(method, path, options = {})
-      path = url(path) if path.is_a?(Array)
-
-      request(method, path, options)
-    end
-
-    def request(method, path, options = {})
-      request_uri(URI.parse(@target + path), method, options)
+    def initialize(target = "https://api.cloudfoundry.com", token = nil)
+      @rest_client = CFoundry::RestClient.new(target, token)
+      self.trace = false
+      self.backtrace = false
+      self.log = false
     end
 
-    def request_uri(uri, method, options = {})
-      uri = URI.parse(@target + uri.to_s) unless uri.host
-
-      # keep original options in case there's a redirect to follow
-      original_options = options.dup
-
-      accept = options.delete(:accept)
-      content = options.delete(:content)
-      payload = options.delete(:payload)
-      params = options.delete(:params)
-      return_headers = options.delete(:return_headers)
-      return_response = options.delete(:return_response)
-
-      headers = {}
-      headers["Authorization"] = @token if @token
-      headers["Proxy-User"] = @proxy if @proxy
-
-      if accept_type = mimetype(accept)
-        headers["Accept"] = accept_type
-      end
-
-      if content_type = mimetype(content)
-        headers["Content-Type"] = content_type
-      end
-
-      unless payload.is_a?(String)
-        case content
-        when :json
-          payload = MultiJson.dump(payload)
-        when :form
-          payload = encode_params(payload)
-        end
-      end
-
-      if payload.is_a?(String)
-        headers["Content-Length"] = payload.size
-      elsif !payload
-        headers["Content-Length"] = 0
+    def uaa
+      @uaa ||= begin
+        endpoint = info[:authorization_endpoint]
+        uaa = CFoundry::UAAClient.new(endpoint)
+        uaa.trace = trace
+        uaa.token = token
+        uaa
       end
+    end
 
-      headers.merge!(options[:headers]) if options[:headers]
-
-      if params
-        if uri.query
-          uri.query += "&" + encode_params(params)
-        else
-          uri.query = encode_params(params)
-        end
-      end
-
-      if payload && payload.is_a?(Hash)
-        multipart = method.const_get(:Multipart)
-        request = multipart.new(uri.request_uri, payload)
-      else
-        request = method.new(uri.request_uri)
-        request.body = payload if payload
-      end
-
-      request["Authorization"] = @token if @token
-      request["Proxy-User"] = @proxy if @proxy
-
-      headers.each do |k, v|
-        request[k] = v
-      end
-
-      # TODO: test http proxies
-      http = Net::HTTP.new(uri.host, uri.port)
-
-      if uri.is_a?(URI::HTTPS)
-        http.use_ssl = true
-        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    def token=(token)
+      if token.is_a?(String)
+        token = CFoundry::AuthToken.new(token)
       end
 
-      print_request(request) if @trace
-
-      before = Time.now
-      http.start do
-        response = http.request(request)
-        time = Time.now - before
-
-        print_response(response) if @trace
-        print_backtrace(caller) if @trace
-
-        log_request(time, request, response)
-
-        if return_headers
-          sane_headers(response)
-        elsif return_response
-          response
-        elsif response.is_a?(Net::HTTPRedirection)
-          request_uri(
-            URI.parse(response["location"]),
-            Net::HTTP::Get,
-            original_options)
-        else
-          handle_response(response, accept, request)
-        end
-      end
-    rescue ::Timeout::Error => e
-      raise Timeout.new(method, uri, e)
-    rescue SocketError, Errno::ECONNREFUSED => e
-      raise TargetRefused, e.message
+      @rest_client.token = token
+      @uaa.token = token if @uaa
     end
 
-    private
-
-    def parse_json(x)
-      if x.empty?
-        raise MultiJson::DecodeError.new("Empty JSON string", [], "")
-      else
-        MultiJson.load(x, :symbolize_keys => true)
-      end
+    def trace=(trace)
+      @rest_client.trace = trace
+      @uaa.trace = trace if @uaa
     end
 
-    def mimetype(content)
-      case content
-      when String
-        content
-      when :json
-        "application/json"
-      when :form
-        "application/x-www-form-urlencoded"
-      when nil
-        nil
-      # return request headers (not really Accept)
-      else
-        raise CFoundry::Error, "Unknown mimetype '#{content.inspect}'"
-      end
+    # Cloud metadata
+    def info
+      get("info", :accept => :json)
     end
 
-    def encode_params(hash, escape = true)
-      hash.keys.map do |k|
-        v = hash[k]
-        v = MultiJson.dump(v) if v.is_a?(Hash)
-        v = URI.escape(v.to_s, /[^#{URI::PATTERN::UNRESERVED}]/) if escape
-        "#{k}=#{v}"
-      end.join("&")
+    def get(*args)
+      request("GET", *args)
     end
 
-    def request_with_options(method, path, options = {})
-      options.merge!(path.pop) if path.last.is_a?(Hash)
-
-      request_path(method, url(path), options)
+    def delete(*args)
+      request("DELETE", *args)
     end
 
-    def get(*path)
-      request_with_options(Net::HTTP::Get, path)
+    def post(*args)
+      request("POST", *args)
     end
 
-    def delete(*path)
-      request_with_options(Net::HTTP::Delete, path)
+    def put(*args)
+      request("PUT", *args)
     end
 
-    def post(payload, *path)
-      request_with_options(Net::HTTP::Post, path, :payload => payload)
+    def request(method, *args)
+      path, options = normalize_arguments(args)
+      request, response = request_raw(method, path, options)
+      handle_response(response, options, request)
     end
 
-    def put(payload, *path)
-      request_with_options(Net::HTTP::Put, path, :payload => payload)
+    def request_raw(method, path, options)
+      @rest_client.request(method, path, options)
     end
 
-    def url(segments)
-      "/#{safe_path(segments)}"
-    end
+    private
 
-    def safe_path(*segments)
-      segments.flatten.collect { |x|
-        URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
-      }.join("/")
+    def status_is_successful?(code)
+      (code >= 200) && (code < 400)
     end
 
-    def log_data(time, request, response)
-      { :time => time,
-        :request => {
-          :method => request.method,
-          :url => request.path,
-          :headers => sane_headers(request)
-        },
-        :response => {
-          :code => response.code,
-          :headers => sane_headers(response)
-        }
-      }
+    def handle_response(response, options, request)
+      if status_is_successful?(response[:status].to_i)
+        handle_successful_response(response, options)
+      else
+        handle_error_response(response, request)
+      end
     end
 
-    def log_line(io, data)
-      io.printf(
-        "[%s]  %0.3fs  %6s -> %d  %s\n",
-        Time.now.strftime("%F %T"),
-        data[:time],
-        data[:request][:method].to_s.upcase,
-        data[:response][:code],
-        data[:request][:url])
+    def handle_successful_response(response, options)
+      if options[:return_response]
+        response
+      elsif options[:accept] == :json
+        parse_json(response[:body])
+      else
+        response[:body]
+      end
     end
 
-    def log_request(time, request, response)
-      return unless @log
-
-      data = log_data(time, request, response)
-
-      case @log
-      when IO
-        log_line(@log, data)
-        return
-      when String
-        if File.exists?(@log)
-          log = File.readlines(@log).last(LOG_LENGTH - 1)
-        elsif !File.exists?(File.dirname(@log))
-          FileUtils.mkdir_p(File.dirname(@log))
-        end
+    def handle_error_response(response, request)
+      body_json = parse_json(response[:body])
+      body_code = body_json && body_json[:code]
+      code = body_code || response[:status].to_i
 
-        File.open(@log, "w") do |io|
-          log.each { |l| io.print l } if log
-          log_line(io, data)
-        end
-
-        return
-      end
-
-      if @log.respond_to?(:call)
-        @log.call(data)
-        return
+      if body_code
+        error_class = CFoundry::APIError.error_classes[body_code] || CFoundry::APIError
+        raise error_class.new(body_json[:description], body_code, request, response)
       end
 
-      if @log.respond_to?(:<<)
-        @log << data
-        return
+      case code
+        when 404
+          raise CFoundry::NotFound.new(nil, code, request, response)
+        when 403
+          raise CFoundry::Denied.new(nil, code, request, response)
+        else
+          raise CFoundry::BadResponse.new(nil, code, request, response)
       end
     end
 
-    def print_request(request)
-      $stderr.puts ">>>"
-      $stderr.puts request_trace(request)
-    end
-
-    def print_response(response)
-      $stderr.puts response_trace(response)
-      $stderr.puts "<<<"
-    end
-
-    def print_backtrace(locs)
-      return unless @backtrace
-
-      interesting_locs = locs.drop_while { |loc|
-        loc =~ /\/(cfoundry\/|restclient\/|net\/http)/
-      }
-
-      $stderr.puts "--- backtrace:"
-
-      $stderr.puts "... (boring)" unless locs == interesting_locs
-
-      trimmed_locs = interesting_locs[0..5]
-
-      trimmed_locs.each do |loc|
-        $stderr.puts "=== #{loc}"
+    def normalize_arguments(args)
+      if args.last.is_a?(Hash)
+        options = args.pop
+      else
+        options = {}
       end
 
-      $stderr.puts "... (trimmed)" unless trimmed_locs == interesting_locs
+      [normalize_path(args), options]
     end
 
-    def handle_response(response, accept, request)
-      case response
-        when Net::HTTPSuccess, Net::HTTPRedirection
-          accept == :json ? parse_json(response.body) : response.body
-
-        when Net::HTTPNotFound
-          raise CFoundry::NotFound.new(request, response)
-
-        when Net::HTTPForbidden
-          raise CFoundry::Denied.new(request, response)
+    URI_ENCODING_PATTERN = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
 
-        else
-          raise CFoundry::BadResponse.new(request, response)
+    def normalize_path(segments)
+      if segments.size == 1 && segments.first =~ /^\//
+        segments.first
+      else
+        segments.flatten.collect { |x|
+          URI.encode(x.to_s, URI_ENCODING_PATTERN)
+        }.join("/")
       end
     end
 
-    def sane_headers(obj)
-      hds = {}
-
-      obj.each_header do |k, v|
-        hds[k] = v
+    def parse_json(x)
+      if x.empty?
+        raise MultiJson::DecodeError.new("Empty JSON string", [], "")
+      else
+        MultiJson.load(x, :symbolize_keys => true)
       end
-
-      hds
+    rescue MultiJson::DecodeError
+      nil
     end
   end
 end