jfoundry 0.1.0.pre

data/lib/jfoundry/v2/app.rb

@@ -0,0 +1,357 @@
+require "tmpdir"
+require "multi_json"
+
+require "jfoundry/zip"
+require "jfoundry/upload_helpers"
+require "jfoundry/chatty_hash"
+
+require "jfoundry/v2/model"
+
+module JFoundry::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 JFoundry::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
+      @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
+      JFoundry::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 JFoundry::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 JFoundry::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 JFoundry::StagingError, JFoundry::NotStaged
+      "STAGING FAILED"
+    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/jfoundry/v2/app_event.rb

@@ -0,0 +1,13 @@
+require "jfoundry/v2/model"
+
+module JFoundry::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/jfoundry/v2/base.rb

@@ -0,0 +1,92 @@
+require "multi_json"
+
+require "jfoundry/baseclient"
+
+require "jfoundry/errors"
+
+module JFoundry::V2
+  class Base < JFoundry::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)
+      put("v2", "apps", guid,
+          :content => :json,
+          :payload => diff,
+          :return_response => true)
+    end
+
+    def user_info
+        get("v2", "user_info", :accept => :json)
+    end
+
+    def for_each(paginated, &block)
+      paginated[:resources].each &block
+
+      while next_page = paginated[:next_url]
+        paginated = get(next_page, :accept => :json)
+        paginated[:resources].each &block
+      end
+    end
+
+    def all_pages(paginated)
+      payload = []
+      for_each(paginated) do |resource|
+        payload << resource
+      end
+      payload
+    end
+  end
+end

data/lib/jfoundry/v2/client.rb

@@ -0,0 +1,78 @@
+require "forwardable"
+
+module JFoundry::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
+    extend Forwardable
+
+    # 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
+
+    def_delegators :@base, :target, :target=, :access_key, :access_key=, :secret_key, 
+      :secret_key=,  :version, :version=, :http_proxy, :http_proxy=, :https_proxy, 
+      :https_proxy=, :trace, :trace=, :log, :log=, :info
+
+    # Create a new Client for interfacing with the given target.
+    #
+    # A token may also be provided to skip the login step.
+    def initialize(target, access_key, secret_key, version)
+      @base = Base.new(target, access_key, secret_key, version)
+    end
+
+    def version
+      2
+    end
+
+    # The currently authenticated user.
+    def current_user
+        user = user(@base.access_key)
+        user_info = @base.user_info
+        if user_info && user_info.key?(:user)
+            user.emails = [{ :value => user_info[:user]}]
+        end
+        user
+    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
+
+    def service_instances(opts={})
+      opts[:user_provided] = true
+      super(opts)
+    end
+
+    def service_instances_from(path, *args)
+      opts = args.first || {}
+      opts[:user_provided] = true
+      super(path, opts, *args)
+    end
+
+    def make_service_instance(json)
+      klass = "JFoundry::V2::#{json[:entity][:type].camelize}".constantize
+      klass.new(
+        json[:metadata][:guid],
+        self,
+        json)
+    end
+  end
+end

data/lib/jfoundry/v2/domain.rb

@@ -0,0 +1,20 @@
+require "jfoundry/v2/model"
+
+module JFoundry::V2
+  class Domain < Model
+    validates_presence_of :name
+    validates_format_of :name, :with => /\A([^\.]+\.)+[^\.]+\Z/
+    validates_presence_of :owning_organization
+
+    attribute :name, :string
+    attribute :wildcard, :boolean
+    to_one    :owning_organization, :as => :organization, :default => nil
+    to_many   :spaces
+
+    queryable_by :name, :owning_organization_guid, :space_guid
+
+    def system?
+      guid.present? && !owning_organization.present?
+    end
+  end
+end

data/lib/jfoundry/v2/managed_service_instance.rb

@@ -0,0 +1,13 @@
+require "jfoundry/v2/service_instance"
+
+module JFoundry::V2
+  class ManagedServiceInstance < ServiceInstance
+    attribute :dashboard_url, :string
+    attribute :credentials, :hash
+    to_one    :service_plan
+
+    def self.object_name
+      'service_instance'
+    end
+  end
+end