atesta 0.0.0 → 0.0.1

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.0.1

data/lib/atesta.rb

@@ -0,0 +1,12 @@
+require 'lib/block_attr'
+require 'lib/class_attr'
+require 'lib/execution'
+require 'lib/hash'
+require 'lib/lock'
+require 'lib/node'
+require 'lib/output'
+require 'lib/recipe'
+require 'lib/release_window'
+require 'lib/runtime_error'
+require 'lib/status'
+require 'lib/resource'

data/lib/block_attr.rb

@@ -0,0 +1,23 @@
+module BlockAttr
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    # No Convention over Configuration attributes.
+    def block_attr *list
+      @attributes = ((@attributes || [])+ list).uniq
+      list.each do |new_method|
+        instance_eval do
+          define_method new_method do |argument|
+            instance_variable_set "@#{new_method}", argument
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/class_attr.rb

@@ -0,0 +1,26 @@
+
+# Dynamically define class attribute accessors
+module ClassAttr
+
+  def self.included klass
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+
+    def class_attr *list
+      list.each do |my_method|
+        eval "
+          def self.#{my_method}= #{my_method}
+            @#{my_method} = #{my_method}
+          end
+          def self.#{my_method}
+            @#{my_method}
+          end
+        "
+      end
+    end
+
+  end
+
+end

data/lib/execution.rb

@@ -0,0 +1,95 @@
+require 'md5'
+
+class Execution
+
+  attr_accessor :user, :always_run
+
+  def initialize title, value
+    @commands   = []
+    @title      = title
+    @value      = value
+    @always_run = false
+  end
+
+  def ignore
+    Output.jump
+    Output.error 'Ignoring execution', '..'
+    Output.ruler
+  end
+
+  def always_run boolean
+    @always_run = boolean
+  end
+
+  def banner
+    Output.jump
+    Output.info @title, @value
+    # Output.info 'Hash', serialize
+    Output.ruler
+  end
+
+  def serialize
+    MD5.hexdigest @title + (@commands * '')
+  end
+
+  def self.block title, value = nil, user = 'deploy', &block
+    @object         = new(title, value)
+    @object.user    = user
+    @object.execute &block
+  end
+
+  def execute &block
+    banner
+    yield(self)
+    run_commands
+  end
+
+  def run_commands
+    st = Status.get
+    st.execution!.hashes = [] unless st.execution.respond_to?(:hashes)
+    if st.execution.hashes.include?(serialize)
+      Output.warn 'Ignoring', 'Already executed..'
+    end
+    if @always_run
+      Output.warn 'Always run switch detected', 'Forcing execution!'
+    end
+    @commands.map { |cmd| code_for(cmd) }.each do |code|
+      Output.command code
+      unless @always_run
+        next if st.execution.hashes.include? serialize
+      end
+      run_or_raise code
+    end
+    unless st.execution.hashes.include? serialize
+      st.execution.hashes << serialize
+    end
+    nil
+  end
+
+  def run_or_raise code
+    return if system code
+    Output.jump
+    Output.ruler :error
+    Output.error 'EXECUTION FAILED', code
+    Output.ruler :error
+    raise 'Que pedo!'
+  end
+
+  def code_for cmd
+    if cmd[:path]
+      "cd #{cmd[:path]} && sudo -u #{@user} #{cmd[:command]}"
+    else
+      "sudo -u #{@user} #{cmd[:command]}"
+    end
+  end
+
+  def run string, path = nil
+    @commands << { :command => string, :path => path }
+  end
+
+  def command string, path = nil
+    run string, path
+  end
+
+end
+

data/lib/hash.rb

@@ -0,0 +1,36 @@
+class Hash
+
+  # Merges self with another hash, recursively.
+  #
+  # This code was lovingly stolen from some random gem:
+  # http://gemjack.com/gems/tartan-0.1.1/classes/Hash.html
+  #
+  # Thanks to whoever made it.
+  def deep_merge(hash)
+    target = dup
+
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+
+      target[key] = hash[key]
+    end
+
+    target
+  end
+
+  # From: http://www.gemtacular.com/gemdocs/cerberus-0.2.2/doc/classes/Hash.html
+  # File lib/cerberus/utils.rb, line 42
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+
+end

data/lib/lock.rb

@@ -0,0 +1,22 @@
+class Lock; end
+
+class << Lock
+
+   def use lock_file
+     @lock_file = lock_file
+   end
+
+   def locked?
+     File.exist? @lock_file
+   end
+
+   def lock
+     system "touch #{@lock_file}"
+   end
+
+   def unlock
+     lock
+     system "rm #{@lock_file}"
+   end
+
+end

data/lib/node.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'hashie'
+
+class Node
+
+  def self.set object
+    @node = object
+  end
+
+  def self.get
+    @node
+  end
+
+  def dna
+    @dna
+  end
+
+  def self.magic matcher, path
+    set resolve(matcher, path)
+  end
+
+  def self.resolve matcher, path
+    Output.banner 'Loading', 'Merging default attributes...'
+    @hash = @dna = eval(File.read path)
+    Dir[matcher].each do |attr_file|
+      next if File.directory? attr_file
+      Output.info 'Merging node', attr_file
+      @hash = @hash.deep_merge(eval(File.read attr_file) || {}).
+        deep_merge(@hash)
+    end
+    # TODO: remove ARGV
+    @hash[:instance_role] = ARGV[1]
+    @hash[:platform] = 'ubuntu'
+    Hashie::Mash.new(@hash)
+  end
+
+end
+

data/lib/output.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'isna'
+
+module Output
+
+  CHAR = '#'
+  RULER = '='
+
+  def self.jump
+    puts ''
+  end
+
+  def self.ruler type_of_output = :info
+    puts "[%s;%s;%sm#{CHAR} #{RULER * 77}" % type_for(type_of_output)
+  end
+
+  def self.banner key, value, type_of_output = :info
+    jump
+    kv key, value, type_for(type_of_output)
+    ruler type_of_output
+  end
+
+  def self.command code
+    puts "#{code}"
+  end
+
+  def self.type_for symbol
+    return [0, 32, 1] if symbol == :info
+    return [0, 33, 1] if symbol == :warn
+    return [5, 31, 1] if symbol == :error
+    [1, 36, 1]
+  end
+
+  def self.info key, value
+    kv key, value, self.type_for(:info)
+  end
+
+  def self.warn key, value
+    kv key, value, type_for(:warn)
+  end
+
+  def self.error key, value
+    kv key, value, type_for(:error)
+  end
+
+  def self.kv key, value, combo
+    puts "[%s;%s;%sm#{CHAR} #{key}: #{value}" % combo
+  end
+
+end

data/lib/recipe.rb

@@ -0,0 +1,183 @@
+module Recipe
+
+  attr_accessor :stack
+
+  def change_binding binding
+    @binding = binding
+  end
+
+  def init binding
+    change_binding binding
+    stack
+  end
+
+  def resource_not_supported *args
+    Output.warn 'Resource not supported', args.inspect
+  end
+
+  def clean_stack!
+    @stack = []
+  end
+
+  def cron_append object
+    @cron_jobs << object
+    Output.info 'Cron job detected', object.get_title
+  end
+
+  def cron_variable title, variable
+    @cron_jobs ||= []
+    @cron_vars ||= []
+    @cron_vars << ''
+    @cron_vars << "# #{title}"
+    @cron_vars << variable
+  end
+
+  def setup_crontab
+    Output.jump
+    Output.info 'Setting up nice cron jobs', 'this is sweeet root crontab!'
+    Output.ruler
+    t = ::Tempfile.new('temporal_crontab')
+    @cron_vars.each do |line|
+      t.puts line
+    end
+    @cron_jobs.each do |resource|
+      t.puts ''
+      t.puts "# #{resource.get_title}"
+      t.puts "#{resource.run}"
+    end
+    t.close
+    system "cat #{t.path} | crontab"
+    system 'crontab -l'
+    t.unlink
+  end
+
+  def stack
+    @stack ||= []
+  end
+
+  def stack_append object
+    @stack << object
+  end
+
+  def template name, &block
+    stack_append ::Resource::Template.new(name, &block)
+  end
+
+  def directory name, &block
+    stack_append ::Resource::Directory.new(name, &block)
+  end
+
+  def gem_package name, &block
+    stack_append ::Resource::Gem.new(name, &block)
+  end
+
+  def package package_name, &block
+    block = Proc.new {} unless block
+    stack_append ::Resource::Package.new(package_name, &block)
+  end
+
+  def execute title, &block
+    stack_append ::Resource::Execute.new(title, &block)
+  end
+
+  def user username, &block
+    stack_append ::Resource::User.new(username, &block)
+  end
+
+  def link source, &block
+    stack_append ::Resource::Link.new(source, &block)
+  end
+
+  def git repository, &block
+    stack_append ::Resource::Git.new(repository, &block)
+  end
+
+  def cron title, &block
+    cron_append ::Resource::Cron.new(title, &block)
+  end
+
+  def service name, &block
+    stack_append ::Resource::Service.new(name, &block)
+  end
+
+  def system_group groupname, &block
+    stack_append ::Resource::Group.new(groupname, &block)
+  end
+
+  def remote_file target, &block
+    stack_append ::Resource::RemoteFile.new(target, &block)
+  end
+
+  def file target, &block
+    stack_append ::Resource::File.new(target, &block)
+  end
+
+  def swap_release release_path, &block
+    stack_append ::Resource::SwapRelease.new(release_path, &block)
+  end
+
+  def version location, &block
+    stack_append ::Resource::Version.new(location, &block)
+  end
+
+  def hook target
+    target = status.release_path + "/deploy/#{target}.rb"
+    Resource::Hook.new(target, @binding).run
+  end
+
+  def node
+    @node ||= ::Node.get
+  end
+
+  def include_recipe name
+    @recipes ||= []
+    if @recipes.include? name
+      Output.warn 'Already loaded recipe with name', name
+      return
+    end
+    @recipes << name
+    Output.info 'Including recipe', name
+    include_file :Recipe, @recipes_target % name
+  end
+
+  def include_file file_type, some_file
+    unless ::File.exist? some_file
+      Output.warn "#{file_type} file not found (skipping)", some_file
+      return
+    end
+    eval(File.read(some_file), @binding)
+    Output.info 'Executable units', stack.size
+  end
+
+  def load_recipes recipes_target, list
+    Output.banner 'Loading', 'Instantiating recipes...'
+    @recipes_target = recipes_target
+    list.each { |recipe| include_recipe recipe }
+  end
+
+  def summary
+    Output.banner 'Printing', 'Execution summary'
+    Output.info 'Total Recipes', node[:recipes].size
+    Output.info 'Total executable stack units', stack.size
+  end
+
+  def status
+    Status.get
+  end
+
+  def transaction &block
+    yield
+  rescue => e
+    Output.error 'Rolling back', ' =:D '
+    raise e
+  end
+
+  def whoami
+    (File.exist? 'env/whoami') ? File.read('env/whoami').chop : 'Unknown user'
+  end
+
+  def server_ip_address
+    (File.exist? 'env/ip') ? File.read('env/ip').chop : 'Unknown ip address'
+  end
+
+end

data/lib/release_window.rb

@@ -0,0 +1,30 @@
+class ReleaseWindow
+
+  def initialize releases_path, releases, window = 5, matcher = '*'
+    @matcher = matcher
+    @releases_path = releases_path
+    @releases = releases.compact
+    @window = window
+  end
+
+  def all_releases
+    Dir[@releases_path + @matcher].map do |r|
+      File.basename(r)
+    end.compact
+  end
+
+  def deletable_releases
+    all_releases - current_window
+  end
+
+  def current_window
+    @releases.last(@window)
+  end
+
+  def deletable_files
+    deletable_releases.map do |r|
+      "#{@releases_path}#{r}"
+    end
+  end
+
+end

data/lib/resource/base.rb

@@ -0,0 +1,49 @@
+module Resource
+
+  class Base
+
+    include ::BlockAttr
+    include ::ClassAttr
+
+    # Access child's class_name statically
+    class_attr :class_name
+
+    # This resource should be executed always??
+    # *boolean*
+    block_attr :always_run
+
+    # Setup class name
+    def self.inherited name
+      @class_name = name
+    end
+
+    # Translate octal to decimal modes
+    def unix_mode
+      @mode.to_i.to_s(8)
+    end
+
+    # Configure default settings for any resource
+    def set_base_defaults
+      @not_if     = false
+      @owner      = 'root'
+      @always_run = false
+    end
+
+    def not_if condition = nil, &block
+      if condition.is_a?(String)
+        if system(condition)
+          @not_if = true
+        end
+      end
+      if block_given? && yield
+        @not_if = true
+      end
+    end
+
+    def should_skip?
+      @not_if == true
+    end
+
+  end
+
+end

data/lib/resource/cron.rb

@@ -0,0 +1,23 @@
+module Resource
+
+  class Cron < Base
+
+    block_attr :title, :command
+
+    def initialize title, &block
+      @command = ''
+      @title = title
+      self.instance_eval(&block)
+    end
+
+    def get_title
+      @title
+    end
+
+    def run
+      @command
+    end
+
+  end
+
+end

data/lib/resource/directory.rb

@@ -0,0 +1,24 @@
+module Resource
+
+  class Directory < Base
+
+    block_attr :owner, :group, :mode, :action, :recursive, :target
+
+    def initialize target, &block
+      set_base_defaults
+      @target = target
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Creating directory', @target, 'root' do |b|
+        b.always_run @always_run
+        b.run "mkdir -p #{@target}"
+        b.run "chmod #{unix_mode} #{@target}"
+        b.run "chown #{@owner}:#{@group} #{@target}"
+      end
+    end
+
+  end
+
+end

data/lib/resource/execute.rb

@@ -0,0 +1,30 @@
+module Resource
+
+  class Execute < Base
+
+    block_attr :owner, :title, :path
+
+    def initialize title, &block
+      set_base_defaults
+      @path = nil
+      @commands = []
+      @title = title
+      self.instance_eval(&block)
+    end
+
+    def command string
+      @commands << { :command => string, :path => @path }
+    end
+
+    def run
+      Execution.block 'Execution', @title, @owner do |b|
+        b.always_run @always_run
+        @commands.each do |command_hash|
+          b.run "#{command_hash[:command]}", command_hash[:path]
+        end
+      end
+    end
+
+  end
+
+end

data/lib/resource/file.rb

@@ -0,0 +1,33 @@
+module Resource
+
+  class File < Base
+
+    block_attr :content, :owner, :group, :mode, :action, :target
+
+    def initialize target, &block
+      set_base_defaults
+      @target = target
+      self.instance_eval(&block)
+    end
+
+    # Compile any given string into a file remotely!
+    #
+    # 1. try to run everytime
+    # 2. if file exists and current string checksum matches the old
+    #    one skip it!
+    # 3. otherwise just re-compile the file!
+    #
+    def run
+      Execution.block 'Creating a custom file', @target, 'root' do |b|
+        b.always_run true
+        b.run "mkdir -p #{::File.dirname(@target)}"
+        ::File.open(@target, 'w+') { |file| file.write @content }
+        b.run "chown #{@owner}:#{@owner} #{::File.dirname(@target)}"
+        b.run "chown #{@owner}:#{@owner} #{@target}"
+        b.run "chmod #{unix_mode} #{@target}"
+      end
+    end
+
+  end
+
+end

data/lib/resource/gem.rb

@@ -0,0 +1,27 @@
+module Resource
+
+  class Gem < Base
+
+    block_attr :version, :source, :action, :owner, :name
+
+    def initialize name, &block
+      set_base_defaults
+      @owner = 'root'
+      @name = name
+      self.instance_eval(&block)
+    end
+
+    def run
+      command = []
+      command << "gem install #{@name}"
+      command << "--source #{@source}" if @source
+      command << "--version #{@version}" if @version
+      Execution.block 'Installing gem', @name, @owner do |b|
+        b.always_run @always_run
+        b.run(command * ' ')
+      end
+    end
+
+  end
+
+end

data/lib/resource/git.rb

@@ -0,0 +1,102 @@
+module Resource
+
+  class Git < Base
+
+    block_attr :owner, :repository, :sandbox_path, :sandbox_name
+    block_attr :branch, :release_path, :timestamped, :swaping_branch
+    block_attr :capsule_object
+
+    def initialize repository, &block
+      set_base_defaults
+      @repository      = repository
+      @sandbox_path    = '/tmp'
+      @sandbox_name    = 'repository_sandbox'
+      @always_run      = true
+      @timestamped     = true
+      @swaping_branch  = 'master'
+      self.instance_eval(&block)
+    end
+
+    def run
+      clone unless cloned?
+      fetch_and_pull
+      revision = revision(@branch)
+      checkout revision
+      key = @timestamped ? Time.now.strftime('%Y%m%d%H%M%S') : revision
+      my_release_path = @release_path + key
+      relocate my_release_path
+      encapsulate_object revision, my_release_path, key
+    end
+
+    protected
+
+    def encapsulate_object revision, my_release_path, key
+      @capsule_object.release_path = my_release_path
+      @capsule_object.revision     = revision
+      @capsule_object.key          = key
+    end
+
+    def clone args = []
+      Execution.block 'Cloning repository', @owner do |b|
+        b.always_run @always_run
+        b.run "git clone #{args.join(' ')} #{@repository} #{@sandbox_path}/#{@sandbox_name}", @sandbox_path
+      end
+    end
+
+    def fetch_and_pull
+      Execution.block 'Updating existing repository changes', @repository, @owner do |b|
+        b.always_run @always_run
+        b.run "git checkout #{@swaping_branch}", checkout_location
+        b.run 'git fetch', checkout_location
+        b.run 'git pull', checkout_location
+      end
+    end
+
+    def relocate target
+      Execution.block 'Installing snapshot of checkout', @owner, @owner do |b|
+        b.always_run @always_run
+        b.run "touch #{target}"
+        b.run "rm -rf #{target}"
+        b.run "cp -r #{checkout_location} #{target}"
+        b.run "ls #{target} | column"
+      end
+    end
+
+    def revision branch
+      return @revision if @revision
+      Execution.block "Extracting revision hash for", branch, @owner do |b|
+        b.always_run @always_run
+        b.run "git ls-remote #{@repository} #{branch}"
+      end
+      @revision = `sudo -u #{@owner} git ls-remote #{@repository} #{branch}`
+      @revision = (@revision.scan /[a-zA-Z0-9]{40}/).first
+    end
+
+    def checkout revision
+      Execution.block "Using revision to create new branch", "#{revision} ~> #{@owner}", @owner do |b|
+        b.always_run @always_run
+        b.run "git checkout #{@swaping_branch}", checkout_location
+        b.run "git branch -f #{@owner}", checkout_location
+        b.run "git branch -D #{@owner}", checkout_location
+        b.run "git checkout -b #{@owner} #{revision}", checkout_location
+      end
+    end
+
+    def checkout_location
+      "#{@sandbox_path}/#{@sandbox_name}"
+    end
+
+    def remove
+      Execution.block "Removing existing copy of repository: #{checkout_location}", @owner do |b|
+        b.always_run @always_run
+        b.run "rm -rf #{checkout_location}"
+      end
+    end
+
+    def cloned?
+      ::File.exist? checkout_location
+    end
+
+  end
+
+end

data/lib/resource/group.rb

@@ -0,0 +1,28 @@
+module Resource
+
+  class Group < Base
+
+    block_attr :groupname, :gid
+
+    def initialize groupname, &block
+      set_base_defaults
+      @groupname = groupname
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Creating new group', @groupname, 'root' do |b|
+        b.always_run @always_run
+        groups = `cat /etc/group | cut -d: -f1`
+        groups = groups.scan(/[a-zA-Z\-_]+/)
+        if groups.include? @groupname
+          Output.warn 'Aborted, I think this group already exists', groups.inspect
+        else
+          b.run "groupadd -g #{@gid} #{@groupname}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/resource/hook.rb

@@ -0,0 +1,25 @@
+module Resource
+
+  class Hook < Base
+
+    def initialize target, binding
+      @target = target
+      @binding = binding
+    end
+
+    def run
+      if ::File.exist?(@target)
+        Output.info 'Hook found', @target
+        eval(::File.read(@target), @binding)
+      else
+        Output.warn 'Hook not found', @target
+      end
+    end
+
+    def should_skip?
+      false
+    end
+
+  end
+
+end

data/lib/resource/link.rb

@@ -0,0 +1,27 @@
+module Resource
+
+  class Link < Base
+
+    block_attr :source, :to, :owner, :group
+
+    def initialize source, &block
+      set_base_defaults
+      @source = source
+      @to = 'no_target'
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Building Link', "#{@source} ~> #{@to}", @owner do |b|
+        b.always_run @always_run
+        b.run "mkdir -p #{::File.dirname(@to)}"
+        b.run "mkdir -p #{::File.dirname(@source)}" unless ::File.exist?(::File.dirname(@source))
+        b.run "touch #{@source}"
+        b.run "rm -rf #{@source}"
+        b.run "ln -s #{@to} #{@source}"
+      end
+    end
+
+  end
+
+end

data/lib/resource/package.rb

@@ -0,0 +1,26 @@
+module Resource
+
+  class Package < Base
+
+    block_attr :action, :package_name, :owner
+
+    def initialize package_name, &block
+      set_base_defaults
+      @package_name = package_name
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Installing Package', @package_name, @owner do |b|
+        b.always_run @always_run
+        b.run "apt-get install -y #{@package_name}"
+      end
+    end
+
+    def value_for_platform *args
+      @package_name
+    end
+
+  end
+
+end

data/lib/resource/remote_file.rb

@@ -0,0 +1,44 @@
+module Resource
+
+  class RemoteFile < Base
+
+    block_attr :owner, :group, :mode, :source
+
+    # Install a static local file into a remote server.
+    def initialize target, &block
+      set_base_defaults
+      @pattern = 'cookbooks/*/files/default/'
+      @target = target
+      self.instance_eval(&block)
+    end
+
+    def content
+      (Dir[@pattern + '*'] + Dir[@pattern + '*.*']).each do |file|
+        return ::File.read(file) if file.include? @source
+      end
+      'Resource was not found'
+    end
+
+    def run
+      Execution.block 'Creating a remote file', @target, @owner do |b|
+        if ::File.exist? @target
+          sums_equal = MD5.hexdigest(::File.read(@target)) == MD5.hexdigest(content)
+        else
+          sums_equal = false
+          @always_run = true
+        end
+        if sums_equal
+          Output.warn 'Skipping', 'checksum comparison matches'
+        else
+          Output.warn 'Generating file with ruby', @target
+          ::File.open(@target, 'w+') { |file| file.write content }
+          b.always_run @always_run
+          b.run "chown #{@owner}:#{@group} #{@target}"
+          b.run "chmod #{unix_mode} #{@target}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/resource/service.rb

@@ -0,0 +1,23 @@
+module Resource
+
+  class Service < Base
+
+    block_attr :action
+
+    def initialize name, &block
+      set_base_defaults
+      @name       = name
+      @always_run = true
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block "Changing #{@name} service", @action, 'root' do |b|
+        b.always_run @always_run
+        b.run "/etc/init.d/#{@name} #{@action}"
+      end
+    end
+
+  end
+
+end

data/lib/resource/swap_release.rb

@@ -0,0 +1,25 @@
+module Resource
+
+  class SwapRelease < Base
+
+    block_attr :owner, :release_path, :current
+
+    def initialize release_path, &block
+      set_base_defaults
+      @release_path = release_path
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Swaping releases', "#{@current} ~> #{@release_path}", 'root' do |b|
+        b.always_run true
+        b.run "touch #{@current.chop}"
+        b.run "rm #{@current.chop}"
+        b.run "ln -s #{@release_path} #{@current.chop}"
+        b.run "chown #{@owner}:#{@owner} #{@current.chop}"
+      end
+    end
+
+  end
+
+end

data/lib/resource/template.rb

@@ -0,0 +1,68 @@
+require 'erubis'
+
+module Resource
+
+  class Template < Base
+
+    class_attr :source
+
+    block_attr :owner, :group, :mode, :source, :action, :variables, :backup, :target
+
+    PREFIX = ''
+
+    def run
+      Execution.block 'Compiling template file', @target, @owner do |b|
+        compile!
+        b.always_run @always_run
+      end
+      Execution.block 'Ensuring file permissions', @target, 'root' do |b|
+        b.run "chown #{@owner}:#{@owner} #{@target}"
+        b.run "chmod #{unix_mode} #{@target}"
+        b.always_run @always_run
+      end
+    end
+
+    protected
+
+    def initialize target, &block
+      set_base_defaults
+      @target = target
+      ensure_target_zone
+      self.instance_eval(&block)
+    end
+
+    def target_path
+      "#{PREFIX}#{@target}"
+    end
+
+    def needs_compilation?
+      return true unless ::File.exist?(target_path)
+      MD5.hexdigest(::File.read target_path) != MD5.hexdigest(compile_template)
+    end
+
+    def compile!
+      Output.info 'Erubis is compiling', target_path
+      ::File.open(target_path, 'w+') { |file| file.write(compile_template) }
+    end
+
+    def ensure_target_zone
+      system "mkdir -p #{PREFIX}#{::File.dirname(@target)}"
+      true
+    end
+
+    def find_source
+      Dir['cookbooks/*/templates/*/*.*'].each do |file|
+        return file if file.include? ::File.basename(@source)
+      end
+    end
+
+    def compile_template
+      @compile_template ||=
+      Erubis::Eruby.new(::File.read(find_source)).evaluate(
+        { :node => Node.get }.merge(@variables || {})
+      )
+    end
+
+  end
+
+end

data/lib/resource/user.rb

@@ -0,0 +1,29 @@
+module Resource
+
+  class User < Base
+
+    block_attr :password, :uid, :gid, :shell, :action, :username
+
+    def initialize username, &block
+      set_base_defaults
+      @username = username
+      @shell = '/bin/bash'
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Creating new user', @username, @owner do |b|
+        b.always_run @always_run
+        users = `cat /etc/passwd | grep "/home" |cut -d: -f1`
+        users = users.scan(/[a-zA-Z\-_]+/)
+        if users.include? @username
+          Output.warn 'Aborted, I think this user already exists', users.inspect
+        else
+          b.run "useradd -b /home  -u #{@uid} -s #{@shell} -g #{@username} -m -k /home/#{@username} #{@username}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/resource/version.rb

@@ -0,0 +1,42 @@
+module Resource
+
+  class Version < Base
+
+    block_attr :location, :current_version, :deployed_by, :deployed_time
+    block_attr :server_info, :environment, :branch, :ip, :copy_to, :owner
+    block_attr :reset
+
+    def initialize location, &block
+      set_base_defaults
+      @location = location
+      @current_version  = 'n/a'
+      @deployed_by      = 'n/a'
+      @server_info      = 'n/a'
+      @environment      = 'n/a'
+      @branch           = 'n/a'
+      @ip               = 'n/a'
+      @copy_to          = '/tmp/'
+      @version = ::Deploy::Version.new
+      self.instance_eval(&block)
+    end
+
+    def run
+      Execution.block 'Deployment version file', @location, 'root' do |b|
+        b.always_run true
+        @version.deployed_by         = @deployed_by
+        @version.current_version     = @current_version
+        @version.add :server_info,     @server_info
+        @version.add :environment,     @environment
+        @version.add :branch,          @branch
+        @version.add :reset,           @reset
+        @version.add :ip,              @ip
+        @version.store_to_file @location
+        Output.info 'Copying version file to', @copy_to
+        b.run "cp #{@location} #{@copy_to}"
+        b.run "chown #{@owner}:#{@owner} #{@copy_to}/#{::File.basename(@location)}"
+      end
+    end
+
+  end
+
+end

data/lib/resource.rb

@@ -0,0 +1,20 @@
+
+module Resource; end
+
+require 'lib/resource/base'
+require 'lib/resource/cron'
+require 'lib/resource/directory'
+require 'lib/resource/execute'
+require 'lib/resource/file'
+require 'lib/resource/gem'
+require 'lib/resource/git'
+require 'lib/resource/group'
+require 'lib/resource/hook'
+require 'lib/resource/link'
+require 'lib/resource/package'
+require 'lib/resource/remote_file'
+require 'lib/resource/service'
+require 'lib/resource/swap_release'
+require 'lib/resource/template'
+require 'lib/resource/user'
+require 'lib/resource/version'

data/lib/runtime_error.rb

@@ -0,0 +1,8 @@
+class RuntimeError
+
+  def initialize *args
+    Status.save
+    super
+  end
+
+end

data/lib/status.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'hashie'
+require 'lib/output'
+
+class Status; end
+
+class << Status
+
+  # TODO: extract this from class
+  FILE = '/tmp/deployment/env/status'
+
+  def load_or_create
+    Output.info 'Loading status file', FILE
+    `mkdir -p #{File.dirname(FILE)}`
+    (File.exist? FILE) ? eval(File.read(FILE)) : {}
+  end
+
+  def get
+    @status ||= Hashie::Mash.new(load_or_create)
+  end
+
+  def reload!
+    Output.jump
+    Output.info 'Reloading status', FILE
+    save
+    @status = nil
+  end
+
+  def save
+    Output.info 'Saving deployment status to file', FILE
+    File.open(FILE, 'w+') do |file|
+      file.write Status.get.to_hash.inspect
+    end
+  end
+
+end
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: atesta
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 29
   prerelease: false
   segments: 
   - 0
   - 0
-  - 0
-  version: 0.0.0
+  - 1
+  version: 0.0.1
 platform: ruby
 authors: 
 - kazuyoshi tlacaelel
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-26 00:00:00 -05:00
+date: 2011-11-29 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,6 +49,35 @@ files:
 - Rakefile
 - VERSION
 - lib/atesta.rb
+- lib/block_attr.rb
+- lib/class_attr.rb
+- lib/execution.rb
+- lib/hash.rb
+- lib/lock.rb
+- lib/node.rb
+- lib/output.rb
+- lib/recipe.rb
+- lib/release_window.rb
+- lib/resource.rb
+- lib/resource/base.rb
+- lib/resource/cron.rb
+- lib/resource/directory.rb
+- lib/resource/execute.rb
+- lib/resource/file.rb
+- lib/resource/gem.rb
+- lib/resource/git.rb
+- lib/resource/group.rb
+- lib/resource/hook.rb
+- lib/resource/link.rb
+- lib/resource/package.rb
+- lib/resource/remote_file.rb
+- lib/resource/service.rb
+- lib/resource/swap_release.rb
+- lib/resource/template.rb
+- lib/resource/user.rb
+- lib/resource/version.rb
+- lib/runtime_error.rb
+- lib/status.rb
 - test/helper.rb
 - test/test_atesta.rb
 has_rdoc: true