cfoundry 0.2.2 → 0.3.0

data/Rakefile

@@ -1,11 +1,31 @@
-require 'rake'
-require "bundler/gem_tasks"
+require "rake"
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require "cfoundry/version"
 
 task :default => "spec"
 
 desc "Run specs"
 task "spec" => ["bundler:install", "test:spec"]
 
+task :build do
+  sh "gem build cfoundry.gemspec"
+end
+
+task :install => :build do
+  sh "gem install --local cfoundry-#{CFoundry::VERSION}"
+end
+
+task :uninstall do
+  sh "gem uninstall cfoundry"
+end
+
+task :reinstall => [:uninstall, :install]
+
+task :release => :build do
+  sh "gem push cfoundry-#{CFoundry::VERSION}.gem"
+end
+
 namespace "bundler" do
   desc "Install gems"
   task "install" do

data/lib/cfoundry/baseclient.rb

@@ -0,0 +1,206 @@
+require "restclient"
+require "json"
+
+module CFoundry
+  class BaseClient # :nodoc:
+    def initialize(target, token = nil)
+      @target = target
+      @token = token
+    end
+
+    def request_path(method, path, types = {}, options = {})
+      path = url(path) if path.is_a?(Array)
+
+      unless types.empty?
+        if params = types.delete(:params)
+          options[:params] = params
+        end
+
+        if types.size > 1
+          raise "request types must contain only one Content-Type => Accept"
+        end
+
+        options[:type] = types.keys.first
+        options[:accept] = types.values.first
+      end
+
+      request(method, path, options)
+    end
+
+    private
+
+    def parse_json(x)
+      JSON.parse(x, :symbolize_names => true)
+    end
+
+    def request(method, path, options = {})
+      accept = options.delete(:accept)
+      type = options.delete(:type)
+      payload = options.delete(:payload)
+      params = options.delete(:params)
+
+      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(type)
+        headers["Content-Type"] = content_type
+      end
+
+      unless payload.is_a?(String)
+        case type
+        when :json
+          payload = payload.to_json
+        when :form
+          payload = encode_params(payload, false)
+        end
+      end
+
+      headers["Content-Length"] = payload ? payload.size : 0
+
+      headers.merge!(options[:headers]) if options[:headers]
+
+      if params
+        path += "?" + encode_params(params)
+      end
+
+      req = options.dup
+      req[:method] = method
+      req[:url] = @target + path
+      req[:headers] = headers
+      req[:payload] = payload
+
+      json = accept == :json
+
+      RestClient::Request.execute(req) do |response, request|
+        if @trace
+          puts '>>>'
+          puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
+          puts "REQUEST: #{req[:method]} #{req[:url]}"
+          puts "RESPONSE_HEADERS:"
+          response.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+          end
+          puts "REQUEST_HEADERS:"
+          request.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+          end
+          puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
+          puts "RESPONSE: [#{response.code}]"
+          begin
+            puts JSON.pretty_generate(JSON.parse(response.body))
+          rescue
+            puts "#{response.body}"
+          end
+          puts '<<<'
+        end
+
+        handle_response(response, accept)
+      end
+    rescue SocketError, Errno::ECONNREFUSED => e
+      raise TargetRefused, e.message
+    end
+
+    def mimetype(type)
+      case type
+      when String
+        type
+      when :json
+        "application/json"
+      when :form
+        "application/x-www-form-urlencoded"
+      when nil
+        nil
+      # return request headers (not really Accept)
+      when :headers
+        nil
+      else
+        raise "unknown mimetype #{type.inspect}"
+      end
+    end
+
+    def encode_params(hash, escape = true)
+      hash.keys.map do |k|
+        v = hash[k]
+
+        value =
+          if v.is_a?(Hash)
+            v.to_json
+          elsif escape
+            URI.escape(v.to_s, /[^#{URI::PATTERN::UNRESERVED}]/)
+          else
+            v
+          end
+
+        "#{k}=#{value}"
+      end.join("&")
+    end
+
+    def request_with_types(method, path, options = {})
+      if path.last.is_a?(Hash)
+        types = path.pop
+      end
+
+      request_path(method, url(path), types || {}, options)
+    end
+
+    def get(*path)
+      request_with_types(:get, path)
+    end
+
+    def delete(*path)
+      request_with_types(:delete, path)
+    end
+
+    def post(payload, *path)
+      request_with_types(:post, path, :payload => payload)
+    end
+
+    def put(payload, *path)
+      request_with_types(:put, path, :payload => payload)
+    end
+
+    def url(segments)
+      "/#{safe_path(segments)}"
+    end
+
+    def safe_path(*segments)
+      segments.flatten.collect { |x|
+        URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+      }.join("/")
+    end
+
+    private
+
+    def handle_response(response, accept)
+      json = accept == :json
+
+      case response.code
+      when 200, 201, 204, 302
+        if accept == :headers
+          return response.headers
+        end
+
+        if json
+          if response.code == 204
+            raise "Expected JSON response, got 204 No Content"
+          end
+
+          parse_json(response)
+        else
+          response
+        end
+
+      when 404
+        raise CFoundry::NotFound
+
+      else
+        raise CFoundry::BadResponse.new(response.code, response)
+      end
+    end
+  end
+end

data/lib/cfoundry/client.rb

@@ -1,155 +1,25 @@
-require "cfoundry/restclient"
-require "cfoundry/app"
-require "cfoundry/service"
-require "cfoundry/user"
+require "cfoundry/baseclient"
 
+require "cfoundry/v1/client"
+require "cfoundry/v2/client"
 
 module CFoundry
-  # The primary API entrypoint. Wraps RESTClient to provide nicer return
-  # values. Initialize with the target and, optionally, an auth token. These
-  # are the only two internal states.
-  class Client
-    # Internal RESTClient instance. Normally won't be touching this.
-    attr_reader :rest
+  class Client < BaseClient
+    def self.new(*args)
+      target, _ = args
 
-    # Create a new Client for interfacing with the given target.
-    #
-    # A token may also be provided to skip the login step.
-    def initialize(target = "http://api.cloudfoundry.com", token = nil)
-      @rest = RESTClient.new(target, token)
-    end
-
-    # The current target URL of the client.
-    def target
-      @rest.target
-    end
-
-    # Current proxy user. Usually nil.
-    def proxy
-      @rest.proxy
-    end
-
-    # Set the proxy user for the client. Must be authorized as an
-    # administrator for this to have any effect.
-    def proxy=(email)
-      @rest.proxy = email
-    end
-
-    # Is the client tracing API requests?
-    def trace
-      @rest.trace
-    end
-
-    # Set the tracing flag; if true, API requests and responses will be
-    # printed out.
-    def trace=(bool)
-      @rest.trace = bool
-    end
-
-
-    # Retrieve target metadata.
-    def info
-      @rest.info
-    end
-
-    # Retrieve available services. Returned as a Hash from vendor => metadata.
-    def system_services
-      services = {}
-
-      @rest.system_services.each do |type, vendors|
-        vendors.each do |vendor, versions|
-          services[vendor] =
-            { :type => type,
-              :versions => versions.keys,
-              :description => versions.values[0]["description"],
-              :vendor => vendor
-            }
-        end
-      end
-
-      services
-    end
-
-    # Retrieve available runtimes.
-    def system_runtimes
-      @rest.system_runtimes
-    end
+      base = super(target)
 
-
-    # Retrieve user list. Admin-only.
-    def users
-      @rest.users.collect do |json|
-        CFoundry::User.new(
-          json["email"],
-          self,
-          { "email" => json["email"],
-            "admin" => json["admin"] })
-      end
-    end
-
-    # Construct a User object. The return value is lazy, and no requests are
-    # made from this alone.
-    #
-    # This should be used for both user creation (after calling User#create!)
-    # and retrieval.
-    def user(email)
-      CFoundry::User.new(email, self)
-    end
-
-    # Create a user on the target and return a User object representing them.
-    def register(email, password)
-      @rest.create_user(:email => email, :password => password)
-      user(email)
-    end
-
-    # Authenticate with the target. Sets the client token.
-    def login(email, password)
-      @rest.token =
-        @rest.create_token({ :password => password }, email)["token"]
-    end
-
-    # Clear client token. No requests are made for this.
-    def logout
-      @rest.token = nil
-    end
-
-    # Is an authentication token set on the client?
-    def logged_in?
-      !!@rest.token
-    end
-
-
-    # Retreive all of the current user's applications.
-    def apps
-      @rest.apps.collect do |json|
-        CFoundry::App.new(json["name"], self, json)
+      case base.info[:version]
+      when 2
+        CFoundry::V2::Client.new(*args)
+      else
+        CFoundry::V1::Client.new(*args)
       end
     end
 
-    # Construct an App object. The return value is lazy, and no requests are
-    # made from this method alone.
-    #
-    # This should be used for both app creation (after calling App#create!)
-    # and retrieval.
-    def app(name)
-      CFoundry::App.new(name, self)
-    end
-
-
-    # Retrieve all of the current user's services.
-    def services
-      @rest.services.collect do |json|
-        CFoundry::Service.new(json["name"], self, json)
-      end
-    end
-
-    # Construct a Service object. The return value is lazy, and no requests are
-    # made from this method alone.
-    #
-    # This should be used for both service creation (after calling
-    # Service#create!) and retrieval.
-    def service(name)
-      CFoundry::Service.new(name, self)
+    def info
+      get("info", nil => :json)
     end
   end
 end

data/lib/cfoundry/uaaclient.rb

@@ -0,0 +1,103 @@
+require "cfoundry/baseclient"
+
+module CFoundry
+  class UAAClient < BaseClient
+    attr_accessor :target, :client_id, :scope, :redirect_uri, :token, :trace
+
+    def initialize(
+        target = "https://uaa.cloudfoundry.com",
+        client_id = "vmc")
+      @target = target
+      @client_id = client_id
+      @scope = ["read"]
+      @redirect_uri = "http://uaa.cloudfoundry.com/redirect/vmc"
+    end
+
+    def prompts
+      get("login", nil => :json)[:prompts]
+    end
+
+    def authorize(credentials)
+      query = {
+        :client_id => @client_id,
+        :scope => Array(@scope).join(" "),
+        :response_type => "token",
+        :redirect_uri => @redirect_uri
+      }
+
+      extract_token(
+        post(
+          { :credentials => credentials },
+          "oauth", "authorize",
+          :form => :headers,
+          :params => query)[:location])
+    end
+
+    def users
+      get("Users", nil => :json)
+    end
+
+    private
+
+    def handle_response(response, accept)
+      json = accept == :json
+
+      case response.code
+      when 200, 204, 302
+        if accept == :headers
+          return response.headers
+        end
+
+        if json
+          if response.code == 204
+            raise "Expected JSON response, got 204 No Content"
+          end
+
+          parse_json(response)
+        else
+          response
+        end
+
+      when 400, 403
+        info = parse_json(response)
+        raise Denied.new(403, info[:error_description])
+
+      when 401
+        info = parse_json(response)
+        raise Denied.new(401, info[:error_description])
+
+      when 404
+        raise NotFound
+
+      when 409
+        info = parse_json(response)
+        raise CFoundry::Denied.new(409, info[:message])
+
+      when 411, 500, 504
+        begin
+          raise_error(parse_json(response))
+        rescue JSON::ParserError
+          raise BadResponse.new(response.code, response)
+        end
+
+      else
+        raise BadResponse.new(response.code, response)
+      end
+    end
+
+    def extract_token(url)
+      _, params = url.split('#')
+      return unless params
+
+      values = {}
+      params.split("&").each do |pair|
+        key, val = pair.split("=")
+        values[key] = val
+      end
+
+      return unless values["access_token"] && values["token_type"]
+
+      "#{values["token_type"]} #{values["access_token"]}"
+    end
+  end
+end