ncfoundry 4.9.2

data/lib/cfoundry/upload_helpers.rb

@@ -0,0 +1,222 @@
+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}
+
+    # 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 .cfignore 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}/#{@guid}.zip"
+      tmpdir = "#{Dir.tmpdir}/.cf_#{@guid}_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(@guid, packed && zipfile, resources || [])
+    ensure
+      FileUtils.rm_f(zipfile) if zipfile
+      FileUtils.rm_rf(tmpdir) if tmpdir
+    end
+
+    private
+
+    def prepare_package(path, to)
+      if path =~ /\.(jar|war|zip)$/
+        CFoundry::Zip.unpack(path, to)
+      elsif (war_file = Dir.glob("#{path}/*.war").first)
+        CFoundry::Zip.unpack(war_file, to)
+      else
+        FileUtils.mkdir(to)
+
+        exclude = UPLOAD_EXCLUDE
+        if File.exists?("#{path}/.cfignore")
+          exclude += File.read("#{path}/.cfignore").split(/\n+/)
+        end
+
+        files = files_to_consider(path, exclude)
+
+        check_unreachable_links(files, path)
+
+        copy_tree(files, path, to)
+
+        find_sockets(to).each do |s|
+          File.delete s
+        end
+      end
+    end
+
+    def check_unreachable_links(files, path)
+      # only used for friendlier error message
+      pwd = Pathname.pwd
+
+      abspath = File.expand_path(path)
+      unreachable = []
+      files.each do |f|
+        file = Pathname.new(f)
+        if file.symlink? && !file.realpath.to_s.start_with?(abspath)
+          unreachable << file.relative_path_from(pwd)
+        end
+      end
+
+      unless unreachable.empty?
+        root = Pathname.new(path).relative_path_from(pwd)
+        raise CFoundry::Error,
+          "Path contains links '#{unreachable}' that point outside '#{root}'"
+      end
+    end
+
+    def files_to_consider(path, exclusions)
+      entries = all_files(path)
+
+      exclusions.each do |exclusion|
+        ignore_pattern = exclusion.start_with?("/") ? File.join(path, exclusion) : File.join(path, "**", exclusion)
+        dir_glob = Dir.glob(ignore_pattern, File::FNM_DOTMATCH)
+        entries -= dir_glob
+
+        ignore_pattern = File.join(path, "**", exclusion, "**", "*")
+        dir_glob = Dir.glob(ignore_pattern, File::FNM_DOTMATCH)
+        entries -= dir_glob
+      end
+
+      entries
+    end
+
+    def glob_matches?(file, path, pattern)
+      name = file.sub("#{path}/", "/")
+      flags = File::FNM_DOTMATCH
+
+      # when pattern ends with /, match only directories
+      if pattern.end_with?("/") && File.directory?(file)
+        name = "#{name}/"
+      end
+
+      case pattern
+      # when pattern contains /, do a pathname match
+      when /\/./
+        flags |= File::FNM_PATHNAME
+
+      # otherwise, match any file path
+      else
+        pattern = "**/#{pattern}"
+      end
+
+      File.fnmatch(pattern, name, flags)
+    end
+
+    def find_sockets(path)
+      all_files(path).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
+
+      prune_empty_directories(path)
+
+      resources
+    end
+
+    # OK, HERES THE PLAN...
+    #
+    # 1. Get all the directories in the entire file tree.
+    # 2. Sort them by the length of their absolute path.
+    # 3. Go through the list, longest paths first, and remove
+    #    the directories that are empty.
+    #
+    # This ensures that directories containing empty directories
+    # are also pruned.
+    def prune_empty_directories(path)
+      all_files = all_files(path)
+
+      directories = all_files.select { |x| File.directory?(x) }
+      directories.sort! { |a, b| b.size <=> a.size }
+
+      directories.each do |directory|
+        entries = all_files(directory)
+        FileUtils.rmdir(directory) if entries.empty?
+      end
+    end
+
+    def make_fingerprints(path)
+      fingerprints = []
+      total_size = 0
+
+      all_files(path).each 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
+
+    def all_files(path)
+      Dir.glob("#{path}/**/*", File::FNM_DOTMATCH).reject do |fn|
+        fn =~ /\.$/
+      end
+    end
+
+    def copy_tree(files, path, to)
+      files.each do |file|
+        dest = file.sub("#{path}/", "#{to}/")
+
+        if File.directory?(file)
+          FileUtils.mkdir_p(dest)
+        else
+          destdir = File.dirname(dest)
+          FileUtils.mkdir_p(destdir)
+          FileUtils.cp(file, dest)
+        end
+      end
+    end
+  end
+end

data/lib/cfoundry/v2/app.rb

@@ -0,0 +1,313 @@
+require "tmpdir"
+require "multi_json"
+
+require "cfoundry/zip"
+require "cfoundry/upload_helpers"
+require "cfoundry/chatty_hash"
+
+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
+    include CFoundry::UploadHelpers
+
+    attribute :name,             :string
+    to_one    :space
+    attribute :environment_json, :hash,    :default => {}
+    attribute :memory,           :integer, :default => 256
+    attribute :total_instances,  :integer, :default => 1, :at => :instances
+    attribute :disk_quota,       :integer, :default => 256
+    attribute :state,            :string,  :default => "STOPPED"
+    attribute :command,          :string,  :default => nil
+    attribute :console,          :boolean, :default => false
+    attribute :buildpack,        :string,  :default => nil
+    to_one    :stack,                      :default => nil
+    attribute :debug,            :string,  :default => nil
+    to_many   :service_bindings
+    to_many   :routes
+    to_many   :events, :as => :app_event
+
+    scoped_to_space
+
+    queryable_by :name, :space_guid, :organization_guid
+
+    has_summary :urls => proc { |x| self.cache[:uris] = x },
+      :running_instances => proc { |x|
+        self.cache[:running_instances] = x
+      },
+      :instances => proc { |x|
+        self.total_instances = x
+      }
+
+    private :environment_json
+
+    def delete!(opts = {})
+      super(opts.merge(:recursive => true))
+    end
+
+    def instances
+      AppInstance.for_app(name, @guid, @client)
+    end
+
+    def crashes
+      @client.base.crashes(@guid).collect do |m|
+        AppInstance.new(self.name, self.guid, m[:instance], @client, m)
+      end
+    end
+
+    def stats
+      stats = {}
+
+      @client.base.stats(@guid).each do |idx, info|
+        stats[idx.to_s] = info
+      end
+
+      stats
+    end
+
+    def system_env
+      system_env = {}
+
+      @client.base.env(@guid).each do |idx, info|
+        system_env[idx.to_s] = info
+      end
+
+      system_env
+    end
+
+    def services
+      service_bindings.collect(&:service_instance)
+    end
+
+    def env
+      CFoundry::ChattyHash.new(
+        method(:env=),
+        stringify(environment_json))
+    end
+
+    def env=(x)
+      self.environment_json = stringify(x.to_hash)
+    end
+
+    alias :debug_mode :debug
+
+    def uris
+      return @cache[:uris] if @cache[:uris]
+
+      routes.collect do |r|
+        "#{r.host}.#{r.domain.name}"
+      end
+    end
+    alias :urls :uris
+
+    def uris=(uris)
+      raise CFoundry::Deprecated,
+        "App#uris= is invalid against V2 APIs; use add/remove_route"
+    end
+    alias :urls= :uris=
+
+    def uri
+      if uris = @cache[:uris]
+        return uris.first
+      end
+
+      if route = routes.first
+        "#{route.host}.#{route.domain.name}"
+      end
+    end
+    alias :url :uri
+
+    def host
+      return nil if routes.empty?
+      routes.first.host
+    end
+
+    def domain
+      return nil if routes.empty?
+      routes.first.domain.name
+    end
+
+    def uri=(x)
+      self.uris = [x]
+    end
+    alias :url= :uri=
+
+    # Stop the application.
+    def stop!
+      self.state = "STOPPED"
+      update!
+    end
+
+    # Start the application.
+    def start!(&blk)
+      self.state = "STARTED"
+      update!(&blk)
+    end
+
+    # Restart the application.
+    def restart!(&blk)
+      stop!
+      start!(&blk)
+    end
+
+    def update!
+      response = @client.base.update_app(@guid, @diff)
+
+      yield response[:headers]["x-app-staging-log"] if block_given?
+
+      @manifest = @client.base.send(:parse_json, response[:body])
+
+      @diff.clear
+
+      true
+    end
+
+    def stream_update_log(log_url)
+      offset = 0
+
+      while true
+        begin
+          @client.stream_url(log_url + "&tail&tail_offset=#{offset}") do |out|
+            offset += out.size
+            yield out
+          end
+        rescue Timeout::Error
+        end
+      end
+    rescue CFoundry::APIError
+    end
+
+    # Determine application health.
+    #
+    # If all instances are running, returns "RUNNING". If only some are
+    # started, returns the percentage of them that are healthy.
+    #
+    # Otherwise, returns application's status.
+    def health
+      if state == "STARTED"
+        healthy_count = running_instances
+        expected = total_instances
+
+        if expected > 0
+          ratio = healthy_count / expected.to_f
+          if ratio == 1.0
+            "RUNNING"
+          else
+            "#{(ratio * 100).to_i}%"
+          end
+        else
+          "N/A"
+        end
+      else
+        state
+      end
+    rescue CFoundry::StagingError, CFoundry::NotStaged
+      "STAGING FAILED"
+    end
+
+    def percent_running
+      if state == "STARTED"
+        healthy_count = running_instances
+        expected = total_instances
+
+        expected > 0 ? (healthy_count / expected.to_f) * 100 : 0
+      else
+        0
+      end
+    rescue CFoundry::StagingError, CFoundry::NotStaged
+      0
+    end
+
+    def running_instances
+      return @cache[:running_instances] if @cache[:running_instances]
+
+      running = 0
+
+      instances.each do |i|
+        running += 1 if i.state == "RUNNING"
+      end
+
+      running
+    end
+
+    # Check that all application instances are running.
+    def healthy?
+      # invalidate cache so the check is fresh
+      invalidate!
+      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(*instances)
+      instances.each do |i|
+        binding = @client.service_binding
+        binding.app = self
+        binding.service_instance = i
+        binding.create!
+      end
+
+      self
+    end
+
+    # Unbind services from application.
+    def unbind(*instances)
+      service_bindings.each do |b|
+        if instances.include? b.service_instance
+          b.delete!
+        end
+      end
+
+      self
+    end
+
+    def binds?(instance)
+      service_bindings.any? { |b|
+        b.service_instance == instance
+      }
+    end
+
+    def files(*path)
+      AppInstance.new(self.name, self.guid, "0", @client).files(*path)
+    end
+
+    def file(*path)
+      AppInstance.new(self.name, self.guid, "0", @client).file(*path)
+    end
+
+    def stream_file(*path, &blk)
+      AppInstance.new(self.name, self.guid, "0", @client).stream_file(*path, &blk)
+    end
+
+    private
+
+    def stringify(hash)
+      new = {}
+
+      hash.each do |k, v|
+        new[k.to_s] = v.to_s
+      end
+
+      new
+    end
+  end
+end

data/lib/cfoundry/v2/app_event.rb

@@ -0,0 +1,13 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class AppEvent < Model
+    to_one :app
+
+    attribute :instance_guid, :string
+    attribute :instance_index, :integer
+    attribute :exit_status, :integer
+    attribute :exit_description, :string, :default => ""
+    attribute :timestamp, :string
+  end
+end

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