cfoundry 0.6.1.rc4 → 0.7.0.rc1

data/lib/cfoundry/v1/base.rb

@@ -1,90 +0,0 @@
-require "multi_json"
-require "tmpdir"
-
-require "cfoundry/baseclient"
-require "cfoundry/uaaclient"
-
-require "cfoundry/errors"
-
-module CFoundry::V1
-  class Base < CFoundry::BaseClient
-    include BaseClientMethods
-
-    def system_services
-      get("services", "v1", "offerings", :content => :json, :accept => :json)
-    end
-
-    def system_runtimes
-      get("info", "runtimes", :accept => :json)
-    end
-
-    # Users
-    def create_user(payload)
-      # no JSON response
-      post("users", :content => :json, :payload => payload)
-    end
-
-    def create_token(payload, email)
-      post("users", email, "tokens", :content => :json, :accept => :json, :payload => payload)
-    end
-
-    # Applications
-    def instances(name)
-      get("apps", name, "instances", :accept => :json)[:instances]
-    end
-
-    def crashes(name)
-      get("apps", name, "crashes", :accept => :json)[:crashes]
-    end
-
-    def files(name, instance, *path)
-      get("apps", name, "instances", instance, "files", *path)
-    end
-    alias :file :files
-
-    def stats(name)
-      get("apps", name, "stats", :accept => :json)
-    end
-
-    def resource_match(fingerprints)
-      post("resources", :content => :json, :accept => :json, :payload => fingerprints)
-    end
-
-    def upload_app(name, zipfile = nil, resources = [])
-      use_or_create_empty_zipfile(zipfile) do |zipfile|
-        payload = {
-          :_method => "put",
-          :resources => MultiJson.dump(resources),
-          :application =>
-            UploadIO.new(
-              if zipfile.is_a? File
-                zipfile
-              elsif zipfile.is_a? String
-                File.new(zipfile, "rb")
-              end,
-              "application/zip")
-        }
-
-        post("apps", name, "application", :payload => payload)
-      end
-    rescue EOFError
-      retry
-    end
-
-    private
-
-    def use_or_create_empty_zipfile(zipfile)
-      Dir.mktmpdir do |working_dir|
-        zip_path = "#{working_dir}/empty_zip.zip"
-
-        zipfile ||= Dir.mktmpdir do |zip_dir|
-          File.new("#{zip_dir}/.__empty_file", "wb").close
-          CFoundry::Zip.pack(zip_dir, zip_path)
-          zip_path
-        end
-
-        yield zipfile
-      end
-    end
-  end
-end

data/lib/cfoundry/v1/client.rb

@@ -1,193 +0,0 @@
-require File.expand_path("../../concerns/login_helpers", __FILE__)
-
-module CFoundry::V1
-  # 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
-
-    attr_reader :base
-
-    # 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
-
-    def version
-      1
-    end
-
-    # The current target URL of the client.
-    def target
-      @base.target
-    end
-
-    # Current authentication token.
-    def token
-      @base.token
-    end
-
-    # Set the authentication token.
-    def token=(token)
-      @base.token = token
-    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 current log. See +log=+.
-    def log
-      @base.log
-    end
-
-    # Set the logging mode. Mode can be one of:
-    #
-    # [+String+] Name of a file to log the last 10 requests to.
-    # [+Array+]  Array to append with log data (a Hash).
-    # [+IO+]     An IO object to write to.
-    # [+false+]  No logging.
-    def log=(mode)
-      @base.log = mode
-    end
-
-    # The currently authenticated user.
-    def current_user
-      if user = info[:user]
-        user(user)
-      end
-    end
-
-    def current_space
-      nil
-    end
-
-    def current_organization
-      nil
-    end
-
-
-    # Retrieve target metadata.
-    def info
-      @base.info
-    end
-
-    # Retrieve available services.
-    def services(options = {})
-      services = []
-
-      @base.system_services.each do |type, vendors|
-        vendors.each do |vendor, providers|
-          providers.each do |provider, properties|
-            properties.each do |_, meta|
-              meta[:supported_versions].each do |ver|
-                state = meta[:version_aliases].find { |k, v| v == ver }
-
-                services <<
-                  Service.new(vendor.to_s, ver.to_s, meta[:description],
-                              type.to_s, provider.to_s, state && state.first,
-                              generate_plans(meta))
-              end
-            end
-          end
-        end
-      end
-
-      services
-    end
-
-    def generate_plans(meta)
-      names = meta[:plans]
-      descriptions = meta[:plan_descriptions]
-      default_name = meta[:default_plan]
-      names.map { |name|
-        description = descriptions[name.to_sym] if descriptions
-        is_default = name == default_name || names.length == 1
-        ServicePlan.new(name, description, is_default)
-      }
-    end
-
-    # Retrieve available runtimes.
-    def runtimes(options = {})
-      runtimes = []
-
-      @base.system_runtimes.each do |name, meta|
-        runtimes <<
-          Runtime.new(name.to_s, meta[:version], meta[:debug_modes])
-      end
-
-      runtimes
-    end
-
-    def runtime(name)
-      Runtime.new(name)
-    end
-
-    def runtime_by_name(name)
-      runtimes.find { |r| r.name == name }
-    end
-
-    # Retrieve available frameworks.
-    def frameworks(options = {})
-      fs = info[:frameworks]
-      return unless fs
-
-      frameworks = []
-      fs.each do |name, meta|
-        runtimes = meta[:runtimes].collect do |r|
-          Runtime.new(r[:name], r[:description])
-        end
-
-        frameworks <<
-          Framework.new(name.to_s, nil, runtimes, meta[:detection])
-      end
-
-      frameworks
-    end
-
-    def framework(name)
-      Framework.new(name)
-    end
-
-    def framework_by_name(name)
-      frameworks.find { |f| f.name == name }
-    end
-
-    # Create a user on the target and return a User object representing them.
-    def register(email, password)
-      @base.create_user(:email => email, :password => password)
-      user(email)
-    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
-  end
-end

data/lib/cfoundry/v1/framework.rb

@@ -1,21 +0,0 @@
-module CFoundry::V1
-  class Framework
-    attr_accessor :name, :description, :runtimes, :detection
-
-    def initialize(name, description = nil, runtimes = [], detection = nil)
-      @name = name
-      @description = description
-      @runtimes = runtimes
-      @detection = detection
-    end
-
-    def eql?(other)
-      other.is_a?(self.class) && other.name == @name
-    end
-    alias :== :eql?
-
-    def apps
-      [] # not supported by v1
-    end
-  end
-end

data/lib/cfoundry/v1/model.rb

@@ -1,178 +0,0 @@
-require "multi_json"
-
-require "cfoundry/v1/model_magic"
-
-
-module CFoundry::V1
-  class Model
-    @@objects = {}
-
-    extend ModelMagic
-
-    class << self
-      attr_writer :object_name, :base_object_name
-
-      def object_name
-        @object_name ||=
-          name.split("::").last.gsub(
-            /([a-z])([A-Z])/,
-            '\1_\2').downcase.to_sym
-      end
-
-      def base_object_name
-        @base_object_name ||= object_name
-      end
-
-      def plural_object_name
-        "#{object_name}s"
-      end
-
-      def plural_base_object_name
-        "#{base_object_name}s"
-      end
-
-      def objects
-        @@objects
-      end
-
-      def inherited(klass)
-        @@objects[klass.object_name] = klass
-        super
-      end
-    end
-
-    attr_accessor :guid, :changes
-
-    def initialize(guid, client, manifest = nil)
-      @guid = guid
-      @client = client
-      @manifest = manifest
-      @changes = {}
-    end
-
-    def manifest
-      @manifest ||= @client.base.send(base_object_name, @guid)
-    end
-
-    def changed?
-      !@changes.empty?
-    end
-
-    def inspect
-      "\#<#{self.class.name} '#@guid'>"
-    end
-
-    def object_name
-      @object_name ||= self.class.object_name
-    end
-
-    def base_object_name
-      @base_object_name ||= self.class.base_object_name
-    end
-
-    def guid_name
-      self.class.guid_name
-    end
-
-    def invalidate!
-      @manifest = nil
-      @changes = {}
-    end
-
-    def create!
-      @manifest = @client.base.send(:"create_#{base_object_name}", write_manifest)
-
-      @guid = read_manifest[guid_name]
-
-      true
-    end
-
-    def update!
-      @client.base.send(:"update_#{base_object_name}", @guid, write_manifest)
-
-      true
-    end
-
-    def delete!
-      @client.base.send(:"delete_#{base_object_name}", @guid)
-
-      @guid = nil
-
-      true
-    end
-
-    def exists?
-      invalidate!
-      manifest
-      true
-    rescue CFoundry::NotFound
-      false
-    end
-
-    def read_manifest
-      read = {}
-
-      self.class.read_locations.each do |name, where|
-        found, val = find_path(manifest, where)
-        read[name] = val if found
-      end
-
-      self.class.write_locations.each do |name, where|
-        next if self.class.read_only_attributes.include? name
-
-        found, val = find_path(manifest, where)
-        read[name] = val if found
-      end
-
-      read[guid_name] = @guid
-
-      read
-    end
-
-    def find_path(hash, path)
-      return [false, nil] unless hash
-
-      first, *rest = path
-      return [false, nil] unless hash.key?(first)
-
-      here = hash[first]
-
-      if rest.empty?
-        [true, here]
-      else
-        find_path(here, rest)
-      end
-    end
-
-    def write_manifest(body = read_manifest, onto = {})
-      onto[guid_name] = @guid if guid_name
-
-      self.class.write_locations.each do |name, where|
-        next if self.class.read_only_attributes.include? name
-        put(body[name], onto, where) if body.key?(name)
-      end
-
-      onto
-    end
-
-    def put(what, where, path)
-      if path.size == 1
-        where[path.last] = what
-      elsif name = path.first
-        where[name] ||= {}
-        put(what, where[name], path[1..-1])
-      end
-
-      nil
-    end
-
-    def eql?(other)
-      other.is_a?(self.class) && @guid == other.guid
-    end
-    alias :== :eql?
-
-    def hash
-      @guid.hash
-    end
-  end
-end