cloulu 0.0.0 → 0.1.1

data/lib/cfoundry/baseclient.rb

@@ -0,0 +1,201 @@
+require "cfoundry/trace_helpers"
+require "net/https"
+require "net/http/post/multipart"
+require "multi_json"
+require "fileutils"
+require "forwardable"
+
+module CFoundry
+  class BaseClient # :nodoc:
+    extend Forwardable
+
+    attr_reader :rest_client
+
+    def_delegators :rest_client, :target, :target=, :token,
+      :proxy, :proxy=, :trace, :backtrace, :backtrace=,
+      :log, :log=
+
+    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 uaa
+      @uaa ||= begin
+        if(endpoint = info[:authorization_endpoint])
+          uaa = CFoundry::UAAClient.new(endpoint)
+          uaa.trace = trace
+          uaa.token = token
+          uaa
+        else
+          nil
+        end
+      end
+    end
+
+    def password_score(password)
+      uaa ? uaa.password_score(password) : :unknown
+    end
+
+    def token=(token)
+      if token.is_a?(String)
+        token = CFoundry::AuthToken.new(token)
+      end
+
+      @rest_client.token = token
+      @uaa.token = token if @uaa
+    end
+
+    def trace=(trace)
+      @rest_client.trace = trace
+      @uaa.trace = trace if @uaa
+    end
+
+    # Cloud metadata
+    def info
+      get("info", :accept => :json)
+    end
+
+    def get(*args)
+      request("GET", *args)
+    end
+
+    def delete(*args)
+      request("DELETE", *args)
+    end
+
+    def post(*args)
+      request("POST", *args)
+    end
+
+    def put(*args)
+      request("PUT", *args)
+    end
+
+    def request(method, *args)
+      if needs_token_refresh?
+        token.auth_header = nil
+        refresh_token!
+      end
+
+      path, options = normalize_arguments(args)
+      request, response = request_raw(method, path, options)
+      handle_response(response, options, request)
+    end
+
+    def request_raw(method, path, options)
+      @rest_client.request(method, path, options)
+    end
+
+    def refresh_token!
+      self.token = uaa.try_to_refresh_token!
+    end
+
+    def stream_url(url, &blk)
+      uri = URI.parse(url)
+
+      Net::HTTP.start(uri.host, uri.port) do |http|
+        http.read_timeout = 10
+
+        req = Net::HTTP::Get.new(uri.request_uri)
+        req["Authorization"] = token.auth_header if token
+
+        http.request(req) do |response|
+          case response
+          when Net::HTTPOK
+            response.read_body(&blk)
+          when Net::HTTPNotFound
+            raise CFoundry::NotFound.new(response.body, 404)
+          when Net::HTTPForbidden
+            raise CFoundry::Denied.new(response.body, 403)
+          else
+            raise CFoundry::BadResponse.new(response.body, response.code)
+          end
+        end
+      end
+    end
+
+    private
+
+    def needs_token_refresh?
+      token && token.auth_header && token.refresh_token && \
+        token.expires_soon?
+    end
+
+    def status_is_successful?(code)
+      (code >= 200) && (code < 400)
+    end
+
+    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 handle_successful_response(response, options)
+      if options[:return_response]
+        response
+      elsif options[:accept] == :json
+        parse_json(response[:body])
+      else
+        response[:body]
+      end
+    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
+
+      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
+
+      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 normalize_arguments(args)
+      if args.last.is_a?(Hash)
+        options = args.pop
+      else
+        options = {}
+      end
+
+      [normalize_path(args), options]
+    end
+
+    URI_ENCODING_PATTERN = Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+
+    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 parse_json(x)
+      if x.empty?
+        raise MultiJson::DecodeError.new("Empty JSON string", [], "")
+      else
+        MultiJson.load(x, :symbolize_keys => true)
+      end
+    rescue MultiJson::DecodeError
+      nil
+    end
+  end
+end

data/lib/cfoundry/chatty_hash.rb

@@ -0,0 +1,46 @@
+module CFoundry
+  class ChattyHash
+    include Enumerable
+
+    def initialize(callback, hash = {})
+      @callback = callback
+      @hash = hash
+    end
+
+    def [](name)
+      @hash[name]
+    end
+
+    def []=(name, value)
+      @hash[name] = value
+      @callback.call(self)
+      value
+    end
+
+    def each(&blk)
+      @hash.each(&blk)
+    end
+
+    def delete(key)
+      value = @hash.delete(key)
+      @callback.call(self)
+      value
+    end
+
+    def to_json(*args)
+      @hash.to_json(*args)
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def to_s
+      @hash.to_s
+    end
+
+    def inspect
+      @hash.inspect
+    end
+  end
+end

data/lib/cfoundry/client.rb

@@ -0,0 +1,46 @@
+require "cfoundry/baseclient"
+require "cfoundry/rest_client"
+require "cfoundry/auth_token"
+
+require "cfoundry/v1/app"
+require "cfoundry/v1/framework"
+require "cfoundry/v1/runtime"
+require "cfoundry/v1/service"
+require "cfoundry/v1/service_plan"
+require "cfoundry/v1/service_instance"
+require "cfoundry/v1/user"
+require "cfoundry/v1/base"
+require "cfoundry/v1/client"
+
+require "cfoundry/v2/app"
+require "cfoundry/v2/framework"
+require "cfoundry/v2/runtime"
+require "cfoundry/v2/service"
+require "cfoundry/v2/service_binding"
+require "cfoundry/v2/service_instance"
+require "cfoundry/v2/service_plan"
+require "cfoundry/v2/service_auth_token"
+require "cfoundry/v2/user"
+require "cfoundry/v2/organization"
+require "cfoundry/v2/space"
+require "cfoundry/v2/domain"
+require "cfoundry/v2/route"
+require "cfoundry/v2/base"
+require "cfoundry/v2/client"
+
+module CFoundry
+  class Client < BaseClient
+    def self.new(*args)
+      target, _ = args
+
+      base = super(target)
+
+      case base.info[:version]
+      when 2
+        CFoundry::V2::Client.new(*args)
+      else
+        CFoundry::V1::Client.new(*args)
+      end
+    end
+  end
+end

data/lib/cfoundry/concerns/login_helpers.rb

@@ -0,0 +1,13 @@
+require "base64"
+
+module CFoundry
+  module LoginHelpers
+    def login_prompts
+      @base.uaa.prompts
+    end
+
+    def login(username, password)
+      @base.token = AuthToken.from_uaa_token_info(@base.uaa.authorize(username, password))
+    end
+  end
+end

data/lib/cfoundry/errors.rb

@@ -0,0 +1,160 @@
+require "net/https"
+require "multi_json"
+require "yaml"
+
+module CFoundry
+  # Base class for CFoundry errors (not from the server).
+  class Error < RuntimeError
+  end
+
+  class Deprecated < Error
+  end
+
+  class Mismatch < Error
+    def initialize(expected, got)
+      @expected = expected
+      @got = got
+    end
+
+    def to_s
+      "Invalid value type; expected #{@expected.inspect}, got #{@got.inspect}"
+    end
+  end
+
+  class InvalidTarget < Error
+    attr_reader :target
+
+    def initialize(target)
+      @target = target
+    end
+
+    def to_s
+      "Invalid target URI: #{@target}"
+    end
+  end
+
+  class TargetRefused < Error
+    # Error message.
+    attr_reader :message
+
+    # Message varies as this represents various network errors.
+    def initialize(message)
+      @message = message
+    end
+
+    # Exception message.
+    def to_s
+      "target refused connection (#@message)"
+    end
+  end
+
+  class Timeout < Timeout::Error
+    attr_reader :method, :uri, :parent
+
+    def initialize(method, uri, parent = nil)
+      @method = method
+      @uri = uri
+      @parent = parent
+      super(to_s)
+    end
+
+    def to_s
+      "#{method} #{uri} timed out"
+    end
+  end
+
+  # Exception representing errors returned by the API.
+  class APIError < RuntimeError
+    include TraceHelpers
+
+    class << self
+      def error_classes
+        @error_classes ||= {}
+      end
+    end
+
+    attr_reader :error_code, :description, :request, :response
+
+    # Create an APIError with a given request and response.
+    def initialize(description = nil, error_code = nil, request = nil, response = nil)
+      @response = response
+      @request = request
+      @error_code = error_code || (response ? response[:status] : nil)
+      @description = description || parse_description
+    end
+
+    # Exception message.
+    def to_s
+      "#{error_code}: #{description}"
+    end
+
+    def request_trace
+      super(request)
+    end
+
+    def response_trace
+      super(response)
+    end
+
+    private
+
+    def parse_description
+      return unless response
+
+      parse_json(response[:body])[:description]
+    rescue MultiJson::DecodeError
+      response[:body]
+    end
+
+    def parse_json(x)
+      if x.empty?
+        raise MultiJson::DecodeError.new("Empty JSON string", [], "")
+      else
+        MultiJson.load(x, :symbolize_keys => true)
+      end
+    end
+  end
+
+  class NotFound < APIError
+  end
+
+  class Denied < APIError
+  end
+
+  class BadResponse < APIError
+  end
+
+  class UAAError < APIError
+  end
+
+  def self.define_error(class_name, code)
+    base =
+      case class_name
+      when /NotFound$/
+        NotFound
+      else
+        APIError
+      end
+
+    klass =
+      if const_defined?(class_name)
+        const_get(class_name)
+      else
+        Class.new(base)
+      end
+
+    APIError.error_classes[code] = klass
+
+    unless const_defined?(class_name)
+      const_set(class_name, klass)
+    end
+  end
+
+  VENDOR_DIR = File.expand_path("../../../vendor", __FILE__)
+
+  %w{errors/v1.yml errors/v2.yml}.each do |errors|
+    YAML.load_file("#{VENDOR_DIR}/#{errors}").each do |code, meta|
+      define_error(meta["name"], code)
+    end
+  end
+end