static 1.0.0 → 1.0.1

data/vendor/cfoundry-0.5.2/lib/cfoundry/v1/app.rb

@@ -0,0 +1,363 @@
+require "cfoundry/upload_helpers"
+require "cfoundry/chatty_hash"
+
+require "cfoundry/v1/model"
+
+module CFoundry::V1
+  class App < Model
+    include CFoundry::UploadHelpers
+
+    attribute :name,      :string,   :guid => true
+    attribute :instances, :integer
+    attribute :state,     :string
+    attribute :created,   :integer,  :at => [:meta, :created], :read_only => true
+    attribute :version,   :integer,  :at => [:meta, :version], :read_only => true
+    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 => []
+
+    attribute :console, :boolean, :default => false,
+              :read => [:meta, :console], :write => :console
+
+    attribute :debug, :string, :default => nil, :read => [:meta, :debug],
+              :write => :debug
+
+    attribute :running_instances, :integer, :read => :runningInstances,
+              :read_only => true
+
+
+    define_client_methods
+
+
+    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=
+
+    alias_method :service_names, :services
+    alias_method :service_names=, :services=
+
+    alias_method :status, :state
+    alias_method :status=, :state=
+
+    alias_method :urls, :uris
+    alias_method :urls=, :uris=
+
+    alias_method :env_array, :env
+    alias_method :env_array=, :env=
+
+    def framework
+      @client.framework(framework_name)
+    end
+
+    def framework=(obj)
+      set_named(:framework, obj)
+    end
+
+    def runtime
+      @client.runtime(runtime_name)
+    end
+
+    def runtime=(obj)
+      set_named(:runtime, obj)
+    end
+
+    def services
+      service_names.collect { |name| @client.service_instance(name) }
+    end
+
+    def services=(objs)
+      set_many_named(:service, objs)
+    end
+
+
+    # Retrieve all of the instances of the app, as Instance objects.
+    def instances
+      @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(@guid).collect do |i|
+        Instance.new(self, i[:instance].to_s, @client, i)
+      end
+    end
+
+    # Retrieve application statistics, e.g. CPU load and memory usage.
+    def stats
+      stats = {}
+
+      @client.base.stats(@guid).each do |idx, info|
+        stats[idx.to_s] = info
+      end
+
+      stats
+    end
+
+    # Stop the application.
+    def stop!
+      self.state = "STOPPED"
+      update!
+    end
+
+    # Start the application.
+    def start!(async = false)
+      self.state = "STARTED"
+      update!
+    end
+
+    # Restart the application.
+    def restart!(async = false)
+      stop!
+      start!
+    end
+
+    def update!(async = false)
+      super()
+    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
+      s = state
+      if s == "STARTED"
+        healthy_count = running_instances
+        expected = total_instances
+
+        if healthy_count && expected > 0
+          ratio = healthy_count / expected.to_f
+          if ratio == 1.0
+            "RUNNING"
+          else
+            "#{(ratio * 100).to_i}%"
+          end
+        else
+          "N/A"
+        end
+      else
+        s
+      end
+    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
+
+
+    # Shortcut for uris[0]
+    def uri
+      uris[0]
+    end
+
+    # Shortcut for uris = [x]
+    def uri=(x)
+      self.uris = [x]
+    end
+
+    alias_method :url, :uri
+    alias_method :url=, :uri=
+
+    def env
+      e = env_array || []
+
+      env = {}
+      e.each do |pair|
+        name, val = pair.split("=", 2)
+        env[name] = val
+      end
+
+      CFoundry::ChattyHash.new(method(:env=), env)
+    end
+
+    def env=(hash)
+      unless hash.is_a?(Array)
+        hash = hash.collect { |k, v| "#{k}=#{v}" }
+      end
+
+      self.env_array = hash
+    end
+
+    def services
+      service_names.collect do |name|
+        @client.service_instance(name)
+      end
+    end
+
+    def services=(instances)
+      self.service_names = instances.collect(&:name)
+    end
+
+
+    # Bind services to application.
+    def bind(*instances)
+      self.services += instances
+      update!
+    end
+
+    # Unbind services from application.
+    def unbind(*instances)
+      self.services -= instances
+      update!
+    end
+
+    def binds?(instance)
+      services.include? instance
+    end
+
+    # Retrieve file listing under path for the first instance of the application.
+    #
+    # [path]
+    #   A sequence of strings representing path segments.
+    #
+    #   For example, <code>files("foo", "bar")</code> for +foo/bar+.
+    def files(*path)
+      Instance.new(self, "0", @client).files(*path)
+    end
+
+    # Retrieve file contents for the first instance of the application.
+    #
+    # [path]
+    #   A sequence of strings representing path segments.
+    #
+    #   For example, <code>files("foo", "bar")</code> for +foo/bar+.
+    def file(*path)
+      Instance.new(self, "0", @client).file(*path)
+    end
+
+    private
+
+    def set_named(attr, val)
+      res = send(:"#{attr}_name=", val.name)
+
+      if @changes.key?(attr)
+        old, new = @changes[attr]
+        @changes[attr] = [@client.send(attr, old), val]
+      end
+
+      res
+    end
+
+    def set_many_named(attr, vals)
+      res = send(:"#{attr}_names=", val.collect(&:name))
+
+      if @changes.key?(attr)
+        old, new = @changes[attr]
+        @changes[attr] = [old.collect { |o| @client.send(attr, o) }, vals]
+      end
+
+      vals
+    end
+
+    # Class represnting a running instance of an application.
+    class Instance
+      # The application this instance belongs to.
+      attr_reader :app
+
+      # Application instance number.
+      attr_reader :id
+
+      # Create an Instance object.
+      #
+      # You'll usually call App#instances instead
+      def initialize(app, id, client, manifest = {})
+        @app = app
+        @id = id
+        @client = client
+        @manifest = manifest
+      end
+
+      # Show string representing the application instance.
+      def inspect
+        "#<App::Instance '#{@app.name}' \##@id>"
+      end
+
+      # Instance state.
+      def state
+        @manifest[:state]
+      end
+      alias_method :status, :state
+
+      # Instance start time.
+      def since
+        Time.at(@manifest[:since])
+      end
+
+      # Instance debugger data. If instance is in debug mode, returns a hash
+      # containing :ip and :port keys.
+      def debugger
+        return unless @manifest[:debug_ip] and @manifest[:debug_port]
+
+        { :ip => @manifest[:debug_ip],
+          :port => @manifest[:debug_port]
+        }
+      end
+
+      # Instance console data. If instance has a console, returns a hash
+      # containing :ip and :port keys.
+      def console
+        return unless @manifest[:console_ip] and @manifest[:console_port]
+
+        { :ip => @manifest[:console_ip],
+          :port => @manifest[:console_port]
+        }
+      end
+
+      # True if instance is starting or running, false if it's down or
+      # flapping.
+      def healthy?
+        case state
+        when "STARTING", "RUNNING"
+          true
+        when "DOWN", "FLAPPING"
+          false
+        end
+      end
+
+      def files(*path)
+        @client.base.files(@app.name, @id, *path).split("\n").collect do |entry|
+          path + [entry.split(/\s+/, 2)[0]]
+        end
+      end
+
+      def file(*path)
+        @client.base.files(@app.name, @id, *path)
+      end
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/lib/cfoundry/v1/base.rb

@@ -0,0 +1,71 @@
+require "multi_json"
+
+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 = [])
+      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)
+    rescue EOFError
+      retry
+    end
+  end
+end

data/vendor/cfoundry-0.5.2/lib/cfoundry/v1/client.rb

@@ -0,0 +1,193 @@
+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/vendor/cfoundry-0.5.2/lib/cfoundry/v1/framework.rb

@@ -0,0 +1,21 @@
+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