vcap_services_base 0.2.10

data/lib/base/cloud_controller_services.rb

@@ -0,0 +1,75 @@
+require 'base/service'
+require 'base/plan'
+
+module VCAP::Services
+  class CloudControllerServices
+    def initialize(http_client, headers, logger)
+      @http_client = http_client
+      @headers = headers
+      @logger = logger
+    end
+
+    attr_reader :logger
+
+    def load_registered_services(service_list_uri)
+      logger.debug("Getting services listing from cloud_controller")
+      registered_services = []
+
+      self.each(service_list_uri, "Registered Offerings") do |s|
+        entity = s["entity"]
+        plans = []
+
+        logger.debug("Getting service plans for: #{entity["label"]}/#{entity["provider"]}")
+        self.each(entity.fetch("service_plans_url"), "Service Plans") do |p|
+          plan_entity = p.fetch('entity')
+          plan_metadata = p.fetch('metadata')
+          plans << Plan.new(
+            :unique_id => plan_entity.fetch("unique_id"),
+            :guid => plan_metadata.fetch("guid"),
+            :name => plan_entity.fetch("name"),
+            :description => plan_entity.fetch("description"),
+            :free => plan_entity.fetch("free"),
+          )
+        end
+
+        registered_services << Service.new(
+          'guid' => s["metadata"]["guid"],
+          'label' => entity["label"],
+          'unique_id' => entity["unique_id"],
+          'description' => entity["description"],
+          'provider' => entity["provider"],
+          'version' => entity['version'],
+          'url' => entity["url"],
+          'info_url' => entity["info_url"],
+          'extra' => entity['extra'],
+          'plans' => plans,
+          'bindable' => entity['bindable']
+        )
+      end
+
+      registered_services
+    end
+
+    def each(seed_url, description, &block)
+      url = seed_url
+      logger.info("Fetching #{description} from: #{seed_url}")
+
+      while !url.nil? do
+        logger.debug("#{self.class.name}: Fetching #{description} from: #{url}")
+        @http_client.call(:uri => url,
+                          :method => "get",
+                          :head => @headers,
+                          :need_raise => true) do |http|
+          result = nil
+          if (200..299) === http.response_header.status
+            result = JSON.parse(http.response)
+          else
+            raise "CCNG Catalog Manager: - Multiple page fetch via: #{url} failed: (#{http.response_header.status}) - #{http.response}"
+          end
+          result.fetch("resources").each { |r| block.yield r }
+          url = result["next_url"]
+        end
+      end
+    end
+  end
+end

data/lib/base/datamapper_l.rb

@@ -0,0 +1,148 @@
+require "fileutils"
+require "monitor"
+require "data_mapper"
+
+# Export Monitor's count
+class Monitor
+  def count
+    @mon_count
+  end
+end
+
+module DataMapper
+
+  class GlobalMutex
+    def initialize(lockfile)
+      @lockfile = lockfile
+      @monitor = Monitor.new
+    end
+
+    def synchronize
+      @monitor.synchronize do
+        File.open(@lockfile, 'r') do |file|
+          # Only Lock/Unlock on first entrance of synchronize to avoid
+          # deadlock on flock
+          file.flock(File::LOCK_EX) if @monitor.count == 1
+          begin
+            yield
+          ensure
+            file.flock(File::LOCK_UN) if @monitor.count == 1
+          end
+        end
+      end
+    end
+  end
+
+  class << self
+    attr_reader :lock
+
+    # extend DataMapper.setup parameters for a new :lock_file options
+    # new setup can be called as following:
+    # DataMapper.setup(<name>, <String>, :lock_file => file)
+    # DataMapper.setup(<name>, <Addressable::URI>, :lock_file => file)
+    # DataMapper.setup(<name>, <other_connection_options, :lock_file => file>)
+    alias original_setup setup
+    def setup(*args)
+      unless @lock
+        lock_file = args[1][:lock_file] if args.size == 2 && args[1].kind_of?(Hash)
+        lock_file = args[2][:lock_file] if args.size == 3
+        lock_file ||= '/var/vcap/sys/run/LOCK'
+        initialize_lock_file(lock_file)
+      end
+      original_setup(*(args[0..1]))
+    end
+
+    def initialize_lock_file(lock_file)
+      FileUtils.mkdir_p(File.dirname(lock_file))
+      File.open(lock_file, 'w') do |file|
+        file.truncate(0)
+      end
+      @lock = GlobalMutex.new(lock_file)
+    end
+  end
+
+  # The following code will overwrite DataMapper's functions, and replace
+  # them with a synchronized version of the same function.
+  module Resource
+    alias original_save save
+    alias original_destroy destroy
+
+    def save
+      DataMapper.lock.synchronize do
+        original_save
+      end
+    end
+
+    def destroy
+      DataMapper.lock.synchronize do
+        original_destroy
+      end
+    end
+  end
+
+  module Model
+    alias original_get get
+    alias original_all all
+
+    def get(*args)
+      DataMapper.lock.synchronize do
+        original_get(*args)
+      end
+    end
+
+    def all(*args)
+      DataMapper.lock.synchronize do
+        original_all(*args)
+      end
+    end
+  end
+
+  class Collection
+    alias original_each each
+    alias original_at []
+    alias original_get get
+    alias original_empty? empty?
+
+    def each(&block)
+      instances = []
+      DataMapper.lock.synchronize do
+        original_each do |instance|
+          instances << instance
+        end
+      end
+      instances.each(&block)
+    end
+
+    def [](*args)
+      DataMapper.lock.synchronize do
+        original_at(*args)
+      end
+    end
+
+    def get(*args)
+      DataMapper.lock.synchronize do
+        original_get(*args)
+      end
+    end
+
+    def empty?()
+      DataMapper.lock.synchronize do
+        original_empty?()
+      end
+    end
+  end
+
+  # For auto_upgrade!
+  module Migrations
+    module SingletonMethods
+      alias original_repository_execute repository_execute
+
+      def repository_execute(*args)
+        DataMapper.lock.synchronize do
+          original_repository_execute(*args)
+        end
+      end
+    end
+  end
+
+end

data/lib/base/gateway.rb

@@ -0,0 +1,167 @@
+# Copyright (c) 2009-2011 VMware, Inc.
+require 'rubygems'
+require 'bundler/setup'
+
+require 'optparse'
+require 'net/http'
+require 'thin'
+require 'yaml'
+require 'steno'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..', '..')
+require 'vcap/common'
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'asynchronous_service_gateway'
+require 'job/config'
+require 'abstract'
+
+module VCAP
+  module Services
+    module Base
+    end
+  end
+end
+
+
+class VCAP::Services::Base::Gateway
+
+  abstract :default_config_file
+  abstract :provisioner_class
+
+  def parse_config
+    config_file = default_config_file
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: $0 [options]"
+      opts.on("-c", "--config [ARG]", "Configuration File") do |opt|
+        config_file = opt
+      end
+      opts.on("-h", "--help", "Help") do
+        puts opts
+        exit
+      end
+    end.parse!
+
+    begin
+      @config = parse_gateway_config(config_file)
+    rescue => e
+      puts "Couldn't read config file: #{e}"
+      exit
+    end
+  end
+
+  def setup_vcap_logging
+    steno_config = Steno::Config.to_config_hash(@config[:logging])
+    steno_config[:context] = Steno::Context::FiberLocal.new
+    Steno.init(Steno::Config.new(steno_config))
+    # Use the current running binary name for logger identity name, since service gateway only has one instance now.
+    logger = Steno.logger(File.basename($0))
+    @config[:logger] = logger
+  end
+
+  def setup_async_job_config
+    resque = @config[:resque]
+    if resque
+      resque = VCAP.symbolize_keys(resque)
+      VCAP::Services::Base::AsyncJob::Config.redis_config = resque
+      VCAP::Services::Base::AsyncJob::Config.logger = @config[:logger]
+    end
+  end
+
+  def setup_pid
+    if @config[:pid]
+      pf = VCAP::PidFile.new(@config[:pid])
+      pf.unlink_at_exit
+    end
+  end
+
+  def start
+    parse_config
+
+    setup_vcap_logging
+
+    setup_pid
+
+    setup_async_job_config
+
+    @config[:host] = VCAP.local_ip(@config[:ip_route])
+    @config[:port] ||= VCAP.grab_ephemeral_port
+    @config[:service][:label] = "#{@config[:service][:name]}-#{@config[:service][:version]}"
+    @config[:service][:url]   = "http://#{@config[:host]}:#{@config[:port]}"
+    node_timeout = @config[:node_timeout] || 5
+
+    EM.error_handler do |ex|
+      @config[:logger].fatal("#{ex} #{ex.backtrace.join("|")}")
+      exit
+    end
+
+    # Go!
+    EM.run do
+      sp = provisioner_class.new(
+             :logger   => @config[:logger],
+             :index    => @config[:index],
+             :ip_route => @config[:ip_route],
+             :mbus => @config[:mbus],
+             :node_timeout => node_timeout,
+             :z_interval => @config[:z_interval],
+             :max_nats_payload => @config[:max_nats_payload],
+             :additional_options => additional_options,
+             :status => @config[:status],
+             :plan_management => @config[:plan_management],
+             :service => @config[:service],
+             :download_url_template => @config[:download_url_template],
+             :cc_api_version => @config[:cc_api_version] || "v1" ,
+             :snapshot_db => @config[:resque],
+           )
+
+      opts = @config.dup
+      opts[:provisioner] = sp
+      opts[:node_timeout] = node_timeout
+      opts[:cloud_controller_uri] = @config[:cloud_controller_uri] || "api.vcap.me"
+
+      sg = async_gateway_class.new(opts)
+
+      server = Thin::Server.new(@config[:host], @config[:port], sg)
+      if @config[:service][:timeout]
+        server.timeout = [@config[:service][:timeout] + 1, Thin::Server::DEFAULT_TIMEOUT].max
+      end
+      server.start!
+    end
+  end
+
+  def async_gateway_class
+    VCAP::Services::AsynchronousServiceGateway
+  end
+
+  def parse_gateway_config(config_file)
+    config = YAML.load_file(config_file)
+    config = VCAP.symbolize_keys(config)
+
+
+    cc_api_version = config[:cc_api_version] || "v1"
+
+    if cc_api_version == "v1"
+      token = config[:token]
+      raise "Token missing" unless token
+      raise "Token must be a String or Int, #{token.class} given" unless (token.is_a?(Integer) || token.is_a?(String))
+      config[:token] = token.to_s
+    else
+      service_auth_tokens = config[:service_auth_tokens]
+      raise "Service auth token missing" unless service_auth_tokens
+      raise "Token must be hash of the form: label_provider => token" unless service_auth_tokens.is_a?(Hash)
+
+      # Each gateway only handles one service, so service_auth_tokens is expected to have just 1 entry
+      raise "Unable to manage multiple services" unless service_auth_tokens.size == 1
+
+      # Used by legacy services for validating incoming request (and temporarily for handle fetch/update v1 api)
+      config[:token] = service_auth_tokens.values[0].to_s # For legacy services
+    end
+
+    config
+  end
+
+  def additional_options
+    {}
+  end
+end

data/lib/base/gateway_service_catalog.rb

@@ -0,0 +1,68 @@
+module VCAP::Services
+  class GatewayServiceCatalog
+    attr_reader :service
+    
+    def initialize(services)
+      raise ArgumentError.new('a service list is required') unless services and services.is_a?(Array)
+      @service = services.fetch(0)
+    end
+
+    def to_hash
+      id, version = VCAP::Services::Api::Util.parse_label(service[:label])
+      version = service[:version_aliases][:current] if service[:version_aliases][:current]
+      provider = service[:provider] || 'core'
+
+      catalog_key = "#{id}_#{provider}"
+
+      unique_id = service[:unique_id] ? {"unique_id" => service[:unique_id]} : {}
+      catalog = {}
+
+      plans = service.fetch(:plans)
+      unless plans.is_a?(Array)
+        plans.each do |name, plan|
+          plan[:name] = name
+        end
+      end
+
+      catalog[catalog_key] = {
+        "id" => id,
+        "version" => version,
+        "label" => service[:label],
+        "url" => service[:url],
+        "plans" => plans,
+        "cf_plan_id" => service[:cf_plan_id],
+        "tags" => service[:tags],
+        "active" => true,
+        "description" => service[:description],
+        "plan_options" => service[:plan_options],
+        "acls" => service[:acls],
+        "timeout" => service[:timeout],
+        "provider" => provider,
+        "default_plan" => service[:default_plan],
+        "supported_versions" => service[:supported_versions],
+        "version_aliases" => service[:version_aliases],
+      }.merge(extra).merge(unique_id)
+
+      return catalog
+    end
+
+    private
+
+    def extra
+      if (service.keys & [:logo_url, :blurb, :provider_name]).empty?
+        {}
+      else
+        {"extra" => Yajl::Encoder.encode(
+          "listing" => {
+            "imageUrl" => service[:logo_url],
+            "blurb" => service[:blurb]
+          },
+          "provider" => {
+            "name" => service[:provider_name]
+          }
+        )
+        }
+      end
+    end
+  end
+end