bosh_common 0.5.4 → 1.5.0.pre.1100

data/lib/common/common.rb

@@ -1,4 +1,6 @@
 # Copyright (c) 2012 VMware, Inc.
+require 'common/errors'
+require 'common/retryable'
 
 module Bosh
 
@@ -43,5 +45,80 @@ module Bosh
     end
 
     module_function :which
+
+    # Retries execution of given block until block returns true
+    #
+    # The block is called with two parameters: the number of tries and the most recent
+    # exception. If the block returns true retrying is stopped.
+    # Examples:
+    #   Bosh::Common.retryable do |retries, exception|
+    #     puts "try #{retries} failed with exception: #{exception}" if retries > 0
+    #     pick_up_soap
+    #   end
+    #
+    #   # Wait for EC2 instance to be terminated
+    #   Bosh::Common.retryable(on: AWS::EC2::Errors::RequestLimitExceeded) do |retries, exception|
+    #     @ec2.instance['i-a3x5g5'].status == :terminated
+    #   end
+    #
+    #
+    # @param [Hash] options
+    # @options opts [Proc] :ensure
+    #   Default: `Proc.new {}`
+    #   Ensure that a block of code is executed, regardless of whether an exception
+    #   was raised. It doesn't matter if the block exits normally, if it retries
+    #   to execute block of code, or if it is terminated by an uncaught exception
+    #   -- the ensure block will get run.
+    #   Example:
+    #   f = File.open("testfile")
+    #
+    #   ensure_cb = Proc.new do |retries|
+    #     puts "total retry attempts: #{retries}"
+    #
+    #     f.close
+    #  end
+    #
+    #  Bosh::Common.retryable(ensure: ensure_cb) do
+    #    # process file
+    #  end
+    #
+    # @options opts [Regexp] :matching
+    #   Default: `/.*/`
+    #   Retry based on the exception message
+    #   Example:
+    #   Bosh::Common.retryable(matching: /IO timeout/) do |retries, exception|
+    #     raise "yo, IO timeout!" if retries == 0
+    #   end
+    #
+    # @options opts [Array<ExceptionClass>] :on
+    #   Default: `[]`
+    #   The array of exception classes to retry on.
+    #   Example:
+    #   Bosh::Common.retryable(on: [StandardError, ArgumentError]) do
+    #     # do something and retry if StandardError or ArgumentError is raised
+    #   end
+    #
+    # @options opts [Proc, Fixnum] :sleep
+    #   Defaults: `lambda { |tries, _| [2**(tries-1), 10].min }`,  1, 2, 4, 8, 10, 10..10 seconds
+    #   If a Fixnum is given, sleep that many seconds between retries.
+    #   If a Proc is given, call it with the expectation that a Fixnum is returned
+    #   and sleep that many seconds. The Proc will be called with the number of tries
+    #   and the raised exception (or nil)
+    #   Example:
+    #   Bosh::Common.retryable(sleep: lambda { |n,e| logger.info(e.message) if e; 4**n }) { }
+    #
+    # @options opts [Fixnum] :tries
+    #   Default: 2
+    #   Number of times to try
+    #   Example:
+    #   Bosh::Common.retryable(tries: 3, on: OpenURI::HTTPError) do
+    #     xml = open("http://example.com/test.xml").read
+    #   end
+    #
+    def retryable(options = {}, &block)
+      Bosh::Retryable.new(options).retryer(&block)
+    end
+
+    module_function :retryable
   end
 end

data/lib/common/deep_copy.rb

@@ -0,0 +1,7 @@
+module Bosh::Common
+  module DeepCopy
+    def self.copy(object)
+      Marshal.load(Marshal.dump(object))
+    end
+  end
+end

data/lib/common/errors.rb

@@ -0,0 +1,7 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module Common
+    class RetryCountExceeded < Exception; end
+  end
+end

data/lib/common/properties/property_helper.rb

@@ -23,7 +23,7 @@ module Bosh::Common
       end
 
       dst_ref[keys[-1]] ||= {}
-      dst_ref[keys[-1]] = src_ref || default
+      dst_ref[keys[-1]] = src_ref.nil? ? default : src_ref
     end
 
     # @param [Hash] collection Property collection
@@ -40,4 +40,4 @@ module Bosh::Common
       ref
     end
   end
-end
+end

data/lib/common/properties/template_evaluation_context.rb

@@ -73,18 +73,14 @@ module Bosh::Common
     #   @return [Object] Property value
     #   @raise [Bosh::Common::UnknownProperty]
     def p(*args)
-      names = args[0]
-      default_given = args.size > 1
-      default = args[1]
-
-      names = Array(names) unless names.kind_of?(Array)
+      names = Array(args[0])
 
       names.each do |name|
         result = lookup_property(@raw_properties, name)
         return result unless result.nil?
       end
 
-      return default if default_given
+      return args[1] if args.length == 2
       raise UnknownProperty.new(names)
     end
 
@@ -94,11 +90,12 @@ module Bosh::Common
     def if_p(*names)
       values = names.map do |name|
         value = lookup_property(@raw_properties, name)
-        return if value.nil?
+        return ActiveElseBlock.new(self) if value.nil?
         value
       end
 
       yield *values
+      InactiveElseBlock.new
     end
 
     # @return [Object] Object representation where all hashes are unrolled
@@ -115,5 +112,29 @@ module Bosh::Common
           object
       end
     end
+
+    private
+    class ActiveElseBlock
+      def initialize(template_context)
+        @context = template_context
+      end
+
+      def else
+        yield
+      end
+
+      def else_if_p(*names, &block)
+        @context.if_p(*names, &block)
+      end
+    end
+
+    class InactiveElseBlock
+      def else
+      end
+
+      def else_if_p(*names)
+        InactiveElseBlock.new
+      end
+    end
   end
-end
+end

data/lib/common/retryable.rb

@@ -0,0 +1,74 @@
+require_relative 'errors'
+
+module Bosh
+  class Retryable
+    def initialize(options = {})
+      opts = validate_options(options)
+
+      @ensure_callback = opts[:ensure]
+      @matching        = opts[:matching]
+      @on_exception    = [opts[:on]].flatten
+      @try_count       = 0
+      @retry_exception = nil
+      @retry_limit     = opts[:tries]
+      @sleeper         = opts[:sleep]
+    end
+
+    # this method will loop until the block returns a true value
+    def retryer(&block)
+      loop do
+        @try_count += 1
+        y = yield @try_count, @retry_exception
+        @retry_exception = nil  # no exception was raised in the block
+        return y if y
+        raise Bosh::Common::RetryCountExceeded if @try_count >= @retry_limit
+        wait
+      end
+    rescue *@on_exception => exception
+      raise unless exception.message =~ @matching
+      raise if @try_count >= @retry_limit
+
+      @retry_exception = exception
+      wait
+      retry
+    ensure
+      @ensure_callback.call(@try_count)
+    end
+
+    private
+
+    def validate_options(options)
+      merged_options = default_options.merge(options)
+      invalid_options = merged_options.keys - default_options.keys
+      raise ArgumentError.new("Invalid options: #{invalid_options.join(", ")}") unless invalid_options.empty?
+
+      merged_options
+    end
+
+    def default_options
+      {
+        tries: 2,
+        sleep: exponential_sleeper,
+        on: [],
+        matching: /.*/,
+        ensure: Proc.new {}
+      }
+    end
+
+    def wait
+      sleep(@sleeper.respond_to?(:call) ? @sleeper.call(@try_count, @retry_exception) : @sleeper)
+    rescue *@on_exception
+      # SignalException could be raised while sleeping, so if you want to catch it,
+      # it need to be passed in the list of exceptions to ignore
+    end
+
+    def exponential_sleeper
+      lambda { |tries, _| [2**(tries-1), 10].min } # 1, 2, 4, 8, 10, 10..10 seconds
+    end
+
+    def sleep(*args, &blk)
+      Kernel.sleep(*args, &blk)
+    end
+  end
+end
+

data/lib/common/runs_commands.rb

@@ -0,0 +1,12 @@
+require 'common/exec'
+
+# Mixin to make it easy to inject an alternate command runner into a class that runs commands.
+module Bosh
+  module RunsCommands
+    def sh(command)
+      (@command_runner || Bosh::Exec).sh(command)
+    end
+
+    attr_accessor :command_runner
+  end
+end

data/lib/common/ssl.rb

@@ -0,0 +1,107 @@
+require 'openssl'
+
+module Bosh
+  module Ssl
+    class Certificate
+      class SubjectsDoNotMatchException < RuntimeError;
+      end
+      class MatchingFileNotFound < RuntimeError;
+      end
+
+      attr_reader :key_path, :certificate_path
+
+      def initialize(key_path, certificate_path, common_name, chain_path = nil)
+        @key_path = key_path
+        @certificate_path = certificate_path
+        @chain_path = chain_path
+        @subject_string = subject_string(common_name)
+      end
+
+      def key
+        @key.to_pem
+      end
+
+      def certificate
+        @csr_cert.to_pem
+      end
+
+      def chain
+        @chain.to_pem if @chain
+      end
+
+      def load_or_create
+        @key, @csr_cert = load_or_create_key_and_csr_cert
+        @chain = OpenSSL::X509::Certificate.new(File.read(@chain_path)) if @chain_path
+
+        self
+      end
+
+      private
+
+      def load_or_create_key_and_csr_cert
+        if File.exists?(@key_path) && !File.exists?(@certificate_path)
+          raise MatchingFileNotFound, 'The key that matches the given certificate could not be found.'
+        end
+
+        if File.exists?(@certificate_path) && !File.exists?(@key_path)
+          raise MatchingFileNotFound, 'The certificate that matches the given key could not be found.'
+        end
+
+        if File.exists?(@key_path) && File.exists?(@certificate_path)
+          load_key_and_csr_cert
+        else
+          create_key_and_csr_cert
+        end
+      end
+
+      def load_key_and_csr_cert
+        key = OpenSSL::PKey::RSA.new(File.read(@key_path))
+        csr_cert = OpenSSL::X509::Certificate.new(File.read(@certificate_path))
+
+        [key, csr_cert]
+      end
+
+      def create_key_and_csr_cert
+        subject = OpenSSL::X509::Name.parse(@subject_string)
+        key = OpenSSL::PKey::RSA.new(2048)
+        csr = new_csr(key, subject)
+        csr_cert = new_csr_certificate(key, csr)
+
+        File.write(@key_path, key.to_pem)
+        File.write(@certificate_path, csr_cert.to_pem)
+
+        [key, csr_cert]
+      end
+
+      def new_csr(key, subject)
+        csr = OpenSSL::X509::Request.new
+        csr.version = 0
+        csr.subject = subject
+        csr.public_key = key.public_key
+        csr.sign key, OpenSSL::Digest::SHA1.new
+
+        csr
+      end
+
+      def new_csr_certificate(key, csr)
+        csr_cert = OpenSSL::X509::Certificate.new
+        csr_cert.serial = 0
+        csr_cert.version = 2
+        csr_cert.not_before = Time.now - 60 * 60 * 24
+        csr_cert.not_after = Time.now + 94608000
+
+        csr_cert.subject = csr.subject
+        csr_cert.public_key = csr.public_key
+        csr_cert.issuer = csr.subject
+
+        csr_cert.sign key, OpenSSL::Digest::SHA1.new
+
+        csr_cert
+      end
+
+      def subject_string(common_name)
+        "/C=US/O=Pivotal/CN=#{common_name}"
+      end
+    end
+  end
+end

data/lib/common/version.rb

@@ -2,6 +2,6 @@
 
 module Bosh
   module Common
-    VERSION = "0.5.4"
+    VERSION = '1.5.0.pre.1100'
   end
 end

data/lib/common/version_number.rb

@@ -0,0 +1,53 @@
+module Bosh::Common
+  class VersionNumber
+    include Comparable
+
+    def initialize(version_value)
+      @version = version_value.to_s
+    end
+
+    def <=>(other)
+      v1 = @version
+      v2 = other.to_s
+      return v1 <=> v2 if [v1, v2].all? { |v| v.to_s.match(/^\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}$/) }
+
+      vp1 = components
+      vp2 = other.components
+
+      [vp1.size, vp2.size].max.times do |i|
+        result = vp1[i].to_i <=> vp2[i].to_i
+        return result unless result == 0
+      end
+
+      0
+    end
+
+    def major
+      components[0].to_i
+    end
+
+    def minor
+      components[1].to_i
+    end
+
+    def components
+      @version.split('.')
+    end
+
+    def to_s
+      @version
+    end
+
+    def final?
+      !@version.end_with?('-dev')
+    end
+
+    def next_minor
+      self.class.new("#{major}.#{minor + 1}")
+    end
+
+    def dev
+      final? ? self.class.new("#{@version}-dev") : self
+    end
+  end
+end

metadata

@@ -1,23 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: bosh_common
 version: !ruby/object:Gem::Version
-  version: 0.5.4
-  prerelease: 
+  version: 1.5.0.pre.1100
+  prerelease: 6
 platform: ruby
 authors:
 - VMware
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-01 00:00:00.000000000 Z
+date: 2013-10-12 00:00:00.000000000 Z
 dependencies: []
-description: BOSH common
-email: support@vmware.com
+description: ! 'BOSH common
+
+  a5984f'
+email: support@cloudfoundry.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/common/common.rb
+- lib/common/deep_copy.rb
+- lib/common/errors.rb
 - lib/common/exec.rb
 - lib/common/exec/error.rb
 - lib/common/exec/result.rb
@@ -25,21 +29,17 @@ files:
 - lib/common/properties/errors.rb
 - lib/common/properties/property_helper.rb
 - lib/common/properties/template_evaluation_context.rb
+- lib/common/retryable.rb
+- lib/common/runs_commands.rb
+- lib/common/ssl.rb
 - lib/common/thread_formatter.rb
 - lib/common/thread_pool.rb
 - lib/common/version.rb
+- lib/common/version_number.rb
 - README
-- Rakefile
-- spec/assets/foo1
-- spec/assets/foo2
-- spec/spec_helper.rb
-- spec/unit/common_spec.rb
-- spec/unit/exec_spec.rb
-- spec/unit/properties/property_helper_spec.rb
-- spec/unit/properties/template_evaluation_context_spec.rb
-- spec/unit/thread_pool_spec.rb
-homepage: http://www.vmware.com
-licenses: []
+homepage: https://github.com/cloudfoundry/bosh
+licenses:
+- Apache 2.0
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -49,26 +49,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: BOSH common
-test_files:
-- spec/assets/foo1
-- spec/assets/foo2
-- spec/spec_helper.rb
-- spec/unit/common_spec.rb
-- spec/unit/exec_spec.rb
-- spec/unit/properties/property_helper_spec.rb
-- spec/unit/properties/template_evaluation_context_spec.rb
-- spec/unit/thread_pool_spec.rb
-has_rdoc: 
+test_files: []

data/Rakefile

@@ -1,50 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-$:.unshift(File.expand_path("../../rake", __FILE__))
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __FILE__)
-
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-
-require "rake"
-begin
-  require "rspec/core/rake_task"
-rescue LoadError
-end
-
-require "bundler_task"
-require "ci_task"
-
-gem_helper = Bundler::GemHelper.new(Dir.pwd)
-
-desc "Build BOSH Common gem into the pkg directory"
-task "build" do
-  gem_helper.build_gem
-end
-
-desc "Build and install BOSH Common into system gems"
-task "install" do
-  Rake::Task["bundler:install"].invoke
-  gem_helper.install_gem
-end
-
-BundlerTask.new
-
-if defined?(RSpec)
-  namespace :spec do
-    desc "Run Unit Tests"
-    rspec_task = RSpec::Core::RakeTask.new(:unit) do |t|
-      t.pattern = "spec/unit/**/*_spec.rb"
-      t.rspec_opts = %w(--format progress --colour)
-    end
-
-    CiTask.new do |task|
-      task.rspec_task = rspec_task
-    end
-  end
-
-  desc "Run tests"
-  task :spec => %w(spec:unit)
-end

data/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
-
-require "rubygems"
-require "bundler"
-Bundler.setup(:default, :test)
-
-require "rspec"
-
-def asset(file)
-  File.expand_path(File.join(File.dirname(__FILE__), "assets", file))
-end

data/spec/unit/common_spec.rb

@@ -1,59 +0,0 @@
-# Copyright (c) 2012 VMware, Inc.
-
-require "spec_helper"
-
-require "common/common"
-
-describe Bosh::Common do
-
-  describe "#symbolize_keys" do
-    ORIGINAL = {
-      "foo1" => "bar",
-      :foo2 => "bar",
-      "foo3" => {
-        "foo4" => "bar"
-      }
-    }.freeze
-
-    EXPECTED = {
-      :foo1 => "bar",
-      :foo2 => "bar",
-      :foo3 => {
-        :foo4 => "bar"
-      }
-    }.freeze
-
-    it "should not modify the original hash" do
-      duplicate = ORIGINAL.dup
-      Bosh::Common.symbolize_keys(ORIGINAL)
-      ORIGINAL.should == duplicate
-    end
-
-    it "should return a new hash with all keys as symbols" do
-      Bosh::Common.symbolize_keys(ORIGINAL).should == EXPECTED
-    end
-  end
-
-  describe "#which" do
-    let(:path) {
-      path = ENV["PATH"]
-      path += ":#{File.expand_path('../../assets', __FILE__)}"
-    }
-
-    it "should return the path when it finds the executable" do
-      Bosh::Common.which("foo1", path).should_not be_nil
-    end
-
-    it "should return the path when it finds an executable" do
-      Bosh::Common.which(%w[foo2 foo1], path).should match(%r{/foo1$})
-    end
-
-    it "should return nil when it isn't executable" do
-      Bosh::Common.which("foo2", path).should be_nil
-    end
-
-    it "should return nil when it doesn't find an executable" do
-      Bosh::Common.which("foo1").should be_nil
-    end
-  end
-end

data/spec/unit/exec_spec.rb

@@ -1,114 +0,0 @@
-# Copyright (c) 2012 VMware, Inc.
-
-require "spec_helper"
-require "common/exec"
-
-describe Bosh::Exec do
-  let(:opts) { {} }
-
-  context "existing command" do
-
-    context "executes successfully" do
-      it "should not fail" do
-        Bosh::Exec.sh("ls /", opts).failed?.should be_false
-      end
-
-      it "should execute block" do
-        block = false
-        Bosh::Exec.sh("ls /", opts) do
-          block = true
-        end
-        block.should be_true
-      end
-    end
-
-    context "fails to execute" do
-      it "should raise error by default" do
-        expect {
-          Bosh::Exec.sh("ls /asdasd 2>&1", opts)
-        }.to raise_error { |error|
-          error.should be_a Bosh::Exec::Error
-          error.output.should match /No such file or directory/
-        }
-      end
-
-      it "should yield block on false" do
-        opts[:yield] = :on_false
-        block = false
-        Bosh::Exec.sh("ls /asdasd 2>&1", opts) do
-          block = true
-        end
-        block.should be_true
-      end
-
-      it "should return result" do
-        opts[:on_error] = :return
-        Bosh::Exec.sh("ls /asdasd 2>&1", opts).failed?.should be_true
-      end
-    end
-
-  end
-
-  context "missing command" do
-    it "should raise error by default" do
-      expect {
-        Bosh::Exec.sh("/asdasd 2>&1", opts)
-      }.to raise_error Bosh::Exec::Error
-    end
-
-    it "should not raise error when requested" do
-      opts[:on_error] = :return
-      expect {
-        Bosh::Exec.sh("/asdasd 2>&1", opts)
-      }.to_not raise_error Bosh::Exec::Error
-    end
-
-    it "should execute block when requested" do
-      opts[:yield] = :on_false
-      expect {
-      Bosh::Exec.sh("/asdasd 2>&1", opts) do
-        raise "foo"
-      end
-      }.to raise_error "foo"
-    end
-
-  end
-
-  context "mock" do
-    it "should be possible fake result" do
-      cmd = "ls /"
-      result = Bosh::Exec::Result.new(cmd, "output", 0)
-      Bosh::Exec.should_receive(:sh).with(cmd).and_return(result)
-      result = Bosh::Exec.sh(cmd)
-      result.success?.should be_true
-    end
-  end
-
-  context "module" do
-    it "should be possible to invoke as a module" do
-      Bosh::Exec.sh("ls /").success?.should be_true
-    end
-  end
-
-  context "include" do
-    class IncludeTest
-      include Bosh::Exec
-      def run
-        sh("ls /")
-      end
-
-      def self.run
-        sh("ls /")
-      end
-    end
-
-    it "should add instance method" do
-      inc = IncludeTest.new
-      inc.run.success?.should be_true
-    end
-
-    it "should add class method" do
-      IncludeTest.run.success?.should be_true
-    end
-  end
-end

data/spec/unit/properties/property_helper_spec.rb

@@ -1,39 +0,0 @@
-# Copyright (c) 2012 VMware, Inc.
-
-require "spec_helper"
-require "common/properties"
-
-describe Bosh::Common::PropertyHelper do
-
-  before(:each) do
-    @helper = Object.new
-    @helper.extend(Bosh::Common::PropertyHelper)
-  end
-
-  it "can copy named property from one collection to another" do
-    dst = {}
-    src = {"foo" => {"bar" => "baz", "secret" => "zazzle"}}
-
-    @helper.copy_property(dst, src, "foo.bar")
-    dst.should == {"foo" => {"bar" => "baz"}}
-
-    @helper.copy_property(dst, src, "no.such.prop", "default")
-    dst.should == {
-      "foo" => {"bar" => "baz"},
-      "no" => {
-        "such" => {"prop" => "default"}
-      }
-    }
-  end
-
-  it "can lookup the property in a Hash using dot-syntax" do
-    properties = {
-      "foo" => {"bar" => "baz"},
-      "router" => {"token" => "foo"}
-    }
-
-    @helper.lookup_property(properties, "foo.bar").should == "baz"
-    @helper.lookup_property(properties, "router").should == {"token" => "foo"}
-    @helper.lookup_property(properties, "no.prop").should be_nil
-  end
-end

data/spec/unit/properties/template_evaluation_context_spec.rb

@@ -1,112 +0,0 @@
-# Copyright (c) 2012 VMware, Inc.
-
-require "spec_helper"
-require "common/properties"
-
-describe Bosh::Common::TemplateEvaluationContext do
-
-  def eval_template(erb, context)
-    ERB.new(erb).result(context.get_binding)
-  end
-
-  def make(spec)
-    Bosh::Common::TemplateEvaluationContext.new(spec)
-  end
-
-  before(:each) do
-    @spec = {
-      "job" => {
-        "name" => "foobar"
-      },
-      "properties" => {
-        "foo" => "bar",
-        "router" => {"token" => "zbb"},
-        "vtrue" => true,
-        "vfalse" => false
-      },
-      "index" => 0,
-    }
-
-    @context = make(@spec)
-  end
-
-  it "unrolls properties into OpenStruct" do
-    eval_template("<%= properties.foo %>", @context).should == "bar"
-  end
-
-  it "retains raw_properties" do
-    eval_template("<%= raw_properties['router']['token'] %>", @context).
-      should == "zbb"
-  end
-
-  it "supports looking up template index" do
-    eval_template("<%= spec.index %>", @context).should == "0"
-  end
-
-  it "supports 'p' helper" do
-    eval_template("<%= p('router.token') %>", @context).should == "zbb"
-
-    eval_template("<%= p('vtrue') %>", @context).should == "true"
-    eval_template("<%= p('vfalse') %>", @context).should == "false"
-
-    expect {
-      eval_template("<%= p('bar.baz') %>", @context)
-    }.to raise_error(Bosh::Common::UnknownProperty,
-                     "Can't find property `[\"bar.baz\"]'")
-    eval_template("<%= p('bar.baz', 22) %>", @context).should == "22"
-  end
-
-  it "supports chaining property lookup via 'p' helper" do
-    eval_template(<<-TMPL, @context).strip.should == "zbb"
-      <%= p(%w(a b router.token c)) %>
-    TMPL
-
-    expect {
-      eval_template(<<-TMPL, @context)
-        <%= p(%w(a b c)) %>
-      TMPL
-    }.to raise_error(Bosh::Common::UnknownProperty,
-                     "Can't find property `[\"a\", \"b\", \"c\"]'")
-
-    eval_template(<<-TMPL, @context).strip.should == "22"
-      <%= p(%w(a b c), 22) %>
-    TMPL
-  end
-
-  it "allows 'false' and 'nil' defaults for 'p' helper" do
-    eval_template(<<-TMPL, @context).strip.should == "false"
-      <%= p(%w(a b c), false) %>
-    TMPL
-
-    eval_template(<<-TMPL, @context).strip.should == ""
-      <%= p(%w(a b c), nil) %>
-    TMPL
-  end
-
-  it "supports 'if_p' helper" do
-    template = <<-TMPL
-      <% if_p("router.token") do |token| %>
-      <%= token %>
-      <% end %>
-    TMPL
-
-    eval_template(template, @context).strip.should == "zbb"
-
-    template = <<-TMPL
-      <% if_p("router.token", "foo") do |token, foo| %>
-      <%= token %>, <%= foo %>
-      <% end %>
-    TMPL
-
-    eval_template(template, @context).strip.should == "zbb, bar"
-
-    template = <<-TMPL
-      <% if_p("router.token", "no.such.prop") do |token, none| %>
-      test output
-      <% end %>
-    TMPL
-
-    eval_template(template, @context).strip.should == ""
-  end
-
-end

data/spec/unit/thread_pool_spec.rb

@@ -1,69 +0,0 @@
-# Copyright (c) 2009-2012 VMware, Inc.
-
-require File.expand_path("../../spec_helper", __FILE__)
-
-require "common/thread_pool"
-
-describe Bosh::ThreadPool do
-
-  before(:all) do
-    @logger = Logger.new(STDOUT)
-    @logger.level = Logger::INFO
-  end
-
-  it "should respect max threads" do
-    max = 0
-    current = 0
-    lock = Mutex.new
-
-    Bosh::ThreadPool.new(:max_threads => 2, :logger => @logger).wrap do |pool|
-      4.times do
-        pool.process do
-          lock.synchronize do
-            current += 1
-            max = current if current > max
-          end
-          sleep(0.050)
-          lock.synchronize do
-            max = current if current > max
-            current -= 1
-          end
-        end
-      end
-    end
-    max.should be <= 2
-  end
-
-  it "should raise exceptions" do
-    lambda {
-      Bosh::ThreadPool.new(:max_threads => 2, :logger => @logger).wrap do |pool|
-        5.times do |index|
-          pool.process do
-            sleep(0.050)
-            raise "bad" if index == 4
-          end
-        end
-      end
-    }.should raise_exception("bad")
-  end
-
-  it "should stop processing new work when there was an exception" do
-    max = 0
-    lock = Mutex.new
-
-    lambda {
-      Bosh::ThreadPool.new(:max_threads => 1, :logger => @logger).wrap do |pool|
-        10.times do |index|
-          pool.process do
-            lock.synchronize { max = index if index > max }
-            sleep(0.050)
-            raise "bad" if index == 4
-          end
-        end
-      end
-    }.should raise_exception("bad")
-
-    max.should be == 4
-  end
-
-end