cfoundry 0.2.2 → 0.3.0

data/lib/cfoundry/v1/client.rb

@@ -0,0 +1,205 @@
+require "cfoundry/v1/base"
+require "cfoundry/v1/app"
+require "cfoundry/v1/service"
+require "cfoundry/v1/service_instance"
+require "cfoundry/v1/user"
+
+
+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
+    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
+
+    # 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 user = info[:user]
+        user(user)
+      end
+    end
+
+
+    # Retrieve target metadata.
+    def info
+      @base.info
+    end
+
+    # Retrieve available services.
+    def services
+      services = []
+
+      @base.system_services.each do |type, vendors|
+        vendors.each do |vendor, versions|
+          versions.each do |num, meta|
+            services << Service.new(vendor, meta[:description], num)
+          end
+        end
+      end
+
+      services
+    end
+
+    # Retrieve available runtimes.
+    def runtimes
+      runtimes = []
+
+      @base.system_runtimes.each do |name, meta|
+        runtimes << Runtime.new(name.to_s, meta[:version])
+      end
+
+      runtimes
+    end
+
+    # Retrieve available frameworks.
+    def frameworks
+      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
+
+
+    # Retrieve user list. Admin-only.
+    def users
+      @base.users.collect do |json|
+        User.new(
+          json[:email],
+          self,
+          { :email => json[:email],
+            :admin => json[:admin] })
+      end
+    end
+
+    # Construct a User object. The return value is lazy, and no requests are
+    # made from this alone.
+    #
+    # This should be used for both user creation (after calling User#create!)
+    # and retrieval.
+    def user(email)
+      User.new(email, self)
+    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
+
+    # 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)
+      @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
+
+
+    # Retreive all of the current user's applications.
+    def apps
+      @base.apps.collect do |json|
+        App.new(json[:name], self, json)
+      end
+    end
+
+    # Construct an App object. The return value is lazy, and no requests are
+    # made from this method alone.
+    #
+    # This should be used for both app creation (after calling App#create!)
+    # and retrieval.
+    def app(name = nil)
+      App.new(name, self)
+    end
+
+
+    # Retrieve all of the current user's services.
+    def service_instances
+      @base.services.collect do |json|
+        Service.new(json[:name], self, json)
+      end
+    end
+
+    # Construct a Service object. The return value is lazy, and no requests are
+    # made from this method alone.
+    #
+    # This should be used for both service creation (after calling
+    # Service#create!) and retrieval.
+    def service_instance(name = nil)
+      ServiceInstance.new(name, self)
+    end
+  end
+end

data/lib/cfoundry/v1/framework.rb

@@ -0,0 +1,16 @@
+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 apps
+      [] # not supported by v1
+    end
+  end
+end

data/lib/cfoundry/v1/runtime.rb

@@ -0,0 +1,14 @@
+module CFoundry::V1
+  class Runtime
+    attr_accessor :name, :description
+
+    def initialize(name, description = nil)
+      @name = name
+      @description = description
+    end
+
+    def apps
+      [] # not supported by v1
+    end
+  end
+end

data/lib/cfoundry/v1/service.rb

@@ -0,0 +1,19 @@
+module CFoundry::V1
+  class Service
+    attr_accessor :label, :description, :version
+
+    def initialize(label, description = nil, version = nil)
+      @label = label
+      @description = description
+      @version = version
+    end
+
+    def provider
+      "core"
+    end
+
+    def active
+      true
+    end
+  end
+end

data/lib/cfoundry/{service.rb → v1/service_instance.rb}

@@ -1,11 +1,11 @@
-module CFoundry
+module CFoundry::V1
   # Class for representing a user's service on a given target (via Client).
   #
-  # Goes not guarantee that the service exists; used for both service creation
+  # Does not guarantee that the service exists; used for both service creation
   # and retrieval, as the attributes are all lazily retrieved. Setting
   # attributes does not perform any requests; use #update! to commit your
   # changes.
-  class Service
+  class ServiceInstance
     # Service name.
     attr_reader :name
 
@@ -43,19 +43,19 @@ module CFoundry
 
     # Delete the service from the target.
     def delete!
-      @client.rest.delete_service(@name)
+      @client.base.delete_service(@name)
     end
 
     # Create the service on the target.
     #
     # Call this after setting the various attributes.
     def create!
-      @client.rest.create_service(@manifest.merge("name" => @name))
+      @client.base.create_service(@manifest.merge(:name => @name))
     end
 
     # Check if the service exists on the target.
     def exists?
-      @client.rest.service(@name)
+      @client.base.service(@name)
       true
     rescue CFoundry::NotFound
       false
@@ -63,20 +63,20 @@ module CFoundry
 
     # Timestamp of when the service was created.
     def created
-      Time.at(meta["created"])
+      Time.at(meta[:created])
     end
 
     # Timestamp of when the service was last updated.
     def updated
-      Time.at(meta["updated"])
+      Time.at(meta[:updated])
     end
 
-    { :type => "type",
-      :vendor => "vendor",
-      :version => "version",
-      :properties => "properties",
-      :tier => "tier",
-      :meta => "meta"
+    { :type => :type,
+      :vendor => :vendor,
+      :version => :version,
+      :properties => :properties,
+      :tier => :tier,
+      :meta => :meta
     }.each do |meth, attr|
       define_method(meth) do
         manifest[attr]
@@ -91,7 +91,7 @@ module CFoundry
     private
 
     def manifest
-      @manifest ||= @client.rest.service(@name)
+      @manifest ||= @client.base.service(@name)
     end
   end
 end

data/lib/cfoundry/{user.rb → v1/user.rb}

@@ -1,7 +1,7 @@
-module CFoundry
+module CFoundry::V1
   # Class for representing a user on a given target (via Client).
   #
-  # Goes not guarantee that the user exists; used for both user creation and
+  # Does not guarantee that the user exists; used for both user creation and
   # retrieval, as the attributes are all lazily retrieved. Setting attributes
   # does not perform any requests; use #update! to commit your changes.
   class User
@@ -25,25 +25,25 @@ module CFoundry
 
     # Delete the user from the target.
     def delete!
-      @client.rest.delete_user(@email)
+      @client.base.delete_user(@email)
     end
 
     # Create the user on the target.
     #
     # Call this after setting the various attributes.
     def create!
-      @client.rest.create_user(@manifest.merge("email" => @email))
+      @client.base.create_user(@manifest.merge(:email => @email))
     end
 
     # Update user attributes.
     def update!(what = {})
-      @client.rest.update_user(@email, manifest.merge(what))
+      @client.base.update_user(@email, manifest.merge(what))
       @manifest = nil
     end
 
     # Check if the user exists on the target.
     def exists?
-      @client.rest.user(@email)
+      @client.base.user(@email)
       true
     rescue CFoundry::Denied
       false
@@ -51,20 +51,20 @@ module CFoundry
 
     # Check if the user is an administrator.
     def admin?
-      manifest["admin"]
+      manifest[:admin]
     end
 
     # Set the user's password.
     #
     # Call #update! after using this.
     def password=(str)
-      manifest["password"] = str
+      manifest[:password] = str
     end
 
     private
 
     def manifest
-      @manifest ||= @client.rest.user(@email)
+      @manifest ||= @client.base.user(@email)
     end
   end
 end

data/lib/cfoundry/v2/app.rb

@@ -0,0 +1,119 @@
+require "fileutils"
+require "digest/sha1"
+require "pathname"
+require "tmpdir"
+
+require "cfoundry/zip"
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  # Class for representing a user's application on a given target (via
+  # Client).
+  #
+  # Does not guarantee that the app exists; used for both app creation and
+  # retrieval, as the attributes are all lazily retrieved. Setting attributes
+  # does not perform any requests; use #update! to commit your changes.
+  class App < Model
+    attribute :name
+    attribute :production
+    to_one    :app_space
+    to_one    :runtime
+    to_one    :framework
+    attribute :environment_json,    :default => {}
+    attribute :memory,              :default => 256
+    attribute :instances,           :default => 1
+    attribute :file_descriptors,    :default => 256
+    attribute :disk_quota,          :default => 256
+    attribute :state,               :default => "STOPPED"
+    to_many   :service_bindings
+
+    alias :total_instances :instances
+    alias :total_instances= :instances=
+
+    alias :services :service_bindings
+    alias :services= :service_bindings=
+
+    alias :space :app_space
+    alias :space= :app_space=
+
+    def debug_mode # TODO v2
+      nil
+    end
+    alias :console :debug_mode
+
+    def uris # TODO v2
+      []
+    end
+    alias :urls :uris
+
+    def uris=(x)
+      nil
+    end
+    alias :urls= :uris=
+
+    def uri
+      uris[0]
+    end
+    alias :url :uri
+
+    # Stop the application.
+    def stop!
+      update! :state => "STOPPED"
+    end
+
+    # Start the application.
+    def start!
+      update! :state => "STARTED"
+    end
+
+    # Restart the application.
+    def restart!
+      stop!
+      start!
+    end
+
+    # Determine application health.
+    #
+    # If all instances are running, returns "RUNNING". If only some are
+    # started, returns the precentage of them that are healthy.
+    #
+    # Otherwise, returns application's status.
+    def health
+      state
+    end
+
+    # Check that all application instances are running.
+    def healthy?
+      # invalidate cache so the check is fresh
+      @manifest = nil
+      health == "RUNNING"
+    end
+    alias_method :running?, :healthy?
+
+    # Is the application stopped?
+    def stopped?
+      state == "STOPPED"
+    end
+
+    # Is the application started?
+    #
+    # Note that this does not imply that all instances are running. See
+    # #healthy?
+    def started?
+      state == "STARTED"
+    end
+
+    # Bind services to application.
+    def bind(*service_names)
+      update!(:services => services + service_names)
+    end
+
+    # Unbind services from application.
+    def unbind(*service_names)
+      update!(:services =>
+                services.reject { |s|
+                  service_names.include?(s)
+                })
+    end
+  end
+end