cfoundry 0.1.0

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c)2012, Alex Suraci
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of Alex Suraci nor the names of other
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require "bundler/gem_tasks"
+
+task :default => "spec"
+
+desc "Run specs"
+task "spec" => ["bundler:install", "test:spec"]
+
+namespace "bundler" do
+  desc "Install gems"
+  task "install" do
+    sh("bundle install")
+  end
+end
+
+namespace "test" do
+  task "spec" do |t|
+    sh("cd spec && bundle exec rake spec")
+  end
+end

data/lib/cfoundry.rb

@@ -0,0 +1,2 @@
+require "cfoundry/version"
+require "cfoundry/client"

data/lib/cfoundry/app.rb

@@ -0,0 +1,369 @@
+require "fileutils"
+require "digest/sha1"
+require "pathname"
+require "tmpdir"
+
+require "cfoundry/zip"
+
+module CFoundry
+  class App
+    attr_reader :name
+
+    def initialize(name, client, manifest = nil)
+      @name = name
+      @client = client
+      @manifest = manifest
+    end
+
+    def inspect
+      "#<App '#@name'>"
+    end
+
+    def manifest
+      @manifest ||= @client.rest.app(@name)
+    end
+
+    def delete!
+      @client.rest.delete_app(@name)
+
+      if @manifest
+        @manifest.delete "meta"
+        @manifest.delete "version"
+        @manifest.delete "state"
+      end
+    end
+
+    def create!
+      @client.rest.create_app(@manifest.merge("name" => @name))
+      @manifest = nil
+    end
+
+    def exists?
+      @client.rest.app(@name)
+      true
+    rescue CFoundry::NotFound
+      false
+    end
+
+    def instances
+      @client.rest.instances(@name).collect do |m|
+        Instance.new(@name, m["index"], @client, m)
+      end
+    end
+
+    def stats
+      @client.rest.stats(@name)
+    end
+
+    def update!(what = {})
+      # TODO: hacky; can we not just set in meta field?
+      # we write to manifest["debug"] but read from manifest["meta"]["debug"]
+      what[:debug] = debug_mode
+
+      @client.rest.update_app(@name, manifest.merge(what))
+      @manifest = nil
+    end
+
+    def stop!
+      update! "state" => "STOPPED"
+    end
+
+    def start!
+      update! "state" => "STARTED"
+    end
+
+    def restart!
+      stop!
+      start!
+    end
+
+    def health
+      s = state
+      if s == "STARTED"
+        healthy_count = manifest["runningInstances"]
+        expected = manifest["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
+
+    def healthy?
+      # invalidate cache so the check is fresh
+      @manifest = nil
+      health == "RUNNING"
+    end
+
+    def stopped?
+      state == "STOPPED"
+    end
+
+    def started?
+      state == "STARTED"
+    end
+    alias_method :running?, :started?
+
+    { :total_instances => "instances",
+      :state => "state",
+      :status => "state",
+      :services => "services",
+      :uris => "uris",
+      :urls => "uris",
+      :env => "env"
+    }.each do |meth, attr|
+      define_method(meth) do
+        manifest[attr]
+      end
+
+      define_method(:"#{meth}=") do |v|
+        @manifest ||= {}
+        @manifest[attr] = v
+      end
+    end
+
+    def framework
+      manifest["staging"]["framework"] ||
+        manifest["staging"]["model"]
+    end
+
+    def framework=(v)
+      @manifest ||= {}
+      @manifest["staging"] ||= {}
+
+      if @manifest["staging"].key? "model"
+        @manifest["staging"]["model"] = v
+      else
+        @manifest["staging"]["framework"] = v
+      end
+    end
+
+    def runtime
+      manifest["staging"]["runtime"] ||
+        manifest["staging"]["stack"]
+    end
+
+    def runtime=(v)
+      @manifest ||= {}
+      @manifest["staging"] ||= {}
+
+      if @manifest["staging"].key? "stack"
+        @manifest["staging"]["stack"] = v
+      else
+        @manifest["staging"]["runtime"] = v
+      end
+    end
+
+    def memory
+      manifest["resources"]["memory"]
+    end
+
+    def memory=(v)
+      @manifest ||= {}
+      @manifest["resources"] ||= {}
+      @manifest["resources"]["memory"] = v
+    end
+
+    def debug_mode
+      manifest.fetch("debug") { manifest["meta"] && manifest["meta"]["debug"] }
+    end
+
+    def debug_mode=(v)
+      @manifest ||= {}
+      @manifest["debug"] = v
+    end
+
+    def bind(*service_names)
+      update!("services" => services + service_names)
+    end
+
+    def unbind(*service_names)
+      update!("services" =>
+                services.reject { |s|
+                  service_names.include?(s)
+                })
+    end
+
+    def files(*path)
+      Instance.new(@name, 0, @client).files(*path)
+    end
+
+    def file(*path)
+      Instance.new(@name, 0, @client).file(*path)
+    end
+
+    UPLOAD_EXCLUDE = %w{.git _darcs .svn}
+
+    def upload(path, check_resources = true)
+      unless File.exist? path
+        raise "invalid application path '#{path}'"
+      end
+
+      zipfile = "#{Dir.tmpdir}/#{@name}.zip"
+      tmpdir = "#{Dir.tmpdir}/.vmc_#{@name}_files"
+
+      FileUtils.rm_f(zipfile)
+      FileUtils.rm_rf(tmpdir)
+
+      prepare_package(path, tmpdir)
+
+      resources = determine_resources(tmpdir) if check_resources
+
+      CFoundry::Zip.pack(tmpdir, zipfile)
+
+      @client.rest.upload_app(@name, zipfile, resources || [])
+    ensure
+      FileUtils.rm_f(zipfile) if zipfile
+      FileUtils.rm_rf(tmpdir) if tmpdir
+    end
+
+    private
+
+    def prepare_package(path, to)
+      if path =~ /\.(war|zip)$/
+        CFoundry::Zip.unpack(path, to)
+      elsif war_file = Dir.glob("#{path}/*.war").first
+        CFoundry::Zip.unpack(war_file, to)
+      else
+        check_unreachable_links(path)
+
+        FileUtils.mkdir(to)
+
+        files = Dir.glob("#{path}/{*,.[^\.]*}")
+
+        UPLOAD_EXCLUDE.each do |e|
+          files.delete e
+        end
+
+        FileUtils.cp_r(files, to)
+
+        find_sockets(to).each do |s|
+          File.delete s
+        end
+      end
+    end
+
+    RESOURCE_CHECK_LIMIT = 64 * 1024
+
+    def determine_resources(path)
+      fingerprints = []
+      total_size = 0
+
+      Dir.glob("#{path}/**/*", File::FNM_DOTMATCH) 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
+
+      return if total_size <= RESOURCE_CHECK_LIMIT
+
+      resources = @client.rest.check_resources(fingerprints)
+
+      resources.each do |resource|
+        FileUtils.rm_f resource["fn"]
+        resource["fn"].sub!("#{path}/", '')
+      end
+
+      resources
+    end
+
+    def check_unreachable_links(path)
+      files = Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
+
+      # 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 "Can't deploy application containing links '#{unreachable}' that reach outside its root '#{root}'"
+      end
+    end
+
+    def find_sockets(path)
+      files = Dir.glob("#{path}/**/*", File::FNM_DOTMATCH)
+      files && files.select { |f| File.socket? f }
+    end
+
+    class Instance
+      attr_reader :app, :index, :manifest
+
+      def initialize(appname, index, client, manifest = {})
+        @app = appname
+        @index = index
+        @client = client
+        @manifest = manifest
+      end
+
+      def inspect
+        "#<App::Instance '#@app' \##@index>"
+      end
+
+      def state
+        @manifest["state"]
+      end
+      alias_method :status, :state
+
+      def since
+        Time.at(@manifest["since"])
+      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.rest.files(@app, @index, *path).split("\n").collect do |entry|
+          path + [entry.split(/\s+/, 2)[0]]
+        end
+      end
+
+      def file(*path)
+        @client.rest.files(@app, @index, *path)
+      end
+    end
+  end
+end

data/lib/cfoundry/client.rb

@@ -0,0 +1,97 @@
+require "cfoundry/restclient"
+require "cfoundry/app"
+require "cfoundry/service"
+require "cfoundry/user"
+
+
+module CFoundry
+  class Client
+    attr_reader :rest
+
+    def initialize(*args)
+      @rest = RESTClient.new(*args)
+    end
+
+    def target
+      @rest.target
+    end
+
+    def proxy
+      @rest.proxy
+    end
+
+    def proxy=(x)
+      @rest.proxy = x
+    end
+
+
+    # Cloud metadata
+    def info
+      @rest.info
+    end
+
+    def system_services
+      @rest.system_services
+    end
+
+    def system_runtimes
+      @rest.system_runtimes
+    end
+
+    # Users
+    def users
+      @rest.users.collect do |json|
+        CFoundry::User.new(
+          json["email"],
+          self,
+          { "email" => json["email"],
+            "admin" => json["admin"] })
+      end
+    end
+
+    def user(email)
+      CFoundry::User.new(email, self)
+    end
+
+    def register(email, password)
+      @rest.create_user(:email => email, :password => password)
+      user(email)
+    end
+
+    def login(email, password)
+      @rest.token =
+        @rest.create_token({ :password => password }, email)["token"]
+    end
+
+    def logout
+      @rest.token = nil
+    end
+
+    def logged_in?
+      !!@rest.token
+    end
+
+
+    # Applications
+    def apps
+      @rest.apps.collect do |json|
+        CFoundry::App.new(json["name"], self, json)
+      end
+    end
+
+    def app(name)
+      CFoundry::App.new(name, self)
+    end
+
+    # Services
+    def services
+      @rest.services.collect do |json|
+        CFoundry::Service.new(json["name"], self, json)
+      end
+    end
+
+    def service(name)
+      CFoundry::Service.new(name, self)
+    end
+  end
+end

data/lib/cfoundry/errors.rb

@@ -0,0 +1,77 @@
+module CFoundry
+  class APIError < RuntimeError
+    class << self
+      attr_reader :error_code, :description
+
+      def setup(code, description = nil)
+        @error_code = code
+        @description = description
+      end
+    end
+
+    def initialize(error_code = nil, description = nil)
+      @error_code = error_code
+      @description = description
+    end
+
+    def error_code
+      @error_code || self.class.error_code
+    end
+
+    def description
+      @description || self.class.description
+    end
+
+    def to_s
+      if error_code
+        "#{error_code}: #{description}"
+      else
+        description
+      end
+    end
+  end
+
+  class NotFound < APIError
+    setup(404, "entity not found or inaccessible")
+  end
+
+  class TargetRefused < APIError
+    @description = "target refused connection"
+
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    def to_s
+      "#{description} (#{@message})"
+    end
+  end
+
+  class UploadFailed < APIError
+    setup(402)
+  end
+
+  class Denied < APIError
+    attr_reader :error_code, :description
+
+    def initialize(
+        error_code = 200,
+        description = "Operation not permitted")
+      @error_code = error_code
+      @description = description
+    end
+  end
+
+  class BadResponse < StandardError
+    def initialize(code, body = nil)
+      @code = code
+      @body = body
+    end
+
+    def to_s
+      "target failed to handle our request due to an internal error (#{@code})"
+    end
+  end
+end

data/lib/cfoundry/restclient.rb

@@ -0,0 +1,259 @@
+require "restclient"
+require "json"
+
+require "cfoundry/errors"
+
+
+module CFoundry
+  class RESTClient
+    attr_accessor :target, :token, :proxy
+
+    def initialize(
+        target = "http://api.cloudfoundry.com",
+        token = nil)
+      @target = target
+      @token = token
+    end
+
+    # Cloud metadata
+    def info
+      json_get("info")
+    end
+
+    def system_services
+      json_get("info", "services")
+    end
+
+    def system_runtimes
+      json_get("info", "runtimes")
+    end
+
+    # Users
+    def users
+      json_get("users")
+    end
+
+    def create_user(payload)
+      post(payload.to_json, "users")
+    end
+
+    def user(email)
+      json_get("users", email)
+    end
+
+    def delete_user(email)
+      delete("users", email)
+      true
+    end
+
+    def update_user(email, payload)
+      put(payload.to_json, "users", email)
+    end
+
+    def create_token(payload, email)
+      json_post(payload.to_json, "users", email, "tokens")
+    end
+
+    # Applications
+    def apps
+      json_get("apps")
+    end
+
+    def create_app(payload)
+      json_post(payload.to_json, "apps")
+    end
+
+    def app(name)
+      json_get("apps", name)
+    end
+
+    def instances(name)
+      json_get("apps", name, "instances")["instances"]
+    end
+
+    def files(name, instance, *path)
+      get("apps", name, "instances", instance, "files", *path)
+    end
+    alias :file :files
+
+    def update_app(name, payload)
+      put(payload.to_json, "apps", name)
+    end
+
+    def delete_app(name)
+      delete("apps", name)
+      true
+    end
+
+    def stats(name)
+      json_get("apps", name, "stats")
+    end
+
+    def check_resources(fingerprints)
+      json_post(fingerprints.to_json, "resources")
+    end
+
+    def upload_app(name, zipfile, resources = [])
+      payload = {
+        :_method => "put",
+        :resources => resources.to_json,
+        :application =>
+          if zipfile.is_a? File
+            zipfile
+          else
+            File.new(zipfile, "rb")
+          end
+      }
+      post(payload, "apps", name, "application")
+    rescue RestClient::ServerBrokeConnection
+      retry
+    end
+
+    # Services
+    def services
+      json_get("services")
+    end
+
+    def create_service(manifest)
+      json_post(manifest.to_json, "services")
+    end
+
+    def service(name)
+      json_get("services", name)
+    end
+
+    def delete_service(name)
+      delete("services", name)
+      true
+    end
+
+  private
+    def request(type, segments, options = {})
+      headers = {}
+      headers["AUTHORIZATION"] = @token if @token
+      headers["PROXY-USER"] = @proxy if @proxy
+      headers["Content-Type"] = "application/json" # TODO: probably not always
+                                                   #       and set Accept
+      headers["Content-Length"] =
+        options[:payload] ? options[:payload].size : 0
+
+      req = options.dup
+      req[:method] = type
+      req[:url] = url(segments)
+      req[:headers] = headers.merge(req[:headers] || {})
+
+      json = req.delete :json
+
+      trace = false
+      RestClient::Request.execute(req) do |response, request|
+        if trace
+          puts '>>>'
+          puts "PROXY: #{RestClient.proxy}" if RestClient.proxy
+          puts "REQUEST: #{req[:method]} #{req[:url]}"
+          puts "RESPONSE_HEADERS:"
+          response.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+          end
+          puts "REQUEST_HEADERS:"
+          request.headers.each do |key, value|
+            puts "    #{key} : #{value}"
+          end
+          puts "REQUEST_BODY: #{req[:payload]}" if req[:payload]
+          puts "RESPONSE: [#{response.code}]"
+          begin
+            puts JSON.pretty_generate(JSON.parse(response.body))
+          rescue
+            puts "#{response.body}"
+          end
+          puts '<<<'
+        end
+
+        case response.code
+        when 200, 204, 302
+          if json
+            if response.code == 204
+              raise "Expected JSON response, got 204 No Content"
+            end
+
+            JSON.parse response
+          else
+            response
+          end
+
+        # TODO: figure out how/when the CC distinguishes these
+        when 400, 403
+          info = JSON.parse response
+          raise Denied.new(
+            info["code"],
+            info["description"])
+
+        when 404
+          raise NotFound
+
+        when 411, 500, 504
+          begin
+            raise_error(JSON.parse(response))
+          rescue JSON::ParserError
+            raise BadResponse.new(response.code, response)
+          end
+
+        else
+          raise BadResponse.new(response.code, response)
+        end
+      end
+    rescue SocketError, Errno::ECONNREFUSED => e
+      raise TargetRefused, e.message
+    end
+
+    def raise_error(info)
+      case info["code"]
+      when 402
+        raise UploadFailed.new(info["description"])
+      else
+        raise APIError.new(info["code"], info["description"])
+      end
+    end
+
+    def get(*path)
+      request(:get, path)
+    end
+
+    def delete(*path)
+      request(:delete, path)
+    end
+
+    def post(payload, *path)
+      request(:post, path, :payload => payload)
+    end
+
+    def put(payload, *path)
+      request(:put, path, :payload => payload)
+    end
+
+    def json_get(*path)
+      request(:get, path, :json => true)
+    end
+
+    def json_delete(*path)
+      request(:delete, path, :json => true)
+    end
+
+    def json_post(payload, *path)
+      request(:post, path, :payload => payload, :json => true)
+    end
+
+    def json_put(payload, *path)
+      request(:put, path, :payload => payload, :json => true)
+    end
+
+    def url(segments)
+      "#@target/#{safe_path(segments)}"
+    end
+
+    def safe_path(*segments)
+      segments.flatten.collect { |x|
+        URI.encode x.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]")
+      }.join("/")
+    end
+  end
+end

data/lib/cfoundry/service.rb

@@ -0,0 +1,59 @@
+module CFoundry
+  class Service
+    attr_reader :name
+
+    def initialize(name, client, manifest = nil)
+      @name = name
+      @client = client
+      @manifest = manifest
+    end
+
+    def inspect
+      "#<Service '#@name'>"
+    end
+
+    def manifest
+      @manifest ||= @client.rest.service(@name)
+    end
+
+    def delete!
+      @client.rest.delete_service(@name)
+    end
+
+    def create!
+      @client.rest.create_service(@manifest.merge("name" => @name))
+    end
+
+    def exists?
+      @client.rest.service(@name)
+      true
+    rescue CFoundry::NotFound
+      false
+    end
+
+    def created
+      Time.at(meta["created"])
+    end
+
+    def updated
+      Time.at(meta["updated"])
+    end
+
+    { :type => "type",
+      :vendor => "vendor",
+      :version => "version",
+      :properties => "properties",
+      :tier => "tier",
+      :meta => "meta"
+    }.each do |meth, attr|
+      define_method(meth) do
+        manifest[attr]
+      end
+
+      define_method(:"#{meth}=") do |v|
+        @manifest ||= {}
+        @manifest[attr] = v
+      end
+    end
+  end
+end

data/lib/cfoundry/user.rb

@@ -0,0 +1,47 @@
+module CFoundry
+  class User
+    attr_reader :email
+
+    def initialize(email, client, manifest = nil)
+      @email = email
+      @client = client
+      @manifest = manifest
+    end
+
+    def inspect
+      "#<User '#@email'>"
+    end
+
+    def manifest
+      @manifest ||= @client.rest.user(@email)
+    end
+
+    def delete!
+      @client.rest.delete_user(@email)
+    end
+
+    def create!
+      @client.rest.create_user(@manifest.merge("email" => @email))
+    end
+
+    def update!(what = {})
+      @client.rest.update_user(@email, manifest.merge(what))
+      @manifest = nil
+    end
+
+    def exists?
+      @client.rest.user(@email)
+      true
+    rescue CFoundry::Denied
+      false
+    end
+
+    def admin?
+      manifest["admin"]
+    end
+
+    def password=(str)
+      manifest["password"] = str
+    end
+  end
+end

data/lib/cfoundry/version.rb

@@ -0,0 +1,3 @@
+module CFoundry
+  VERSION = "0.1.0"
+end

data/lib/cfoundry/zip.rb

@@ -0,0 +1,43 @@
+require 'zip/zipfilesystem'
+
+module CFoundry
+  module Zip
+    PACK_EXCLUSION_GLOBS = ['..', '.', '*~', '#*#', '*.log']
+
+    module_function
+
+    def entry_lines(file)
+      entries = []
+      ::Zip::ZipFile.foreach(file) do |zentry|
+        entries << zentry
+      end
+      entries
+    end
+
+    def unpack(file, dest)
+      ::Zip::ZipFile.foreach(file) do |zentry|
+        epath = "#{dest}/#{zentry}"
+        dirname = File.dirname(epath)
+        FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
+        zentry.extract(epath) unless File.exists?(epath)
+      end
+    end
+
+    def files_to_pack(dir)
+      Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH).select do |f|
+        File.exists?(f) &&
+          PACK_EXCLUSION_GLOBS.none? do |e|
+            File.fnmatch(e, File.basename(f))
+          end
+      end
+    end
+
+    def pack(dir, zipfile)
+      ::Zip::ZipFile.open(zipfile, true) do |zf|
+        files_to_pack(dir).each do |f|
+          zf.add(f.sub("#{dir}/",''), f)
+        end
+      end
+    end
+  end
+end

data/spec/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'bundler/setup'
+Bundler.require(:default, :development)
+
+require 'rake/dsl_definition'
+require 'rake'
+require 'rspec'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "**/*_spec.rb"
+  t.rspec_opts = ["--format", "documentation", "--colour"]
+end
+

data/spec/client_spec.rb

@@ -0,0 +1,206 @@
+require "cfoundry"
+require "./helpers"
+
+RSpec.configure do |c|
+  c.include CFoundryHelpers
+end
+
+describe CFoundry::Client do
+  TARGET = ENV["CFOUNDRY_TEST_TARGET"] || "http://api.vcap.me"
+  USER = ENV["CFOUNDRY_TEST_USER"] || "dev@cloudfoundry.org"
+  PASSWORD = ENV["CFOUNDRY_TEST_PASSWORD"] || "test"
+
+  before(:all) do
+    @client = CFoundry::Client.new(TARGET)
+    @client.login(USER, PASSWORD)
+  end
+
+  describe :target do
+    it "returns the current API target" do
+      @client.target.should == TARGET
+    end
+  end
+
+  describe "metadata" do
+    describe :info do
+      it "returns the cloud meta-info" do
+        @client.info.should be_a(Hash)
+      end
+    end
+
+    describe :system_services do
+      it "returns the service vendors" do
+        @client.system_services.should be_a(Hash)
+      end
+
+      it "denies if not authenticated" do
+        without_auth do
+          proc {
+            @client.system_services
+          }.should raise_error(CFoundry::Denied)
+        end
+      end
+    end
+
+    describe :system_runtimes do
+      it "returns the supported runtime information" do
+        @client.system_runtimes.should be_a(Hash)
+      end
+
+      it "works if not authenticated" do
+        without_auth do
+          proc {
+            @client.system_runtimes
+          }.should_not raise_error(CFoundry::Denied)
+        end
+      end
+    end
+  end
+
+  describe :user do
+    it "creates a lazy User object" do
+      with_new_user do
+        @client.user(@user.email).should be_a(CFoundry::User)
+      end
+    end
+  end
+
+  describe :register do
+    it "registers an account and returns the User" do
+      email = random_user
+
+      user = @client.register(email, "test")
+
+      begin
+        @client.user(email).should satisfy(&:exists?)
+      ensure
+        user.delete!
+      end
+    end
+
+    it "fails if a user by that name already exists" do
+      proc {
+        @client.register(USER, PASSWORD)
+      }.should raise_error(CFoundry::Denied)
+    end
+  end
+
+  describe :login do
+    it "authenticates and sets the client token" do
+      client = CFoundry::Client.new(TARGET)
+      email = random_user
+      pass = random_str
+
+      client.register(email, pass)
+      begin
+        client.login(email, pass)
+        client.should satisfy(&:logged_in?)
+      ensure
+        @client.user(email).delete!
+      end
+    end
+
+    it "fails with invalid credentials" do
+      client = CFoundry::Client.new(TARGET)
+      email = random_user
+
+      client.register(email, "right")
+      begin
+        proc {
+          client.login(email, "wrong")
+        }.should raise_error(CFoundry::Denied)
+      ensure
+        @client.user(email).delete!
+      end
+    end
+  end
+
+  describe :logout do
+    it "clears the login token" do
+      client = CFoundry::Client.new(TARGET)
+      email = random_user
+      pass = random_str
+
+      client.register(email, pass)
+
+      begin
+        client.login(email, pass)
+        client.should satisfy(&:logged_in?)
+
+        client.logout
+        client.should_not satisfy(&:logged_in?)
+      ensure
+        @client.user(email).delete!
+      end
+    end
+  end
+
+  describe :app do
+    it "creates a lazy App object" do
+      @client.app("foo").should be_a(CFoundry::App)
+      @client.app("foo").name.should == "foo"
+    end
+  end
+
+  describe :apps do
+    it "returns an empty array if a user has no apps" do
+      with_new_user do
+        @client.apps.should == []
+      end
+    end
+
+    it "returns an array of App objects if a user has any" do
+      with_new_user do
+        name = random_str
+
+        new = @client.app(name)
+        new.total_instances = 1
+        new.urls = []
+        new.framework = "sinatra"
+        new.runtime = "ruby18"
+        new.memory = 64
+        new.create!
+
+        apps = @client.apps
+        apps.should be_a(Array)
+        apps.size.should == 1
+        apps.first.should be_a(CFoundry::App)
+        apps.first.name.should == name
+      end
+    end
+  end
+
+  describe :service do
+    it "creates a lazy Service object" do
+      @client.service("foo").should be_a(CFoundry::Service)
+      @client.service("foo").name.should == "foo"
+    end
+  end
+
+  describe :services do
+    it "returns an empty array if a user has no apps" do
+      with_new_user do
+        @client.services.should == []
+      end
+    end
+
+    it "returns an array of Service objects if a user has any" do
+      with_new_user do
+        name = random_str
+
+        new = @client.service(name)
+        new.type = "key-value"
+        new.vendor = "redis"
+        new.version = "2.2"
+        new.tier = "free"
+        new.create!
+
+        svcs = @client.services
+        svcs.should be_a(Array)
+        svcs.size.should == 1
+        svcs.first.should be_a(CFoundry::Service)
+        svcs.first.name.should == name
+      end
+    end
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,29 @@
+module CFoundryHelpers
+  def random_str
+    format("%x", rand(1000000))
+  end
+
+  def random_user
+    "#{random_str}@cfoundry-spec.com"
+  end
+
+  def without_auth
+    proxy = @client.proxy
+    @client.logout
+    @client.proxy = nil
+    yield
+  ensure
+    @client.login(USER, PASSWORD)
+    @client.proxy = proxy
+  end
+
+  def with_new_user
+    @user = @client.register(random_user, "test")
+    @client.proxy = @user.email
+    yield
+  ensure
+    @client.proxy = nil
+    @user.delete!
+    @user = nil
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: cfoundry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Alex Suraci
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-05 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: &70172796555500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70172796555500
+- !ruby/object:Gem::Dependency
+  name: json_pure
+  requirement: &70172796555080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70172796555080
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: &70172796554660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70172796554660
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70172796554240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70172796554240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70172796553820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70172796553820
+description: 
+email:
+- asuraci@vmware.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/cfoundry/app.rb
+- lib/cfoundry/client.rb
+- lib/cfoundry/errors.rb
+- lib/cfoundry/restclient.rb
+- lib/cfoundry/service.rb
+- lib/cfoundry/user.rb
+- lib/cfoundry/version.rb
+- lib/cfoundry/zip.rb
+- lib/cfoundry.rb
+- spec/client_spec.rb
+- spec/helpers.rb
+- spec/Rakefile
+homepage: http://cloudfoundry.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cfoundry
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: High-level library for working with the Cloud Foundry API.
+test_files:
+- spec/client_spec.rb
+- spec/helpers.rb
+- spec/Rakefile