cfoundry-IronFoundry 0.3.34

data/lib/cfoundry/v2/base.rb

@@ -0,0 +1,175 @@
+require "multi_json"
+require "base64"
+
+require "cfoundry/baseclient"
+require "cfoundry/uaaclient"
+
+require "cfoundry/errors"
+
+module CFoundry::V2
+  class Base < CFoundry::BaseClient
+    attr_accessor :target, :token, :proxy, :trace
+
+    def initialize(
+        target = "https://api.cloudfoundry.com",
+        token = nil)
+      @target = target
+      @token = token
+    end
+
+
+    # invalidate token data when changing token
+    def token=(t)
+      @token = t
+    end
+
+
+    # The UAA used for this client.
+    #
+    # `false` if no UAA (legacy)
+    def uaa
+      return @uaa unless @uaa.nil?
+
+      endpoint = info[:authorization_endpoint]
+      return @uaa = false unless endpoint
+
+      @uaa = CFoundry::UAAClient.new(endpoint)
+      @uaa.trace = @trace
+      @uaa.token = @token
+      @uaa
+    end
+
+
+    # Cloud metadata
+    def info
+      get("info", nil => :json)
+    end
+
+
+    [ :app, :organization, :space, :user, :runtime, :framework, :service,
+      :domain, :route, :service_plan, :service_binding, :service_instance,
+      :service_auth_token
+    ].each do |obj|
+      plural = "#{obj}s"
+
+      define_method(obj) do |guid, *args|
+        depth, _ = args
+        depth ||= 1
+
+        params = { :"inline-relations-depth" => depth }
+
+        get("v2", plural, guid, nil => :json, :params => params)
+      end
+
+      define_method(:"create_#{obj}") do |payload|
+        post(payload, "v2", plural, :json => :json)
+      end
+
+      define_method(:"delete_#{obj}") do |guid|
+        delete("v2", plural, guid, nil => nil)
+        true
+      end
+
+      define_method(:"update_#{obj}") do |guid, payload|
+        put(payload, "v2", plural, guid, :json => :json)
+      end
+
+      define_method(plural) do |*args|
+        get("v2", plural, nil => :json, :params => params_from(args))
+      end
+    end
+
+    def resource_match(fingerprints)
+      put(fingerprints, "v2", "resource_match", :json => :json)
+    end
+
+    def upload_app(guid, zipfile, resources = [])
+      payload = {
+        :resources => MultiJson.dump(resources),
+        :multipart => true,
+        :application =>
+          if zipfile.is_a? File
+            zipfile
+          elsif zipfile.is_a? String
+            File.new(zipfile, "rb")
+          end
+      }
+
+      put(payload, "v2", "apps", guid, "bits")
+    rescue RestClient::ServerBrokeConnection
+      retry
+    end
+
+    def files(guid, instance, *path)
+      get("v2", "apps", guid, "instances", instance, "files", *path)
+    end
+    alias :file :files
+
+    def instances(guid)
+      get("v2", "apps", guid, "instances", nil => :json)
+    end
+
+    def stats(guid)
+      get("v2", "apps", guid, "stats", nil => :json)
+    end
+
+
+    def params_from(args)
+      depth, query = args
+      depth ||= 1
+
+      params = { :"inline-relations-depth" => depth }
+
+      if query
+        params[:q] = "#{query.keys.first}:#{query.values.first}"
+      end
+
+      params
+    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 400
+        info = parse_json(response)
+        raise CFoundry::APIError.new(info[:code], info[:description])
+
+      when 401, 403
+        info = parse_json(response)
+        raise CFoundry::Denied.new(info[:code], info[:description])
+
+      when 404
+        raise CFoundry::NotFound
+
+      when 411, 500, 504
+        begin
+          info = parse_json(response)
+          raise CFoundry::APIError.new(info[:code], info[:description])
+        rescue MultiJson::DecodeError
+          raise CFoundry::BadResponse.new(response.code, response)
+        end
+
+      else
+        raise CFoundry::BadResponse.new(response.code, response)
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/client.rb

@@ -0,0 +1,198 @@
+require "multi_json"
+require "base64"
+
+require "cfoundry/v2/base"
+
+require "cfoundry/v2/app"
+require "cfoundry/v2/framework"
+require "cfoundry/v2/organization"
+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/space"
+require "cfoundry/v2/user"
+require "cfoundry/v2/domain"
+require "cfoundry/v2/route"
+
+module CFoundry::V2
+  # The primary API entrypoint. Wraps a BaseClient to provide nicer return
+  # values. Initialize with the target and, optionally, an auth token. These
+  # are the only two internal states.
+  class Client
+    # Internal BaseClient instance. Normally won't be touching this.
+    attr_reader :base
+
+    # [Organization] Currently targeted organization.
+    attr_accessor :current_organization
+
+    # [Space] Currently targeted space.
+    attr_accessor :current_space
+
+
+    # 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)
+      @base = Base.new(target, token)
+    end
+
+    # The current target URL of the client.
+    def target
+      @base.target
+    end
+
+    # Current proxy user. Usually nil.
+    def proxy
+      @base.proxy
+    end
+
+    # Set the proxy user for the client. Must be authorized as an
+    # administrator for this to have any effect.
+    def proxy=(email)
+      @base.proxy = email
+    end
+
+    # Is the client tracing API requests?
+    def trace
+      @base.trace
+    end
+
+    # Set the tracing flag; if true, API requests and responses will be
+    # printed out.
+    def trace=(bool)
+      @base.trace = bool
+    end
+
+    # The currently authenticated user.
+    def current_user
+      if guid = @base.token_data[:user_id]
+        user = user(guid)
+        user.emails = [{ :value => @base.token_data[:email] }]
+        user
+      end
+    end
+
+    # Cloud metadata
+    def info
+      @base.info
+    end
+
+    # Login prompts
+    def login_prompts
+      if @base.uaa
+        @base.uaa.prompts
+      else
+        { :username => ["text", "Email"],
+          :password => ["password", "Password"]
+        }
+      end
+    end
+
+    # Authenticate with the target. Sets the client token.
+    #
+    # Credentials is a hash, typically containing :username and :password
+    # keys.
+    #
+    # The values in the hash should mirror the prompts given by
+    # `login_prompts`.
+    def login(credentials)
+      @current_organization = nil
+      @current_space = nil
+
+      @base.token =
+        if @base.uaa
+          @base.uaa.authorize(credentials)
+        else
+          @base.create_token(
+            { :password => credentials[:password] },
+            credentials[:username])[:token]
+        end
+    end
+
+    # Clear client token. No requests are made for this.
+    def logout
+      @base.token = nil
+    end
+
+    # Is an authentication token set on the client?
+    def logged_in?
+      !!@base.token
+    end
+
+
+    [ :app, :organization, :space, :user, :runtime, :framework, :service,
+      :domain, :route, :service_plan, :service_binding, :service_instance,
+      :service_auth_token
+    ].each do |singular|
+      plural = :"#{singular}s"
+
+      classname = singular.to_s.capitalize.gsub(/(.)_(.)/) do
+        $1 + $2.upcase
+      end
+
+      klass = CFoundry::V2.const_get(classname)
+
+      has_space = klass.method_defined? :space
+      has_name = klass.method_defined? :name
+
+      define_method(singular) do |*args|
+        guid, _ = args
+        klass.new(guid, self)
+      end
+
+      define_method(plural) do |*args|
+        depth, query = args
+        depth ||= 1
+
+        if has_space && current_space
+          query ||= {}
+          query[:space_guid] ||= current_space.guid
+        end
+
+        @base.send(plural, depth, query)[:resources].collect do |json|
+          send(:"make_#{singular}", json)
+        end
+      end
+
+      if has_name
+        define_method(:"#{singular}_by_name") do |name|
+          if has_space && current_space
+            current_space.send(plural, 1, :name => name).first
+          else
+            send(plural, 1, :name => name).first
+          end
+        end
+      end
+
+      define_method(:"#{singular}_from") do |path, *args|
+        send(
+          :"make_#{singular}",
+          @base.request_path(
+            :get,
+            path,
+            nil => :json,
+            :params => @base.params_from(args)))
+      end
+
+      define_method(:"#{plural}_from") do |path, *args|
+        @base.request_path(
+            :get,
+            path,
+            nil => :json,
+            :params => @base.params_from(args))[:resources].collect do |json|
+          send(:"make_#{singular}", json)
+        end
+      end
+
+      define_method(:"make_#{singular}") do |json|
+        klass.new(
+          json[:metadata][:guid],
+          self,
+          json)
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/domain.rb

@@ -0,0 +1,8 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Domain < Model
+    attribute :name, :string
+    to_one    :owning_organization, :as => :organization
+  end
+end

data/lib/cfoundry/v2/framework.rb

@@ -0,0 +1,12 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Framework < Model
+    attribute :name, :string
+    attribute :description, :string
+    to_many   :apps
+
+    attr_accessor :detection, :runtimes
+  end
+end
+

data/lib/cfoundry/v2/model.rb

@@ -0,0 +1,268 @@
+require "multi_json"
+
+module CFoundry::V2
+  class Model
+    class << self
+      def value_matches?(val, type)
+        case type
+        when Class
+          val.is_a?(type)
+        when Regexp
+          val.is_a?(String) && val =~ type
+        when :url
+          value_matches?(val, URI::regexp(%w(http https)))
+        when :https_url
+          value_matches?(val, URI::regexp("https"))
+        when :boolean
+          val.is_a?(TrueClass) || val.is_a?(FalseClass)
+        when Array
+          val.all? do |x|
+            value_matches?(x, type.first)
+          end
+        when Hash
+          val.is_a?(Hash) &&
+            type.all? { |name, subtype|
+              val.key?(name) && value_matches?(val[name], subtype)
+            }
+        else
+          val.is_a?(Object.const_get(type.to_s.capitalize))
+        end
+      end
+
+      def validate_type(val, type)
+        unless value_matches?(val, type)
+          raise "invalid attribute; expected #{type.inspect} but got #{val.inspect}"
+        end
+      end
+
+      def defaults
+        @defaults ||= {}
+      end
+
+      def attribute(name, type, opts = {})
+        default = opts[:default] || nil
+
+        has_default = opts.key?(:default)
+        defaults[name] = default if has_default
+
+        define_method(name) {
+          manifest[:entity][name] || default
+        }
+
+        define_method(:"#{name}=") { |val|
+          unless has_default && val == default
+            Model.validate_type(val, type)
+          end
+
+          @manifest ||= {}
+          @manifest[:entity] ||= {}
+          @manifest[:entity][name] = val
+          @diff[name] = val
+        }
+      end
+
+      def to_one(name, opts = {})
+        obj = opts[:as] || name
+        kls = obj.to_s.capitalize.gsub(/(.)_(.)/) do
+          $1 + $2.upcase
+        end
+
+        define_method(name) {
+          if @manifest && @manifest[:entity].key?(name)
+            @client.send(:"make_#{obj}", @manifest[:entity][name])
+          else
+            @client.send(
+              :"#{obj}_from",
+              send("#{name}_url"),
+              opts[:depth] || 1)
+          end
+        }
+
+        define_method(:"#{name}_url") {
+          manifest[:entity][:"#{name}_url"]
+        }
+
+        define_method(:"#{name}=") { |x|
+          Model.validate_type(x, CFoundry::V2.const_get(kls))
+
+          @manifest ||= {}
+          @manifest[:entity] ||= {}
+          @manifest[:entity][:"#{name}_guid"] =
+            @diff[:"#{name}_guid"] = x.guid
+        }
+      end
+
+      def to_many(plural, opts = {})
+        singular = plural.to_s.sub(/s$/, "").to_sym
+
+        object = opts[:as] || singular
+        plural_object = :"#{object}s"
+
+        kls = object.to_s.capitalize.gsub(/(.)_(.)/) do
+          $1 + $2.upcase
+        end
+
+        define_method(plural) { |*args|
+          depth, query = args
+
+          if @manifest && @manifest[:entity].key?(plural) && !depth
+            objs = @manifest[:entity][plural]
+
+            if query
+              find_by = query.keys.first
+              find_val = query.values.first
+              objs = objs.select { |o| o[:entity][find_by] == find_val }
+            end
+
+            objs.collect do |json|
+              @client.send(:"make_#{object}", json)
+            end
+          else
+            @client.send(
+              :"#{plural_object}_from",
+              "/v2/#{object_name}s/#@guid/#{plural}",
+              depth || opts[:depth],
+              query)
+          end
+        }
+
+        define_method(:"#{plural}_url") {
+          manifest[:entity][:"#{plural}_url"]
+        }
+
+        define_method(:"add_#{singular}") { |x|
+          # TODO: reflect this change in the app manifest?
+          Model.validate_type(x, CFoundry::V2.const_get(kls))
+
+          @client.base.request_path(
+            :put,
+            ["v2", "#{object_name}s", @guid, plural, x.guid],
+            nil => :json)
+        }
+
+        define_method(:"remove_#{singular}") { |x|
+          # TODO: reflect this change in the app manifest?
+          Model.validate_type(x, CFoundry::V2.const_get(kls))
+
+          @client.base.request_path(
+            :delete,
+            ["v2", "#{object_name}s", @guid, plural, x.guid],
+            nil => :json)
+        }
+
+        define_method(:"#{plural}=") { |xs|
+          Model.validate_type(x, [CFoundry::V2.const_get(kls)])
+
+          @manifest ||= {}
+          @manifest[:entity] ||= {}
+          @manifest[:entity][:"#{singular}_guids"] =
+            @diff[:"#{singular}_guids"] = xs.collect(&:guid)
+        }
+      end
+    end
+
+    attr_reader :guid
+
+    def initialize(guid, client, manifest = nil)
+      @guid = guid
+      @client = client
+      @manifest = manifest
+      @diff = {}
+    end
+
+    def manifest
+      @manifest ||= @client.base.send(object_name, @guid)
+    end
+
+    def inspect
+      "\#<#{self.class.name} '#@guid'>"
+    end
+
+    def object_name
+      @object_name ||=
+        self.class.name.split("::").last.gsub(
+          /([a-z])([A-Z])/,
+          '\1_\2').downcase
+    end
+
+    def invalidate!
+      @manifest = nil
+      @diff = {}
+    end
+
+    # this does a bit of extra processing to allow for
+    # `delete!' followed by `create!'
+    def create!
+      payload = {}
+
+      self.class.defaults.merge(@manifest[:entity]).each do |k, v|
+        if v.is_a?(Hash) && v.key?(:metadata)
+          # skip; there's a _guid attribute already
+        elsif v.is_a?(Array) && v.all? { |x|
+                x.is_a?(Hash) && x.key?(:metadata)
+              }
+          singular = k.to_s.sub(/s$/, "")
+
+          payload[:"#{singular}_guids"] = v.collect do |x|
+            if x.is_a?(Hash) && x.key?(:metadata)
+              x[:metadata][:guid]
+            else
+              x
+            end
+          end
+        elsif k.to_s.end_with?("_json") && v.is_a?(String)
+          payload[k] = MultiJson.load(v)
+        elsif k.to_s.end_with?("_url")
+        else
+          payload[k] = v
+        end
+      end
+
+      @manifest = @client.base.send(:"create_#{object_name}", payload)
+
+      @guid = @manifest[:metadata][:guid]
+
+      @diff.clear
+
+      true
+    end
+
+    def update!(diff = @diff)
+      @manifest = @client.base.send(:"update_#{object_name}", @guid, diff)
+
+      @diff.clear if diff == @diff
+
+      true
+    end
+
+    def delete!
+      @client.base.send(:"delete_#{object_name}", @guid)
+
+      @guid = nil
+
+      @diff.clear
+
+      if @manifest
+        @manifest.delete :metadata
+      end
+
+      true
+    end
+
+    def exists?
+      @client.base.send(object_name, @guid)
+      true
+    rescue CFoundry::APIError # TODO: NotFound would be better
+      false
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && @guid == other.guid
+    end
+    alias :== :eql?
+
+    def hash
+      @guid.hash
+    end
+  end
+end