jfoundry 0.1.0.pre

data/lib/jfoundry/auth_token.rb

@@ -0,0 +1,63 @@
+module JFoundry
+  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_accessor :auth_header
+    attr_reader :refresh_token
+
+    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
+      return {} unless @auth_header
+
+      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
+
+    def auth_header=(auth_header)
+      @token_data = nil
+      @auth_header = auth_header
+    end
+
+    def expiration
+      Time.at(token_data[:exp])
+    end
+
+    def expires_soon?
+      (expiration.to_i - Time.now.to_i) < 60
+    end
+  end
+end

data/lib/jfoundry/baseclient.rb

@@ -0,0 +1,177 @@
+require "jfoundry/trace_helpers"
+require "net/https"
+require "net/http/post/multipart"
+require "multi_json"
+require "fileutils"
+require "forwardable"
+
+module JFoundry
+  class BaseClient # :nodoc:
+    include JFoundry::ProxyOptions
+
+    extend Forwardable
+
+    attr_reader :rest_client
+
+    def_delegators :rest_client, :target, :target=, :access_key, :secret_key, :version, #:token,
+      :trace, :backtrace, :backtrace=, :log, :log=,
+      :http_proxy, :http_proxy=, :https_proxy, :https_proxy=
+
+    def initialize(target, access_key, secret_key, version)
+      @rest_client = JFoundry::RestClient.new(target, access_key, secret_key, version)
+      self.trace = false
+      self.backtrace = false
+      self.log = false
+    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)
+      #puts "args: ", args
+      path, options = normalize_arguments(args)
+      #puts "path: ", path
+      #puts "options: ", options
+      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 stream_url(url, &blk)
+      uri = URI.parse(url)
+
+      opts = {}
+      
+      if uri.scheme == "https"
+        opts[:use_ssl] = true
+        opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE 
+      end
+
+      Net::HTTP.start(uri.host, uri.port, *proxy_options_for(uri), opts) do |http|
+        http.read_timeout = 5
+
+        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 JFoundry::NotFound.new(response.body, 404)
+          when Net::HTTPForbidden
+            raise JFoundry::Denied.new(response.body, 403)
+          when Net::HTTPUnauthorized
+            raise JFoundry::Unauthorized.new(response.body, 401)
+          else
+            raise JFoundry::BadResponse.new(response.body, response.code)
+          end
+        end
+      end
+    end
+
+    private
+
+    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 = JFoundry::APIError.error_classes[body_code] || JFoundry::APIError
+        raise error_class.new(body_json[:description], body_code, request, response)
+      end
+
+      case code
+        when 404
+          raise JFoundry::NotFound.new(nil, code, request, response)
+        when 403
+          raise JFoundry::Denied.new(nil, code, request, response)
+        when 401
+          raise JFoundry::Unauthorized.new(nil, code, request, response)
+        else
+          raise JFoundry::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/jfoundry/chatty_hash.rb

@@ -0,0 +1,46 @@
+module JFoundry
+  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/jfoundry/client.rb

@@ -0,0 +1,39 @@
+require "jfoundry/concerns/proxy_options"
+
+require "jfoundry/baseclient"
+require "jfoundry/rest_client"
+#require "jfoundry/auth_token"
+
+require "jfoundry/v2/app"
+require "jfoundry/v2/service"
+require "jfoundry/v2/service_binding"
+require "jfoundry/v2/managed_service_instance"
+require "jfoundry/v2/user_provided_service_instance"
+require "jfoundry/v2/service_plan"
+#require "jfoundry/v2/service_auth_token"
+require "jfoundry/v2/user"
+require "jfoundry/v2/organization"
+require "jfoundry/v2/space"
+require "jfoundry/v2/domain"
+require "jfoundry/v2/route"
+require "jfoundry/v2/stack"
+require "jfoundry/v2/quota_definition"
+require "jfoundry/v2/app_event"
+require "jfoundry/v2/service_broker"
+
+require "jfoundry/v2/base"
+require "jfoundry/v2/client"
+#require "jfoundry/v2/fake_client"
+
+module JFoundry
+  class Client < BaseClient
+    def self.new(*args)
+      warn "DEPRECATION WARNING: Please use JFoundry::Client.get instead of JFoundry::Client.new"
+      get(*args)
+    end
+
+    def self.get(*args)
+      JFoundry::V2::Client.new(*args).tap { |client| client.info }
+    end
+  end
+end

data/lib/jfoundry/concerns/proxy_options.rb

@@ -0,0 +1,17 @@
+module JFoundry
+  module ProxyOptions
+    def proxy_options_for(uri)
+      ssl = uri.is_a?(URI::HTTPS)
+      proxy_to_use = (ssl ? https_proxy : http_proxy)
+
+      if proxy_to_use.blank?
+        []
+      else
+        proxy_to_use = "proto://#{proxy_to_use}" unless proxy_to_use =~ /:\/\//
+        proxy_uri = URI.parse(proxy_to_use)
+        proxy_user, proxy_password = proxy_uri.userinfo.split(/:/) if proxy_uri.userinfo
+        [proxy_uri.host, proxy_uri.port, proxy_user, proxy_password]
+      end
+    end
+  end
+end

data/lib/jfoundry/errors.rb

@@ -0,0 +1,163 @@
+require "net/https"
+require "multi_json"
+require "yaml"
+
+module JFoundry
+  # Base class for JFoundry 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 Unauthorized < 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