cloulu 0.0.0 → 0.1.1

data/lib/cfoundry/v2/app.rb

@@ -0,0 +1,392 @@
+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
+    attribute :production,       :boolean, :default => false
+    to_one    :space
+    to_one    :runtime
+    to_one    :framework
+    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_many   :service_bindings
+    to_many   :routes
+
+    scoped_to_space
+
+    queryable_by :name, :space_guid, :organization_guid, :framework_guid,
+      :runtime_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
+      },
+
+      # TODO: remove these when cc consistently returns nested hashes
+      :framework_guid => proc { |x|
+        if f = self.cache[:framework]
+          f.guid = x
+        else
+          self.framework = @client.framework(x, true)
+        end
+      },
+      :framework_name => proc { |x|
+        if f = self.cache[:framework]
+          f.name = x
+        else
+          self.framework = @client.framework(nil, true)
+          self.framework.name = x
+        end
+      },
+      :runtime_guid => proc { |x|
+        if f = self.cache[:runtime]
+          f.guid = x
+        else
+          self.runtime = @client.runtime(x, true)
+        end
+      },
+      :runtime_name => proc { |x|
+        if f = self.cache[:runtime]
+          f.name = x
+        else
+          self.runtime = @client.runtime(nil, true)
+          self.runtime.name = x
+        end
+      }
+
+    private :environment_json
+
+    def instances
+      @client.base.instances(@guid).collect do |i, m|
+        Instance.new(self, i.to_s, @client, m)
+      end
+    end
+
+    def crashes
+      @client.base.crashes(@guid).collect do |m|
+        Instance.new(self, 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
+
+    def debug_mode # TODO v2
+      nil
+    end
+
+    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 create_routes(*uris)
+      uris.each do |uri|
+        host, domain_name = uri.split(".", 2)
+
+        domain =
+          @client.current_space.domains.find { |d|
+            d.name == domain_name
+          }
+
+        unless domain
+          raise CFoundry::Error, "Invalid domain '#{domain_name}'"
+        end
+
+        route = @client.routes.find { |r|
+          r.host == host && r.domain == domain
+        }
+
+        unless route
+          route = @client.route
+          route.host = host
+          route.domain = domain
+          route.space = space
+          route.create!
+        end
+
+        add_route(route)
+      end
+    end
+    alias :create_route :create_routes
+
+    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 uri=(x)
+      self.uris = [x]
+    end
+    alias :url= :uri=
+
+    # Stop the application.
+    def stop!
+      self.state = "STOPPED"
+      update!
+    end
+
+    # Start the application.
+    def start!(async = false, &blk)
+      self.state = "STARTED"
+      update!(async, &blk)
+    end
+
+    # Restart the application.
+    def restart!(async = false, &blk)
+      stop!
+      start!(async, &blk)
+    end
+
+    def update!(async = false)
+      response = @client.base.update_app(@guid, @diff, async)
+
+      yield response[:headers]["x-app-staging-log"] if block_given?
+
+      @manifest = @client.base.send(:parse_json, response[:body])
+
+      @diff.clear
+
+      true
+    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
+      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
+    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)
+      Instance.new(self, "0", @client).files(*path)
+    end
+
+    def file(*path)
+      Instance.new(self, "0", @client).file(*path)
+    end
+
+    def stream_file(*path, &blk)
+      Instance.new(self, "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
+
+    class Instance
+      attr_reader :app, :id
+
+      def initialize(app, id, client, manifest = {})
+        @app = app
+        @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
+end

data/lib/cfoundry/v2/base.rb

@@ -0,0 +1,83 @@
+require "multi_json"
+
+require "cfoundry/baseclient"
+require "cfoundry/uaaclient"
+
+require "cfoundry/errors"
+
+module CFoundry::V2
+  class Base < CFoundry::BaseClient
+    include BaseClientMethods
+
+    def resource_match(fingerprints)
+      put("v2", "resource_match", :content => :json, :accept => :json, :payload => fingerprints)
+    end
+
+    def upload_app(guid, zipfile = nil, resources = [])
+      payload = {}
+      payload[:resources] = MultiJson.dump(resources)
+
+      if zipfile
+        payload[:application] =
+          UploadIO.new(
+            if zipfile.is_a? File
+              zipfile
+            elsif zipfile.is_a? String
+              File.new(zipfile, "rb")
+            end,
+            "application/zip")
+      end
+
+      put("v2", "apps", guid, "bits", :payload => payload)
+    rescue EOFError
+      retry
+    end
+
+    def files(guid, instance, *path)
+      get("v2", "apps", guid, "instances", instance, "files", *path)
+    end
+    alias :file :files
+
+    def stream_file(guid, instance, *path, &blk)
+      path_and_options = path + [{:return_response => true, :follow_redirects => false}]
+      redirect = get("v2", "apps", guid, "instances", instance, "files", *path_and_options)
+
+      if location = redirect[:headers]["location"]
+        stream_url(location + "&tail", &blk)
+      else
+        yield redirect[:body]
+      end
+    end
+
+    def instances(guid)
+      get("v2", "apps", guid, "instances", :accept => :json)
+    end
+
+    def crashes(guid)
+      get("v2", "apps", guid, "crashes", :accept => :json)
+    end
+
+    def stats(guid)
+      get("v2", "apps", guid, "stats", :accept => :json)
+    end
+
+    def update_app(guid, diff, async = false)
+      put("v2", "apps", guid,
+          :content => :json,
+          :payload => diff,
+          :return_response => true,
+          :params => { :stage_async => !!async })
+    end
+
+    def all_pages(paginated)
+      payload = paginated[:resources]
+
+      while next_page = paginated[:next_url]
+        paginated = get(next_page, :accept => :json)
+        payload += paginated[:resources]
+      end
+
+      payload
+    end
+  end
+end

data/lib/cfoundry/v2/client.rb

@@ -0,0 +1,138 @@
+require File.expand_path("../../concerns/login_helpers", __FILE__)
+
+module CFoundry::V2
+  # 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
+
+    # Internal BaseClient instance. Normally won't be touching this.
+    attr_reader :base
+
+    # [Organization] Currently targeted organization.
+    attr_accessor :current_organization
+
+    # [Space] Currently targeted space.
+    attr_accessor :current_space
+
+
+    # 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
+      2
+    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
+      return unless token
+
+      token_data = @base.token.token_data
+      if guid = token_data[:user_id]
+        user = user(guid)
+        user.emails = [{ :value => token_data[:email] }]
+        user
+      end
+    end
+
+    # Cloud metadata
+    def info
+      @base.info
+    end
+
+    def login(username, password)
+      @current_organization = nil
+      @current_space = nil
+      super
+    end
+
+    def register(email, password)
+      uaa_user = @base.uaa.add_user(email, password)
+      cc_user = user
+      cc_user.guid = uaa_user['id']
+      cc_user.create!
+      cc_user
+    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
+
+    def query_target(klass)
+      if klass.scoped_space && space = current_space
+        space
+      elsif klass.scoped_organization && org = current_organization
+        org
+      else
+        self
+      end
+    end
+
+    def stream_url(url, &blk)
+      @base.stream_url(url, &blk)
+    end
+  end
+end

data/lib/cfoundry/v2/domain.rb

@@ -0,0 +1,11 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Domain < Model
+    attribute :name, :string
+    attribute :wildcard, :boolean
+    to_one    :owning_organization, :as => :organization, :default => nil
+
+    queryable_by :name, :owning_organization_guid, :space_guid
+  end
+end

data/lib/cfoundry/v2/framework.rb

@@ -0,0 +1,14 @@
+require "cfoundry/v2/model"
+
+module CFoundry::V2
+  class Framework < Model
+    attribute :name, :string
+    attribute :description, :string
+    to_many   :apps
+
+    queryable_by :name, :app_guid
+
+    attr_accessor :detection, :runtimes
+  end
+end
+