cfoundry 0.4.8 → 0.4.9

data/lib/cfoundry/chatty_hash.rb

@@ -34,5 +34,13 @@ module CFoundry
     def to_hash
       @hash
     end
+
+    def to_s
+      @hash.to_s
+    end
+
+    def inspect
+      @hash.inspect
+    end
   end
 end

data/lib/cfoundry/client.rb

@@ -1,18 +1,25 @@
 require "cfoundry/baseclient"
 
+require "cfoundry/v1/app"
+require "cfoundry/v1/framework"
+require "cfoundry/v1/runtime"
+require "cfoundry/v1/service"
+require "cfoundry/v1/service_instance"
+require "cfoundry/v1/user"
+require "cfoundry/v1/base"
 require "cfoundry/v1/client"
 
 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/organization"
+require "cfoundry/v2/space"
 require "cfoundry/v2/domain"
 require "cfoundry/v2/route"
 require "cfoundry/v2/base"

data/lib/cfoundry/upload_helpers.rb

@@ -1,31 +1,54 @@
+require "tmpdir"
 require "fileutils"
 require "pathname"
 require "digest/sha1"
 
+require "cfoundry/zip"
+
 module CFoundry
   module UploadHelpers
     # Default paths to exclude from upload payload.
     UPLOAD_EXCLUDE = %w{.git _darcs .svn}
 
-    def make_fingerprints(path)
-      fingerprints = []
-      total_size = 0
+    # Minimum size for an application payload to bother checking resources.
+    RESOURCE_CHECK_LIMIT = 64 * 1024
+
+    # Upload application's code to target. Do this after #create! and before
+    # #start!
+    #
+    # [path]
+    #   A path pointing to either a directory, or a .jar, .war, or .zip
+    #   file.
+    #
+    #   If a .vmcignore file is detected under the given path, it will be used
+    #   to exclude paths from the payload, similar to a .gitignore.
+    #
+    # [check_resources]
+    #   If set to `false`, the entire payload will be uploaded
+    #   without checking the resource cache.
+    #
+    #   Only do this if you know what you're doing.
+    def upload(path, check_resources = true)
+      unless File.exist? path
+        raise CFoundry::Error, "Invalid application path '#{path}'"
+      end
 
-      Dir.glob("#{path}/**/*", File::FNM_DOTMATCH) do |filename|
-        next if File.directory?(filename)
+      zipfile = "#{Dir.tmpdir}/#{@guid}.zip"
+      tmpdir = "#{Dir.tmpdir}/.vmc_#{@guid}_files"
 
-        size = File.size(filename)
+      FileUtils.rm_f(zipfile)
+      FileUtils.rm_rf(tmpdir)
 
-        total_size += size
+      prepare_package(path, tmpdir)
 
-        fingerprints << {
-          :size => size,
-          :sha1 => Digest::SHA1.file(filename).hexdigest,
-          :fn => filename
-        }
-      end
+      resources = determine_resources(tmpdir) if check_resources
 
-      [fingerprints, total_size]
+      packed = CFoundry::Zip.pack(tmpdir, zipfile)
+
+      @client.base.upload_app(@guid, packed && zipfile, resources || [])
+    ensure
+      FileUtils.rm_f(zipfile) if zipfile
+      FileUtils.rm_rf(tmpdir) if tmpdir
     end
 
     def prepare_package(path, to)
@@ -97,5 +120,41 @@ module CFoundry
       files = Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
       files && files.select { |f| File.socket? f }
     end
+
+    def determine_resources(path)
+      fingerprints, total_size = make_fingerprints(path)
+
+      return if total_size <= RESOURCE_CHECK_LIMIT
+
+      resources = @client.base.resource_match(fingerprints)
+
+      resources.each do |resource|
+        FileUtils.rm_f resource[:fn]
+        resource[:fn].sub!("#{path}/", "")
+      end
+
+      resources
+    end
+
+    def make_fingerprints(path)
+      fingerprints = []
+      total_size = 0
+
+      Dir.glob("#{path}/**/*", File::FNM_DOTMATCH) do |filename|
+        next if File.directory?(filename)
+
+        size = File.size(filename)
+
+        total_size += size
+
+        fingerprints << {
+          :size => size,
+          :sha1 => Digest::SHA1.file(filename).hexdigest,
+          :fn => filename
+        }
+      end
+
+      [fingerprints, total_size]
+    end
   end
 end

data/lib/cfoundry/v1/app.rb

@@ -1,123 +1,99 @@
-require "tmpdir"
-
-require "cfoundry/zip"
 require "cfoundry/upload_helpers"
 require "cfoundry/chatty_hash"
 
-require "cfoundry/v1/framework"
-require "cfoundry/v1/runtime"
+require "cfoundry/v1/model"
 
 module CFoundry::V1
-  # 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
+  class App < Model
     include CFoundry::UploadHelpers
 
-    # Application name.
-    attr_accessor :name
+    attribute :name,      :string,   :guid => true
+    attribute :instances, :integer
+    attribute :state,     :string
+    attribute :created,   :integer,  :at => [:meta, :created]
+    attribute :version,   :integer,  :at => [:meta, :version]
+    attribute :framework, :string,   :at => [:staging, :model]
+    attribute :runtime,   :string,   :at => [:staging, :stack]
+    attribute :command,   :string,   :at => [:staging, :command]
+    attribute :memory,    :integer,  :at => [:resources, :memory]
+    attribute :disk,      :integer,  :at => [:resources, :disk]
+    attribute :fds,       :integer,  :at => [:resources, :fds]
+    attribute :env,       [:string], :default => []
+    attribute :uris,      [:string], :default => []
+    attribute :services,  [:string], :default => []
 
-    # Application instance count.
-    attr_accessor :total_instances
+    attribute :console, :boolean, :default => false,
+              :read => [:meta, :console], :write => :console
 
-    # Services bound to the application.
-    attr_accessor :services
+    attribute :debug, :string, :default => nil, :read => [:meta, :debug],
+              :write => :debug
 
-    # Application environment variables.
-    attr_accessor :env
+    attribute :running_instances, :integer, :read => :runningInstances,
+              :read_only => true
 
-    # Application memory limit.
-    attr_accessor :memory
 
-    # Application framework.
-    attr_accessor :framework
+    define_client_methods
 
-    # Application runtime.
-    attr_accessor :runtime
 
-    # Application startup command.
-    #
-    # Used for standalone apps.
-    attr_accessor :command
+    alias_method :total_instances, :instances
+    alias_method :total_instances=, :instances=
+
+    alias_method :debug_mode, :debug
+    alias_method :debug_mode=, :debug=
+
+    alias_method :framework_name, :framework
+    alias_method :framework_name=, :framework=
+
+    alias_method :runtime_name, :runtime
+    alias_method :runtime_name=, :runtime=
 
-    # Application debug mode.
-    attr_accessor :debug_mode
+    alias_method :service_names, :services
+    alias_method :service_names=, :services=
 
-    # Application state.
-    attr_accessor :state
     alias_method :status, :state
+    alias_method :status=, :state=
 
-    # URIs mapped to the application.
-    attr_accessor :uris
     alias_method :urls, :uris
+    alias_method :urls=, :uris=
 
+    alias_method :env_array, :env
+    alias_method :env_array=, :env=
 
-    # Create an App object.
-    #
-    # You'll usually call Client#app instead
-    def initialize(name, client, manifest = nil)
-      @name = name
-      @client = client
-      @manifest = manifest
-      @diff = {}
+    def framework
+      @client.framework(framework_name)
     end
 
-    # Show string representing the application.
-    def inspect
-      "#<App '#@name'>"
+    def framework=(obj)
+      set_named(:framework, obj)
     end
 
-    # Basic equality test by name.
-    def eql?(other)
-      other.is_a?(self.class) && other.name == @name
+    def runtime
+      @client.runtime(runtime_name)
     end
-    alias :== :eql?
-
-    # Delete the application from the target.
-    #
-    # Keeps the metadata, but clears target-specific state from it.
-    def delete!
-      @client.base.delete_app(@name)
 
-      if @manifest
-        @diff = read_manifest
-        @manifest = nil
-      end
+    def runtime=(obj)
+      set_named(:runtime, obj)
     end
 
-    # Create the application on the target.
-    #
-    # Call this after setting the various attributes.
-    def create!
-      @client.base.create_app(create_manifest)
-      @diff = {}
+    def services
+      service_names.collect { |name| @client.service_instance(name) }
     end
 
-    def invalidate!
-      @manifest = nil
+    def services=(objs)
+      set_many_named(:service, objs)
     end
 
-    # Check if the application exists on the target.
-    def exists?
-      @client.base.app(@name)
-      true
-    rescue CFoundry::AppNotFound
-      false
-    end
 
     # Retrieve all of the instances of the app, as Instance objects.
     def instances
-      @client.base.instances(@name).collect do |m|
+      @client.base.instances(@guid).collect do |m|
         Instance.new(self, m[:index].to_s, @client, m)
       end
     end
 
     # Retrieve crashed instances
     def crashes
-      @client.base.crashes(@name).collect do |i|
+      @client.base.crashes(@guid).collect do |i|
         Instance.new(self, i[:instance].to_s, @client, i)
       end
     end
@@ -126,35 +102,23 @@ module CFoundry::V1
     def stats
       stats = {}
 
-      @client.base.stats(@name).each do |idx, info|
+      @client.base.stats(@guid).each do |idx, info|
         stats[idx.to_s] = info
       end
 
       stats
     end
 
-    # Update application attributes. Does not restart the application.
-    def update!(what = {})
-      what.each do |k, v|
-        send(:"#{k}=", v)
-      end
-
-      @client.base.update_app(@name, update_manifest)
-
-      @manifest = nil
-      @diff = {}
-
-      self
-    end
-
     # Stop the application.
     def stop!
-      update! :state => "STOPPED"
+      self.state = "STOPPED"
+      update!
     end
 
     # Start the application.
     def start!
-      update! :state => "STARTED"
+      self.state = "STARTED"
+      update!
     end
 
     # Restart the application.
@@ -193,7 +157,7 @@ module CFoundry::V1
     # Check that all application instances are running.
     def healthy?
       # invalidate cache so the check is fresh
-      @manifest = nil
+      invalidate!
       health == "RUNNING"
     end
     alias_method :running?, :healthy?
@@ -212,40 +176,6 @@ module CFoundry::V1
     end
 
 
-    { :total_instances => :instances,
-      :running_instances => :running_instances,
-      :runtime_name => :runtime,
-      :framework_name => :framework,
-      :service_names => :services,
-      :env_array => :env,
-      :state => :state,
-      :status => :state,
-      :uris => :uris,
-      :urls => :uris,
-      :command => :command,
-      :console => :console,
-      :memory => :memory,
-      :disk => :disk,
-      :fds => :fds,
-      :debug_mode => :debug,
-      :version => :version,
-      :meta_version => :meta_version,
-      :created => :created
-    }.each do |meth, attr|
-      define_method(meth) do
-        if @diff.key?(attr)
-          @diff[attr]
-        else
-          read_manifest[attr]
-        end
-      end
-
-      define_method(:"#{meth}=") do |v|
-        @diff[attr] = v
-      end
-    end
-
-
     # Shortcut for uris[0]
     def uri
       uris[0]
@@ -256,28 +186,8 @@ module CFoundry::V1
       self.uris = [x]
     end
 
-    alias :url :uri
-    alias :url= :uri=
-
-    # Application framework.
-    def framework
-      Framework.new(framework_name)
-    end
-
-    def framework=(v) # :nodoc:
-      v = v.name if v.is_a?(Framework)
-      self.framework_name = v
-    end
-
-    # Application runtime.
-    def runtime
-      Runtime.new(runtime_name)
-    end
-
-    def runtime=(v) # :nodoc:
-      v = v.name if v.is_a?(Runtime)
-      self.runtime_name = v
-    end
+    alias_method :url, :uri
+    alias_method :url=, :uri=
 
     def env
       e = env_array || []
@@ -312,15 +222,14 @@ module CFoundry::V1
 
     # Bind services to application.
     def bind(*instances)
-      update!(:services => services + instances)
+      self.services += instances
+      update!
     end
 
     # Unbind services from application.
     def unbind(*instances)
-      update!(:services =>
-                services.reject { |s|
-                  instances.any? { |i| i.name == s.name }
-                })
+      self.services -= instances
+      update!
     end
 
     def binds?(instance)
@@ -347,139 +256,28 @@ module CFoundry::V1
       Instance.new(self, "0", @client).file(*path)
     end
 
-    # Upload application's code to target. Do this after #create! and before
-    # #start!
-    #
-    # [path]
-    #   A path pointing to either a directory, or a .jar, .war, or .zip
-    #   file.
-    #
-    #   If a .vmcignore file is detected under the given path, it will be used
-    #   to exclude paths from the payload, similar to a .gitignore.
-    #
-    # [check_resources]
-    #   If set to `false`, the entire payload will be uploaded
-    #   without checking the resource cache.
-    #
-    #   Only do this if you know what you're doing.
-    def upload(path, check_resources = true)
-      unless File.exist? path
-        raise CFoundry::Error, "Invalid application path '#{path}'"
-      end
-
-      zipfile = "#{Dir.tmpdir}/#{@name}.zip"
-      tmpdir = "#{Dir.tmpdir}/.vmc_#{@name}_files"
-
-      FileUtils.rm_f(zipfile)
-      FileUtils.rm_rf(tmpdir)
-
-      prepare_package(path, tmpdir)
-
-      resources = determine_resources(tmpdir) if check_resources
-
-      packed = CFoundry::Zip.pack(tmpdir, zipfile)
-
-      @client.base.upload_app(@name, packed && zipfile, resources || [])
-    ensure
-      FileUtils.rm_f(zipfile) if zipfile
-      FileUtils.rm_rf(tmpdir) if tmpdir
-    end
-
     private
 
-    ATTR_MAP = {
-      :instances => :instances,
-      :state => :state,
-      :env => :env,
-      :uris => :uris,
-      :services => :services,
-      :debug => :debug,
-      :console => :console,
-
-      :framework => [:staging, :model],
-      :runtime => [:staging, :stack],
-      :command => [:staging, :command],
-
-      :meta_version => [:meta, :version],
-      :created => [:meta, :created],
-
-      :memory => [:resources, :memory],
-      :disk => [:resources, :disk],
-      :fds => [:resources, :fds]
-    }
-
-    def manifest
-      @manifest ||= @client.base.app(@name)
-    end
-
-    def write_manifest(body = read_manifest, onto = {})
-      onto[:name] = @name
+    def set_named(attr, val)
+      res = send(:"#{attr}_name=", val.name)
 
-      ATTR_MAP.each do |what, where|
-        if body.key?(what)
-          put(body[what], onto, Array(where))
-        end
-      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])
+      if @changes.key?(attr)
+        old, new = @changes[attr]
+        @changes[attr] = [@client.send(attr, old), val]
       end
 
-      nil
-    end
-
-    def update_manifest
-      write_manifest(@diff, write_manifest)
-    end
-
-    def create_manifest
-      write_manifest(@diff)
+      res
     end
 
-    def read_manifest
-      { :name => @name,
-        :instances => manifest[:instances],
-        :running_instances => manifest[:runningInstances],
-        :state => manifest[:state],
-        :env => manifest[:env],
-        :uris => manifest[:uris],
-        :version => manifest[:version],
-        :services => manifest[:services],
-        :framework => manifest[:staging][:model],
-        :runtime => manifest[:staging][:stack],
-        :console => manifest[:meta][:console],
-        :meta_version => manifest[:meta][:version],
-        :debug => manifest[:meta][:debug],
-        :created => manifest[:meta][:created],
-        :memory => manifest[:resources][:memory],
-        :disk => manifest[:resources][:disk],
-        :fds => manifest[:resources][:fds]
-      }
-    end
-
-    # Minimum size for an application payload to bother checking resources.
-    RESOURCE_CHECK_LIMIT = 64 * 1024
-
-    def determine_resources(path)
-      fingerprints, total_size = make_fingerprints(path)
-
-      return if total_size <= RESOURCE_CHECK_LIMIT
-
-      resources = @client.base.check_resources(fingerprints)
+    def set_many_named(attr, vals)
+      res = send(:"#{attr}_names=", val.collect(&:name))
 
-      resources.each do |resource|
-        FileUtils.rm_f resource[:fn]
-        resource[:fn].sub!("#{path}/", "")
+      if @changes.key?(attr)
+        old, new = @changes[attr]
+        @changes[attr] = [old.collect { |o| @client.send(attr, o) }, vals]
       end
 
-      resources
+      vals
     end
 
     # Class represnting a running instance of an application.
@@ -547,24 +345,12 @@ module CFoundry::V1
         end
       end
 
-      # Retrieve file listing under path for this instance.
-      #
-      # [path]
-      #   A sequence of strings representing path segments.
-      #
-      #   For example, <code>files("foo", "bar")</code> for +foo/bar+.
       def files(*path)
         @client.base.files(@app.name, @id, *path).split("\n").collect do |entry|
           path + [entry.split(/\s+/, 2)[0]]
         end
       end
 
-      # Retrieve file contents for this instance.
-      #
-      # [path]
-      #   A sequence of strings representing path segments.
-      #
-      #   For example, <code>files("foo", "bar")</code> for +foo/bar+.
       def file(*path)
         @client.base.files(@app.name, @id, *path)
       end