vcap_services_base 0.2.10

data/lib/base/provisioner_v1.rb

@@ -0,0 +1,125 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2009-2011 VMware, Inc.
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require "base/provisioner"
+
+module VCAP::Services::Base::ProvisionerV1
+
+  attr_accessor :prov_svcs
+
+  # Updates our internal handle state from external v1 handles, e.g., ccdb handles
+  # @param hash handles
+  def update_handles(handles)
+    @logger.info("[#{service_description}] Updating #{handles.size} handles v1")
+    handles.each do |handle|
+      unless verify_handle_format(handle)
+        @logger.warn("Skip not well-formed handle:#{handle}.")
+        next
+      end
+
+      h = handle.deep_dup
+      @prov_svcs[h['service_id']] = {
+        :configuration => h['configuration'],
+        :credentials => h['credentials'],
+        :service_id => h['service_id']
+      }
+    end
+    @logger.info("[#{service_description}] Handles updated")
+  end
+
+  def verify_handle_format(handle)
+    return nil unless handle
+    return nil unless handle.is_a? Hash
+
+    VCAP::Services::Internal::ServiceHandle.new(handle)
+    true
+  rescue => e
+    @logger.warn("Verify handle #{handle} failed:#{e}")
+    return nil
+  end
+
+  def indexing_handles(handles)
+    # instance handles hash's key is service_id, value is handle
+    # binding handles hash's key is credentials name & username, value is handle
+    ins_handles = {}
+    bin_handles = {}
+
+    handles.each do |h|
+      if h["service_id"] == h["credentials"]["name"]
+        ins_handles[h["service_id"]] = h
+      else
+        user = h["credentials"]["username"] || h["credentials"]["user"]
+        next unless user
+        key = h["credentials"]["name"] + user
+        bin_handles[key] = h
+      end
+    end
+
+    [ins_handles, bin_handles]
+  end
+
+  def get_instance_id_list(node_id, &blk)
+    @logger.debug("Get instance id list for migration")
+
+    id_list = []
+    @prov_svcs.each do |k, v|
+      id_list << k if (k == v[:credentials]["name"] && node_id == v[:credentials]["node_id"])
+    end
+    blk.call(success(id_list))
+  end
+
+  ########
+  # Helpers
+  ########
+
+  def get_all_instance_handles
+    instance_handles = @prov_svcs.select {|service_id, entity| service_id.to_s == entity[:credentials]["name"]}
+    instance_handles.each {|service_id, handle| yield handle if block_given?}
+    instance_handles
+  end
+
+  def get_all_binding_handles
+    binding_handles = @prov_svcs.select {|service_id, entity| service_id.to_s != entity[:credentials]["name"]}
+    binding_handles.each {|service_id, handle| yield handle if block_given?}
+    binding_handles
+  end
+
+  def get_instance_handle(instance_id)
+    @prov_svcs[instance_id].deep_dup
+  end
+
+  def get_binding_handle(binding_id)
+    @prov_svcs[binding_id].deep_dup
+  end
+
+  def add_instance_handle(response)
+    @prov_svcs[response[:service_id]] = response
+  end
+
+  def add_binding_handle(response)
+    @prov_svcs[response[:service_id]] = response
+  end
+
+  def delete_instance_handle(instance_handle)
+    @prov_svcs.delete(instance_handle[:service_id])
+  end
+
+  def delete_binding_handle(binding_handle)
+    @prov_svcs.delete(binding_handle[:service_id])
+  end
+
+  def find_instance_bindings(instance_id)
+    binding_handles = []
+    @prov_svcs.each do |_, handle|
+      if handle[:credentials]["name"] == instance_id
+        binding_handles << handle if handle[:service_id] != instance_id
+      end
+    end
+    binding_handles
+  end
+
+  def get_all_handles
+    @prov_svcs.deep_dup
+  end
+end

data/lib/base/provisioner_v2.rb

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2009-2011 VMware, Inc.
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require "base/provisioner"
+
+module VCAP::Services::Base::ProvisionerV2
+
+  attr_accessor :service_instances
+  attr_accessor :service_bindings
+
+  # Updates our internal handle state from external v2 handles, e.g., ccdb handles
+  # @param array handles
+  #    handles[0] contains all instance handles
+  #    handles[1] contains all binding handles
+  def update_handles(handles)
+    if handles.size == 2
+      @logger.info("[#{service_description}] Updating #{handles[0].size} instance handles and #{handles[1].size} binding handles in v2 api...")
+      update_instance_handles(handles[0])
+      update_binding_handles(handles[1])
+      @logger.info("[#{service_description}] Handles updated")
+    elsif handles.size == 1
+      # this is for the internal update when doing version update and some other updates
+      # and thus it would only be updating either binding or instance handle;
+      # binding handle would have a field of gateway_name but instance handle would not;
+      if handles[0].has_key?('gateway_name')
+        internal_handle = { handles[0]['gateway_name'] => handles[0] }
+        update_binding_handles(internal_handle)
+      else
+        internal_handle = { handles[0]['credentials']['name'] => handles[0] }
+        update_instance_handles(internal_handle)
+      end
+    else
+      raise "unknown handle type in update handles v2"
+    end
+  end
+
+  def update_instance_handles(instance_handles)
+    instance_handles.each do |instance_id, instance_handle|
+      unless verify_instance_handle_format(instance_handle)
+        @logger.warn("Skip not well-formed instance handle:#{instance_handle}.")
+        next
+      end
+
+      handle = instance_handle.deep_dup
+      @service_instances[instance_id] = {
+        :credentials   => handle['credentials'],
+        # NOTE on gateway we have have 'configuration' field in instance handle in replacement
+        # of the 'gateway_data' field as in ccdb handle, this is for a easy management/translation
+        # between gateway v1 and v2 provisioner code
+        :configuration => handle['gateway_data'],
+        :gateway_name  => handle['credentials']['name'],
+      }
+    end
+  end
+
+  def update_binding_handles(binding_handles)
+    binding_handles.each do |binding_id, binding_handle|
+      unless verify_binding_handle_format(binding_handle)
+        @logger.warn("Skip not well-formed binding handle:#{binding_handle}.")
+        next
+      end
+
+      handle = binding_handle.deep_dup
+      @service_bindings[binding_id] = {
+        :credentials   => handle['credentials'],
+        # NOTE on gateway we have have 'configuration' field in binding handle in replacement
+        # of the 'gateway_data' field as in ccdb, this is for a easy management/translation
+        # between gateway v1 and v2 provisioner code
+        :configuration => handle['gateway_data'],
+        :gateway_name  => handle['gateway_name'],
+      }
+    end
+  end
+
+  def verify_instance_handle_format(handle)
+    return nil unless handle
+    return nil unless handle.is_a? Hash
+
+    VCAP::Services::Internal::ServiceInstanceHandleV2.new(handle)
+    true
+  rescue => e
+    @logger.warn("Verify v2 instance handle #{handle} failed:#{e}")
+    return nil
+  end
+
+  def verify_binding_handle_format(handle)
+    return nil unless handle
+    return nil unless handle.is_a? Hash
+
+    VCAP::Services::Internal::ServiceBindingHandleV2.new(handle)
+    true
+  rescue => e
+    @logger.warn("Verify v2 binding handle #{handle} failed:#{e}")
+    return nil
+  end
+
+  # indexing handles for (double) check orphan only
+  # @param: array handles
+  #         handles[0] contains an array of instance handles
+  #         handles[1] contains an array of binding handles
+  # returns: array of handles which contains two hashes for instance handles and binding handle.
+  def indexing_handles(handles)
+    instance_handles = {}
+    binding_handles  = {}
+    handles[0].each { |instance_id, _| instance_handles[instance_id] = nil }
+    handles[1].each do |binding_id, binding_handle|
+      user = binding_handle["credentials"]["username"] || binding_handle["credentials"]["user"]
+      next unless user
+      key = binding_handle["credentials"]["name"] + user
+      binding_handles[key] = nil
+    end
+    [instance_handles, binding_handles]
+  end
+
+  def get_instance_id_list(node_id, &blk)
+    @logger.debug("Get instance id list for migration")
+
+    id_list = []
+    @service_instances.each do |service_id, entity|
+      id_list << service_id if node_id == entity[:credentials]["node_id"]
+    end
+    blk.call(success(id_list))
+  end
+
+  ########
+  # Helpers
+  ########
+
+  def get_all_instance_handles
+    instance_handles = @service_instances.deep_dup
+    instance_handles.each {|instance_id, handle| yield handle if block_given?}
+    instance_handles
+  end
+
+  def get_all_binding_handles
+    binding_handles = @service_bindings.deep_dup
+    binding_handles.each {|binding_id, handle| yield handle if block_given?}
+    binding_handles
+  end
+
+  def get_instance_handle(instance_id)
+    @service_instances[instance_id].deep_dup
+  end
+
+  def get_binding_handle(binding_id)
+    @service_bindings[binding_id].deep_dup
+  end
+
+  def add_instance_handle(entity)
+    # NOTE this handle contains a subset of the information of the handles in ccdb
+    # the handle will possess the full information after the next fetch handle operation
+    # on the gateway and update the corresponding handle; but these information is sufficient
+    # for current operations
+    @service_instances[entity[:service_id]] = {
+      :credentials   => entity[:credentials],
+      :configuration => entity[:configuration],
+      :gateway_name  => entity[:service_id],
+    }
+  end
+
+  def add_binding_handle(entity)
+    # NOTE this handle contains a subset of the information of the handles in ccdb
+    # the handle will possess the full information after the next fetch handle operation
+    # on the gateway and update the corresponding handle; but these information is sufficient
+    # for current operations
+    @service_bindings[entity[:service_id]] = {
+      :credentials   => entity[:credentials],
+      :configuration => entity[:configuration],
+      :gateway_name  => entity[:service_id],
+    }
+  end
+
+  def delete_instance_handle(instance_handle)
+    @service_instances.delete(instance_handle[:credentials]["name"])
+  end
+
+  def delete_binding_handle(binding_handle)
+    @service_bindings.delete(binding_handle[:gateway_name])
+  end
+
+  def find_instance_bindings(instance_id)
+    binding_handles = []
+    @service_bindings.each do |_, handle|
+      binding_handles << handle if handle[:credentials]["name"] == instance_id
+    end
+    binding_handles
+  end
+
+  def get_all_handles
+    @service_instances.merge(@service_bindings).deep_dup
+  end
+end

data/lib/base/service.rb

@@ -0,0 +1,93 @@
+require "base/plan"
+require "base/service_plan_change_set"
+
+module VCAP::Services
+  class Service
+    attr_reader :description, :provider, :version, :url, :info_url, :documentation_url, :plans, :tags,
+                :unique_id, :label, :active, :tags, :plan_options, :acls, :timeout,
+                :default_plan, :supported_versions, :version_aliases, :extra, :bindable
+    attr_accessor :guid
+
+    def initialize(attrs)
+      @unique_id = attrs.fetch('unique_id')
+      @label = attrs['label']
+      @active = attrs['active']
+      @active = true if @active.nil?
+      @tags = attrs['tags']
+      @plan_options = attrs['plan_options']
+      @acls = attrs['acls']
+      @timeout = attrs['timeout']
+      @default_plan = attrs['default_plan']
+      @supported_versions = attrs['supported_versions']
+      @version_aliases = attrs['version_aliases']
+      @extra = attrs.fetch('extra')
+      @info_url = attrs['info_url']
+      @documentation_url = attrs['documentation_url']
+      @bindable = attrs.fetch('bindable', true)
+      @guid = attrs['guid']
+      @description = attrs['description']
+      @provider = attrs.fetch('provider')
+      @version = attrs.fetch('version')
+      @url = attrs.fetch('url')
+      @plans = Plan.plan_hash_as_plan_array(attrs.fetch('plans'))
+      @tags = attrs['tags']
+    end
+
+    def create_change_set(service_in_ccdb)
+
+      if service_in_ccdb
+        service_guid    = service_in_ccdb.guid
+        plans_to_update = []
+        plans_to_add    = []
+
+        self.plans.each do |catalog_plan|
+          ccdb_plan = service_in_ccdb.plans.find { |ccp| catalog_plan.unique_id == ccp.unique_id }
+          ccdb_plan = service_in_ccdb.plans.find { |ccp| catalog_plan.name.to_s == ccp.name.to_s } unless ccdb_plan
+
+          if ccdb_plan
+            catalog_plan.guid = ccdb_plan.guid
+            plans_to_update << catalog_plan
+          else
+            plans_to_add << catalog_plan
+          end
+        end
+      else
+        service_guid    = nil
+        plans_to_add    = self.plans
+        plans_to_update = []
+      end
+
+      ServicePlanChangeSet.new(self, service_guid,
+        plans_to_add: plans_to_add,
+        plans_to_update: plans_to_update,
+      )
+    end
+
+    def to_hash
+      {
+        "description" => description,
+        "provider" => provider,
+        "version" => version,
+        "url" => url,
+        "documentation_url" => documentation_url,
+        "plans" => Plan.plans_array_to_hash(plans),
+        "unique_id" => unique_id,
+        "label" => label,
+        "active" => active,
+        "acls" => acls,
+        "timeout" => timeout,
+        "extra" => extra,
+        "bindable" => bindable,
+        "tags" => tags
+      }
+    end
+
+    def same_tuple?(other)
+      [self.label, self.provider, self.version].each { |x| return false if x.nil? }
+
+      (self.label == other.label &&
+        self.provider == other.provider &&
+        self.version == other.version)
+    end
+  end
+end

data/lib/base/service_advertiser.rb

@@ -0,0 +1,184 @@
+module VCAP::Services
+  class ServiceAdvertiser
+    attr_reader :logger, :active, :catalog_services, :registered_services
+
+    def initialize(options)
+      @catalog_services = options.fetch(:current_catalog)
+      @registered_services = options.fetch(:catalog_in_ccdb)
+      @http_handler = options.fetch(:http_handler)
+      @logger = options.fetch(:logger)
+      @active = options.fetch(:active, true)
+      @offering_uri = "/v2/services"
+      @service_plans_uri = "/v2/service_plans"
+
+      build_service_lists_and_prepare_guids
+    end
+
+    def advertise_services
+      logger.debug("CCNG Catalog Manager: Registered in ccng: #{registered_services.inspect}")
+      logger.debug("CCNG Catalog Manager: Current catalog: #{catalog_services.inspect}")
+
+      active_services.each do |active_service|
+        service_in_ccdb = registered_services.find do |registered_service|
+          active_service.guid == registered_service.guid
+        end
+
+        service_change_set = active_service.create_change_set(service_in_ccdb)
+        logger.debug("CCNG Catalog Manager:  service_change_set = #{service_change_set.inspect}")
+        advertise_service_to_cc(active_service,
+                                active_service.guid,
+                                service_change_set.plans_to_add,
+                                service_change_set.plans_to_update)
+      end
+
+      new_services.each do |service|
+        service_plan_change_set = service.create_change_set(nil)
+        logger.debug("CCNG Catalog Manager: plans_to_add = #{service_plan_change_set.plans_to_add.inspect}")
+
+        logger.debug("CCNG Catalog Manager: Add new offering: #{service.inspect}")
+        advertise_service_to_cc(service, nil, service_plan_change_set.plans_to_add, {}) # nil guid => new service, so add all plans
+      end
+
+      logger.info("CCNG Catalog Manager: Found #{active_services.size} active, #{disabled_count} disabled and #{new_services.size} new service offerings")
+
+    end
+
+    def active_count
+      active ? @catalog_services.size : 0
+    end
+
+    def disabled_count
+      active ? inactive_services.size : registered_services.size
+    end
+
+    def active_services
+      @active_services
+    end
+
+    def inactive_services
+      @inactive_services
+    end
+
+    def new_services
+      @new_services
+    end
+
+    private
+
+    def build_service_lists_and_prepare_guids
+      @inactive_services = registered_services.dup
+      @active_services   = []
+      @new_services      = []
+
+      @catalog_services.each do |service|
+        registered_service = registered_services.find { |rs| service.unique_id == rs.unique_id }
+
+        unless registered_service
+          registered_service = registered_services.find { |rs| service.same_tuple?(rs) }
+
+          if registered_service && service.unique_id
+            logger.warn("CCNG Catalog Manager: Service with unique id #{service.unique_id} in broker catalog matched service with unique id #{registered_service.unique_id} from cloud controller using label-version-provider tuple.")
+          end
+        end
+
+        if registered_service
+          service.guid = registered_service.guid
+          @active_services << service
+          @inactive_services.delete(registered_service)
+        else
+          @new_services << service
+        end
+      end
+    end
+
+    def add_or_update_offering(offering, guid)
+      update = !guid.nil?
+      uri = update ? "#{@offering_uri}/#{guid}" : @offering_uri
+      service_guid = nil
+
+      logger.debug("CCNG Catalog Manager: #{update ? "Update" : "Advertise"} service offering #{offering.inspect} to cloud_controller: #{uri}")
+
+      offerings_hash = offering.to_hash
+      method = update ? "put" : "post"
+      if method == 'put'
+        offerings_hash.delete('unique_id')
+      end
+      offerings_hash.delete('plans')
+      @http_handler.cc_http_request(:uri => uri,
+                                    :method => method,
+                                    :body => Yajl::Encoder.encode(offerings_hash)) do |http|
+        if !http.error
+          if (200..299) === http.response_header.status
+            response = JSON.parse(http.response)
+            logger.info("CCNG Catalog Manager: Advertise offering response (code=#{http.response_header.status}): #{response.inspect}")
+            service_guid = response["metadata"]["guid"]
+          else
+            logger.error("CCNG Catalog Manager: Failed advertise offerings:#{offering.inspect}, status=#{http.response_header.status}")
+          end
+        else
+          logger.error("CCNG Catalog Manager: Failed advertise offerings:#{offering.inspect}: #{http.error}")
+        end
+      end
+
+      return service_guid
+    end
+
+    def advertise_service_to_cc(service, guid, plans_to_add, plans_to_update)
+      service_guid = add_or_update_offering(service, guid)
+      return false if service_guid.nil?
+
+      return true if !service.active # If deactivating, don't update plans
+
+      logger.debug("CCNG Catalog Manager: Processing plans for: #{service_guid} -Add: #{plans_to_add.size} plans, Update: #{plans_to_update.size} plans")
+
+      plans_to_add.each { |plan|
+        add_plan(plan, service_guid)
+      }
+
+      plans_to_update.each { |plan|
+        update_plan(plan, service_guid)
+      }
+      return true
+    end
+
+    def add_plan(plan, service_guid)
+      uri          = @service_plans_uri
+      method       = 'post'
+      plan_as_hash = plan.get_add_hash(service_guid)
+
+      logger.info("CCNG Catalog Manager: Add new plan #{plan.inspect} via #{uri}")
+
+      make_plan_request(uri, method, plan_as_hash, plan)
+    end
+
+    def update_plan(plan, service_guid)
+      uri          = "#{@service_plans_uri}/#{plan.guid}"
+      method       = 'put'
+      plan_as_hash = plan.get_update_hash(service_guid)
+
+      logger.info("CCNG Catalog Manager: Update plan (guid: #{plan.guid}) to #{plan.inspect} via #{uri}")
+
+      make_plan_request(uri, method, plan_as_hash, plan)
+    end
+
+    def make_plan_request(uri, method, plan_as_hash, plan)
+      add_plan = method == 'post'
+
+      @http_handler.cc_http_request(:uri    => uri,
+                                    :method => method,
+                                    :body   => Yajl::Encoder.encode(plan_as_hash)) do |http|
+        if !http.error
+          if (200..299) === http.response_header.status
+            logger.info("CCNG Catalog Manager: Successfully #{add_plan ? "added" : "updated"} service plan: #{plan.inspect}")
+            return true
+          else
+            logger.error("CCNG Catalog Manager: Failed to #{add_plan ? "add" : "update"} plan: #{plan.inspect}, status=#{http.response_header.status}")
+          end
+        else
+          logger.error("CCNG Catalog Manager: Failed to #{add_plan ? "add" : "update"} plan: #{plan.inspect}: #{http.error}")
+        end
+      end
+      return false
+    end
+  end
+end