stackmate 0.0.1

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Chiradeep Vittal 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,144 @@
+
+# Stackmate - CloudFormation for CloudStack
+
+A library designed to read existing CloudFormation templates 
+and execute them on a CloudStack deployment. 
+Uses the [ruote](http://ruote.rubyforge.org) workflow engine,
+and embeds a modular [Sinatra](http://www.sinatrarb.com/) application for wait handles.
+
+Unlike CloudFormation, it does not  run as a web application. 
+Instead it runs everything on the client side.
+
+[Stacktician](https://github.com/chiradeep/stacktician) embeds stackmate to run it as a web application.
+
+Note that only Basic Zone (aka EC2-Classic) is supported for now.
+
+Follow:
+* \#cloudstack-dev on Freenode
+* <http://cloudstack.apache.org/mailing-lists.html>
+* [@chiradeep](http://twitter.com/chiradeep) on Twitter
+
+## Dependencies
+
+stackmate uses [Bundler](http://gembundler.com/) to setup and maintain its
+environment. Before running stackmate for the first time you need to install
+Bundler (gem install bundler) and then run:
+
+```bash
+$ bundle install
+
+```
+
+Bundler will download all the required gems and install them for you.
+
+Have a look at the Gemfile if you want to see the various dependencies.
+
+## Getting started quickly
+
+### Using the source
+
+* Get the source files using git
+
+```bash
+$ git clone http://github.com/chiradeep/stackmate.git
+$ cd stackmate
+```
+
+* Make sure every dependency is resolved.
+
+```bash
+$ bundle install
+```
+* Find your API key and secret key and the url for CloudStack
+
+For example
+
+```bash
+$ export APIKEY=upf7L-tvcHFCSYhKhw-45l9IfaKXNQSWf0nXyWye6eqOBpLT5TqN8XQGeuloV3LbSwD6zuucz22L233Nrqg2pg
+$ export SECKEY=9iSsuImdUxU0oumHu0p11li4IoUtwcvrSHcU63ZHS_y-4Iz3w5xPROzyjZTUXkhI9E7dy0r3vejzgCmaQfI-yw
+$ export URL="http://localhost:8080/client/api"
+```
+
+* The supplied templates are taken from the AWS samples. 
+
+You need a couple of mappings from AWS ids to your CloudStack implementation:
+
+```bash
+$ cat local.yaml 
+service_offerings : {'m1.small' : '13954c5a-60f5-4ec8-9858-f45b12f4b846'}
+templates : {'ami-1b814f72': '7fc2c704-a950-11e2-8b38-0b06fbda5106'}
+```
+
+* Ensure you have a ssh keypair called 'Foo' (used in the template parameter below) for your account FIRST:
+
+```bash
+$ cloudmonkey
+☁ Apache CloudStack 🐵 cloudmonkey 4.1.0-snapshot3. Type help or ? to list commands.
+
+> create sshkeypair name='Foo'
+```
+
+
+* Create a LAMP stack:
+
+```bash
+bin/stackmate MYSTACK01   --template-file=templates/LAMP_Single_Instance.template -p "DBName=cloud;DBUserName=cloud;SSHLocation=75.75.75.0/24;DBUsername=cloud;DBPassword=cloud;DBRootPassword=cloud;KeyName=Foo"
+```
+
+* If everything is successful, stackmate will hang after deploying the security groups and vms. 
+You should see an output like this:
+
+```bash
+Your pre-signed URL is: http://localhost:4567/waitcondition/20130425-0706-kerujere-punopapa/WaitHandle
+Try: curl -X PUT --data 'foo' http://localhost:4567/waitcondition/20130425-0706-kerujere-punopapa/WaitHandle
+```
+Executing the curl should unblock the wait handle. The idea of course is that the instance boots up, and reads its userdata and calls the same URL.
+
+If you don't want the wait condition server to run, just use '-n'. Stackmate will not hang with this flag.
+
+If you want to validate your template, you can use the --dry-run option. This will parse and validate the template and create an execution schedule.
+
+## TODO
+* Parallelize (with ruote concurrence) where possible
+* rollback on error
+* timeouts
+* embed in a web app ( [Stacktician](https://github.com/chiradeep/stacktician) )
+* add support for Advanced Zone templates (VPC), LB, etc
+
+## Feedback & bug reports
+
+Feedback and bug reports are welcome on the [mailing-list](dev@cloudstack.apache.org), or on the `#cloudstack-dev` IRC channel at Freenode.net.
+
+## License
+
+(The MIT License)
+
+Copyright (c) 2013 Chiradeep Vittal
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## libraries used
+
+- ruote, <http://ruote.rubyforge.org/>
+- sinatra, <http://www.sinatrarb.com/>
+- cloudstack_ruby_client, <https://github.com/chipchilders/cloudstack_ruby_client>
+
+Many thanks to the authors 
+

data/lib/stackmate/classmap.rb

@@ -0,0 +1,25 @@
+module StackMate
+   PROFILES = ['CLOUDSTACK', 'NOOP']
+   @profile = 'CLOUDSTACK'
+
+   CS_CLASS_MAP = { 
+              'AWS::CloudFormation::WaitConditionHandle' => 'StackMate::WaitConditionHandle',
+              'AWS::CloudFormation::WaitCondition' => 'StackMate::WaitCondition',
+              'AWS::EC2::Instance' => 'StackMate::CloudStackInstance',
+              'AWS::EC2::SecurityGroup' => 'StackMate::CloudStackSecurityGroup'
+   }
+
+   def StackMate.class_for(cf_resource)
+       case @profile
+         when 'CLOUDSTACK'
+           return CS_CLASS_MAP[cf_resource]
+         when 'NOOP'
+           return 'StackMate::NoOpResource'
+       end
+   end
+
+   def StackMate.configure(profile)
+       @profile = profile
+   end
+
+end

data/lib/stackmate/logging.rb

@@ -0,0 +1,28 @@
+require 'logger'
+
+module StackMate
+module Logging
+  def logger
+    @logger ||= Logging.logger_for(self.class.name)
+  end
+
+  # Use a hash class-ivar to cache a unique Logger per class:
+  @loggers = {}
+
+  class << self
+    def logger_for(classname)
+      @loggers[classname] ||= configure_logger_for(classname)
+    end
+
+    def configure_logger_for(classname)
+      logger = Logger.new(STDOUT)
+      logger.progname = classname
+      logger.datetime_format= '%F %T'
+      logger.formatter = proc do |severity, datetime, progname, msg|
+            "[#{datetime}] #{severity} #{progname} #{msg}\n"
+      end
+      logger
+    end
+  end
+end
+end

data/lib/stackmate/participants/cloudstack.rb

@@ -0,0 +1,202 @@
+require 'json'
+require 'cloudstack_ruby_client'
+require 'yaml'
+require 'stackmate/logging'
+
+module StackMate
+
+class CloudStackApiException < StandardError
+    def initialize(msg)
+        super(msg)
+    end
+end
+
+class CloudStackResource < Ruote::Participant
+  include Logging
+
+  attr_reader :name
+
+  def initialize()
+      @url = ENV['URL']
+      @apikey = ENV['APIKEY']
+      @seckey = ENV['SECKEY']
+      @client = CloudstackRubyClient::Client.new(@url, @apikey, @seckey, false)
+  end
+
+  def on_workitem
+    p workitem.participant_name
+    reply
+  end
+
+  protected
+    
+    def make_request(cmd, args)
+        begin
+          logger.debug "Going to make request #{cmd} to CloudStack server for resource #{@name}"
+          resp = @client.send(cmd, args)
+          jobid = resp['jobid'] if resp
+          resp = api_poll(jobid, 3, 3) if jobid
+          return resp
+        rescue => e
+          logger.error("Failed to make request #{cmd} to CloudStack server while creating resource #{@name}")
+          logger.error e.message + "\n " + e.backtrace.join("\n ")
+          raise e
+        rescue SystemExit
+          logger.error "Rescued a SystemExit exception"
+          raise CloudStackApiException, "Did not get 200 OK while making api call #{cmd}"
+        end
+    end
+  
+    def api_poll (jobid, num, period)
+      i = 0 
+      loop do 
+        break if i > num
+        resp = @client.queryAsyncJobResult({'jobid' => jobid})
+        if resp
+            return resp['jobresult'] if resp['jobstatus'] == 1
+            return {'jobresult' => {}} if resp['jobstatus'] == 2
+        end
+        sleep(period)
+        i += 1 
+      end
+    return {}
+    end
+
+end
+
+class CloudStackInstance < CloudStackResource
+  def initialize()
+    super
+    @localized = {}
+    load_local_mappings()
+  end
+
+  def on_workitem
+    myname = workitem.participant_name
+    @name = myname
+    resolved = workitem.fields['ResolvedNames']
+    resolved['AWS::StackId'] = workitem.fei.wfid #TODO put this at launch time
+    props = workitem.fields['Resources'][workitem.participant_name]['Properties']
+    security_group_names = []
+    props['SecurityGroups'].each do |sg| 
+        sg_name = resolved[sg['Ref']]
+        security_group_names << sg_name
+    end
+    keypair = resolved[props['KeyName']['Ref']] if props['KeyName']
+    userdata = nil
+    if props['UserData']
+        userdata = user_data(props['UserData'], resolved)
+    end
+    templateid = image_id(props['ImageId'], resolved, workitem.fields['Mappings'])
+    templateid = @localized['templates'][templateid] if @localized['templates']
+    svc_offer = resolved[props['InstanceType']['Ref']]  #TODO fragile
+    svc_offer = @localized['service_offerings'][svc_offer] if @localized['service_offerings']
+    args = { 'serviceofferingid' => svc_offer,
+             'templateid' => templateid,
+             'zoneid' => default_zone_id,
+             'securitygroupnames' => security_group_names.join(','),
+             'displayname' => myname,
+             #'name' => myname
+    }
+    args['keypair'] = keypair if keypair
+    args['userdata'] = userdata  if userdata
+    resultobj = make_request('deployVirtualMachine', args)
+    logger.debug("Created resource #{myname}")
+
+    reply
+  end
+
+  def user_data(datum, resolved)
+      #TODO make this more general purpose
+      actual = datum['Fn::Base64']['Fn::Join']
+      delim = actual[0]
+      data = actual[1].map { |d|
+          d.kind_of?(Hash) ? resolved[d['Ref']]: d
+      }
+      Base64.urlsafe_encode64(data.join(delim))
+  end
+
+  def load_local_mappings()
+      begin
+          @localized = YAML.load_file('local.yaml')
+      rescue
+          print "Warning: Failed to load localized mappings from local.yaml\n"
+      end
+  end
+
+  def default_zone_id
+      if @localized['zoneid'] 
+          @localized['zoneid']
+      else
+          '1'
+      end
+  end
+
+  def image_id(imgstring, resolved, mappings)
+      #TODO convoluted logic only handles the cases
+      #ImageId : {"Ref" : "FooBar"}
+      #ImageId :  { "Fn::FindInMap" : [ "Map1", { "Ref" : "OuterKey" },
+      #                          { "Fn::FindInMap" : [ "Map2", { "Ref" : "InnerKey" }, "InnerVal" ] } ] },
+      #ImageId :  { "Fn::FindInMap" : [ "Map1", { "Ref" : "Key" },  "Value" ] } ] },
+      if imgstring['Ref']
+          return resolved[imgstring['Ref']]
+      else 
+          if imgstring['Fn::FindInMap']
+              key = resolved[imgstring['Fn::FindInMap'][1]['Ref']]
+              #print "Key = ", key, "\n"
+              if imgstring['Fn::FindInMap'][2]['Ref']
+                  val = resolved[imgstring['Fn::FindInMap'][2]['Ref']]
+                  #print "Val [Ref] = ", val, "\n"
+              else
+                  if imgstring['Fn::FindInMap'][2]['Fn::FindInMap']
+                      val = image_id(imgstring['Fn::FindInMap'][2], resolved, mappings)
+                      #print "Val [FindInMap] = ", val, "\n"
+                  else
+                      val = imgstring['Fn::FindInMap'][2]
+                  end
+              end
+          end
+          return mappings[imgstring['Fn::FindInMap'][0]][key][val]
+      end
+  end
+
+end
+
+
+class CloudStackSecurityGroup < CloudStackResource
+  def on_workitem
+    myname = workitem.participant_name
+    logger.debug("Going to create resource #{myname}")
+    @name = myname
+    p myname
+    resolved = workitem.fields['ResolvedNames']
+    props = workitem.fields['Resources'][myname]['Properties']
+    name = workitem.fields['StackName'] + '-' + workitem.participant_name;
+    resolved[myname] = name
+    args = { 'name' => name,
+             'description' => props['GroupDescription']
+    }
+    make_request('createSecurityGroup', args)
+    logger.debug("created resource #{myname}")
+    props['SecurityGroupIngress'].each do |rule|
+        cidrIp = rule['CidrIp']
+        if cidrIp.kind_of?  Hash
+            #TODO: some sort of validation
+            cidrIpName = cidrIp['Ref']
+            cidrIp = resolved[cidrIpName]
+        end
+        args = { 'securitygroupname' => name,
+            'startport' => rule['FromPort'],
+            'endport' => rule['ToPort'],
+            'protocol' => rule['IpProtocol'],
+            'cidrlist' => cidrIp
+        }
+        #TODO handle usersecuritygrouplist
+        make_request('authorizeSecurityGroupIngress', args)
+    end
+    reply
+  end
+end
+
+
+end

data/lib/stackmate/participants/common.rb

@@ -0,0 +1,64 @@
+require 'stackmate/logging'
+
+module StackMate
+
+
+class WaitConditionHandle < Ruote::Participant
+  include Logging
+
+  def on_workitem
+    myname = workitem.participant_name
+    logger.debug "Entering #{workitem.participant_name} "
+    presigned_url = 'http://localhost:4567/waitcondition/' + workitem.fei.wfid + '/' + myname
+    workitem.fields['ResolvedNames'][myname] = presigned_url
+    logger.info "Your pre-signed URL is: #{presigned_url} "
+    logger.info "Try: \ncurl -X PUT --data 'foo' #{presigned_url}"
+    WaitCondition.create_handle(myname, presigned_url)
+
+    reply
+  end
+end
+
+class WaitCondition < Ruote::Participant
+  include Logging
+  @@handles = {}
+  @@conditions = []
+  def on_workitem
+    logger.debug "Entering #{workitem.participant_name} "
+    @@conditions << self
+    @wi = workitem
+  end
+
+  def self.create_handle(handle_name, handle)
+      @@handles[handle_name] = handle
+  end
+
+  def set_handle(handle_name)
+      reply(@wi) if @@handles[handle_name]
+  end
+
+  def self.get_conditions()
+      @@conditions
+  end
+end
+
+class Output < Ruote::Participant
+  include Logging
+  def on_workitem
+    #p workitem.fields.keys
+    logger.debug "Entering #{workitem.participant_name} "
+    logger.debug "Done"
+    reply
+  end
+end
+
+class NoOpResource < Ruote::Participant
+  include Logging
+
+  def on_workitem
+    logger.debug "Entering #{workitem.participant_name} "
+    reply
+  end
+end
+
+end

data/lib/stackmate/stack.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'set'
+require 'tsort'
+require 'stackmate/logging'
+
+module StackMate
+
+class Stacker
+    include TSort
+    include Logging
+
+    def initialize(templatefile, stackname, params)
+        @stackname = stackname
+        @resolved = {}
+        stackstr = File.read(templatefile)
+        @templ = JSON.parse(stackstr) 
+        @templ['StackName'] = @stackname
+        @param_names = @templ['Parameters']
+        @deps = {}
+        @pdeps = {}
+        resolve_param_refs(params)
+        validate_param_values
+        resolve_dependencies()
+        @templ['ResolvedNames'] = @resolved
+    end
+
+    def resolve_param_refs(params)
+        params.split(';').each do |p|
+           i = p.split('=')
+           @resolved[i[0]] = i[1]
+        end
+        @resolved['AWS::Region'] = 'us-east-1' #TODO handle this better
+    end
+    
+    def validate_param_values
+        #TODO CloudFormation parameters have validity constraints specified
+        #Use them to validate parameter values (e.g., email addresses)
+    end
+
+    def resolve_dependencies
+        @templ['Resources'].each { |key,val| 
+            deps = Set.new
+            pdeps = Set.new
+            find_refs(key, val, deps, pdeps)
+            deps << val['DependsOn'] if val['DependsOn']
+            #print key, " depends on ", deps.to_a, "\n"
+            @deps[key] = deps.to_a
+            @pdeps[key] = pdeps.to_a
+        }
+        @pdeps.keys.each do |k|
+            unres = @pdeps[k] - @resolved.keys
+            if ! unres.empty?
+                unres.each do |u|
+                    deflt = @param_names[u]['Default']
+                    #print "Found default value ", deflt, " for ", u, "\n" if deflt
+                    @resolved[u] = deflt if deflt
+                end
+                unres = @pdeps[k] - @resolved.keys
+                throw :unresolved, (@pdeps[k] - @resolved.keys) if !unres.empty?
+            end
+        end
+    end
+
+
+    def find_refs (parent, jsn, deps, pdeps)
+        case jsn
+            when Array
+                jsn.each {|x| find_refs(parent, x, deps, pdeps)}
+                #print parent, ": ", jsn, "\n"
+            when Hash
+                jsn.keys.each do |k|
+                    #TODO Fn::GetAtt
+                    if k == "Ref"
+                        #only resolve dependencies on other resources for now
+                        if !@param_names.keys.index(jsn[k]) && jsn[k] != 'AWS::Region' && jsn[k] != 'AWS::StackId'
+                            deps << jsn[k]
+                            #print parent, ": ", deps.to_a, "\n"
+                        else if @param_names.keys.index(jsn[k])
+                            pdeps << jsn[k]
+                        end
+                        end
+                    else
+                        find_refs(parent, jsn[k], deps, pdeps)
+                    end
+                end
+        end
+        return deps
+    end
+
+    def tsort_each_node(&block)
+        @deps.each_key(&block)
+    end
+
+    def tsort_each_child(name, &block)
+        @deps[name].each(&block) if @deps.has_key?(name)
+    end
+    
+end
+
+end

data/lib/stackmate/stack_executor.rb

@@ -0,0 +1,51 @@
+require 'ruote'
+require 'json'
+require 'stackmate/stack'
+require 'stackmate/logging'
+require 'stackmate/classmap'
+require 'stackmate/participants/cloudstack'
+require 'stackmate/participants/common'
+
+module StackMate
+
+class StackExecutor < StackMate::Stacker
+    include Logging
+
+    def initialize(templatefile, stackname, params, engine, create_wait_conditions)
+        super(templatefile, stackname, params)
+        @engine = engine
+        @create_wait_conditions = create_wait_conditions
+    end
+
+    def pdef
+        participants = self.strongly_connected_components.flatten
+        #if we want to skip creating wait conditions (useful for automated tests)
+        participants = participants.select { |p|
+            StackMate.class_for(@templ['Resources'][p]['Type']) != 'StackMate::WaitCondition'
+        } if !@create_wait_conditions
+
+        logger.info("Ordered list of participants: #{participants}")
+
+        participants.each do |p|
+            t = @templ['Resources'][p]['Type']
+            throw :unknown, t if !StackMate.class_for(t)
+            @engine.register_participant p, StackMate.class_for(t)
+        end
+
+        @engine.register_participant 'Output', 'StackMate::Output'
+        participants << 'Output'
+        @pdef = Ruote.define @stackname.to_s() do
+            cursor do
+                participants.collect{ |name| __send__(name) }
+            end
+        end
+    end
+    
+    def launch
+        wfid = @engine.launch( pdef, @templ)
+        @engine.wait_for(wfid)
+        logger.error { "engine error : #{@engine.errors.first.message}"} if @engine.errors.first
+    end
+end
+
+end

data/lib/stackmate/version.rb

@@ -0,0 +1,3 @@
+module StackMate
+  VERSION = "0.0.1"
+end

data/lib/stackmate/waitcondition_server.rb

@@ -0,0 +1,32 @@
+require 'rufus-json/automatic'
+require 'ruote'
+require 'ruote/storage/fs_storage'
+require 'json'
+require 'sinatra/base'
+require 'stackmate/participants/common'
+
+module StackMate
+
+class WaitConditionServer < Sinatra::Base
+  set :static, false
+  set :run, true
+
+  def initialize()
+      super
+  end
+
+  put '/waitcondition/:wfeid/:waithandle' do
+    #print "Got PUT of " , params[:wfeid],  ", name = ", params[:waithandle], "\n"
+    WaitCondition.get_conditions.each  do |w|
+      w.set_handle(params[:waithandle].to_s)
+    end
+    'success
+    '
+  end
+
+
+  run! if app_file == $0
+
+end
+
+end

data/lib/stackmate.rb

@@ -0,0 +1,4 @@
+require 'stackmate/stack'
+require 'stackmate/stack_executor'
+require 'stackmate/participants/common.rb'
+require 'stackmate/participants/cloudstack.rb'

data/stackmate.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stackmate/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'stackmate'
+  s.version       = StackMate::VERSION
+  s.summary     = "Execute CloudFormation templates on CloudStack"
+  s.description = "Parse and execute CloudFormation templates on CloudStack and other clouds"
+  s.authors     = ["Chiradeep Vittal"]
+  s.email       = 'chiradeepv@gmail.com'
+  s.files = Dir[
+    'lib/**/*.rb', 'test/**/*.rb',
+    '*.gemspec', '*.txt', '*.rdoc', '*.md'
+  ]
+  s.homepage    =
+    'https://github.com/chiradeep/stackmate'
+  s.platform = Gem::Platform::RUBY
+
+  #s.add_runtime_dependency 'ruby_parser', '~> 2.3'
+  s.add_runtime_dependency 'cloudstack_ruby_client', '>= 0.0.4'
+  s.add_runtime_dependency 'json'
+  s.add_runtime_dependency 'ruote', '>= 2.3.0'
+  s.add_runtime_dependency 'sinatra', '>= 1.4.2'
+  s.add_runtime_dependency 'yajl-ruby', '= 1.1.0'
+
+  s.add_development_dependency 'json'
+
+  s.require_path = 'lib'
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: stackmate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Chiradeep Vittal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cloudstack_ruby_client
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.4
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruote
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse and execute CloudFormation templates on CloudStack and other clouds
+email: chiradeepv@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/stackmate/classmap.rb
+- lib/stackmate/logging.rb
+- lib/stackmate/participants/cloudstack.rb
+- lib/stackmate/participants/common.rb
+- lib/stackmate/stack.rb
+- lib/stackmate/stack_executor.rb
+- lib/stackmate/version.rb
+- lib/stackmate/waitcondition_server.rb
+- lib/stackmate.rb
+- stackmate.gemspec
+- LICENSE.txt
+- README.md
+homepage: https://github.com/chiradeep/stackmate
+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.25
+signing_key: 
+specification_version: 3
+summary: Execute CloudFormation templates on CloudStack
+test_files: []