containerize_me 0.1.1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,12 @@
+
+=== 0.1.1 / 2011-07-11
+* Added ability to add users to a chroot jail which do not exists on the 
+system.  This is good if one wants a user to be able to ssh into the jail
+without any login capability outside of the jail.
+
+=== 0.1.0 / 2011-07-11
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,19 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/containerize_me
+lib/containerize_me.rb
+lib/constants.rb
+lib/file.rb
+lib/cp_dep_libs.rb
+test/test_containerize_me.rb
+templates/ubuntu_rails_hosting_stack.yaml
+templates/ubuntu_mysqld.yaml
+templates/ubuntu_ruby191.yaml
+templates/ubuntu_ruby18.yaml
+templates/nginx.yaml
+templates/ruby-enterprise-passenger.yaml
+templates/ubuntu_sshd.yaml
+

data/README.txt

@@ -0,0 +1,41 @@
+= containerize_me
+
+http://cyberconnect.biz/opensource
+
+
+== DESCRIPTION:
+
+Containerize Me is intended to provide a cross distro linux means for easily defining charactieristics of a chroot jail in yaml format.  While there are other Linux tools out there aiming at delivering similar solutions often times they differ between distros.  With containerize_me it's easy to get hosting setup in chroot jail's in a matter of minutes from any Linux distro.
+
+== FEATURES:
+
+*  :copy_items Required YAML hash pointing to an array of files to copy over to the chroot environment.
+*  :depends_on Optional YAML configuration key referencing one or more dependancies.  Dependancies may be may be nesed as many levels deep as long as there are no ciclic conditions.
+* :mkdir: Optional YAML configuration key referencing an array of hashes where the has defines keys(:item, :user, :group, :mode) 
+
+
+== USAGE:
+
+      containerize_me --config <chroot yaml configuration file> --jail <full path to jail eg: /hosting/some_jail>
+
+      where <chroot yaml configuration file> defines the charicteristics of
+      the chroot environment being created.  Items, such as which files are copied
+      over, and dependent yaml configuration files as well.  See the templates directory
+      for examples.
+
+
+
+== REQUIREMENTS:
+
+* Linux
+* jailkit 
+
+== INSTALL:
+
+* Install jailkit: http://olivier.sessink.nl/jailkit/index.html#download
+* gem install containerize_me 
+
+
+== LICENSE:
+
+GPLv3: http://www.gnu.org/licenses/gpl.html

data/Rakefile

@@ -0,0 +1,17 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+# Hoe.plugin :compiler
+# Hoe.plugin :gem_prelude_sucks
+# Hoe.plugin :inline
+# Hoe.plugin :racc
+# Hoe.plugin :rubyforge
+
+Hoe.spec 'containerize_me' do
+  developer('Cliff Cyphers', 'cliff.cyphers@gmail.com')
+  extra_deps << 'platform_helpers'
+end
+
+# vim: syntax=ruby

data/bin/containerize_me

@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+
+base=File.expand_path(File.dirname(__FILE__) + '/..')
+require 'getoptlong'
+require base + '/lib/constants'
+require base + '/lib/containerize_me.rb'
+require 'yaml'
+require 'open3'
+require 'fileutils'
+require 'find'
+require 'rubygems'
+require 'platform_helpers'
+
+
+module Init
+  def usage
+    msg=<<-EOF
+
+
+      Usage:
+      containerize_me --config <chroot yaml configuration file> --jail <full path to jail: /hosting/some_jail>
+
+      where <chroot yaml configuration file> defines the charicteristics of
+      the chroot environment being created.  Items, such as which files are copied
+      over, and dependent yaml configuration files as well.  See the templates directory
+      for examples.
+
+    EOF
+    raise ArgumentError, msg
+  end
+
+  def valid?(cfg)
+    unless cfg.kind_of?(Hash)
+      raise ArgumentError, "Configuration yaml is expected to contain a hash format but found #{cfg.class}"
+    end
+    required_keys = { :system_binaries => {:type => Array, :required => false}, 
+                      :other_files => {:type => Array, :required => false},
+                      :copy_items => {:type => Array, :required => true},
+                      :mkdir => {:type => Array, :required => false},
+                      :depends_on => {:type => Array, :required => false},
+                      :users => {:type => Array, :required => false} }
+    cfg.each_pair{ |k, v|
+      if required_keys.has_key?(k)
+        unless v.kind_of?(required_keys[k][:type])
+          raise ArgumentError, "Configuration for key #{k} is type #{v.class} but expected #{required_keys[k][:type]}"
+        end 
+        required_keys.delete(k)
+      end 
+    }
+
+    required_keys.each_pair { |k, v| 
+      raise ArgumentError "Expected to find configuration key #{k}" if v[:required]
+    }
+
+  end
+
+  def config
+    opts = GetoptLong.new( [ '--config', '-c', GetoptLong::REQUIRED_ARGUMENT ],
+                           ['--jail', '-j', GetoptLong::REQUIRED_ARGUMENT ] )
+    cfg = {:cfg => nil, :jail => nil, :templates => nil}
+    begin
+      opts.each { |opt, arg|
+        case opt
+          when '--config'
+            raise StandardError, "config file not found: #{arg}" unless File.exists?(arg)
+            begin
+              cfg[:cfg] = YAML::load_file(arg)
+              cfg[:templates] = File.dirname(File.expand_path(arg))
+            rescue => e
+              raise StandardError, "\n\nUnable to parse yaml file.  Use irb and\nrequire 'yaml'\nYAML::load_file(#{'arg'})\n\nto test out your configuration.\n\n" 
+            end
+          when '--jail'
+            cfg[:jail] = arg
+        end
+      }
+    rescue => e
+      usage
+    end
+    Init.usage unless cfg[:cfg] && cfg[:jail] &&cfg[:templates]
+    Init.valid?(cfg[:cfg])
+    cfg
+  end
+
+  def run
+    cfg=config
+    Jail.module_eval { @config = Jail::Config.new(:cfg => cfg[:cfg], :jail => cfg[:jail], :templates => cfg[:templates]) }
+    Jail.perform
+  end
+  module_function :run, :config, :usage, :valid?
+end
+
+Init.run

data/lib/constants.rb

@@ -0,0 +1,14 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+module Constants
+  module Errors
+    MISSING_JK = "jk_init not found as a system command.  Ensure that you have jailkit installed and is in your path"
+    JAIL_NOT_WRITABLE = "Jail directory not writable or does not exists.  Ensure that the user running the application has read, write and execute permissions on the directory where the jail resides."
+    JK_INIT_ERROR = "Issue running jk_init: "
+    NO_TMPL = "Template not found.  Ensure that the templates defined in your config contain valid templates"
+  end
+end

data/lib/containerize_me.rb

@@ -0,0 +1,262 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+base = File.expand_path(File.dirname(__FILE__))
+require base + '/file'
+require base + '/cp_dep_libs'
+
+ENV['PATH'] += "/opt/cyberconnect/bin:/opt/cyberconnect/usr/bin:/opt/cyberconnect/sbin:/opt/cyberconnect/usr/sbin"
+
+class ContainerizeMe
+  VERSION = '0.1.1'
+end
+class JailKitNotFoundError < StandardError ; end
+class JailNotWritable < StandardError ; end
+class NoJailDirectory < StandardError ; end
+
+
+module Jail
+  class Config
+    attr_reader :jail, :dep_order, :cfg
+    def initialize(params={})
+      @cfg = params[:cfg]
+      @cfg[:system_binaries] ||= []
+      @cfg[:other_binaries] ||= []
+      @cfg[:copy_items] ||= []
+
+      @jail = params[:jail]
+      @templates = params[:templates]
+      @system_binaries = @cfg[:system_binaries]
+      @other_files = @cfg[:other_files]
+      @dep_order = []
+      order(@cfg)
+    end
+
+    def order(file)
+      if File.exists?("#{@templates}/#{file}")
+        cfg = YAML::load_file("#{@templates}/#{file}")
+      else
+        cfg = file
+      end
+      @dep_order << cfg unless @dep_order.include?(cfg)
+      if cfg.has_key?(:depends_on)
+        if cfg[:depends_on].kind_of?(Array)
+          cfg[:depends_on].each { |f| order(f) }
+        end
+      end 
+    end
+  end
+
+  def exec(str)
+    res = '' 
+    std_in, std_out, std_err = Open3::popen3(str) 
+    puts std_out.read
+    err = std_err.read
+    err.each_line { |line|
+      next if "#{line}" =~ /empty, not checked/
+      res += line
+    }
+    res 
+  end
+  def has_jailkit?
+    out=`which jk_init`
+    out.length > 0 ? true : false
+  end
+  def create
+    FileUtils.mkdir_p @config.jail unless File.directory?(@config.jail)
+    raise JailKitNotFoundError, Constants::Errors::MISSING_JK unless has_jailkit?
+    raise JailNotWritable, Constants::Errors::JAIL_NOT_WRITABLE unless File.writable?(@config.jail)
+
+    err = Jail.exec("jk_init -j #{@config.jail} jk_lsh")
+    if err.length != 0
+      raise StandardError, "#{Constants::Errors::JK_INIT_ERROR} #{err}"
+    end
+    true
+  end
+ 
+  # TODO: update to use following:
+  # jk_cp takes too long when copying large directory structures.  Use
+  # FileUtils.cp_r first followed by cp_dep_libs to use jk_cp to copy over
+  # deps for executable and shared object items
+  def cp(item)
+#=begin
+    if File.directory?(item)
+      dir = File.dirname(item)
+      begin
+        FileUtils.mkdir_p("#{@config.jail}#{dir}") unless File.directory?("#{@config.jail}#{dir}")
+        FileUtils.cp_r(item, "#{@config.jail}#{dir}", {:remove_destination => true})#, :preserve => true})
+      rescue => e
+      end
+      Jail.cp_dep_libs(item, @config.jail)
+      err = ''
+    else
+#=end
+      err = Jail.exec("jk_cp -o -j #{@config.jail} #{item}") 
+    end
+    FileUtils.clone_perms(item, @config.jail)
+    if err.length != 0
+      raise StandardError, "#{Constants::Errors::JK_INIT_ERROR} #{err}"
+    end
+    true
+  end
+
+  def add_common_items
+    files = []
+    common = %w(libnss libcurl)
+    common.each { |lib|
+      Find.find('/lib').each { |i| files << i if i =~ /#{lib}/ }
+    }
+    files
+  end
+
+  def user_in_jail?(user)
+    File.read(@config.jail + '/etc/passwd').grep(/^#{user}/).first != nil ? true : false
+  end
+
+  def group_in_jail?(gid)
+    File.read(@config.jail + '/etc/group').grep(/#{gid}:$/).first != nil ? true : false
+  end
+
+
+  # In order to preserve the system's /etc/passwd jailkit's jk_addjailuser is avoided.  
+  # We only require that the user exists in the jail for all actions needed to host 
+  # apps.  Also, all other services(sshd, mysql, beanstalkd, etc) work fine 
+  # using chroot with the --userspec. It's assumed system user's are not 
+  # chrooted to a jail.  A separate sshd process runs in the jail on a custom port
+  # and when a required jail user logs into that ssh instance they are confined to the jail. 
+  # For this separation user's are added to the jail by grabbing the user info 
+  # from /etc/passwd and appending to @config.jail/etc/passwd.  
+  def add_user(user)
+    unless Jail.user_in_jail?(user) 
+      system_users = File.read('/etc/passwd').split(/\n/).grep(/^#{user}/)
+      raise StandardError unless system_users.length == 1
+      user_info = system_users.first.split(':')
+      #Jail.cp(user_info[5])
+     
+      fd = File.open(@config.jail + '/etc/passwd', 'a')
+      fd.puts system_users.first
+      fd.close
+
+      unless Jail.group_in_jail?(user_info[3])
+        group = File.read('/etc/group').grep(/:#{user_info[3]}:/).first
+        fd = File.open(@config.jail + '/etc/group', 'a')
+        fd.puts group
+        fd.close
+      end
+    end
+    true
+  end
+
+  def max_uid(passwd_file)
+    max = 0
+    raise ArgumentError unless File.exists?(passwd_file)
+    File.readlines(passwd_file).each { |l|
+      pass_entry = l.split(':')
+      next if pass_entry[2].to_i >= 65534
+      max = pass_entry[2].to_i if pass_entry[2].to_i > max
+    }
+    max
+  end
+
+  # add a user to the jail that's not in the root system's /etc/passwd
+  # assumes uid == gid
+  def add_user_not_in_root_system(user, uid=nil)
+    unless Jail.user_in_jail?(user) 
+      uid ||= max_uid("#{@config.jail}/etc/passwd")+1
+      fd = File.open("#{@config.jail}/etc/passwd", 'a')
+      fd.puts "#{user}:x:#{uid}:#{uid}::/home/#{user}:/bin/bash"
+      fd.close
+      fd = File.open("#{@config.jail}/etc/group", 'a')
+      fd.puts "#{user}:x:#{uid}:"
+      fd.close
+    end
+  end
+
+  def process(cfg)
+    if cfg.kind_of?(Jail::Config)
+      cfg = @config.cfg
+    end
+    files = []
+    files += cfg[:system_binaries] if cfg[:system_binaries].kind_of?(Array)
+    files +=  cfg[:other_files] if cfg[:other_files].kind_of?(Array)
+    files +=  cfg[:copy_items] if cfg[:copy_items].kind_of?(Array)
+    files += Jail.add_common_items
+    files.each { |file| Jail.cp(file) } 
+    if cfg.has_key?(:users)
+      cfg[:users].each { |user| Jail.add_user(user) } if cfg[:users].kind_of?(Array)
+    end
+
+    if cfg.has_key?(:mkdir)
+      if cfg[:mkdir].kind_of?(Array)
+        cfg[:mkdir].each { |dir|
+          d = "#{@config.jail}#{dir[:item]}"
+          FileUtils.mkdir_p d unless File.directory?(d)
+          if dir[:user].length > 0 && dir[:group].length > 0
+            FileUtils.chown(dir[:user], dir[:group], d)
+            FileUtils.chmod(dir[:mode], d) if dir.has_key?(:mode)
+          end
+        }
+      
+      end
+    end
+
+    if cfg.has_key?(:symlinks)
+      if cfg[:symlinks].kind_of?(Array)
+        cfg[:symlinks].each { |i|
+          begin
+            i[:force] ||= nil
+            unless i.has_key?(:source) && i.has_key?(:destination)
+              raise StandardError, ":source and :destination must be provided when creating a symlink" 
+            end
+            unless File.exists?i[:source]
+              raise StandardError, ":source file/directory not found"
+            end
+            if i[:force]
+              FileUtils.ln_sf(i[:source], "#{@config.jail}/#{i[:destination]}")
+            else
+              FileUtils.ln_s(i[:source], "#{@config.jail}/#{i[:destination]}")
+            end
+          rescue => e
+            p "issue creating symlink: #{e.inspect}"
+          end 
+        }
+      end
+    end
+  
+    if cfg.has_key?(:chown)
+      if cfg[:chown].kind_of?(Array)
+        cfg[:chown].each { |i|
+          begin
+            FileUtils.chown_R(i[:user], i[:group], "#{@config.jail}#{i[:item]}") if File.exists?("#{@config.jail}#{i[:item]}")
+          rescue => e
+            p "issue chown: #{e.inspect}"
+          end 
+        }
+      end 
+    end 
+
+    if cfg.has_key?(:add_non_system_users)
+      if cfg[:add_non_system_users].kind_of?(Array)
+        cfg[:add_non_system_users].each { |user|
+          add_user_not_in_root_system(user)
+        }
+      end
+    end
+
+
+  end
+
+  def perform
+    if Jail.create
+      @config.dep_order.reverse.each { |i| process(i) }
+      process(@config)
+    end
+  end
+
+  module_function :create, :has_jailkit?, :cp, :exec, :add_user, :process, :perform
+  module_function :user_in_jail?, :add_common_items, :group_in_jail?, :max_uid, :add_user_not_in_root_system
+end
+

data/lib/cp_dep_libs.rb

@@ -0,0 +1,21 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+require 'find'
+
+module Jail
+  def self.cp_dep_libs(src, jail_dir)
+    if File.directory?(src) && File.directory?(jail_dir)
+      Find.find(src) { |entry|
+        next if File.directory?(entry)
+        stat = File.stat(entry)
+        if entry =~ /\.so/ || stat.executable?
+          `jk_cp -f -j #{jail_dir} #{entry}`
+        end
+      }
+   end
+ end
+end

data/lib/file.rb

@@ -0,0 +1,24 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+require 'fileutils'
+require 'find'
+
+module FileUtils
+  def self.clone_perms(src, dest)
+    if File.directory?(src) && File.directory?(dest)
+      Find.find(src) { |entry|
+        next if entry =~ /^\/proc/ 
+        begin
+          stat = File.stat(entry)
+          FileUtils.chmod(stat.mode, "#{dest}#{entry}")
+          FileUtils.chown(stat.uid, stat.gid, "#{dest}#{entry}")
+        rescue => e
+        end
+      }    
+    end
+  end
+end

data/templates/nginx.yaml

@@ -0,0 +1,11 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /opt/cyberconnect/nginx
+- /bin/sh
+:users:
+- www-data

data/templates/ruby-enterprise-passenger.yaml

@@ -0,0 +1,10 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:system_binaries:
+- /usr/local/ruby-enterprise-1.8.7-2011.03/bin/ruby
+:other_files:
+- /usr/local/ruby-enterprise-1.8.7-2011.03

data/templates/ubuntu_mysqld.yaml

@@ -0,0 +1,47 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /usr/sbin/mysqld
+- /usr/bin/mysqlhotcopy
+- /bin/sh
+- /etc/mysql
+- /usr/share/mysql
+- /usr/share/mysql-common
+- /usr/bin/perl
+- /usr/share/perl
+- /usr/share/perl5
+- /usr/lib/perl
+- /usr/lib/perl5
+- /var/lib/mysql/mysql
+:mkdir:
+- :item: /var/run/mysqld
+  :user: mysql
+  :group: root
+- :item: /usr/lib/mysql
+  :user: mysql
+  :group: root
+- :item: /usr/lib/mysql/plugin
+  :user: mysql
+  :group: root
+- :item: /usr/local/share
+  :user: root
+  :group: root
+:symlinks:
+-
+  :source: /usr/lib/perl
+  :destination: /usr/local/lib/perl
+  :force: true
+-
+  :source: /usr/share/perl
+  :destination: /usr/local/share/perl
+  :force: true
+:users:
+- mysql
+:chown:
+- :item: /var/lib/mysql
+  :user: mysql
+  :group: root

data/templates/ubuntu_rails_hosting_stack.yaml

@@ -0,0 +1,36 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /usr/bin/beanstalkd
+- /bin/uname
+- /usr/bin/env
+- /bin/sh
+- /usr/bin/which
+- /bin/bash
+- /usr/bin/nohup
+- /etc/debian_version
+- /var/lib/gems/1.9.1/gems/passenger-3.0.8/
+- /var/lib/gems/1.9.1/specifications/passenger-3.0.8.gemspec
+:depends_on:
+- ubuntu_mysqld.yaml   
+- ubuntu_sshd.yaml
+- ubuntu_ruby191.yaml
+- nginx.yaml
+:mkdir:
+- :item: /proc
+  :user: root
+  :group: root
+  :mode: 0755
+- :item: /dev
+  :user: root
+  :group: root
+  :mode: 0755
+- :item: /tmp
+  :user: root
+  :group: root
+  :mode: 0777
+

data/templates/ubuntu_ruby18.yaml

@@ -0,0 +1,17 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /usr/bin/ruby1.8
+- /usr/bin/gem1.8
+- /usr/local/lib/site_ruby
+- /usr/lib/ruby/1.9.1
+- /usr/lib/ruby/gems/1.8/
+- /usr/lib/ruby/1.8
+- /var/lib/gems/1.9.1
+- /var/lib/gems/1.8
+- /bin/sh
+- /bin/bash

data/templates/ubuntu_ruby191.yaml

@@ -0,0 +1,22 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /usr/bin/ruby1.9.1
+- /usr/bin/gem1.9.1
+- /usr/local/lib/site_ruby
+- /usr/lib/ruby/1.9.1
+- /bin/sh
+- /bin/bash
+:symlinks:
+-
+  :source: /usr/bin/ruby1.9.1
+  :destination: /usr/bin/ruby
+  :force: true
+-
+  :source: /usr/bin/gem1.9.1
+  :destination: /usr/bin/gem
+  :force: true

data/templates/ubuntu_sshd.yaml

@@ -0,0 +1,13 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+:copy_items:
+- /usr/sbin/sshd
+- /etc/ssh
+- /bin/sh
+- /bin/bash
+:users:
+- sshd

data/test/test_containerize_me.rb

@@ -0,0 +1,13 @@
+# Authod: Cliff Cyphers
+# Published as part of the cyberconnect's platform mainly used
+# in hosting rails applications.  
+# Licesnse: GPLv3: http://www.gnu.org/licenses/gpl.html
+
+
+require "test/unit"
+require "containerize_me"
+
+class TestContainerizeMe < Test::Unit::TestCase
+  def test_sanity
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: containerize_me
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Cliff Cyphers
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: platform_helpers
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.12"
+  type: :development
+  version_requirements: *id002
+description: Containerize Me is intended to provide a cross distro linux means for easily defining charactieristics of a chroot jail in yaml format.  While there are other Linux tools out there aiming at delivering similar solutions often times they differ between distros.  With containerize_me it's easy to get hosting setup in chroot jail's in a matter of minutes from any Linux distro.
+email: 
+- cliff.cyphers@gmail.com
+executables: 
+- containerize_me
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/containerize_me
+- lib/containerize_me.rb
+- lib/constants.rb
+- lib/file.rb
+- lib/cp_dep_libs.rb
+- test/test_containerize_me.rb
+- templates/ubuntu_rails_hosting_stack.yaml
+- templates/ubuntu_mysqld.yaml
+- templates/ubuntu_ruby191.yaml
+- templates/ubuntu_ruby18.yaml
+- templates/nginx.yaml
+- templates/ruby-enterprise-passenger.yaml
+- templates/ubuntu_sshd.yaml
+- .gemtest
+homepage: http://cyberconnect.biz/opensource
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+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: containerize_me
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: Containerize Me is intended to provide a cross distro linux means for easily defining charactieristics of a chroot jail in yaml format
+test_files: 
+- test/test_containerize_me.rb