ncfoundry 4.9.2

data/lib/cfoundry/v2/model_magic/has_summary.rb

@@ -0,0 +1,49 @@
+module CFoundry::V2::ModelMagic
+  module HasSummary
+    def has_summary(actions = {})
+      #
+      # def summary
+      #
+      define_method(:summary) do
+        @client.base.get("v2", plural_object_name, @guid, "summary", :accept => :json)
+      end
+
+      #
+      # def summarize!
+      #
+      define_method(:summarize!) do |*args|
+        body, _ = args
+
+        body ||= summary
+
+        body.each do |key, val|
+          if act = actions[key]
+            instance_exec(val, &act)
+
+          elsif self.class.attributes[key]
+            self.send(:"#{key}=", val)
+
+          elsif self.class.to_many_relations[key]
+            singular = key.to_s.sub(/s$/, "").to_sym
+
+            vals = val.collect do |sub|
+              obj = @client.send(singular, sub[:guid], true)
+              obj.summarize! sub
+              obj
+            end
+
+            self.send(:"#{key}=", vals)
+
+          elsif self.class.to_one_relations[key]
+            obj = @client.send(key, val[:guid], true)
+            obj.summarize! val
+
+            self.send(:"#{key}=", obj)
+          end
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/query_multi_value_helper.rb

@@ -0,0 +1,21 @@
+module CFoundry::V2
+  module ModelMagic
+    module QueryValueHelper
+      class QueryMultiValue
+        attr_accessor :query_values
+
+        def initialize(*query_hashes)
+          self.query_values = query_hashes.collect do |query_hash|
+            QueryValue.new query_hash
+          end
+        end
+
+        def collect_values(key)
+          query_values.collect do |value|
+            "#{key}#{value}"
+          end.join(';')
+        end
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/query_value_helper.rb

@@ -0,0 +1,33 @@
+module CFoundry::V2
+  module ModelMagic
+    module QueryValueHelper
+      class QueryValue
+        attr_accessor :comparator, :value
+        def initialize(params)
+          self.comparator = params[:comparator] || params[:comp] || ':'
+          self.value = params[:value]
+        end
+
+        def to_s
+          "#{comparator_string}#{value_string}"
+        end
+
+        def comparator_string
+          if comparator.downcase == 'in' || value.is_a?(Array)
+            " IN "
+          else
+            comparator
+          end
+        end
+
+        def value_string
+          if value.is_a? Array
+            value.join(",")
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/queryable_by.rb

@@ -0,0 +1,39 @@
+module CFoundry::V2
+  module ModelMagic::QueryableBy
+    def queryable_by(*names)
+      klass = self
+      singular = object_name
+      plural = plural_object_name
+
+      query = ::CFoundry::V2::QUERIES[singular]
+
+      query.module_eval do
+        names.each do |name|
+          #
+          # def MODEL_by_ATTRIBUTE
+          #
+          define_method(:"#{singular}_by_#{name}") do |*args|
+            send(:"#{plural}_by_#{name}", *args).first
+          end
+
+          #
+          # def MODELs_by_ATTRIBUTE
+          #
+          define_method(:"#{plural}_by_#{name}") do |val, *args|
+            options, _ = args
+            options ||= {}
+            options[:query] = [name, val]
+
+            query_target(klass).send(plural, options)
+          end
+        end
+      end
+
+      const_set(:Queries, query)
+
+      ClientMethods.module_eval do
+        include query
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/to_many.rb

@@ -0,0 +1,145 @@
+module CFoundry::V2::ModelMagic
+  module ToMany
+    def to_many(plural, opts = {})
+      to_many_relations[plural] = opts
+
+      singular = plural.to_s.sub(/s$/, "").to_sym
+
+      include ::CFoundry::V2::QUERIES[singular]
+
+      object = opts[:as] || singular
+
+      kls = object.to_s.camelcase
+
+      #
+      # def MODELs
+      #
+      define_method(plural) do |*args|
+        klass = CFoundry::V2.const_get(kls)
+
+        opts, _ = args
+        opts ||= {}
+
+        if opts.empty? && cache = @cache[plural]
+          return cache
+        end
+
+        if @manifest && @manifest[:entity].key?(plural) && opts.empty?
+          objs = @manifest[:entity][plural]
+
+          if query = opts[:query]
+            find_by, find_val = query
+            objs = objs.select { |o| o[:entity][find_by] == find_val }
+          end
+
+          res =
+            objs.collect do |json|
+              @client.send(:"make_#{object}", json)
+            end
+        else
+          res =
+            @client.send(
+              :"#{klass.plural_object_name}_from",
+              "/v2/#{plural_object_name}/#@guid/#{plural}",
+              opts)
+        end
+
+        if opts.empty?
+          @cache[plural] = res
+        end
+
+        res
+      end
+
+      #
+      # def MODELs_url
+      #
+      define_method(:"#{plural}_url") do
+        manifest[:entity][:"#{plural}_url"]
+      end
+
+      #
+      # def add_MODEL
+      #
+      define_method(:"add_#{singular}") do |x|
+        klass = self.class.objects[object]
+
+        CFoundry::Validator.validate_type(x, klass)
+
+        if cache = @cache[plural]
+          cache << x unless cache.include?(x)
+        end
+
+        @client.base.put("v2", plural_object_name, @guid, plural, x.guid, :accept => :json)
+      end
+
+      #
+      # def add_MODEL_by_username
+      #
+      define_method(:"add_#{singular}_by_username") do |username|
+        @client.base.put("v2", plural_object_name, @guid, plural, :accept => :json, :content => :json, :payload => {:username => username.to_s})
+      end
+
+      #
+      # def create_MODEL
+      #
+      define_method("create_#{singular}") do |*args|
+        associated_instance = @client.send(:"#{singular}")
+        args.first.each do |name, value|
+          associated_instance.send("#{name}=", value)
+        end if args.first.is_a? Hash
+
+        associated_instance.create!
+        self.send(:"add_#{singular}", associated_instance)
+        associated_instance
+      end
+
+      #
+      # def remove_MODEL
+      #
+      define_method(:"remove_#{singular}") do |x|
+        klass = self.class.objects[object]
+
+        CFoundry::Validator.validate_type(x, klass)
+
+        if cache = @cache[plural]
+          cache.delete(x)
+        end
+
+        @client.base.delete("v2", plural_object_name, @guid, plural, x.guid, :accept => :json)
+      end
+
+      #
+      # def MODELs=
+      #
+      define_method(:"#{plural}=") do |xs|
+        klass = self.class.objects[object]
+
+        CFoundry::Validator.validate_type(xs, [klass])
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old = @manifest[:entity][:"#{singular}_guids"]
+        if old != xs.collect(&:guid)
+          old_objs =
+            @cache[plural] ||
+              if all = @manifest[:entity][plural]
+                all.collect do |m|
+                  klass.new(@client, m[:metadata][:guid], m)
+                end
+              elsif old
+                old.collect { |id| klass.new(@client, id) }
+              end
+
+          @changes[plural] = [old_objs, xs]
+        end
+
+        @cache[plural] = xs
+
+        @manifest[:entity][:"#{singular}_guids"] =
+          @diff[:"#{singular}_guids"] = xs.collect(&:guid)
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic/to_one.rb

@@ -0,0 +1,81 @@
+module CFoundry::V2::ModelMagic
+  module ToOne
+    def to_one(name, opts = {})
+      to_one_relations[name] = opts
+
+      association_name = opts[:as] || name
+      default = opts[:default]
+
+      if has_default = opts.key?(:default)
+        defaults[:"#{name}_guid"] = default
+      end
+
+      #
+      # def MODEL
+      #
+      define_method(name) do
+        return @cache[name] if @cache.key?(name)
+        return @client.send(association_name) unless persisted?
+
+        @cache[name] =
+          if @manifest && @manifest[:entity].key?(name)
+            @client.send(:"make_#{association_name}", @manifest[:entity][name])
+          elsif url = send("#{name}_url")
+            @client.send(:"#{association_name}_from", url)
+          else
+            default
+          end
+      end
+
+      #
+      # def create_MODEL
+      #
+      define_method("create_#{name}") do |*args|
+        associated_instance = @client.send(:"#{association_name}")
+        args.first.each do |name, value|
+          associated_instance.send("#{name}=", value)
+        end if args.first.is_a? Hash
+
+        associated_instance.create!
+        self.send("#{name}=", associated_instance)
+      end
+
+      #
+      # def MODEL_url
+      #
+      define_method(:"#{name}_url") do
+        manifest[:entity][:"#{name}_url"]
+      end
+
+      #
+      # def MODEL=
+      #
+      define_method(:"#{name}=") do |assigned_value|
+        klass = self.class.objects[association_name]
+
+        unless has_default && assigned_value == default
+          CFoundry::Validator.validate_type(assigned_value, klass)
+        end
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old_guid = @manifest[:entity][:"#{name}_guid"]
+        association_guid = assigned_value ? assigned_value.guid : nil
+
+        if old_guid != (association_guid)
+          old_obj =
+            @cache[name] || klass.new(@client, old_guid, @manifest[:entity][name])
+
+          @changes[name] = [old_obj, assigned_value]
+        end
+
+        @cache[name] = assigned_value
+
+        @manifest[:entity][:"#{name}_guid"] = association_guid
+        @diff[:"#{name}_guid"] = association_guid
+        assigned_value
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/model_magic.rb

@@ -0,0 +1,134 @@
+require "cfoundry/validator"
+require "cfoundry/v2/model_magic/client_extensions"
+require "cfoundry/v2/model_magic/has_summary"
+require "cfoundry/v2/model_magic/attribute"
+require "cfoundry/v2/model_magic/to_one"
+require "cfoundry/v2/model_magic/to_many"
+require "cfoundry/v2/model_magic/queryable_by"
+require "cfoundry/v2/model_magic/query_value_helper"
+require "cfoundry/v2/model_magic/query_multi_value_helper"
+
+module CFoundry::V2
+  # object name -> module containing query methods
+  #
+  # e.g. app -> { app_by_name, app_by_space_guid, ... }
+  QUERIES = Hash.new do |h, k|
+    h[k] = Module.new
+  end
+
+  module BaseClientMethods
+  end
+
+  module ClientMethods
+  end
+
+  module ModelMagic
+    include ModelMagic::ClientExtensions
+    include ModelMagic::HasSummary
+    include ModelMagic::Attribute
+    include ModelMagic::ToOne
+    include ModelMagic::ToMany
+    include ModelMagic::QueryableBy
+    include ModelMagic::QueryValueHelper
+
+    attr_reader :scoped_organization, :scoped_space
+
+    def object_name
+      @object_name ||=
+        name.split("::").last.gsub(
+          /([a-z])([A-Z])/,
+          '\1_\2').downcase.to_sym
+    end
+
+    def plural_object_name
+      :"#{object_name}s"
+    end
+
+    def defaults
+      @defaults ||= {}
+    end
+
+    def attributes
+      @attributes ||= {}
+    end
+
+    def to_one_relations
+      @to_one_relations ||= {}
+    end
+
+    def to_many_relations
+      @to_many_relations ||= {}
+    end
+
+    def inherited(klass)
+      add_client_methods(klass)
+      has_summary
+    end
+
+    def scoped_to_organization(relation = :organization)
+      @scoped_organization = relation
+    end
+
+    def scoped_to_space(relation = :space)
+      @scoped_space = relation
+    end
+
+    # To query a single attribute using equality,
+    # you can use :query => ["attribute", "value"]
+    #
+    # To query multiple attributes, you can specify
+    # a hash of attributes to values, where the values
+    # can be:
+    #   A single value with equality
+    #     :query => {attr1: 'value1', attr2: 'value2'}
+    #   Multiple values for an attribute
+    #     :query => {attr1: ['value1', 'value2']}
+    #   Complex comparisons i.e ('<', '>', '<=', '>=')
+    #     :query => {attr1: QueryValue.new(comparator: '>', value: 'VALUE')}
+    #
+    # QueryValue can be found in CFoundry::V2::ModelMagic::QueryValueHelper
+    # You can include this module in your class to access QueryValue directly
+    # priting is handled by #to_s
+    def self.params_from(args)
+      options, _ = args
+      options ||= {}
+      options[:depth] ||= 1
+
+      params = {}
+      options.each do |k, v|
+        case k
+        when :depth
+          params[:"inline-relations-depth"] = v
+        when :query
+          if v.is_a? Array
+            params[:q] = v.join(":")
+          else
+            params[:q] = query_from_hash(v)
+          end
+        when :user_provided
+          params[:"return_user_provided_service_instances"] = v
+        else
+          params[k] = v
+        end
+      end
+
+      params
+    end
+
+    def self.query_from_hash(query_params)
+      query_params.collect do |key, value|
+        case value
+          when Array
+            qv = QueryValue.new(:comp => 'IN', :value => value)
+            "#{key}#{qv}"
+          when QueryValue
+            "#{key}#{value}"
+          when QueryMultiValue
+            value.collect_values(key)
+          else
+            "#{key}:#{value}"
+        end
+      end.join(";")
+    end
+  end
+end

data/lib/cfoundry/v2/organization.rb

@@ -0,0 +1,44 @@
+require 'cfoundry/v2/model'
+require "cfoundry/v2/helper"
+
+module CFoundry::V2
+  class Organization < Model
+    extend Helper
+
+    attribute :name, :string
+    attribute :billing_enabled, :boolean
+    attribute :status, :string
+
+    to_many   :spaces
+    to_many   :domains
+    to_many   :users
+    to_many   :managers, :as => :user
+    to_many   :billing_managers, :as => :user
+    to_many   :auditors, :as => :user
+
+    to_many_support   :spaces
+    to_many_support   :domains
+    to_many_support   :users
+    to_many_support   :managers
+    to_many_support   :billing_managers
+    to_many_support   :auditors
+
+    to_one    :quota_definition
+
+    queryable_by :name, :space_guid, :user_guid, :manager_guid,
+      :billing_manager_guid, :auditor_guid
+
+    def delete_user_from_all_roles(user)
+      remove_user(user)
+      remove_manager(user)
+      remove_billing_manager(user)
+      remove_auditor(user)
+
+      spaces.each do |space|
+        space.remove_developer(user)
+        space.remove_auditor(user)
+        space.remove_manager(user)
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/quota_definition.rb

@@ -0,0 +1,12 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class QuotaDefinition < Model
+    attribute :name,                       :string
+    attribute :non_basic_services_allowed, :boolean
+    attribute :total_services,             :integer
+    attribute :memory_limit,               :integer
+
+    queryable_by :name
+  end
+end

data/lib/cfoundry/v2/route.rb

@@ -0,0 +1,25 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Route < Model
+    attribute :host, :string
+    validates_format_of :host, :with => /\A[a-z]+([a-z0-9\-]*[a-z0-9]+)?\Z/i
+    validates_length_of :host, :maximum => 63
+    validates_presence_of :domain
+    validates_presence_of :space
+    to_one    :domain
+    to_one    :space
+
+    queryable_by :host, :domain_guid
+
+    def name
+      "#{host}.#{domain.name}"
+    end
+
+    private
+
+    def attribute_for_error(error)
+      error.is_a?(CFoundry::RouteHostTaken) ? :host : :base
+    end
+  end
+end

data/lib/cfoundry/v2/service.rb

@@ -0,0 +1,22 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Service < Model
+    attribute :label, String
+    attribute :provider, String
+    attribute :unique_id, String
+    attribute :url, :url
+    attribute :description, String
+    attribute :version, String
+    attribute :info_url, :url
+    attribute :acls, { "users" => [String], "wildcards" => [String] },
+      :default => nil
+    attribute :timeout, Integer, :default => nil
+    attribute :active, :boolean, :default => false
+    attribute :extra, String
+    attribute :tags, [String]
+    to_many   :service_plans
+
+    queryable_by :service_plan_guid
+  end
+end

data/lib/cfoundry/v2/service_auth_token.rb

@@ -0,0 +1,9 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class ServiceAuthToken < Model
+    attribute :label, :string
+    attribute :provider, :string
+    attribute :token, :string
+  end
+end

data/lib/cfoundry/v2/service_binding.rb

@@ -0,0 +1,10 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class ServiceBinding < Model
+    to_one    :app
+    to_one    :service_instance
+
+    queryable_by :app_guid, :service_instance_guid
+  end
+end

data/lib/cfoundry/v2/service_broker.rb

@@ -0,0 +1,12 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class ServiceBroker < Model
+    attribute :name, :string
+    attribute :broker_url, :string
+    attribute :auth_username, :string
+    attribute :auth_password, :string
+
+    queryable_by :name
+  end
+end

data/lib/cfoundry/v2/service_instance.rb

@@ -0,0 +1,14 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class ServiceInstance < Model
+    attribute :name, :string
+    attribute :dashboard_url, :string
+    to_one    :space
+    to_many   :service_bindings
+
+    scoped_to_space
+
+    queryable_by :name, :space_guid, :service_plan_guid, :service_binding_guid, :gateway_name
+  end
+end

data/lib/cfoundry/v2/service_plan.rb

@@ -0,0 +1,16 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class ServicePlan < Model
+    attribute :name, :string
+    attribute :description, :string
+    attribute :unique_id, String
+    attribute :free, :boolean, :default => false
+    attribute :extra, :string
+    attribute :public, :boolean
+    to_one    :service
+    to_many   :service_instances
+
+    queryable_by :service_guid, :service_instance_guid
+  end
+end