vcap_common 1.0.10 → 2.0.8

data/lib/json_message.rb

@@ -1,46 +1,67 @@
-# Copyright (c) 2009-2011 VMware, Inc.
+# Copyright (c) 2009-2011 VMware, Inc
 require 'rubygems'
-
 require 'yajl'
-
-require 'json_schema'
+require 'membrane'
 
 class JsonMessage
-  # Base error class that all other JsonMessage related errors should inherit from
+  # Base error class that all other JsonMessage related errors should
+  # inherit from
   class Error < StandardError
   end
 
+  # Fields not defined properly.
+  class DefinitionError < Error
+  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
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
     end
 
     def to_s
-      err_strs = @field_errs.map{|f, e| "Field: #{f}, Error: #{e}"}
+      err_strs = @errors.map { |f, e| "Field: #{f}, Error: #{e}" }
       err_strs.join(', ')
     end
   end
 
   class Field
-    attr_reader :name, :schema, :required
+    attr_reader :name, :schema, :required, :default
+
+    def initialize(name, options = {}, &blk)
+      blk ||= lambda { |*_| options[:schema] || any }
 
-    def initialize(name, schema, required=true)
       @name = name
-      @schema = schema.is_a?(JsonSchema) ? schema : JsonSchema.new(schema)
-      @required = required
+      @schema = Membrane::SchemaParser.parse(&blk)
+      @required = options[:required] || false
+      @default = options[:default]
+
+      if @required && @default
+        raise DefinitionError, \
+          "Cannot define a default value for required field #{name}"
+      end
+
+      validate(@default) if @default
+    end
+
+    def validate(value)
+      begin
+        @schema.validate(value)
+      rescue Membrane::SchemaValidationError => e
+        raise ValidationError.new( { name => e.message } )
+      end
     end
   end
 
   class << self
-    attr_reader :fields
-
-    def schema(&blk)
-      instance_eval &blk
+    def fields
+      @fields ||= {}
     end
 
     def decode(json)
@@ -58,19 +79,23 @@ class JsonMessage
 
       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.
+      # 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|
+      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])
+        if dec_json.has_key?(name.to_s)
+          begin
+            field.validate(dec_json[name.to_s])
+          rescue ValidationError => e
+            err = e.errors[name]
+          end
         elsif field.required
           err = "Missing field #{name}"
         end
+
         errs[name] = err if err
       end
 
@@ -79,27 +104,27 @@ class JsonMessage
       new(dec_json)
     end
 
-    def required(field_name, schema=JsonSchema::WILDCARD)
-      define_field(field_name, schema, true)
+    def required(name, schema = nil, &blk)
+      define_field(name, :schema => schema, :required => true, &blk)
     end
 
-    def optional(field_name, schema=JsonSchema::WILDCARD)
-      define_field(field_name, schema, false)
+    def optional(name, schema = nil, default = nil, &blk)
+      define_field(name, :schema => schema, :default => default, &blk)
     end
 
     protected
 
-    def define_field(name, schema, required)
+    def define_field(name, options = {}, &blk)
       name = name.to_sym
 
-      @fields ||= {}
-      @fields[name] = Field.new(name, schema, required)
+      fields[name] = Field.new(name, options, &blk)
 
-      define_method name.to_sym do
+      define_method(name) do
+        set_default(name)
         @msg[name]
       end
 
-      define_method "#{name}=".to_sym do |value|
+      define_method("#{name}=") do |value|
         set_field(name, value)
       end
     end
@@ -107,33 +132,61 @@ class JsonMessage
 
   def initialize(fields={})
     @msg = {}
-    fields.each {|k, v| set_field(k, v)}
+    fields.each { |name, value| set_field(name, value) }
+    set_defaults
   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))
+    set_defaults
+
+    missing_fields = {}
+
+    self.class.fields.each do |name, field|
+      if field.required && !@msg.has_key?(name)
+        missing_fields[name] = "Missing field #{name}"
       end
-      raise ValidationError.new(missing_fields) unless missing_fields.empty?
     end
 
+    raise ValidationError.new(missing_fields) unless missing_fields.empty?
+
     Yajl::Encoder.encode(@msg)
   end
 
-  def extract
-    @msg.dup.freeze
+  def extract(opts = {})
+    hash = @msg.dup
+    if opts[:stringify_keys]
+      hash = hash.inject({}) { |memo,(k,v)| memo[k.to_s] = v; memo }.freeze
+    end
+
+    hash.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)
+  def set_field(name, value)
+    name = name.to_sym
+    field = self.class.fields[name]
+
+    unless field
+      raise ValidationError.new( { name => "Unknown field: #{name}" } )
+    end
 
-    errs = self.class.fields[field].schema.validate(value)
-    raise ValidationError.new({field => errs}) if errs
-    @msg[field] = value
+    field.validate(value)
+    @msg[name] = value
+  end
+
+  def set_defaults
+    self.class.fields.each do |name, _|
+      set_default(name)
+    end
+  end
+
+  def set_default(name)
+    unless @msg.has_key?(name)
+      field = self.class.fields[name]
+      if field
+        @msg[name] = field.default if field.default
+      end
+    end
   end
 end

data/lib/services/api.rb

@@ -3,4 +3,5 @@ require 'services/api/async_requests'
 require 'services/api/const'
 require 'services/api/messages'
 require 'services/api/clients/service_gateway_client'
+require 'services/api/clients/sds_client'
 require 'services/api/util'

data/lib/services/api/async_requests.rb

@@ -2,6 +2,7 @@
 require 'eventmachine'
 require 'em-http-request'
 require 'fiber'
+require 'httpclient'
 
 require 'services/api/const'
 
@@ -31,11 +32,54 @@ module VCAP::Services::Api
         end
       end
 
-      def fibered(url, token, verb, timeout, msg=VCAP::Services::Api::EMPTY_REQUEST)
+      def request(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) }
+        http = Fiber.yield
+        raise UnexpectedResponse, "Error sending request #{msg.extract.to_json} to gateway #{@url}: #{http.error}" unless http.error.empty?
+        code = http.response_header.status.to_i
+        body = http.response
+        [code, body]
+      end
+    end
+  end
+
+  module SynchronousHttpRequest
+    def self.request(url, token, verb, timeout, msg=VCAP::Services::Api::EMPTY_REQUEST)
+      header = {
+        VCAP::Services::Api::GATEWAY_TOKEN_HEADER => token,
+        'Content-Type' => 'application/json',
+      }
+      body = msg.encode
+      client = HTTPClient.new
+      msg = client.request(verb.to_sym, url, :body => body, :header => header)
+      [msg.code, msg.body]
+    end
+  end
+
+  class AsyncHttpMultiPartUpload
+    class << self
+      def new(url, timeout, multipart, head={})
+        req = {
+          :head => head,
+          :body => "",
+          :multipart => multipart
+        }
+
+        if timeout
+          EM::HttpRequest.new(url, :inactivity_timeout => timeout).post req
+        else
+          EM::HttpRequest.new(url).post req
+        end
+      end
+
+      def fibered(url, timeout, multipart, head={})
+        req = new(url, timeout, multipart, head)
+        f = Fiber.current
+        req.callback { f.resume(req) }
+        req.errback {f.resume(req)}
         Fiber.yield
       end
     end

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

@@ -0,0 +1,84 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+require 'net/http'
+require 'net/http/post/multipart'
+require 'mime/types'
+require 'uri'
+
+require 'services/api/const'
+require 'services/api/messages'
+require 'services/api/multipart'
+
+module VCAP
+  module Services
+    module Api
+    end
+  end
+end
+
+module VCAP::Services::Api
+  class SDSClient
+
+    class SDSErrorResponse < StandardError; end
+    class UnexpectedResponse < StandardError; end
+
+    def initialize(url, upload_token, timeout=60, opts={})
+      @url = url
+      @timeout = timeout
+      @hdrs  = {
+        'Content-Type' => 'application/json',
+      }
+      @upload_hdrs = {
+        'Content-Type' => 'multipart/form-data',
+        SDS_UPLOAD_TOKEN_HEADER => upload_token
+      }
+    end
+
+    def import_from_data(args)
+      resp = perform_multipart_upload("/serialized/#{args[:service]}/#{args[:service_id]}/serialized/data", args[:msg])
+      SerializedURL.decode(resp)
+    end
+
+    protected
+
+    def perform_multipart_upload(path, file_path)
+      # upload file using multipart/form data
+      result = nil
+      uri = URI.parse(@url)
+
+      mime_types = MIME::Types.type_for(file_path) || []
+      mime_types << "application/octet-stream" if mime_types.empty?
+
+      if EM.reactor_running?
+        payload = {:_method => 'put', :data_file => EM::StreamUploadIO.new(file_path, mime_types[0])}
+        multipart = EM::Multipart.new(payload, @upload_hdrs)
+        url = URI.parse(uri.to_s + path)
+        http = AsyncHttpMultiPartUpload.fibered(url, @timeout, multipart)
+        raise UnexpectedResponse, "Error uploading #{file_path} to serialized_data_server #{@url}: #{http.error}" unless http.error.empty?
+        code = http.response_header.status.to_i
+        body = http.response
+      else
+        payload = {:_method => 'put', :data_file => UploadIO.new(file_path, mime_types[0])}
+        req = Net::HTTP::Post::Multipart.new(path, payload, @upload_hdrs)
+        resp = Net::HTTP.new(uri.host, uri.port).start do |http|
+          http.request(req)
+        end
+        code = resp.code.to_i
+        body = resp.body
+      end
+      case code
+      when 200
+        body
+      when 400
+        raise SDSErrorResponse, "Fail to upload the file to serialization_data_server."
+      when 403
+        raise SDSErrorResponse, "You are forbidden to access serialization_data_server."
+      when 404
+        raise SDSErrorResponse, "Not found in serialization_data_server."
+      when 501
+        raise SDSErrorResponse, "Serialized data file is recognized, but file not found in serialization_data_server."
+      else
+        raise UnexpectedResponse, "Unexpected exception in serialization_data_server: #{(uri.to_s + path)} #{code} #{body}"
+      end
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
 # Copyright (c) 2009-2011 VMware, Inc.
 require 'net/http'
+require 'uri'
 
 require 'services/api/const'
 require 'services/api/messages'
+require 'services/api/async_requests'
 
 module VCAP
   module Services
@@ -11,97 +13,172 @@ module VCAP
   end
 end
 
-class VCAP::Services::Api::ServiceGatewayClient
+module VCAP::Services::Api
+  class ServiceGatewayClient
+    METHODS_MAP = {
+      :get => Net::HTTP::Get,
+      :post=> Net::HTTP::Post,
+      :put => Net::HTTP::Put,
+      :delete => Net::HTTP::Delete,
+    }
 
-  class UnexpectedResponse < StandardError
-    attr_reader :response
+    # Public: Indicate gateway client encounter an unexpected error,
+    # such as can't connect to gateway or can't decode response.
+    #
+    class UnexpectedResponse < StandardError; end
+
+    # Public: Indicate an error response from gateway
+    #
+    class ErrorResponse < StandardError
+      attr_reader :status, :error
+
+      # status - the http status
+      # error  - a ServiceErrorResponse object
+      #
+      def initialize(status, error)
+        @status = status
+        @error = error
+      end
+
+      def to_s
+        "Reponse status:#{status},error:[#{error.extract}]"
+      end
+    end
 
-    def initialize(resp)
-      @response = resp
+    class NotFoundResponse < ErrorResponse
+      def initialize(error)
+        super(404, error)
+      end
     end
-  end
 
-  attr_reader :host, :port, :token
+    class GatewayInternalResponse < ErrorResponse
+      def initialize(error)
+        super(503, error)
+      end
+    end
 
-  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
+    attr_reader :host, :port, :token
+    attr_reader :requester
+    def initialize(url, token, timeout, opts={})
+      @url = url
+      @timeout = timeout
+      @token = token
+      @hdrs  = {
+        'Content-Type' => 'application/json',
+        GATEWAY_TOKEN_HEADER => @token
+      }
+      # contract: @requester.responds_to? :request(url, token, timeout, [msg])
+      # contract @requester.request(url, token, timeout, [msg]) => [code, body]
+      @requester = opts[:requester] || AsyncHttpRequest
+    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 provision(args)
+      msg = GatewayProvisionRequest.new(args)
+      resp = perform_request(:post, '/gateway/v1/configurations', msg)
+      GatewayHandleResponse.decode(resp)
+    end
 
-  def unprovision(args)
-    perform_request(Net::HTTP::Delete, "/gateway/v1/configurations/#{args[:service_id]}")
-  end
+    def unprovision(args)
+      resp = perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}")
+      EMPTY_REQUEST
+    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 create_snapshot(args)
+      resp = perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+      Job.decode(resp)
+    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 enum_snapshots(args)
+      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots")
+      SnapshotList.decode(resp)
+    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 snapshot_details(args)
+      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      Snapshot.decode(resp)
+    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 update_snapshot_name(args)
+      perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}/name", args[:msg])
+      EMPTY_REQUEST
+    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 rollback_snapshot(args)
+      resp = perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      Job.decode(resp)
+    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 delete_snapshot(args)
+      resp = perform_request(:delete, "/gateway/v1/configurations/#{args[:service_id]}/snapshots/#{args[:snapshot_id]}")
+      Job.decode(resp)
+    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 create_serialized_url(args)
+      resp = perform_request(:post, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
+      Job.decode(resp)
+    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 serialized_url(args)
+      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url/snapshots/#{args[:snapshot_id]}")
+      SerializedURL.decode(resp)
+    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 import_from_url(args)
+      resp = perform_request(:put, "/gateway/v1/configurations/#{args[:service_id]}/serialized/url", args[:msg])
+      Job.decode(resp)
+    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
+    def job_info(args)
+      resp = perform_request(:get, "/gateway/v1/configurations/#{args[:service_id]}/jobs/#{args[:job_id]}")
+      Job.decode(resp)
+    end
 
-  protected
+    def bind(args)
+      msg = GatewayBindRequest.new(args)
+      resp = perform_request(:post, "/gateway/v1/configurations/#{msg.service_id}/handles", msg)
+      GatewayHandleResponse.decode(resp)
+    end
 
-  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
+    def unbind(args)
+      msg = GatewayUnbindRequest.new(args)
+      perform_request(:delete, "/gateway/v1/configurations/#{msg.service_id}/handles/#{msg.handle_id}", msg)
+      EMPTY_REQUEST
+    end
 
+    protected
+
+    def perform_request(http_method, path, msg=VCAP::Services::Api::EMPTY_REQUEST)
+      result = nil
+      uri = URI.parse(@url)
+      if EM.reactor_running?
+        url = URI.parse(uri.to_s + path)
+        code, body = requester.request(url, @token, http_method, @timeout, msg)
+      else
+        klass = METHODS_MAP[http_method]
+        req = klass.new(path, initheader=@hdrs)
+        req.body = msg.encode
+        resp = Net::HTTP.new(uri.host, uri.port).start {|http| http.request(req)}
+        code = resp.code.to_i
+        body = resp.body
+      end
+      case code
+      when 200
+        body
+      when 404
+        err = ServiceErrorResponse.decode(body)
+        raise NotFoundResponse.new(err)
+      when 503
+        err = ServiceErrorResponse.decode(body)
+        raise GatewayInternalResponse.new(err)
+      else
+        begin
+          # try to decode the response
+          err = ServiceErrorResponse.decode(body)
+        rescue => e
+          raise UnexpectedResponse, "Can't decode gateway response. status code:#{code}, response body:#{body}"
+        end
+        raise ErrorResponse.new(code, err)
+      end
+    end
+  end
 end