deltadsl 1.0

data/README.md

@@ -0,0 +1,92 @@
+Deltacloud API client DSL
+-------------------------
+
+Documentation
+
+<a href="http://rdoc.info/github/mifo/deltadsl/master/frames">rdoc.info/github/mifo/deltadsl/master/frames</a>
+
+Installation:
+
+* No installation available yet ;-)
+
+Prerequires:
+
+* Deltacloud API server and client gems installed:
+
+    $ gem install deltacloud-core deltacloud-client
+
+* Eventmachine (gem install eventmachine)
+* Thin (gem install thin)
+
+Examples
+-------------------------
+
+Simple scenario:
+
+<script src="https://gist.github.com/1933563.js?file=dsl_sample.rb"></script>
+
+    @sample = Deltacloud::DSL::Task('launch some EC2 and RHEV-M instances') do
+
+      instances(:driver => :ec2, :username => '', :password => '') do
+        instance 'test-ec2-1' do
+          realm 'us-west-1'
+          image 'ami-12345'
+          profile 't1.micro'
+        end
+
+        instance 'test-ec2-2' do
+          realm 'us-west-1'
+          image 'ami-54321'
+          profile 't1.micro'
+        end
+      end
+
+      instances(:driver => :rhevm, :username => '', :password => '', :provider => '') do
+        instance 'test-rhev-1' do
+          image '12345-12345-12345-12345'
+          profile 'SERVER' do |p|
+            p.memory = 512
+            p.cpu = 4
+          end
+        end
+      end
+
+      on(:instance_started) do |i|
+        # i.pool_for_ssh ??
+      end
+
+      on(:running) do
+        ec2_instance('test-ec2-1') do |i|
+          # do something with this instance
+        end
+
+        rhevm_instance('test-rhev-1') do |i|
+          # Do someting ;-)
+        end
+      end
+    end
+
+    # Thing above is just an definition, so now let start it:
+
+    @sample.start!
+
+    # All instances will be started in parallel (using threads)
+
+
+License
+-----------------
+
+    Licensed to the Apache Software Foundation (ASF) under one or more
+    contributor license agreements.  See the NOTICE file distributed with
+    this work for additional information regarding copyright ownership.  The
+    ASF licenses this file to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance with the
+    License.  You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+    License for the specific language governing permissions and limitations
+    under the License.

data/lib/client.rb

@@ -0,0 +1,17 @@
+require 'deltacloud'
+
+module Deltacloud
+
+  def self.Client(d)
+    config = {
+      :driver => d.configuration.driver || :mock, 
+      :username => d.configuration.user || 'mockuser',
+      :password => d.configuration.password || 'mockpassword',
+    }
+    config.merge!({
+      :provider => d.configuration.provider
+    }) unless d.configuration.provider.nil?
+    DeltaCloud::API.new(nil, nil, d.configuration.url || 'http://localhost:3001/api').with_config(config)
+  end
+
+end

data/lib/dsl.rb

@@ -0,0 +1,21 @@
+module Deltacloud
+  module DSL
+
+    def self.Task(name, &block)
+      Task.new(name, &block)
+    end
+
+    def self.Instance(name, &block)
+      Instance.new(name, &block) if block_given?
+    end
+
+    def self.Configuration(params={})
+      InstanceConfiguration.new(params)
+    end
+
+    def self.Instances(configuration={}, &block)
+      InstanceDefinition.new(configuration, &block) if block_given?
+    end
+
+  end
+end

data/lib/instance.rb

@@ -0,0 +1,194 @@
+module Deltacloud
+  module DSL
+
+    class Instance
+
+      include EM::Deferrable
+
+      attr_reader :name
+      attr_reader :parameters
+
+      def initialize(name, &block)
+        @name = name
+        @parameters = {
+          :state => :new
+        }
+        instance_eval(&block) if block_given?
+        warn "WARNING: Realm is not defined for instance '#{name}'. (Default driver realm will be used)." if params.realm_id.nil?
+        raise "Image is not defined for instance '#{@name}'" if params.image_id.nil?
+        raise "Profile is not defined for instance '#{@name}'" if params.profile.nil?
+      end
+
+      # Make call to Deltacloud to create this instance object
+      # Please note that this call will put the instance into
+      # PENDING state in most cases (except Mock).
+      #
+      # Use .wait_for_running! to pool Deltacloud until instance
+      # is not RUNNING
+      #
+      def create(definition)
+        @client = Deltacloud::Client(@definition = definition)
+        instance_opts = {
+          :name => self.name
+        }
+        instance_opts.merge!(profile.to_instance_params)
+        instance_opts.merge!({
+          :realm_id => instance_realm_id,
+        })
+        from_instance!(@client.create_instance(instance_image_id, instance_opts))
+        self
+      end
+
+      # Pool Deltacloud API for the state change of instance every 5 seconds.
+      # This will block program execution for time needed to transient from
+      #
+
+      %w(running stopped pending).each do |state|
+        define_method :"wait_for_#{state}!" do |*max_retries|
+          retries = 0
+          return if state_is?(state)
+          begin
+            update!
+            # Some Deltacloud drivers (like RHEV-M) put instance to STOPPED state
+            # instead of RUNNING. Is not an error, but backend cloud behavior.
+            # If instance transient to STOPPED, then we try to START it without
+            # incrementing retry counter.
+            if state == 'running' and is_stopped?
+              start!
+              raise 'NotRunning'
+            else
+              retries += 1
+              raise 'NotInState' if (!state_is?(state)) && sleep(5)
+            end
+          rescue => e
+            retry if (e.message == 'NotInState') && (retries <= max_retries.first)
+            raise "Failed to put instance '#{self.name}' in #{state} state."
+          end
+        end
+      end
+
+      # This method will try to connect to Deltacloud API and refresh all attributes
+      #
+      def update!
+        raise 'Instance must be created first in order to call update' if @definition.nil?
+        from_instance!(@client.instance(params.instance_id))
+      end
+
+      # Instance actions:
+      #
+      # instance.start! will start stopped instance (if supported)
+      # instance.stop! will stop running instance (if supported)
+      # instance.destroy! will destroy instance and set state to ':destroyed'
+      #
+      %w(start stop destroy).each do |action|
+        define_method :"#{action}!" do
+          instance_action(action.intern)
+        end
+      end
+
+      # Helper for instance actions
+      #
+      def instance_action(action)
+        must_have_definition!
+        @client.instance(params.instance_id).send(:"#{action}!")
+        instance = @client.instance(params.instance_id)
+        if instance.nil?
+          @parameters[:state] = :destroyed
+          @parameters.delete(:instance_id)
+          self
+        else
+          from_instance!(instance)
+        end
+      end
+
+      # Convert attributes from DeltaCloud::Instance object to Instance
+      #
+      def from_instance!(instance)
+        attrs = {
+          :instance_id => instance.id,
+          :state => instance.state.downcase.intern,
+          :public_addresses => instance.public_addresses,
+          :private_addresses => instance.private_addresses
+        }
+        attrs.merge!(:owner_id => instance.owner_id)
+        @parameters.merge!(attrs)
+        self
+      end
+
+      # Assing InstanceProfile to the instance.
+      # If no profile name is provided, will return the active profile
+      #
+      # InstanceProfile DSL example:
+      #
+      # instance 'test-instance' do
+      #   profile 'm1-small' do |p|
+      #     p.memory = 500
+      #   end
+      # end
+      #
+      def profile(name=nil, &block)
+        if name
+          @parameters[:profile] = Deltacloud::DSL::InstanceProfile(name, &block)
+        else
+          instance_profile
+        end
+      end
+
+      # Convert instance param hash to OpenStruct object for easy retrieval
+      #
+      def params
+        Deltacloud::DSL::Configuration(@parameters)
+      end
+
+      # Define various helper methods:
+      #
+      # instance_[attribute]  -> retrieve instance attribute (instance_state,
+      #                          instance_public_addresses, etc...)
+      # is_[state]?           -> true if instance is in given state
+      # is_not_[state]?       -> same as above just negated
+      #
+      # Whatever else method is called on this object with some parameters,
+      # this method will automatically be transformed to instance variable.
+      #
+      def method_missing(name, *args)
+        if name.to_s =~ /^instance_([\w_]+)$/
+          @parameters[$1.intern]
+        elsif name.to_s =~ /^is_(\w+)\?$/
+          state_is?($1.intern)
+        elsif name.to_s =~ /^is_not_(\w+)\?$/
+          !state_is?($1.intern)
+        elsif !args.empty?
+          set_param(name.to_sym, args)
+        else
+          super
+        end
+      end
+
+      private
+
+      def state_is?(state)
+        instance_state == state.to_sym
+      end
+
+      def must_have_definition!
+        raise 'Instance must be created first in order to start it' if @definition.nil?
+      end
+
+      def convert_id_param(name)
+        case name
+          when :realm then :realm_id
+          when :image then :image_id
+          else name
+        end
+      end
+
+      def set_param(key, val)
+        @parameters ||= {}
+        k = convert_id_param(key)
+        @parameters[k] = (val.size == 1) ? val[0] : val
+      end
+
+    end
+
+  end
+end

data/lib/instance_configuration.rb

@@ -0,0 +1,13 @@
+require 'ostruct'
+
+module Deltacloud
+  module DSL
+
+    class InstanceConfiguration < OpenStruct
+      def initialize(params={})
+        super(params)
+      end
+    end
+
+  end
+end

data/lib/instance_definition.rb

@@ -0,0 +1,45 @@
+module Deltacloud
+  module DSL
+
+    class InstanceDefinition
+      include Enumerable
+
+      attr_reader :instances, :configuration
+
+      def initialize(configuration, &block)
+        @instances = []
+        @configuration = Deltacloud::DSL::Configuration(configuration)
+        define &block
+      end
+
+      def define(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      # Add more instances to this instance definition
+      #
+      # @task.mock_instances.first << Deltacloud::DSL::Instance('instance-2') do
+      #   realm 'us'
+      #   image 'img1'
+      # end
+      #
+      def <<(instance)
+        @instances << instance
+      end
+
+      # Syntax suggar for adding new instances to instance definition
+      #
+      def instance(name, &block)
+        self << Deltacloud::DSL::Instance(name, &block) if block_given?
+      end
+
+      # Make instance definition enumerative for instances
+      #
+      def each(&block)
+        @instances.each { |instance| block.call(instance) }
+      end
+
+    end
+
+  end
+end

data/lib/instance_profile.rb

@@ -0,0 +1,37 @@
+require 'ostruct'
+
+module Deltacloud
+  module DSL
+
+    def self.InstanceProfile(name, &block)
+      InstanceProfile.new(name, &block) if block_given?
+    end
+
+    class InstanceProfile < OpenStruct
+
+      def initialize(name, &block)
+        super(:name => name)
+        define &block
+      end
+
+      def define(&block)
+        yield self if block_given?
+      end
+
+      # Convert InstanceProfile to DeltaCloud create_instance method parameters.
+      # Some property names varies from the names used in DeltaCloud. This
+      # method will deal with them.
+      #
+      def to_instance_params
+        params = self.marshal_dump
+        params[:hardware_profile] = params.delete(:name)
+        params[:hwp_memory] = params.delete(:memory) unless params[:memory].nil?
+        params[:hwp_cpu] = params.delete(:cpu) unless params[:cpu].nil?
+        params[:hwp_storage] = params.delete(:storage) unless params[:storage].nil?
+        params
+      end
+
+    end
+
+  end
+end

data/lib/models.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+
+# Workaround for Ruby 1.8 which does not have 'require_relative'
+# method defined
+#
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative 'client'
+require_relative 'dsl'
+require_relative 'task'
+require_relative 'instance'
+require_relative 'instance_configuration'
+require_relative 'instance_definition'
+require_relative 'instance_profile'

data/lib/task.rb

@@ -0,0 +1,142 @@
+require 'eventmachine'
+require 'logger'
+
+module Deltacloud
+  module DSL
+
+    class Task
+
+      attr_reader :name, :state_machine, :log
+
+      def initialize(name, &block)
+        @name = name
+        @state_machine = {}
+        @log = Logger.new(STDERR)
+        define &block
+      end
+
+      def define(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      # Configure group of instances that would be launched
+      # using specified configuration.
+      # 
+      # Configuration:
+      #
+      # :driver   - Deltacloud API driver to use (default: mock)
+      # :provider - API_PROVIDER (eg. URL to RHEV-M API)
+      # :username - API key (default: mockuser)
+      # :password - API secret (default: mockpassword)
+      # :url      - Deltacloud API url (default: http://localhost:3001/api)
+      #
+      # The block should define single instances:
+      #
+      # instances(:driver => :ec2, :username => API_KEY, :password => API_SECRET) do
+      #   instance 'instance-1' do
+      #     # instance configuration here
+      #   end
+      # end
+      #
+      def instances(configuration={}, &block)
+        return find_instances_by_driver(configuration) if configuration.kind_of? Symbol
+        @instances ||= []
+        @instances << Deltacloud::DSL::Instances(configuration, &block) if block_given?
+        @instances
+      end
+
+      # Declare a set of methods dynamically:
+      #
+      # find_instances_by_[attribute] => returns InstanceDefinition objects that
+      #                     match the value of attribute provided in method name
+      #
+      # [driver]_instances => return InstanceDefinition objects that correspond
+      #                   to given driver
+      #
+      # [driver]_instance => return Instance object that match with name
+      #                   eg. mock_instance 'test-mock-1' will find this
+      #                   instance.
+      #
+      # instances_[state] => return Instance objects with corresponding state
+      #                                 
+      def method_missing(name, *args)
+        if name.to_s =~ /^find_instances_by_([\w_]+)$/
+          @instances.select { |i| i.configuration.respond_to?($1.intern) && args.include?(i.configuration.send($1.intern)) }
+        elsif name.to_s =~ /^(\w+)_instances$/
+          find_instances_by_driver($1.intern)
+        elsif name.to_s =~ /^(\w+)_instance$/
+          inst = find_instances_by_driver($1.intern).map { |instances| instances.find { |i| args.include?(i.name) } }.flatten.compact.first
+          yield inst if block_given?
+          inst
+        elsif name.to_s =~ /^instances_(\w+)\?$/
+          @instances.any? { |d| d.map { |i| (i.update! rescue true) && i.instance_state == $1.intern }.include? true }
+        else
+          super
+        end
+      end
+
+      # Start executing given task.
+      #
+      # This method will try to start all instances defined for all drivers.
+      # Then it will wait for instances to become running.
+      #
+      # Various callback can be provided for different state:
+      #
+      # on(:running) callback is triggered when all instances are running
+      # on(:instance_started) callback is triggered for every instance when become running
+      #
+      def start!
+        task = self
+        EventMachine::run do
+          inst_arr = []
+          task.instances.each do |definition|
+            inst_arr += definition.instances
+            definition.instances.each do |instance|
+              Thread.new do
+                begin
+                  instance.create(definition).wait_for_running!
+                  perform(:instance_started, instance)
+                  log.info "Instance #{instance.name}[#{definition.configuration.driver}] successfully started."
+                rescue => e
+                  log.error "ERROR: #{e.message}"
+                ensure
+                  inst_arr.delete(instance)
+                end
+              end
+            end
+          end
+          until inst_arr.empty?; end
+          perform(:running)
+          EM.stop
+        end
+      end
+
+      # Handler for callback definition:
+      #
+      # on(:running) do
+      # end
+      #
+      # on(:instance_started) do |instance|
+      # end
+      #
+      def on(state, &block)
+        @state_machine[state] = block if block_given?
+      end
+
+      # Syntax sugar for @state_machine callbacks
+      #
+      def state(state)
+        @state_machine[state]
+      end
+
+      # Syntax sugar for performing callbacks
+      #
+      def perform(s, item=nil)
+        return unless @state_machine.keys.include?(s)
+        state(s).call(item)
+      end
+
+    end
+
+  end
+end

data/tests/deltacloud_perf_test.rb

@@ -0,0 +1,52 @@
+# 1.8 compatibility fix
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative '../lib/models'
+require 'minitest/autorun'
+require 'minitest/benchmark'
+
+describe Deltacloud::DSL::Task do
+
+  def prepare_threaded_sample(prefix)
+    @threaded_sample = Deltacloud::DSL::Task('threaded pool') do
+
+      # Say we want to launch 80 instances in Mock
+      instances(:driver => :mock) do
+        1.upto(80) do |i|
+          instance "test-#{prefix}-#{i}" do
+            realm 'us'
+            image 'img1'
+            profile 'm1-large' do |p|
+              p.memory = 7680
+            end
+          end
+        end
+      end
+
+      # After benchmarch destroy all instances
+      on(:ready) do
+        mock_instances.each do |d|
+          d.instances.each do |i|
+            i.stop!.wait_for_stopped!
+            i.destroy!
+          end
+        end
+      end
+
+    end
+  end
+
+  bench_performance_linear "threaded_pool" do |n|
+    10.times do
+      threaded_sample = prepare_threaded_sample(Time.now.to_i)
+      threaded_sample.start!
+    end
+  end
+
+end

data/tests/dsl_test.rb

@@ -0,0 +1,203 @@
+# 1.8 compatibility fix
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative '../lib/models'
+require 'minitest/autorun'
+
+describe Deltacloud::DSL::Task do
+  before do
+    @sample = Deltacloud::DSL::Task('launch instance') do
+      instances(:driver => :mock) do
+        instance 'test-instance-1' do
+          realm 'us'
+          image 'img1'
+          profile('m1-large') do |p|
+            p.memory = 7680
+          end
+        end
+        instance 'test-instance-2' do
+          realm 'us'
+          image 'img1'
+          profile('m1-large') do |p|
+            p.memory = 10000
+          end
+        end
+        instance 'test-instance-3' do
+          realm 'eu'
+          image 'img1'
+          profile('m1-large') do |p|
+            p.memory = 10000
+          end
+        end
+        instance 'test-instance-4' do
+          realm 'us'
+          image 'img1'
+          profile('m1-large') do |p|
+            p.memory = 10000
+          end
+        end
+        instance 'test-instance-5' do
+          realm 'eu'
+          image 'img1'
+          profile('m1-large') do |p|
+            p.memory = 10000
+          end
+        end
+      end
+      on :instance_started do |i|
+        puts i.params.state
+      end
+      on :running do
+        mock_instance 'test-instance-1' do |i|
+          #puts "Getting IP address out of test-instance-1"
+          #puts i.params.public_addresses
+        end
+        mock_instance 'test-instance-2' do |i|
+          #puts "Destroying instance test-instance-2..."
+          i.stop!.wait_for_stopped!
+          i.destroy!
+          #puts i.params.state
+        end
+      end
+    end
+  end
+
+  describe Deltacloud::DSL::Task do
+    it 'should be constructed' do
+      @sample.must_be_instance_of Deltacloud::DSL::Task
+    end
+
+    it 'should have proper name' do
+      @sample.name.must_equal 'launch instance'
+    end
+
+    it 'should have state machine' do
+      @sample.state_machine.must_be_instance_of Hash
+    end
+
+    it 'should find instance by driver' do
+      @sample.find_instances_by_driver(:mock).must_be_instance_of Array
+      @sample.find_instances_by_driver(:mock).size.must_equal 1
+      @sample.find_instances_by_driver(:mock).first.must_be_instance_of Deltacloud::DSL::InstanceDefinition
+    end
+
+    it 'should return all mock instances' do
+      @sample.mock_instances.must_be_instance_of Array
+      @sample.mock_instances.size.must_equal 1
+      @sample.mock_instances.first.must_be_instance_of Deltacloud::DSL::InstanceDefinition
+    end
+
+    it 'should be able to find single instance by name' do
+      @sample.mock_instance('test-instance-1').must_be_instance_of Deltacloud::DSL::Instance
+      @sample.mock_instance('test-instance-1') do |i|
+        i.must_be_instance_of Deltacloud::DSL::Instance
+      end
+    end
+
+    it 'should figure out if instances are new or running' do
+      @sample.instances_running?.must_equal false
+      @sample.instances_new?.must_equal true
+    end
+
+    it 'should run' do
+      @sample.start!
+    end
+
+  end
+
+  describe Deltacloud::DSL::InstanceDefinition do
+
+    it 'should return all defined instances' do
+      @sample.instances.must_be_instance_of Array
+      @sample.instances.size.must_equal 1
+      @sample.instances.each do |i|
+        i.must_be_instance_of Deltacloud::DSL::InstanceDefinition
+      end
+    end
+
+    it 'should have configuration set for every instances' do
+      @sample.instances.first.configuration.wont_be_nil
+    end
+
+    it 'should have mock driver configuration' do
+      @sample.instances.first.configuration.driver.must_equal :mock
+    end
+
+    it 'should find instances using driver' do
+      @sample.find_instances_by_driver(:mock).must_be_instance_of Array
+      @sample.find_instances_by_driver(:mock).size.must_equal 1
+      @sample.find_instances_by_driver(:mock).first.must_be_instance_of Deltacloud::DSL::InstanceDefinition
+    end
+
+  end
+
+  describe Deltacloud::DSL::Instance do
+
+    it 'should be all valid instances' do
+      @sample.mock_instances.first.each do |inst|
+        inst.must_be_instance_of Deltacloud::DSL::Instance
+      end
+    end
+
+    it 'should find mock instance by name' do
+      @sample.mock_instance('test-instance-1') do |i|
+        i.wont_be_nil
+        i.must_be_instance_of Deltacloud::DSL::Instance
+        i.name.must_equal 'test-instance-1'
+      end
+    end
+
+    it 'should all have have valid name' do
+      @sample.mock_instances.first.each do |inst|
+        inst.name.wont_be_nil
+      end
+    end
+
+    it 'should have realm_id and image_id parameters defined' do
+      @sample.mock_instances.first.each do |inst|
+        ['us', 'eu'].must_include inst.params.realm_id
+        inst.params.image_id.must_equal 'img1'
+      end
+    end
+
+    it 'should have valid instance profile defined' do
+      @sample.mock_instances.first.each do |inst|
+        inst.instance_profile.must_be_instance_of Deltacloud::DSL::InstanceProfile
+        inst.instance_profile.name.wont_be_nil
+      end
+    end
+
+    it 'should have memory specified in instance profile' do
+      @sample.mock_instances.first.each do |inst|
+        inst.instance_profile.memory.wont_be_nil
+        inst.instance_profile.memory.must_be_instance_of Fixnum
+      end
+    end
+
+    it 'should allow manipulation of instances' do
+      definition = @sample.mock_instances.first
+      instance = @sample.mock_instance('test-instance-3')
+      instance.create(definition).must_be_instance_of Deltacloud::DSL::Instance
+      instance.instance_owner_id.must_equal 'mockuser'
+      instance.params.state.must_equal :running
+      instance.is_running?.must_equal true
+      instance.is_not_running?.must_equal false
+      instance.is_stopped?.must_equal false
+      instance.stop!.must_be_instance_of Deltacloud::DSL::Instance
+      instance.params.state.must_equal :stopped
+      instance.is_running?.must_equal false
+      instance.is_stopped?.must_equal true
+      instance.destroy!.must_be_instance_of Deltacloud::DSL::Instance
+      instance.is_destroyed?.must_equal true
+      instance.params.instance_id.must_be_nil
+    end
+
+  end
+
+end

data/tests/test_test.rb

@@ -0,0 +1,28 @@
+require 'minitest/autorun'
+
+class Meme
+  def initialize
+  end
+    
+  def i_can_has_cheezburger?
+    'OHAI!'
+  end
+end
+
+describe Meme do
+  before do
+    @meme = Meme.new
+  end
+
+  describe "when asked about cheeseburgers" do
+    it "must respond positively" do
+      @meme.i_can_has_cheezburger?.must_equal "OHAI!"
+    end
+  end
+
+  describe "when asked about blending possibilities" do
+    it "won't say no" do
+      @meme.will_it_blend?.wont_match /^no/i
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: deltadsl
+version: !ruby/object:Gem::Version
+  version: '1.0'
+  prerelease: 
+platform: ruby
+authors:
+- Michal Fojtik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: deltacloud-client
+  requirement: &70175076503460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70175076503460
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70175076501840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70175076501840
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &70175076500080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70175076500080
+description: Deltacloud API powered DSL for creating complex deployments
+email: dev@deltacloud.apache.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- lib/client.rb
+- lib/dsl.rb
+- lib/instance.rb
+- lib/instance_configuration.rb
+- lib/instance_definition.rb
+- lib/instance_profile.rb
+- lib/models.rb
+- lib/task.rb
+- tests/deltacloud_perf_test.rb
+- tests/dsl_test.rb
+- tests/test_test.rb
+homepage: http://www.deltacloud.org
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Deltacloud API DSL
+test_files:
+- tests/deltacloud_perf_test.rb
+- tests/dsl_test.rb
+- tests/test_test.rb