tdl 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2010-2012 three.js authors
+
+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,72 @@
+# Background
+
+The [Aeolus](http://aeolusproject.org) [Template Description Language](https://github.com/clalancette/oz/wiki/Oz-template-description-language) is used by [Oz](https://github.com/clalancette/oz), [Imagefactory](https://github.com/aeolusproject/imagefactory), and [Snap](https://github.com/movitto/snap) to describe operating systems and the components and configurations installed on them for useful purposes. 
+
+Oz and imagefactory use the TDL format in conjunction with native system tooling to bootstrap environments to be used as the basis of cloud images, while Snap uses native system tooling to deconstruct cloud instances into a TDLs which can be used on other cloud providers.
+
+The problem at hand is that constructing these TDLs currently is a resource-intensive operation, as building these from scratch takes lots of time and bandwidth, a detriment to growing the Aeolus community. TDLs are built through a manual trial and error process, and even one small mistake in a TDL might not be discovered for hours and after alot of bandwidth is used.
+
+tdl-tools aims to provide a few simple tools which makes TDL creation simple and easy. Furthermore these same tools can be used to facilitate systems and service orchestration using the Aeolus TDL format, which combined w/ the image creation capabilities provided by Oz/Imagefactory leads to a unique and easy-to-understand selling point for the Aeolus framework.
+
+# Solution
+
+We are proposing adding the following tools to the Aeolus suite to facilitate the creation and management of these TDLs:
+
+* tdl-create: simple tool used to prompt the end user for a few optional fields and create a barebones TDL with blanks for the user to fill in
+* tdl-verify: verified a tdl is in the correct format and is standards compliant
+* tdl-launch: the main utility script which will launch a cloud instance using [Deltacloud](http://deltacloud.apache.org/) and execute the commands on the newly created instance. For the time being tdl-launch will only support rpm and deb based Linux instances, though other package systems and windows support may eventually be added
+
+Furthermore, going forward we may add the following to the tdl-tools project:
+
+* tdl-diff: a utility to compare tdls for differences
+* web-tdl: A RESTful frontend to tdl-launch which will provide the capability to construct TDLs on the fly and automatically launch them on the cloud
+* hostmytdl: a wrapper to the [Aeolus Templates Git Repository](https://github.com/aeolus-incubator/templates) which allows for the simple uploading and downloading of TDLs
+* img2tdl: a utility similar to Snap but geared towards deconstructing a cloud image into a TDL
+* tdl-update: a mechanism to update an instance launched by tdl-launch so as to incorporate new additions to a modified TDL
+
+This set of utilities are still in the conceptual stage and will be flushed out further before proceeding. For now the first set (tdl-create, tdl-launch, and tdl-verify) are the main components that constitute the tdl-tools project.
+
+
+# eTDLs
+
+tdl-tools will require data pertaining to cloud provider credentials so as to launch new instances on that provider. To keep things simple, these will be added to the TDL files themselves as new fields under a 'cloud' tag so as to not overlap w/ the existing attributes. To prevent confusion, these TDLs will be known as 'extended TDLs', or eTDLs.
+
+Besides these attributes, the TDL format will be left unchanged. The standard TDL fields will all be used to setup the cloud instance, with the exception of the 'os' fields which will have no material effect on the new instance, though will be used for comparison and reporting purposes (eg if set 'os' will be read and compared against the local cloud instance, with a warning being displayed if there is a mismatch).
+
+At some point tdl-tools may also support reading cloud provider credentials from a file of the local filesystem (such as /etc/tdl-tools and/or ~/.tdl-tools) and/or from the command line so that standard TDLs can be launched on the cloud as is.
+
+The eTDL fields will contain:
+
+* type - the type of cloud provider to launch instance against
+* provider - the deltacloud provider id to launch instance against
+* username - the cloud username to use when launching the instance
+* password - the cloud password to use when launching the instance
+* image - the cloud image to base the instance off of
+* keyname - the name of the key on the cloud provider to access the instance
+* ssh_cmd - the command to run to use to ssh into the instance and run commands
+* scp_cmd - the command to run to use to scp files to the instance
+
+ssh_cmd and scp_cmd are templates with variables such as [address], [source] and [dst] which will be filled in on the fly with values representing the address of the cloud instance, and the source and destination filenames.
+
+An example cloud section in an eTDL is as following
+
+    <cloud>
+      <type>ec2</type>
+      <provider>ec2-east-1</provider>
+      <username>ABCDEF</username>
+      <password>FEDCBA</password>
+      <image>ami-2ea50247</image>
+      <keyname>MYKEY</keyname>
+      <ssh_cmd>ssh -q -o StrictHostKeyChecking=no -t ec2-user@[address] -i ~/.ssh/my.key</ssh_cmd>
+      <scp_cmd>scp -o StrictHostKeyChecking=no -i ~/.ssh/my.key [source] ec2-user@[address]:[dst]</scp_cmd>
+    </cloud>
+
+
+This of course relies on a few assumptions, namely the end user has access to the cloud provider they will be running instances on before hand, the specified image and key exists, and instances come up w/ a publically available ip address. Though these are the same assumptions that hold for various other Aeolus components.
+
+
+# Going forward
+
+The tdl-launch utility (in a previous incantation called 'mycloud') was already demonstrated in action to deploy various instances to facilitate a cross-cloud koji installation ( [screencast here](http://www.youtube.com/watch?v=qF2ctg7ItNc) ).
+
+The tdl-launch utility needs to be cleaned up and optimized / abstracted a bit, and packaged into gem, rpm, and deb packages. Furthuremore the create-tdl utility needs to be written to facilitate setting up a tdl from scratch.

data/Rakefile

@@ -0,0 +1,21 @@
+# tdl-tools project Rakefile
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2012 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--backtrace']
+end
+
+desc "build the tdl gem"
+task :build do
+  system "gem build tdl.gemspec"
+end

data/bin/tdl-convert.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/ruby
+# Utility to convert tdls/etdls
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2012 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'thor'
+require 'nokogiri'
+
+VERSION = "0.1.0"
+
+class TDLConvert < Thor
+  desc "convert", "convert tdl to/from etdl"
+  def convert(source)
+    extname = File.extname(source)
+    output  = File.read(source)
+    if extname == ".etdl"
+      etdl2tdl(output)
+    else
+      tdl2etdl(output)
+    end
+  end
+
+  map "--version" => :__version
+  desc "--version", "Version information"
+  def __version
+    say "tdl-tools convert #{VERSION}"
+  end
+
+  desc "help", "Command usage and other information"
+  def help
+    say 'Convert a tdl to / from an etdl'
+    super
+  end
+
+  private
+  def etdl2tdl(output)
+    xml = Nokogiri::XML(output)
+
+    xml.xpath('/template/cloud').remove
+    xml.xpath('/template/verify').remove
+
+    puts xml.to_s
+  end
+
+  def tdl2etdl(output)
+    xml = Nokogiri::XML(output)
+
+    cloudn  = Nokogiri::XML::Node.new('cloud', xml)
+    cloudn << "\n"
+    cloud_nodes = ['type',  'provider', 'username', 'password',
+                   'image', 'keyname',  'ssh_cmd',  'scp_cmd'].each { |cn|
+                     cnn = Nokogiri::XML::Node.new(cn, xml)
+                     cnn << " "
+                     cloudn << "\t\t"
+                     cloudn << cnn
+                     cloudn << "\n"
+                  }
+    cloudn << "\t"
+
+    verifycmdn = Nokogiri::XML::Node.new('command', xml)
+    verifycmdn['name'] = ''
+    verifyn    = Nokogiri::XML::Node.new('verify', xml)
+    verifyn << "\n\t\t"
+    verifyn << verifycmdn
+    verifyn << "\n\t"
+
+    xml.xpath('/template').first << "\t"
+    xml.xpath('/template').first << cloudn
+    xml.xpath('/template').first << "\n\n\t"
+    xml.xpath('/template').first << verifyn
+    xml.xpath('/template').first << "\n"
+    puts xml.to_s
+  end
+
+end
+
+TDLConvert.start(ARGV)

data/bin/tdl-create.rb

@@ -0,0 +1,99 @@
+#!/usr/bin/ruby
+# Utility to create a barebones (e)TDL from the command line
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2012 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'thor'
+require 'nokogiri'
+
+# use fedora api to verify packages
+require 'pkgwat'
+
+VERSION = "0.1.0"
+SAMPLE_TDL  = 'data/sample.tdl'
+SAMPLE_ETDL = 'data/sample.etdl'
+
+class TDLCreate < Thor
+  desc "tdl", "create a new TDL"
+  method_options :interactive => :boolean
+  method_options :verify      => :boolean
+  def tdl
+    output = File.read(SAMPLE_TDL)
+    output = run_interactive(output, options) if options[:interactive]
+    puts output
+  end
+
+  desc "etdl", "create a new eTDL"
+  method_options :interactive => :boolean
+  method_options :verify      => :boolean
+  def etdl
+    output = File.read(SAMPLE_ETDL)
+    output = run_interactive(output, options) if options[:interactive]
+    puts output
+  end
+
+  map "--version" => :__version
+  desc "--version", "Version information"
+  def __version
+    say "tdl-tools create #{VERSION}"
+  end
+
+  desc "help", "Command usage and other information"
+  def help
+    say 'Create a new TDL from scratch'
+    super
+  end
+
+  private
+  def run_interactive(output, options = {})
+    xml = Nokogiri::XML(output)
+    say "CTRL-D at any point to terminate prompts and output (e)tdl"
+
+    begin
+      packages   = []
+      name        = ask("Template Name:")
+      description = ask("Template Description:")
+      os_name    = ask("OS Name:")
+      os_version = ask("OS Version:")
+      while true
+        package = ask('Package:')
+        packages << package
+      end
+      # TODO also files and commands
+      # TODO also cloud and verify for etdls
+    rescue Exception => e
+      say "\n"
+    end
+
+    xml.xpath('/template/name').first.content = name
+    xml.xpath('/template/description').first.content = description
+    xml.xpath('/template/os/name').first.content = os_name
+    xml.xpath('/template/os/version').first.content = os_version
+    pkgnode = xml.xpath('/template/packages').first
+    pkgnode.children[0..1].remove
+    packages.each { |pkg|
+      # verify
+      if options[:verify]
+        fpkg = Pkgwat.get_package(pkg)
+        raise "Could not find package #{pkg} in Fedora" if fpkg.nil?
+      end
+
+      node = Nokogiri::XML::Node.new('package', xml)
+      node['name'] = pkg
+      pkgnode << node
+
+      node = pkgnode.children.first.clone
+      pkgnode << node
+    }
+
+    output = xml.to_s
+  end
+
+end
+
+TDLCreate.start(ARGV)

data/bin/tdl-launch.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/ruby
+# Utility to read in eTDLs and use Deltacloud to launch them
+# Run with the path to the eTDL like so:
+#    ./tdl-launch.rb <path-to-etdl>
+#
+# The etdls are the same format as the TDLs supported by imagefactory/oz
+# with additional ('extended') data pertaining to the cloud provider to
+# deploy to and the environment to setup.
+#
+# Assumes instances are started on clouds w/ a public accessible
+# address and with the ability to ssh in and run operations
+# (eTDLs must specify ssh and scp commands  to use)
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2012 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'pp'
+require 'colored'
+require 'nokogiri'
+require 'tempfile'
+
+require 'etdl'
+require 'etdl_processor'
+
+###############################################################
+# Read in configuration from cmd line and xml file
+
+if ARGV.size != 1
+  puts "Usage: tdl-launch.rb <path-to-tdl>".red
+  exit 1
+end
+
+ETDL = ARGV.first
+
+unless File.readable?(ETDL)
+  puts "eTDL #{ETDL} is not readable".red
+  exit 1
+end
+
+doc  = Nokogiri::XML(open(ARGV.first))
+etdl = TDLTools::ETDL.parse(doc)
+
+launch = ETDLProcessor.new
+
+etdl.process(launch)
+
+puts "Done!".bold

data/bin/tdl-verify.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/ruby
+# Utility to verify a specified (e)TDL 
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2012 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'thor'
+require 'nokogiri'
+require 'colored'
+
+VERSION = "0.1.0"
+TDL_RNG  = 'data/tdl.rng'
+ETDL_RNG = 'data/etdl.rng'
+
+class TDLVerify < Thor
+  desc "verify [path-to-tdl]", "Verify the tdl (or etdl) specified on the command line"
+  def verify(path)
+    say "Validating (e)TDL".bold
+    rng = (File.extname(path) == ".etdl" ? ETDL_RNG : TDL_RNG)
+    xsd = Nokogiri::XML::RelaxNG(File.read(rng))
+    doc = Nokogiri::XML(File.open(path))
+    errs = xsd.validate(doc)
+    if errs.empty?
+      say " TDL is valid".bold.green
+      exit 0
+
+    else
+      say " Errors in TDL".bold.red
+      errs.each { |err|
+        say "  #{err.message}".red
+      }
+      exit 1
+
+    end
+  end
+
+  map "--version" => :__version
+  desc "--version", "Version information"
+  def __version
+    say "tdl-tools verify #{VERSION}"
+  end
+
+  desc "help", "Command usage and other information"
+  def help
+    say 'Verify a TDL'
+    super
+  end
+end
+
+TDLVerify.start(ARGV) if __FILE__ == $0

data/lib/cloud_inst.rb

@@ -0,0 +1,81 @@
+# tdl-tools cloud instance representation
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'deltacloud'
+
+module TDLTools
+class CloudInst
+  DC_URL = "http://localhost:3002/api"
+
+  NO_START = false # set to true to disable creation of instances
+
+  # ssh address of the instance
+  attr_reader :address
+
+  # ssh command to use
+  attr_reader :ssh
+
+  # scp command to use
+  attr_reader :scp
+
+  def initialize(cloud_attributes)
+    # Use deltacloud to launch and setup instance
+    @cloud_type = cloud_attributes[:type].intern
+
+    @image   = cloud_attributes[:image]
+    @keyname = cloud_attributes[:keyname]
+
+    @dc = DeltaCloud.new(cloud_attributes[:username],
+                         cloud_attributes[:password],
+                         DC_URL)
+    @dc.use_driver @cloud_type
+
+    @dc.instance_variable_set :@api_provider,
+                              cloud_attributes[:provider] if @cloud_type == :openstack # XXX needed for openstack
+
+    @ssh = cloud_attributes[:ssh_cmd]
+    @scp = cloud_attributes[:scp_cmd]
+  end
+
+  def launch
+    # startup cloud instance
+    unless NO_START
+      dc_inst = @dc.create_instance(@image, :keyname => @keyname)
+      sleep 300 # 5 minutes
+    end
+
+    # set various propertries from the instance
+    dc_inst = (@cloud_type == :openstack ? @dc.instances.first : @dc.instances.last) # XXX for openstack its first, for ec2 its last
+    address =  dc_inst.public_addresses.first
+    address = dc_inst.private_addresses.first if address.nil?
+    @address = address[:address]
+
+    @ssh = @ssh.gsub(/\[address\]/, address)
+    @scp = @scp.gsub(/\[address\]/, address)
+
+    self
+  end
+
+  def exec(cmd)
+    `#{@ssh} #{cmd}`
+  end
+
+  def cp(from, to, append=false)
+    scpf = @scp.gsub(/\[source\]/, from).
+               gsub(/\[dst\]/,    from)
+    `#{scpf}`
+    if append
+      `#{ssh} sudo 'cat #{to} #{from} > #{from}.new'`
+      `#{ssh} sudo mv #{from}.new #{to}`
+    else
+    `#{ssh} sudo mv #{from} #{to}`
+    end
+  end
+end
+end

data/lib/etdl.rb

@@ -0,0 +1,125 @@
+# tdl-tools etdl representation
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+module TDLTools
+class ETDL
+  # cloud attributes
+  #attr_reader :type, :provider, :username, :password, :keyname, :image, :ssh_cmd, :scp_cmd
+  attr_reader :cloud_attributes
+
+  # instance attributes
+  #attr_reader :name, :description, :hostname, :firewall, :packages, :services, :files, :dirs, :commands
+  attr_reader :instance_attributes
+
+  def initialize(args = {})
+    @cloud_attributes    = args[:cloud_attributes]    || {}
+    @instance_attributes = args[:instance_attributes] || {}
+  end
+
+  # Parse / return new eTDL instance from xml document
+  def self.parse(doc)
+    cloud_attributes    = {}
+    instance_attributes = {}
+
+    doc.children.last.children.each { |c|
+      if c.name == 'name'
+        instance_attributes[:name] = c.text
+
+      elsif c.name == 'description'
+        instance_attributes[:description] = c.text
+
+      elsif c.name == 'hostname'
+        instance_attributes[:hostname] = c.text
+
+      elsif c.name == 'cloud'
+        c.children.each { |ca|
+          cloud_attributes[ca.name.intern] = ca.text
+        }
+
+      elsif c.name == 'firewall'
+        c.children.each { |rule|
+          if rule.name == "tcp" || rule.name == "udp"
+            instance_attributes[:firewall] ||= []
+            instance_attributes[:firewall] << {:proto => rule.name, :value => rule.text}
+          end
+        }
+
+      elsif c.name == 'packages'
+        c.children.each { |pkg|
+          unless pkg['name'].nil?
+            instance_attributes[:packages] ||= []
+            instance_attributes[:packages] << pkg['name']
+          end
+        }
+
+      elsif c.name == 'services'
+        c.children.each { |srv|
+          unless srv['name'].nil?
+            pre_cmds = []
+            post_cmds = []
+            srv.children.each { |s|
+              if s.name == "before"
+                pre_cmds << s.text
+              elsif s.name == "after"
+                post_cmds << s.text
+              end
+            }
+            instance_attributes[:services] ||= []
+            instance_attributes[:services] << {:name => srv['name'], :pre => pre_cmds, :post => post_cmds}
+          end
+        }
+
+      elsif c.name == 'dirs'
+        c.children.each { |dir|
+          owner = dir['owner'] || 'root'
+          group = dir['group'] || 'root'
+          remove = dir['remove'] || false
+          instance_attributes[:dirs] ||= []
+          instance_attributes[:dirs] << {:name => dir.text, :owner => owner, :group => group, :remove => remove} if dir.text.strip != ""
+        }
+
+      elsif c.name == 'files'
+        c.children.each { |file|
+          unless file['name'].nil?
+            mode = file['mode'] || '644'
+            owner = file['owner'] || 'root'
+            group = file['group'] || 'root'
+            instance_attributes[:files] ||= []
+            instance_attributes[:files] << {:name => file['name'], :mode => mode, :append => file['append'],
+                                            :owner => owner, :group => group,
+                                            :contents => file.text}
+          end
+        }
+
+      elsif c.name == 'commands'
+        c.children.each { |cmd|
+          unless cmd.name != "command"
+            user = cmd['user'] || 'root'
+            instance_attributes[:commands] ||= []
+            instance_attributes[:commands] << {:cmd => cmd.text, :user => user}
+          end
+        }
+      end
+    }
+    pp instance_attributes
+    #pp cloud_attributes
+
+    etdl = ETDL.new :cloud_attributes    => cloud_attributes,
+                    :instance_attributes => instance_attributes
+  end
+
+  def process(processor)
+    instance = processor.launch_instance(self)
+    processor.process(self, instance)
+    processor.verify(self, instance)
+    processor.terminate_instance(instance)
+  end
+
+end
+end

data/lib/etdl_processor.rb

@@ -0,0 +1,106 @@
+# tdl-tools etdl processor
+#
+# Part of the Aeolus suite http://aeolusproject.org
+# Licensed under the MIT license
+# Copyright (C) 2013 Red Hat, Inc.
+# Written By Mo Morsi <mmorsi@redhat.com>
+#
+###########################################################
+
+require 'cloud_inst'
+
+###############################################################
+# Use various subsystems to process an etdl
+
+class ETDLProcessor
+  def launch_instance(etdl)
+    puts "Connecting to deltacloud instance at #{TDLTools::CloudInst::DC_URL}...".green
+    inst = TDLTools::CloudInst.new etdl.cloud_attributes
+
+    puts "Booting up cloud instance".green
+    puts "  This will take a few minutes to become fully accessible".green
+    inst.launch
+
+    if inst.address.nil?
+      puts "could not find address to access instance with".red
+      exit 1
+    end
+
+    puts "using address #{inst.address}\nssh:#{inst.ssh}\nscp:#{inst.scp}".green
+
+    inst
+  end
+
+  def process(etdl, instance)
+    # TODO need to open firewall ports (we have to open them manually now)
+
+    # set hostname
+    hostname = etdl.instance_attributes[:hostname]
+      unless hostname.nil?
+        puts "Setting hostname to #{hostname}".green
+        instance.exec "sudo hostname #{hostname}"
+
+        # append hostname to /etc/hosts/
+        etdl.instance_attributes[:files] <<
+          {:name => '/etc/hosts', :append => true,
+           :owner => 'root', :group => 'root', :mode => 644,
+           :contents => "#{instance.address} #{hostname}"}
+      end
+
+    # yum install packages
+    packages = etdl.instance_attributes[:packages].join(" ")
+      puts "installing #{packages}".green
+      puts instance.exec("sudo yum install -y --nogpgcheck #{packages}").blue
+
+    # start services
+    services = etdl.instance_attributes[:services]
+      services.each { |s|
+        puts "starting/enabling service #{s[:name]}".green
+        s[:pre].each { |cmd|
+          puts " running precommand #{cmd}".green
+          puts instance.exec("sudo #{cmd}").blue
+        }
+        puts instance.exec("sudo service #{s[:name]} start").blue
+        puts instance.exec("sudo chkconfig --levels 35 #{s[:name]} on").blue
+        s[:post].each { |cmd|
+          puts " running postcommand #{cmd}".green
+          puts instance.exec("sudo #{cmd}").blue
+        }
+      }
+
+    # create dirs
+    dirs = etdl.instance_attributes[:dirs]
+      dirs.each { |d|
+        puts "creating dir #{d[:name]}".green
+        instance.exec("sudo rm -rf #{d[:name]}") if d[:remove]
+        instance.exec("sudo mkdir -p #{d[:name]}")
+        instance.exec("sudo chown #{d[:owner]}.#{d[:group]} #{d[:name]}")
+      }
+
+    # copy files over
+    files = etdl.instance_attributes[:files]
+      files.each { |f|
+        tf = Tempfile.new('tdl-launch')
+        tf.write f[:contents]
+        tf.close
+
+        instance.cp tf.path, f[:name]
+        instance.exec("sudo chown #{f[:owner]}.#{f[:group]} #{f[:name]}")
+        instance.exec("sudo chmod #{f[:mode]} #{f[:name]}")
+      }
+
+    cmds = etdl.instance_attributes[:commands]
+      cmds.each { |c|
+        puts "running command #{c[:cmd]} as #{c[:user]}"
+        puts instance.exec("sudo -u #{c[:user]} -i #{c[:cmd]}").blue
+      }
+  end
+
+  def verify(etdl, instance)
+    # TODO
+  end
+
+  def terminate_instance(instance)
+    # TODO
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: tdl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Mo Morsi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+description: Aeolus Template Description Language Tools
+email: mmorsi@redhat.com
+executables:
+- tdl-launch.rb
+- tdl-convert.rb
+- tdl-verify.rb
+- tdl-create.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/etdl_processor.rb
+- lib/etdl.rb
+- lib/cloud_inst.rb
+- LICENSE
+- Rakefile
+- README.md
+- bin/tdl-launch.rb
+- bin/tdl-convert.rb
+- bin/tdl-verify.rb
+- bin/tdl-create.rb
+homepage: http://aeolusproject.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: 1.8.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.3
+requirements:
+- deltacloud is required to launch etdls against cloud instances
+- imagefactory is required to build images from tdls
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Aeolus tdl-tools
+test_files: []
+has_rdoc: