ncfoundry 4.9.2

data/lib/cc_api_stub/routes.rb

@@ -0,0 +1,26 @@
+module CcApiStub
+  module Routes
+    extend Helper
+
+    class << self
+      def succeed_to_load_none
+        stub_get(collection_endpoint, {}, response(200, {:resources => []}))
+      end
+
+      def succeed_to_create
+        response_body = Helper.load_fixtures("fake_cc_created_route")
+        stub_post(collection_endpoint, {}, response(201, response_body))
+      end
+
+      private
+
+      def collection_endpoint
+        %r{/v2/routes/?.*$}
+      end
+
+      def object_endpoint(id = nil)
+        %r{/v2/routes/#{id}[^/]+$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/runtimes.rb

@@ -0,0 +1,22 @@
+module CcApiStub
+  module Runtimes
+    extend Helper
+
+    class << self
+      def succeed_to_load
+        response_body = Helper.load_fixtures("fake_cc_runtimes")
+        stub_get(collection_endpoint, {}, response(200, response_body))
+      end
+
+      def fail_to_load
+        stub_get(collection_endpoint, {}, response(500))
+      end
+
+      private
+
+      def collection_endpoint
+        %r{/v2/runtimes\?inline-relations-depth=1$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/service_bindings.rb

@@ -0,0 +1,22 @@
+module CcApiStub
+  module ServiceBindings
+    extend Helper
+
+    class << self
+      def succeed_to_create
+        response_body = Helper.load_fixtures("fake_cc_service_binding")
+        stub_post(collection_endpoint, {}, response(201, response_body))
+      end
+
+      private
+
+      def object_endpoint(id = nil)
+        %r{/v2/service_bindings/#{id}[^/]+$}
+      end
+
+      def collection_endpoint
+        %r{/v2/service_bindings$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/service_instances.rb

@@ -0,0 +1,22 @@
+module CcApiStub
+  module ServiceInstances
+    extend Helper
+
+    class << self
+      def succeed_to_create
+        response_body = Helper.load_fixtures("fake_cc_created_service_instance")
+        stub_post(collection_endpoint, {}, response(201, response_body))
+      end
+
+      private
+
+      def object_endpoint(id = nil)
+        %r{/v2/service_instances/#{id}[^/]+$}
+      end
+
+      def collection_endpoint
+        %r{/v2/service_instances$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/services.rb

@@ -0,0 +1,21 @@
+module CcApiStub
+  module Services
+    extend Helper
+
+    class << self
+      def service_fixture_hash
+        MultiJson.load(services_fixture["resources"].first.to_json, :symbolize_keys => true)
+      end
+
+      private
+
+      def collection_endpoint
+        %r{/v2/services\?inline-relations-depth=1}
+      end
+
+      def services_fixture
+        Helper.load_fixtures("fake_cc_services")
+      end
+    end
+  end
+end

data/lib/cc_api_stub/space_users.rb

@@ -0,0 +1,27 @@
+module CcApiStub
+  module SpaceUsers
+    extend Helper
+
+    class << self
+      def succeed_to_delete(options = {})
+        if options.has_key? :roles
+          options[:roles].each do |role|
+            stub_delete(object_endpoint(options[:id], role.to_s.pluralize), {}, response(200, ""))
+          end
+        end
+
+        stub_delete(object_endpoint(options[:id]), {}, response(200, ""))
+      end
+
+      def fail_to_delete(options = {})
+        stub_delete(object_endpoint(options[:id]), {}, response(500))
+      end
+
+      private
+
+      def object_endpoint(id = nil, role="users")
+        %r{/v2/spaces/[^/]+/#{role}/#{id}[^/]+$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/spaces.rb

@@ -0,0 +1,58 @@
+module CcApiStub
+  module Spaces
+    extend Helper
+
+    class << self
+      def succeed_to_load(options={})
+        response_body = Helper.load_fixtures(options.delete(:fixture) || "fake_cc_#{object_name}", options)
+        stub_get(object_endpoint(options[:id]), {}, response(200, response_body))
+      end
+
+      def succeed_to_create
+        response_body = Helper.load_fixtures("fake_cc_created_space")
+        stub_post(collection_endpoint, {}, response(201, response_body))
+      end
+
+      def summary_fixture
+        Helper.load_fixtures("fake_cc_space_summary")
+      end
+
+      def succeed_to_load_summary(options={})
+        response_body = summary_fixture
+        response_body["services"] = [] if options.delete(:no_services)
+        stub_get(%r{/v2/spaces/[^/]+/summary$}, {}, response(200, response_body))
+      end
+
+      def succeed_to_load_apps(options={})
+        response = response_from_options(options.reverse_merge!({:fixture => "fake_cc_space_apps"}))
+        stub_get(%r{/v2/spaces/[^/]+/apps\?inline-relations-depth=1}, {}, response(200, response))
+      end
+
+      def fail_to_find(space_id)
+        stub_get(%r{/v2/spaces/#{space_id}}, {}, response(404, {:code => 40004, :description => "The app space could not be found:"}))
+      end
+
+      def space_fixture_hash
+        {
+          :metadata => {
+            :guid => "space-id-1",
+            :url => "/v2/spaces/space-id-1"
+          },
+          :entity => {
+            :name => "space-name-1"
+          }
+        }
+      end
+
+      private
+
+      def collection_endpoint
+        %r{/v2/spaces$}
+      end
+
+      def object_endpoint(id = nil)
+        %r{/v2/spaces/#{id}[^/]+$}
+      end
+    end
+  end
+end

data/lib/cc_api_stub/users.rb

@@ -0,0 +1,85 @@
+module CcApiStub
+  module Users
+    extend Helper
+
+    class << self
+      def succeed_to_load(options={})
+        response_body = Helper.load_fixtures(options[:fixture] || "fake_cc_user")
+        response_body["metadata"]["guid"] = options[:id] || "user-id-1"
+
+        if options[:no_organizations]
+          response_body["entity"]["organizations"] = []
+        else
+          def space(space_id) {"metadata" => { "guid" => space_id }, "entity" => {}} end
+
+          organization = response_body["entity"]["organizations"].first
+          organization["metadata"]["guid"] = options[:organization_id] || "organization-id-1"
+          organization["entity"]["spaces"] = [] if options[:no_spaces]
+
+          permissions = options[:permissions] || [:organization_manager]
+
+          response_body["entity"]["managed_organizations"] << organization if permissions.include?(:organization_manager)
+          response_body["entity"]["billing_managed_organizations"] << organization if permissions.include?(:organization_billing_manager)
+          response_body["entity"]["audited_organizations"] << organization if permissions.include?(:organization_auditor)
+
+          unless options[:no_spaces]
+            space = space("space-id-1")
+            response_body["entity"]["spaces"] << space         if permissions.include?(:space_developer)
+            response_body["entity"]["managed_spaces"] << space if permissions.include?(:space_manager)
+            response_body["entity"]["audited_spaces"] << space if permissions.include?(:space_auditor)
+
+            space2 = space("space-id-2")
+            response_body["entity"]["spaces"] << space2         if permissions.include?(:space2_developer)
+            response_body["entity"]["managed_spaces"] << space2 if permissions.include?(:space2_manager)
+            response_body["entity"]["audited_spaces"] << space2 if permissions.include?(:space2_auditor)
+          end
+        end
+
+        stub_get(%r{/v2/users/[^/]+\?inline-relations-depth=2$}, {}, response(200, response_body))
+        stub_get(%r{/v2/users/[^/]+/summary(\?inline-relations-depth=\d)?$}, {}, response(200, response_body))
+      end
+
+      def fail_to_find(options = {})
+        stub_get(object_endpoint(options[:id]), {}, response(404, {:code => 20003, :description => "The user could not be found"}))
+      end
+
+      def succeed_to_create
+        response_body = Helper.load_fixtures("fake_cc_created_user")
+        stub_post(collection_endpoint, {}, response(201, response_body))
+      end
+
+      def fail_to_create
+        CcApiStub::Helper.fail_request(:post, 500, {}, /users/)
+      end
+
+      def succeed_to_replace_permissions(options = {})
+        stub_put(object_endpoint(options[:id]), {}, response(200, ""))
+      end
+
+      def fail_to_replace_permissions(options = {})
+        stub_put(object_endpoint(options[:id]), {}, response(500))
+      end
+
+      def organizations_fixture
+        Helper.load_fixtures("fake_cc_user")["entity"]["organizations"]
+      end
+
+      def organization_fixture_hash(options={})
+        fixture = organizations_fixture.first
+        fixture["entity"].delete("spaces") if options[:no_spaces]
+        fixture["entity"].delete("managers") if options[:no_managers]
+        MultiJson.load(fixture.to_json, :symbolize_keys => true)
+      end
+
+      private
+
+      def collection_endpoint
+        %r{/v2/users$}
+      end
+
+      def object_endpoint(id = nil)
+        %r{/v2/users/#{id}[^/]+(/summary)?}
+      end
+    end
+  end
+end

data/lib/cc_api_stub.rb

@@ -0,0 +1,20 @@
+require "cc_api_stub/helper"
+require "cc_api_stub/organizations"
+require "cc_api_stub/login"
+require "cc_api_stub/app_usage_events"
+require "cc_api_stub/applications"
+require "cc_api_stub/domains"
+require "cc_api_stub/events"
+require "cc_api_stub/frameworks"
+require "cc_api_stub/organization_users"
+require "cc_api_stub/routes"
+require "cc_api_stub/runtimes"
+require "cc_api_stub/service_bindings"
+require "cc_api_stub/service_instances"
+require "cc_api_stub/services"
+require "cc_api_stub/spaces"
+require "cc_api_stub/space_users"
+require "cc_api_stub/users"
+
+module CcApiStub
+end

data/lib/cfoundry/auth_token.rb

@@ -0,0 +1,62 @@
+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_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
+
+      data_json = @auth_header.split(" ", 2).last
+      return {} unless data_json
+
+      @token_data = JWT.decode(data_json, nil, false)[0].symbolize_keys
+    rescue
+      {}
+    end
+
+    def auth_header=(auth_header)
+      @token_data = nil
+      @auth_header = auth_header
+    end
+
+    def expiration
+      token_data[:exp].nil? ? Time.at(0) : Time.at(token_data[:exp])
+    end
+
+    def expires_soon?
+      (expiration.to_i - Time.now.to_i) < 60
+    end
+  end
+end

data/lib/cfoundry/baseclient.rb

@@ -0,0 +1,220 @@
+require "cfoundry/trace_helpers"
+require "net/https"
+require "net/http/post/multipart"
+require "multi_json"
+require "fileutils"
+require "forwardable"
+
+module CFoundry
+  class BaseClient # :nodoc:
+    include CFoundry::ProxyOptions
+
+    extend Forwardable
+
+    attr_reader :rest_client
+    attr_accessor :client_id, :client_secret
+
+    def_delegators :rest_client, :target, :target=, :token,
+      :trace, :backtrace, :backtrace=, :log, :log=
+
+    def initialize(target, token = nil, options = {})
+      @rest_client = CFoundry::RestClient.new(target, token)
+      self.client_id = options[:client_id]
+      self.client_secret = options[:client_secret]
+      self.trace = false
+      self.backtrace = false
+      self.log = false
+    end
+
+    def uaa
+      @uaa ||= begin
+        endpoint = info[:authorization_endpoint]
+
+        if endpoint
+          uaa = CFoundry::UAAClient.new(endpoint,
+                                        client_id || "cf",
+                                        client_secret: client_secret)
+          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)
+
+      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 CFoundry::NotFound.new(response.body, 404)
+          when Net::HTTPForbidden
+            raise CFoundry::Denied.new(response.body, 403)
+          when Net::HTTPUnauthorized
+            raise CFoundry::Unauthorized.new(response.body, 401)
+          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)
+        when 401
+          raise CFoundry::Unauthorized.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.nil? || 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,42 @@
+require "cfoundry/concerns/proxy_options"
+
+require "cfoundry/baseclient"
+require "cfoundry/rest_client"
+require "cfoundry/auth_token"
+
+require "cfoundry/v2/app"
+require "cfoundry/v2/app_instance"
+require "cfoundry/v2/service"
+require "cfoundry/v2/service_binding"
+require "cfoundry/v2/managed_service_instance"
+require "cfoundry/v2/user_provided_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/stack"
+require "cfoundry/v2/quota_definition"
+require "cfoundry/v2/app_event"
+require "cfoundry/v2/app_usage_event"
+require "cfoundry/v2/event"
+require "cfoundry/v2/service_broker"
+
+require "cfoundry/v2/base"
+require "cfoundry/v2/client"
+#require "cfoundry/v2/fake_client"
+
+module CFoundry
+  class Client < BaseClient
+    def self.new(*args)
+      warn "DEPRECATION WARNING: Please use CFoundry::Client.get instead of CFoundry::Client.new"
+      get(*args)
+    end
+
+    def self.get(*args)
+      CFoundry::V2::Client.new(*args).tap { |client| client.info }
+    end
+  end
+end

data/lib/cfoundry/concerns/login_helpers.rb

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