vcap_common 1.0.10

data/lib/json_message.rb

@@ -0,0 +1,139 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'rubygems'
+
+require 'yajl'
+
+require 'json_schema'
+
+class JsonMessage
+  # Base error class that all other JsonMessage related errors should inherit from
+  class Error < StandardError
+  end
+
+  # Failed to parse json during +decode+
+  class ParseError < Error
+  end
+
+  # One or more field's values didn't match their schema
+  class ValidationError < Error
+    def initialize(field_errs)
+      @field_errs = field_errs
+    end
+
+    def to_s
+      err_strs = @field_errs.map{|f, e| "Field: #{f}, Error: #{e}"}
+      err_strs.join(', ')
+    end
+  end
+
+  class Field
+    attr_reader :name, :schema, :required
+
+    def initialize(name, schema, required=true)
+      @name = name
+      @schema = schema.is_a?(JsonSchema) ? schema : JsonSchema.new(schema)
+      @required = required
+    end
+  end
+
+  class << self
+    attr_reader :fields
+
+    def schema(&blk)
+      instance_eval &blk
+    end
+
+    def decode(json)
+      begin
+        dec_json = Yajl::Parser.parse(json)
+      rescue => e
+        raise ParseError, e.to_s
+      end
+
+      from_decoded_json(dec_json)
+    end
+
+    def from_decoded_json(dec_json)
+      raise ParseError, "Decoded JSON cannot be nil" unless dec_json
+
+      errs = {}
+
+      # Treat null values as if the keys aren't present. This isn't as strict as one would like,
+      # but conforms to typical use cases.
+      dec_json.delete_if {|k, v| v == nil}
+
+      # Collect errors by field
+      @fields.each do |name, field|
+        err = nil
+        name_s = name.to_s
+        if dec_json.has_key?(name_s)
+          err = field.schema.validate(dec_json[name_s])
+        elsif field.required
+          err = "Missing field #{name}"
+        end
+        errs[name] = err if err
+      end
+
+      raise ValidationError.new(errs) unless errs.empty?
+
+      new(dec_json)
+    end
+
+    def required(field_name, schema=JsonSchema::WILDCARD)
+      define_field(field_name, schema, true)
+    end
+
+    def optional(field_name, schema=JsonSchema::WILDCARD)
+      define_field(field_name, schema, false)
+    end
+
+    protected
+
+    def define_field(name, schema, required)
+      name = name.to_sym
+
+      @fields ||= {}
+      @fields[name] = Field.new(name, schema, required)
+
+      define_method name.to_sym do
+        @msg[name]
+      end
+
+      define_method "#{name}=".to_sym do |value|
+        set_field(name, value)
+      end
+    end
+  end
+
+  def initialize(fields={})
+    @msg = {}
+    fields.each {|k, v| set_field(k, v)}
+  end
+
+  def encode
+    if self.class.fields
+      missing_fields = {}
+      self.class.fields.each do |name, field|
+        missing_fields[name] = "Missing field #{name}" unless (!field.required || @msg.has_key?(name))
+      end
+      raise ValidationError.new(missing_fields) unless missing_fields.empty?
+    end
+
+    Yajl::Encoder.encode(@msg)
+  end
+
+  def extract
+    @msg.dup.freeze
+  end
+
+  protected
+
+  def set_field(field, value)
+    field = field.to_sym
+    raise ValidationError.new({field => "Unknown field #{field}"}) unless self.class.fields.has_key?(field)
+
+    errs = self.class.fields[field].schema.validate(value)
+    raise ValidationError.new({field => errs}) if errs
+    @msg[field] = value
+  end
+end

data/lib/json_schema.rb

@@ -0,0 +1,84 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+# This class provides dead simple declarative validation for decoded json using
+# a fairly intuitive DSL like syntax.
+#
+# For example, the following is a sample schema that exercises all functionality
+#
+# {'foo' => [String],            # 'foo' must be a list of strings
+#  'bar' => {'baz' => Fixnum,    # 'bar' must be a hash where
+#            'jaz' => /foo/,     #   'baz' is a Fixnum, and
+#           }                    #   'jaz' matches the regex /foo/
+# }
+#
+class JsonSchema
+  WILDCARD = Object
+
+  # TODO(mjp): validate that schema is syntatically correct
+
+  def initialize(schema)
+    @schema = schema
+  end
+
+  def validate(json)
+    _validate(json, @schema)
+  end
+
+  protected
+
+  def _validate(json, schema)
+    case schema
+    when Class
+      # Terminal case, type check
+      klass = json.class
+      if json.is_a? schema
+        nil
+      else
+        "Type mismatch (expected #{schema}, got #{klass})"
+      end
+
+    when Hash
+      # Recursive case, check for required params, recursively check them against the supplied schema
+      missing_keys = schema.keys.select {|k| !json.has_key?(k)} if json.is_a? Hash
+
+      if !(json.is_a? Hash)
+        "Type mismatch (expected hash, got #{json.class})"
+      elsif missing_keys.length > 0
+        "Missing params: '#{missing_keys.join(', ')}'"
+      else
+        errs = nil
+        schema.each_key do |k|
+          sub_errs = _validate(json[k], schema[k])
+          if sub_errs
+            errs ||= {}
+            errs[k] = sub_errs
+          end
+        end
+        errs
+      end
+
+    when Array
+      # Recursive case, check that array isn't empty, recursively check array against supplied schema
+      if !(json.is_a? Array)
+        "Type mismatch (expected array, got #{json.class}"
+      else
+        errs = nil
+        json.each do |v|
+          errs = _validate(v, schema[0])
+          break if errs
+        end
+        errs
+      end
+
+    when Regexp
+      if schema.match(json)
+        nil
+      else
+        "Invalid value (doesn't match '#{schema.source})"
+      end
+
+    else
+      # Terminal case, value check
+      "Value mismatch (expected '#{schema}', got #{json})" unless json == schema
+    end
+  end
+end

data/lib/services/api/async_requests.rb

@@ -0,0 +1,43 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'eventmachine'
+require 'em-http-request'
+require 'fiber'
+
+require 'services/api/const'
+
+module VCAP
+  module Services
+    module Api
+    end
+  end
+end
+
+module VCAP::Services::Api
+  class AsyncHttpRequest
+    class << self
+      def new(url, token, verb, timeout, msg=VCAP::Services::Api::EMPTY_REQUEST)
+
+        req = {
+          :head => {
+            VCAP::Services::Api::GATEWAY_TOKEN_HEADER => token,
+            'Content-Type' => 'application/json',
+          },
+          :body => msg.encode,
+        }
+        if timeout
+          EM::HttpRequest.new(url, :inactivity_timeout => timeout).send(verb.to_sym, req)
+        else
+          EM::HttpRequest.new(url).send(verb.to_sym, req)
+        end
+      end
+
+      def fibered(url, token, verb, timeout, msg=VCAP::Services::Api::EMPTY_REQUEST)
+        req = new(url, token, verb, timeout, msg)
+        f = Fiber.current
+        req.callback { f.resume(req) }
+        req.errback  { f.resume(req) }
+        Fiber.yield
+      end
+    end
+  end
+end

data/lib/services/api/clients/service_gateway_client.rb

@@ -0,0 +1,107 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'net/http'
+
+require 'services/api/const'
+require 'services/api/messages'
+
+module VCAP
+  module Services
+    module Api
+    end
+  end
+end
+
+class VCAP::Services::Api::ServiceGatewayClient
+
+  class UnexpectedResponse < StandardError
+    attr_reader :response
+
+    def initialize(resp)
+      @response = resp
+    end
+  end
+
+  attr_reader :host, :port, :token
+
+  def initialize(host, token, port=80)
+    @host  = host
+    @port  = port
+    @token = token
+    @hdrs  = {
+      'Content-Type' => 'application/json',
+      VCAP::Services::Api::GATEWAY_TOKEN_HEADER => @token
+    }
+  end
+
+  def provision(args)
+    msg = VCAP::Services::Api::GatewayProvisionRequest.new(args)
+    resp = perform_request(Net::HTTP::Post, '/gateway/v1/configurations', msg)
+    VCAP::Services::Api::GatewayProvisionResponse.decode(resp.body)
+  end
+
+  def unprovision(args)
+    perform_request(Net::HTTP::Delete, "/gateway/v1/configurations/#{args[:service_id]}")
+  end
+
+  def create_snapshot(args)
+    resp = perform_request(Net::HTTP::Post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def enum_snapshots(args)
+    resp = perform_request(Net::HTTP::Get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+    VCAP::Services::Api::SnapshotList.decode(resp.body)
+  end
+
+  def snapshot_details(args)
+    resp = perform_request(Net::HTTP::Get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+    VCAP::Services::Api::Snapshot.decode(resp.body)
+  end
+
+  def rollback_snapshot(args)
+    resp = perform_request(Net::HTTP::Put, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def serialized_url(args)
+    resp = perform_request(Net::HTTP::Get, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url")
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def import_from_url(args)
+    resp = perform_request(Net::HTTP::Put, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url", args[:msg])
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def import_from_data(args)
+    resp = perform_request(Net::HTTP::Put, "/gateway/v1/configurations/#{args[:service_id]}/serialized/data", args[:msg])
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def job_info(args)
+    resp = perform_request(Net::HTTP::Get, "/gateway/v1/configurations/#{args[:service_id]}/jobs/#{args[:job_id]}")
+    VCAP::Services::Api::Job.decode(resp.body)
+  end
+
+  def bind(args)
+    msg = VCAP::Services::Api::GatewayBindRequest.new(args)
+    resp = perform_request(Net::HTTP::Post, "/gateway/v1/configurations/#{msg.service_id}/handles", msg)
+    VCAP::Services::Api::GatewayBindResponse.decode(resp.body)
+  end
+
+  def unbind(args)
+    msg = VCAP::Services::Api::GatewayUnbindRequest.new(args)
+    perform_request(Net::HTTP::Delete, "/gateway/v1/configurations/#{msg.service_id}/handles/#{msg.handle_id}", msg)
+  end
+
+  protected
+
+  def perform_request(klass, path, msg=VCAP::Services::Api::EMPTY_REQUEST)
+    req = klass.new(path, initheader=@hdrs)
+    req.body = msg.encode
+    resp = Net::HTTP.new(@host, @port).start {|http| http.request(req)}
+    raise UnexpectedResponse, resp unless resp.is_a? Net::HTTPOK
+    resp
+  end
+
+end

data/lib/services/api/const.rb

@@ -0,0 +1,9 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+module VCAP
+  module Services
+    module Api
+      GATEWAY_TOKEN_HEADER = 'X-VCAP-Service-Token'
+      SERVICE_LABEL_REGEX  = /^\S+-\S+$/
+    end
+  end
+end

data/lib/services/api/messages.rb

@@ -0,0 +1,153 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'uri'
+
+require 'services/api/const'
+require 'json_message'
+
+module VCAP
+  module Services
+    module Api
+
+      class EmptyRequest < JsonMessage
+      end
+      EMPTY_REQUEST = EmptyRequest.new.freeze
+
+      #
+      # Tell the CloudController about a service
+      # NB: Deleting an offering takes all args in the url
+      #
+      class ServiceOfferingRequest < JsonMessage
+        required :label,       SERVICE_LABEL_REGEX
+        required :url,         URI::regexp(%w(http https))
+
+        optional :description, String
+        optional :info_url,    URI::regexp(%w(http https))
+        optional :tags,        [String]
+        optional :plans,       [String]
+        optional :plan_options
+        optional :binding_options
+        optional :acls
+        optional :active
+        optional :timeout,     Integer
+      end
+
+      class BrokeredServiceOfferingRequest < JsonMessage
+        required :label,        SERVICE_LABEL_REGEX
+        required :options,      [{"name" => String, "credentials" => Hash}]
+        optional :description,  String
+      end
+
+      class HandleUpdateRequest < JsonMessage
+        required :service_id, String
+        required :configuration
+        required :credentials
+      end
+
+      class ListHandlesResponse < JsonMessage
+        required :handles, [::JsonSchema::WILDCARD]
+      end
+
+      class ListBrokeredServicesResponse < JsonMessage
+        required :brokered_services, [{"label" => String, "description" => String, "acls" => {"users" => [String], "wildcards" => [String]}}]
+      end
+
+      #
+      # Provision a service instance
+      # NB: Unprovision takes all args in the url
+      #
+      class CloudControllerProvisionRequest < JsonMessage
+        required :label, SERVICE_LABEL_REGEX
+        required :name,  String
+        required :plan,  String
+
+        optional :plan_option
+      end
+
+      class GatewayProvisionRequest < JsonMessage
+        required :label, SERVICE_LABEL_REGEX
+        required :name,  String
+        required :plan,  String
+        required :email, String
+
+        optional :plan_option
+      end
+
+      class GatewayProvisionResponse < JsonMessage
+        required :service_id, String
+        required :data
+        required :credentials
+      end
+
+      #
+      # Bind a previously provisioned service to an app
+      #
+      class CloudControllerBindRequest < JsonMessage
+        required :service_id, String
+        required :app_id,     Integer
+        required :binding_options
+      end
+
+      class GatewayBindRequest < JsonMessage
+        required :service_id,    String
+        required :label,         String
+        required :email,         String
+        required :binding_options
+      end
+
+      class GatewayUnbindRequest < JsonMessage
+        required :service_id,    String
+        required :handle_id,     String
+        required :binding_options
+      end
+
+      class CloudControllerBindResponse < JsonMessage
+        required :label,         SERVICE_LABEL_REGEX
+        required :binding_token, String
+      end
+
+      class GatewayBindResponse < JsonMessage
+        required :service_id, String
+        required :configuration
+        required :credentials
+      end
+
+      # Bind app_name using binding_token
+      class BindExternalRequest < JsonMessage
+        required :binding_token, String
+        required :app_id,        Integer
+      end
+
+      class BindingTokenRequest < JsonMessage
+        required :service_id, String
+        required :binding_options
+      end
+
+      class Snapshot < JsonMessage
+        required :snapshot_id,  String
+        required :date,  String
+        required :size,  Integer
+      end
+
+      class SnapshotList < JsonMessage
+        required :snapshots,  [::JsonSchema::WILDCARD]
+      end
+
+      class Job < JsonMessage
+        required :job_id,  String
+        required :status,  String
+        required :start_time, String
+        optional :description, String
+        optional :complete_time, String
+        optional :result, ::JsonSchema::WILDCARD
+      end
+
+      class SerializedURL < JsonMessage
+        required :url, URI::regexp(%w(http https))
+      end
+
+      class SerializedData < JsonMessage
+        required :data,  String
+      end
+    end
+  end
+end

data/lib/services/api/util.rb

@@ -0,0 +1,17 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+module VCAP
+  module Services
+    module Api
+    end
+  end
+end
+
+class VCAP::Services::Api::Util
+  class << self
+    def parse_label(label)
+      raise ArgumentError, "Invalid label" unless label.match(/-/)
+      name, _, version = label.rpartition(/-/)
+      [name, version]
+    end
+  end
+end

data/lib/services/api.rb

@@ -0,0 +1,6 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'services/api/async_requests'
+require 'services/api/const'
+require 'services/api/messages'
+require 'services/api/clients/service_gateway_client'
+require 'services/api/util'