cfoundry-IronFoundry 0.3.34

data/lib/cfoundry/v1/base.rb

@@ -0,0 +1,209 @@
+require "multi_json"
+
+require "cfoundry/baseclient"
+require "cfoundry/uaaclient"
+
+require "cfoundry/errors"
+
+module CFoundry::V1
+  class Base < CFoundry::BaseClient
+    attr_accessor :target, :token, :proxy, :trace
+
+    def initialize(
+        target = "https://api.cloudfoundry.com",
+        token = nil)
+      @target = target
+      @token = token
+    end
+
+
+    # invalidate token data when changing token
+    def token=(t)
+      @token = t
+    end
+
+
+    # The UAA used for this client.
+    #
+    # `false` if no UAA (legacy)
+    def uaa
+      return @uaa unless @uaa.nil?
+
+      endpoint = info[:authorization_endpoint]
+      return @uaa = false unless endpoint
+
+      @uaa = CFoundry::UAAClient.new(endpoint)
+      @uaa.trace = @trace
+      @uaa.token = @token
+      @uaa
+    end
+
+
+    # Cloud metadata
+    def info
+      get("info", nil => :json)
+    end
+
+    def system_services
+      get("info", "services", nil => :json)
+    end
+
+    def system_runtimes
+      get("info", "runtimes", nil => :json)
+    end
+
+    # Users
+    def users
+      get("users", nil => :json)
+    end
+
+    def create_user(payload)
+      post(payload, "users", :json => nil)
+    end
+
+    def user(email)
+      get("users", email, nil => :json)
+    end
+
+    def delete_user(email)
+      delete("users", email, nil => :json)
+      true
+    end
+
+    def update_user(email, payload)
+      put(payload, "users", email, :json => nil)
+    end
+
+    def create_token(payload, email)
+      post(payload, "users", email, "tokens", :json => :json)
+    end
+
+    # Applications
+    def apps
+      get("apps", nil => :json)
+    end
+
+    def create_app(payload)
+      post(payload, "apps", :json => :json)
+    end
+
+    def app(name)
+      get("apps", name, nil => :json)
+    end
+
+    def instances(name)
+      get("apps", name, "instances", nil => :json)[:instances]
+    end
+
+    def crashes(name)
+      get("apps", name, "crashes", nil => :json)[:crashes]
+    end
+
+    def files(name, instance, *path)
+      get("apps", name, "instances", instance, "files", *path)
+    end
+    alias :file :files
+
+    def update_app(name, payload)
+      put(payload, "apps", name, :json => nil)
+    end
+
+    def delete_app(name)
+      delete("apps", name)
+      true
+    end
+
+    def stats(name)
+      get("apps", name, "stats", nil => :json)
+    end
+
+    def check_resources(fingerprints)
+      post(fingerprints, "resources", :json => :json)
+    end
+
+    def upload_app(name, zipfile, resources = [])
+      payload = {
+        :_method => "put",
+        :resources => MultiJson.dump(resources),
+        :multipart => true,
+        :application =>
+          if zipfile.is_a? File
+            zipfile
+          elsif zipfile.is_a? String
+            File.new(zipfile, "rb")
+          end
+      }
+
+      post(payload, "apps", name, "application")
+    rescue RestClient::ServerBrokeConnection
+      retry
+    end
+
+    # Services
+    def services
+      get("services", nil => :json)
+    end
+
+    def create_service(manifest)
+      post(manifest, "services", :json => :json)
+    end
+
+    def service(name)
+      get("services", name, nil => :json)
+    end
+
+    def delete_service(name)
+      delete("services", name, nil => :json)
+      true
+    end
+
+    private
+
+    def handle_response(response, accept)
+      json = accept == :json
+
+      case response.code
+      when 200, 204, 302
+        if accept == :headers
+          return response.headers
+        end
+
+        if json
+          if response.code == 204
+            raise "Expected JSON response, got 204 No Content"
+          end
+
+          parse_json(response)
+        else
+          response
+        end
+
+      when 400, 403
+        info = parse_json(response)
+        raise CFoundry::Denied.new(403, info[:description])
+
+      when 404
+        raise CFoundry::NotFound
+
+      when 411, 500, 504
+        begin
+          raise_error(parse_json(response))
+        rescue MultiJson::DecodeError
+          raise CFoundry::BadResponse.new(response.code, response)
+        end
+
+      else
+        raise CFoundry::BadResponse.new(response.code, response)
+      end
+    end
+
+    def raise_error(info)
+      case info[:code]
+      when 402
+        raise CFoundry::UploadFailed.new(info[:description])
+      else
+        raise CFoundry::APIError.new(info[:code], info[:description])
+      end
+    end
+  end
+end

data/lib/cfoundry/v1/client.rb

@@ -0,0 +1,232 @@
+require "cfoundry/v1/base"
+require "cfoundry/v1/app"
+require "cfoundry/v1/service"
+require "cfoundry/v1/service_instance"
+require "cfoundry/v1/user"
+
+
+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
+    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
+
+    # The current target URL of the client.
+    def target
+      @base.target
+    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 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
+      services = []
+
+      @base.system_services.each do |type, vendors|
+        vendors.each do |vendor, versions|
+          versions.each do |num, meta|
+            services <<
+              Service.new(vendor.to_s, num.to_s, meta[:description], type)
+          end
+        end
+      end
+
+      services
+    end
+
+    # Retrieve available runtimes.
+    def runtimes
+      runtimes = []
+
+      @base.system_runtimes.each do |name, meta|
+        runtimes <<
+          Runtime.new(name.to_s, meta[:version], meta[:debug_modes])
+      end
+
+      runtimes
+    end
+
+    def runtime_by_name(name)
+      runtimes.find { |r| r.name == name }
+    end
+
+    # Retrieve available frameworks.
+    def frameworks
+      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_by_name(name)
+      frameworks.find { |f| f.name == name }
+    end
+
+    # Retrieve user list. Admin-only.
+    def users
+      @base.users.collect do |json|
+        User.new(
+          json[:email],
+          self,
+          { :email => json[:email],
+            :admin => json[:admin] })
+      end
+    end
+
+    # Construct a User object. The return value is lazy, and no requests are
+    # made from this alone.
+    #
+    # This should be used for both user creation (after calling User#create!)
+    # and retrieval.
+    def user(email)
+      User.new(email, self)
+    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
+
+    # Login prompts
+    def login_prompts
+      if @base.uaa
+        @base.uaa.prompts
+      else
+        { :username => ["text", "Email"],
+          :password => ["password", "Password"]
+        }
+      end
+    end
+
+    # Authenticate with the target. Sets the client token.
+    #
+    # Credentials is a hash, typically containing :username and :password
+    # keys.
+    #
+    # The values in the hash should mirror the prompts given by
+    # `login_prompts`.
+    def login(credentials)
+      @base.token =
+        if @base.uaa
+          @base.uaa.authorize(credentials)
+        else
+          @base.create_token(
+            { :password => credentials[:password] },
+            credentials[:username])[:token]
+        end
+    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
+
+
+    # Retreive all of the current user's applications.
+    def apps(depth = 1, query = {})
+      @base.apps.collect do |json|
+        App.new(json[:name], self, json)
+      end
+    end
+
+    # Construct an App object. The return value is lazy, and no requests are
+    # made from this method alone.
+    #
+    # This should be used for both app creation (after calling App#create!)
+    # and retrieval.
+    def app(name = nil)
+      App.new(name, self)
+    end
+
+    def app_by_name(name)
+      app = app(name)
+      app if app.exists?
+    end
+
+    # Retrieve all of the current user's services.
+    def service_instances(depth = 1, query = {})
+      @base.services.collect do |json|
+        ServiceInstance.new(json[:name], self, json)
+      end
+    end
+
+    # Construct a Service object. The return value is lazy, and no requests are
+    # made from this method alone.
+    #
+    # This should be used for both service creation (after calling
+    # Service#create!) and retrieval.
+    def service_instance(name = nil)
+      ServiceInstance.new(name, self)
+    end
+
+    def service_instance_by_name(name)
+      service = service_instance(name)
+      service if service.exists?
+    end
+  end
+end

data/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