cfoundry-IronFoundry 0.3.34

data/Rakefile

@@ -0,0 +1,40 @@
+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
+    sh("bundle install")
+  end
+end
+
+namespace "test" do
+  task "spec" do |t|
+    sh("cd spec && bundle exec rake spec")
+  end
+end

data/lib/cfoundry.rb

@@ -0,0 +1,2 @@
+require "cfoundry/version"
+require "cfoundry/client"

data/lib/cfoundry/baseclient.rb

@@ -0,0 +1,235 @@
+require "restclient"
+require "multi_json"
+
+module CFoundry
+  class BaseClient # :nodoc:
+    attr_accessor :trace, :no_backtrace
+
+    def initialize(target, token = nil)
+      @target = target
+      @token = token
+      @trace = false
+      @no_backtrace = false
+    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
+
+    # grab the metadata from a token that looks like:
+    #
+    # bearer (base64 ...)
+    def token_data
+      tok = Base64.decode64(@token.sub(/^bearer\s+/, ""))
+      tok.sub!(/\{.+?\}/, "") # clear algo
+      MultiJson.load(tok[/\{.+?\}/], :symbolize_keys => true)
+
+    # normally i don't catch'em all, but can't expect all tokens to be the
+    # proper format, so just silently fail as this is not critical
+    rescue
+      {}
+    end
+
+    private
+
+    def parse_json(x)
+      MultiJson.load(x, :symbolize_keys => 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 = MultiJson.dump(payload)
+        when :form
+          payload = encode_params(payload)
+        end
+      end
+
+      headers["Content-Length"] = payload ? payload.size : 0
+
+      headers.merge!(options[:headers]) if options[:headers]
+
+      if params
+        uri = URI.parse(path)
+        path += (uri.query ? "&" : "?") + 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|
+        print_trace(req, request, response, caller) if @trace
+        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]
+        v = MultiJson.dump(v) if v.is_a?(Hash)
+        v = URI.escape(v.to_s, /[^#{URI::PATTERN::UNRESERVED}]/) if escape
+        "#{k}=#{v}"
+      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
+
+    def print_trace(req, request, response, locs)
+      $stderr.puts ">>>"
+      $stderr.puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
+      $stderr.puts "REQUEST: #{req[:method]} #{req[:url]}"
+      $stderr.puts "RESPONSE_HEADERS:"
+      response.headers.each do |key, value|
+        $stderr.puts "    #{key} : #{value}"
+      end
+      $stderr.puts "REQUEST_HEADERS:"
+      request.headers.each do |key, value|
+        $stderr.puts "    #{key} : #{value}"
+      end
+      $stderr.puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
+      $stderr.puts "RESPONSE: [#{response.code}]"
+      begin
+        parsed_body = MultiJson.load(response.body)
+        $stderr.puts MultiJson.dump(parsed_body, :pretty => true)
+      rescue
+        $stderr.puts "#{response.body}"
+      end
+      $stderr.puts "<<<"
+
+      return if @no_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}"
+      end
+
+      $stderr.puts "... (trimmed)" unless trimmed_locs == interesting_locs
+    end
+
+    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/chatty_hash.rb

@@ -0,0 +1,34 @@
+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
+  end
+end

data/lib/cfoundry/client.rb

@@ -0,0 +1,25 @@
+require "cfoundry/baseclient"
+
+require "cfoundry/v1/client"
+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
+
+    def info
+      get("info", nil => :json)
+    end
+  end
+end

data/lib/cfoundry/errors.rb

@@ -0,0 +1,106 @@
+module CFoundry
+  # Exception representing errors returned by the API.
+  class APIError < RuntimeError
+    class << self
+      # Generic error code for the exception.
+      attr_reader :error_code
+
+      # Generic description for the exception.
+      attr_reader :description
+
+      private
+
+      def setup(code, description = nil)
+        @error_code = code
+        @description = description
+      end
+    end
+
+    # Create an APIError with a given error code and description.
+    def initialize(error_code = nil, description = nil)
+      @error_code = error_code
+      @description = description
+    end
+
+    # A number representing the error.
+    def error_code
+      @error_code || self.class.error_code
+    end
+
+    # A description of the error.
+    def description
+      @description || self.class.description
+    end
+
+    # Exception message.
+    def to_s
+      if error_code
+        "#{error_code}: #{description}"
+      else
+        description
+      end
+    end
+  end
+
+  # Generic exception thrown when accessing something that doesn't exist (e.g.
+  # getting info of unknown application).
+  class NotFound < APIError
+    setup(404, "entity not found or inaccessible")
+  end
+
+  # Lower-level exception for when we cannot connect to the target.
+  class TargetRefused < APIError
+    @description = "target refused connection"
+
+    # Error message.
+    attr_reader :message
+
+    # Message varies as this represents various network errors.
+    def initialize(message)
+      @message = message
+    end
+
+    # Exception message.
+    def to_s
+      "#{description} (#{@message})"
+    end
+  end
+
+  # Exception raised when an application payload fails to upload.
+  class UploadFailed < APIError
+    setup(402)
+  end
+
+  # Exception raised when access is denied to something, either because the
+  # user is not logged in or is not an administrator.
+  class Denied < APIError
+    # Specific error code.
+    attr_reader :error_code
+
+    # Specific description.
+    attr_reader :description
+
+    # Initialize, with a default error code and message.
+    def initialize(
+        error_code = 200,
+        description = "Operation not permitted")
+      @error_code = error_code
+      @description = description
+    end
+  end
+
+  # Exception raised when the response is unexpected; usually from a server
+  # error.
+  class BadResponse < StandardError
+    # Initialize, with the HTTP response code and body.
+    def initialize(code, body = nil)
+      @code = code
+      @body = body
+    end
+
+    # Exception message.
+    def to_s
+      "target failed to handle our request due to an internal error (#{@code})"
+    end
+  end
+end