new_cfoundry 4.8.2

data/lib/cfoundry/v2/app_instance.rb

@@ -0,0 +1,74 @@
+module CFoundry::V2
+  class AppInstance
+    attr_reader :id
+
+    def self.for_app(name, guid, client)
+      client.base.instances(guid).collect do |i, m|
+        AppInstance.new(name, guid, i.to_s, client, m)
+      end
+    end
+
+    def initialize(app_name, app_guid, id, client, manifest = {})
+      @app_name = app_name
+      @app_guid = app_guid
+      @id = id
+      @client = client
+      @manifest = manifest
+    end
+
+    def inspect
+      "#<App::Instance '#{@app_name}' \##@id>"
+    end
+
+    def state
+      @manifest[:state]
+    end
+
+    alias_method :status, :state
+
+    def since
+      if since = @manifest[:since]
+        Time.at(@manifest[:since])
+      end
+    end
+
+    def debugger
+      return unless @manifest[:debug_ip] and @manifest[:debug_port]
+
+      {:ip => @manifest[:debug_ip],
+        :port => @manifest[:debug_port]
+      }
+    end
+
+    def console
+      return unless @manifest[:console_ip] and @manifest[:console_port]
+
+      {:ip => @manifest[:console_ip],
+        :port => @manifest[:console_port]
+      }
+    end
+
+    def healthy?
+      case state
+      when "STARTING", "RUNNING"
+        true
+      when "DOWN", "FLAPPING"
+        false
+      end
+    end
+
+    def files(*path)
+      @client.base.files(@app_guid, @id, *path).split("\n").collect do |entry|
+        path + [entry.split(/\s+/, 2)[0]]
+      end
+    end
+
+    def file(*path)
+      @client.base.files(@app_guid, @id, *path)
+    end
+
+    def stream_file(*path, &blk)
+      @client.base.stream_file(@app_guid, @id, *path, &blk)
+    end
+  end
+end

data/lib/cfoundry/v2/app_usage_event.rb

@@ -0,0 +1,14 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class AppUsageEvent < Model
+    attribute :state, :string
+    attribute :memory_in_mb_per_instance, :integer
+    attribute :instance_count, :integer
+    attribute :app_guid, :string
+    attribute :app_name, :string
+    attribute :space_guid, :string
+    attribute :space_name, :string
+    attribute :org_guid, :string
+  end
+end

data/lib/cfoundry/v2/base.rb

@@ -0,0 +1,108 @@
+require "multi_json"
+
+require "cfoundry/baseclient"
+require "cfoundry/uaaclient"
+
+require "cfoundry/errors"
+
+module CFoundry::V2
+  class Base < CFoundry::BaseClient
+    include BaseClientMethods
+
+    def resource_match(fingerprints)
+      put("v2", "resource_match", :content => :json, :accept => :json, :payload => fingerprints)
+    end
+
+    def upload_app(guid, zipfile = nil, resources = [])
+      payload = {}
+      payload[:resources] = MultiJson.dump(resources)
+
+      if zipfile
+        payload[:application] =
+          UploadIO.new(
+            if zipfile.is_a? File
+              zipfile
+            elsif zipfile.is_a? String
+              File.new(zipfile, "rb")
+            end,
+            "application/zip")
+      end
+
+      response = put("v2", "apps", guid, "bits",
+        :payload => payload,
+        :params => {"async" => "true"})
+
+      if response.present?
+        response_json = JSON.parse(response)
+        poll_upload_until_finished(response_json['metadata']['guid'])
+      end
+    rescue EOFError
+      retry
+    end
+
+    def poll_upload_until_finished(guid)
+      while true
+        response = get("v2", "jobs", guid, :accept => :json)
+        break if response[:entity][:status] == "finished"
+
+        if response[:entity][:status] == "failed"
+          raise CFoundry::BadResponse
+        end
+        sleep 0.2
+      end
+    end
+
+    def files(guid, instance, *path)
+      get("v2", "apps", guid, "instances", instance, "files", *path)
+    end
+
+    alias :file :files
+
+    def stream_file(guid, instance, *path, &blk)
+      path_and_options = path + [{:return_response => true, :follow_redirects => false}]
+      redirect = get("v2", "apps", guid, "instances", instance, "files", *path_and_options)
+
+      if location = redirect[:headers]["location"]
+        stream_url(location + "&tail", &blk)
+      else
+        yield redirect[:body]
+      end
+    end
+
+    def instances(guid)
+      get("v2", "apps", guid, "instances", :accept => :json)
+    end
+
+    def crashes(guid)
+      get("v2", "apps", guid, "crashes", :accept => :json)
+    end
+
+    def stats(guid)
+      get("v2", "apps", guid, "stats", :accept => :json)
+    end
+
+    def update_app(guid, diff)
+      put("v2", "apps", guid,
+          :content => :json,
+          :payload => diff,
+          :return_response => true)
+    end
+
+    def for_each(paginated, &block)
+      paginated[:resources].each &block
+
+      while (next_page = paginated[:next_url])
+        paginated = get(next_page, :accept => :json)
+        paginated[:resources].each &block
+      end
+    end
+
+    def all_pages(paginated)
+      payload = []
+      for_each(paginated) do |resource|
+        payload << resource
+      end
+      payload
+    end
+  end
+end

data/lib/cfoundry/v2/client.rb

@@ -0,0 +1,104 @@
+require File.expand_path("../../concerns/login_helpers", __FILE__)
+require "forwardable"
+
+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
+    include ClientMethods, CFoundry::LoginHelpers
+    extend Forwardable
+
+    # 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
+
+    def_delegators :@base, :target, :target=, :token, :token=, :http_proxy, :http_proxy=,
+      :https_proxy, :https_proxy=, :trace, :trace=, :log, :log=, :info
+
+    # Create a new Client for interfacing with the given target.
+    #
+    # A token may also be provided to skip the login step.
+    def initialize(target, token = nil)
+      @base = Base.new(target, token)
+    end
+
+    def version
+      2
+    end
+
+    # The currently authenticated user.
+    def current_user
+      return unless token
+
+      token_data = @base.token.token_data
+      if guid = token_data[:user_id]
+        user = user(guid)
+        user.emails = [{ :value => token_data[:email] }]
+        user
+      end
+    end
+
+    def login(credentials)
+      @current_organization = nil
+      @current_space = nil
+      super
+    end
+
+    def register(email, password, options = {})
+      uaa_user = @base.uaa.add_user(email, password, options)
+      cc_user = user
+      cc_user.guid = uaa_user[:id]
+      cc_user.create!
+      cc_user
+    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
+
+    def query_target(klass)
+      if klass.scoped_space && space = current_space
+        space
+      elsif klass.scoped_organization && org = current_organization
+        org
+      else
+        self
+      end
+    end
+
+    def stream_url(url, &blk)
+      @base.stream_url(url, &blk)
+    end
+
+    def service_instances(opts={})
+      opts[:user_provided] = true
+      super(opts)
+    end
+
+    def service_instances_from(path, *args)
+      opts = args.first || {}
+      opts[:user_provided] = true
+      super(path, opts, *args)
+    end
+
+    def make_service_instance(json)
+      klass = "CFoundry::V2::#{json[:entity][:type].camelize}".constantize
+      klass.new(
+        json[:metadata][:guid],
+        self,
+        json)
+    end
+  end
+end

data/lib/cfoundry/v2/domain.rb

@@ -0,0 +1,20 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Domain < Model
+    validates_presence_of :name
+    validates_format_of :name, :with => /\A([^\.]+\.)+[^\.]+\Z/
+    validates_presence_of :owning_organization
+
+    attribute :name, :string
+    attribute :wildcard, :boolean
+    to_one    :owning_organization, :as => :organization, :default => nil
+    to_many   :spaces
+
+    queryable_by :name, :owning_organization_guid, :space_guid
+
+    def system?
+      guid.present? && !owning_organization.present?
+    end
+  end
+end

data/lib/cfoundry/v2/event.rb

@@ -0,0 +1,17 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Event < Model
+    attribute :actee, :string
+    attribute :actee_type, :string
+    attribute :actor, :string
+    attribute :actor_type, :string
+    attribute :organization_guid, :string
+    attribute :space_guid, :string
+    attribute :timestamp, :string
+    attribute :type, :string
+    attribute :metadata, Hash
+
+    queryable_by :type, :timestamp
+  end
+end

data/lib/cfoundry/v2/helper.rb

@@ -0,0 +1,11 @@
+module CFoundry::V2::Helper
+  def to_many_support(plural)
+    singular = plural.to_s.sub(/s$/, "").to_sym
+
+    alias_method :"remove_#{singular}_without_support", :"remove_#{singular}"
+    define_method(:"remove_#{singular}") do |x|
+      result = self.__send__("remove_#{singular}_without_support", x)
+      result.nil?
+    end
+  end
+end

data/lib/cfoundry/v2/managed_service_instance.rb

@@ -0,0 +1,12 @@
+require "cfoundry/v2/service_instance"
+
+module CFoundry::V2
+  class ManagedServiceInstance < ServiceInstance
+    attribute :credentials, :hash
+    to_one    :service_plan
+
+    def self.object_name
+      'service_instance'
+    end
+  end
+end

data/lib/cfoundry/v2/model.rb

@@ -0,0 +1,211 @@
+require "multi_json"
+require "cfoundry/v2/model_magic"
+
+module CFoundry::V2
+  class Model
+    include ActiveModel::Validations
+
+    @@objects = {}
+
+    extend ModelMagic
+
+    class << self
+      def objects
+        @@objects
+      end
+
+      def inherited(klass)
+        @@objects[klass.object_name] = klass
+        super
+      end
+    end
+
+    attr_accessor :guid, :cache, :changes
+    attr_reader :created_at, :updated_at
+    attr_reader :diff
+
+    def initialize(guid, client, manifest = nil, partial = false)
+      @guid = guid
+      @client = client
+      @manifest = manifest
+      @partial = partial
+      @cache = {}
+      @diff = {}
+      @changes = {}
+    end
+
+    def created_at
+      timestamp = @manifest.try(:[], :metadata).try(:[], :created_at)
+      DateTime.parse(timestamp) if timestamp.present?
+    end
+
+    def updated_at
+      timestamp = @manifest.try(:[], :metadata).try(:[], :updated_at)
+      DateTime.parse(timestamp) if timestamp.present?
+    end
+
+    def manifest
+      @manifest ||= @client.base.send(object_name, @guid)
+    end
+
+    def partial?
+      @partial
+    end
+
+    def changed?
+      !@changes.empty?
+    end
+
+    def inspect
+      "\#<#{self.class.name} '#@guid'>"
+    end
+
+    def object_name
+      @object_name ||= self.class.object_name
+    end
+
+    def plural_object_name
+      @plural_object_name ||= self.class.plural_object_name
+    end
+
+    def invalidate!
+      @manifest = nil
+      @partial = false
+      @cache = {}
+      @diff = {}
+      @changes = {}
+    end
+
+    def create
+      create!
+      true
+    rescue CFoundry::APIError => e
+      if e.instance_of? CFoundry::APIError
+        errors.add(:base, :cc_client)
+      else
+        errors.add(attribute_for_error(e), e.message)
+      end
+      false
+    end
+
+    def attribute_for_error(error)
+      :base
+    end
+
+    # this does a bit of extra processing to allow for
+    # `delete!' followed by `create!'
+    def create!
+      payload = {}
+
+      @manifest ||= {}
+      @manifest[:entity] ||= {}
+
+      @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.empty? && 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
+        else
+          payload[k] = v
+        end
+      end
+
+      @manifest = @client.base.post("v2", create_endpoint_name,
+        :content => :json,
+        :accept => :json,
+        :payload => payload
+      )
+
+      @guid = @manifest[:metadata][:guid]
+
+      @diff.clear
+
+      true
+    end
+
+    def create_endpoint_name
+      plural_object_name
+    end
+
+    def update!
+      @manifest = @client.base.put("v2", plural_object_name, guid,
+        :content => :json,
+        :accept => :json,
+        :payload => @diff
+      )
+
+      @diff.clear
+
+      true
+    end
+
+    def delete(options = {})
+      delete!(options)
+    rescue CFoundry::APIError => e
+      if e.instance_of? CFoundry::APIError
+        errors.add(:base, :cc_client)
+      else
+        errors.add(attribute_for_error(e), e.message)
+      end
+      false
+    end
+
+    def delete!(options = {})
+      @client.base.delete("v2", plural_object_name, guid, :params => options)
+
+      @deleted = true
+
+      @diff.clear
+
+      if @manifest
+        @manifest.delete :metadata
+      end
+
+      true
+    end
+
+    def to_param
+      persisted? ? @guid.to_s : nil
+    end
+
+    def to_key
+      persisted? ? [@guid] : nil
+    end
+
+    def persisted?
+      @guid && !@deleted
+    end
+
+    def exists?
+      invalidate!
+      manifest
+      true
+    rescue CFoundry::NotFound
+      false
+    end
+
+    def query_target(klass)
+      self
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) && @guid == other.guid
+    end
+
+    alias :== :eql?
+
+    def hash
+      @guid.hash
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module CFoundry::V2::ModelMagic
+  module Attribute
+    def attribute(name, type, opts = {})
+      attributes[name] = opts
+      json_name = opts[:at] || name
+
+      default = opts[:default]
+
+      if has_default = opts.key?(:default)
+        defaults[name] = default
+      end
+
+      #
+      # def ATTRIBUTE
+      #
+      define_method(name) do
+        return @cache[name] if @cache.key?(name)
+        return nil unless persisted?
+
+        @cache[name] =
+          if manifest[:entity].key?(json_name)
+            manifest[:entity][json_name]
+          else
+            default
+          end
+      end
+
+      #
+      # def ATTRIBUTE=
+      #
+      define_method(:"#{name}=") do |val|
+        unless has_default && val == default
+          CFoundry::Validator.validate_type(val, type)
+        end
+
+        @cache[name] = val
+
+        @manifest ||= {}
+        @manifest[:entity] ||= {}
+
+        old = @manifest[:entity][json_name]
+        @changes[name] = [old, val] if old != val
+        @manifest[:entity][json_name] = val
+
+        @diff[json_name] = val
+      end
+    end
+  end
+end