new_cfoundry 4.8.2

data/lib/cfoundry/uaaclient.rb

@@ -0,0 +1,160 @@
+require "cfoundry/baseclient"
+require "uaa"
+
+module CFoundry
+  class UAAClient
+    attr_accessor :target, :client_id, :token, :trace, :http_proxy, :https_proxy
+
+    def initialize(target, client_id = "cf", options = {})
+      @target = target
+      @client_id = client_id
+      @http_proxy = options[:http_proxy]
+      @https_proxy = options[:https_proxy]
+      @uaa_info_client = uaa_info_client_for(target)
+    end
+
+    def prompts
+      wrap_uaa_errors do
+        @uaa_info_client.server[:prompts]
+      end
+    end
+
+    def authorize(credentials)
+      wrap_uaa_errors do
+        authenticate_with_password_grant(credentials) ||
+          authenticate_with_implicit_grant(credentials)
+      end
+    end
+
+    def user(guid)
+      wrap_uaa_errors do
+        scim.get(:user, guid)
+      end
+    end
+
+    def users
+      wrap_uaa_errors do
+        scim.query(:user)
+      end
+    end
+
+    def change_password(guid, new, old)
+      wrap_uaa_errors do
+        scim.change_password(guid, new, old)
+      end
+    end
+
+    def password_score(password)
+      wrap_uaa_errors do
+        response = uaa_info_client_for(uaa_url).password_strength(password)
+
+        required_score = response[:requiredScore] || 0
+        case (response[:score] || 0)
+          when 10 then
+            :strong
+          when required_score..9 then
+            :good
+          else
+            :weak
+        end
+      end
+    end
+
+    def add_user(email, password, options = {})
+      wrap_uaa_errors do
+        scim.add(
+          :user,
+          {:userName => email,
+            :emails => [{:value => email}],
+            :password => password,
+            :name => {:givenName => options[:givenName] || email,
+                      :familyName => options[:familyName] || email}
+          }
+        )
+      end
+    end
+
+    def delete_user(guid)
+      wrap_uaa_errors do
+        scim.delete(:user, guid)
+      end
+    end
+
+    def try_to_refresh_token!
+      wrap_uaa_errors do
+        begin
+          token_info = token_issuer.refresh_token_grant(token.refresh_token)
+          self.token = AuthToken.from_uaa_token_info(token_info)
+        rescue CF::UAA::TargetError
+          self.token
+        end
+      end
+    end
+
+    private
+
+    def uaa_info_client_for(url)
+      CF::UAA::Info.new(url,
+                        :symbolize_keys => true,
+                        :http_proxy => http_proxy,
+                        :https_proxy => https_proxy
+      )
+    end
+
+    def token_issuer
+      @token_issuer ||= CF::UAA::TokenIssuer.new(target, client_id, nil,
+        :symbolize_keys => true,
+        :http_proxy => @http_proxy,
+        :https_proxy => @https_proxy
+      )
+      @token_issuer.logger.level = @trace ? Logger::Severity::TRACE : 1
+      @token_issuer
+    end
+
+    def scim
+      auth_header = token && token.auth_header
+      scim = CF::UAA::Scim.new(uaa_url, auth_header, :symbolize_keys => true)
+      scim.logger.level = @trace ? Logger::Severity::TRACE : 1
+      scim
+    end
+
+    def uaa_url
+      @uaa_url ||= @uaa_info_client.discover_uaa
+    end
+
+    def authenticate_with_password_grant(credentials)
+      begin
+        # Currently owner_password_grant method does not allow
+        # non-password based authenticate; so we have cheat a little bit.
+        token_issuer.send(:request_token,
+          {:grant_type => "password", :scope => nil}.merge(credentials))
+      rescue CF::UAA::BadResponse => e
+        status_code = e.message[/\d+/] || 400
+        raise CFoundry::Denied.new("Authorization failed", status_code)
+      rescue CF::UAA::TargetError
+        false
+      end
+    end
+
+    def authenticate_with_implicit_grant(credentials)
+      begin
+        token_issuer.implicit_grant_with_creds(credentials)
+      rescue CF::UAA::BadResponse => e
+        status_code = e.message[/\d+/] || 400
+        raise CFoundry::Denied.new("Authorization failed", status_code)
+      end
+    end
+
+    def wrap_uaa_errors
+      yield
+    rescue CF::UAA::BadResponse
+      raise CFoundry::BadResponse
+    rescue CF::UAA::NotFound
+      raise CFoundry::NotFound
+    rescue CF::UAA::InvalidToken
+      raise CFoundry::Denied
+    rescue CF::UAA::TargetError => e
+      raise CFoundry::UAAError.new(e.info[:error_description], e.info[:error])
+    end
+  end
+end

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,303 @@
+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 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