BackupMan 0.1.1 → 0.1.2

data/.gitignore

@@ -19,5 +19,5 @@ rdoc
 pkg
 doc
 .yardoc
-*.gemspec
+tmp/
 ## PROJECT::SPECIFIC

data/Rakefile

@@ -12,7 +12,8 @@ begin
     gem.authors = ["Markus Strauss"]
     gem.rubyforge_project = "backupman"
     gem.add_development_dependency "rspec", ">= 1.2.9"
-    gem.add_development_dependency "yard", ">= 0"
+    gem.add_development_dependency "yard", ">= 0.4.0"
+    gem.add_development_dependency "cucumber", ">= 0.4.4"
     gem.add_dependency "log4r", ">= 1.1.2"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
@@ -39,7 +40,18 @@ end
 
 task :spec => :check_dependencies
 
-task :default => :spec
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :features
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.2

data/features/development.feature

@@ -0,0 +1,18 @@
+Feature: Development processes of BackupMan itself (rake tasks)
+
+  As a BackupMan maintainer or contributor
+  I want rake tasks to maintain and release the gem
+  So that I can spend time on the tests and code, and not excessive time on maintenance processes
+    
+  Scenario: Generate RubyGem
+    Given this project is active project folder
+    And "pkg" folder is deleted
+    When I invoke task "rake build"
+    Then folder "pkg" is created
+    And file with name matching "pkg/*.gem" is created
+    # And gem spec key "rdoc_options" contains /--mainREADME.rdoc/
+
+  Scenario: Test specs
+    Given this project is active project folder
+    When I invoke task "rake spec"
+    Then I should see all 2 examples pass

data/features/dsl_parameters.feature

@@ -0,0 +1,33 @@
+Feature: The DSL supports various parameters
+  
+  Scenario Outline: Presence of DSL parameters
+    Given the task is "<task>"
+    And the parameters are "<parameters>"
+    And that goes into file "tmp/configuration_file"
+    And this project is active project folder
+    When I run project executable "./bin/backup_man" with arguments "-t tmp/configuration_file"
+    Then the result should be <result>
+    
+    Scenarios: full set, all parameters are provided and existent (valid)
+      | task  | parameters                                        | result |
+      | Tar   | onlyif, backup, to, user, host, filename, options | ok     |
+      | Mysql | onlyif, backup, to, user, host, filename, options | ok     |
+      | Rsync | onlyif, backup, to, user, host,           options | ok     |
+    
+    Scenarios: full set, but invalid parameters are present
+      | task  | parameters                                                           | result                                       |
+      | Tar   | onlyif, backup, to, user, host, filename, options, invalid_parameter | fatal "undefined method `invalid_parameter'" |
+      | Mysql | onlyif, backup, to, user, host, filename, options, invalid_parameter | fatal "undefined method `invalid_parameter'" |
+      | Rsync | onlyif, backup, to, user, host,           options, invalid_parameter | fatal "undefined method `invalid_parameter'" |
+   
+    Scenarios: minimal set, all required parameters are provided
+      | task  | parameters  | result |
+      | Tar   | backup      | ok     |
+      | Mysql |             | ok     |
+      | Rsync | backup      | ok     |
+  
+    Scenarios: one required parameter is missing
+      | task  | parameters                                | result                                          |
+      | Tar   | onlyif, to, user, host, filename, options | error "A required parameter is missing: backup" |
+      | Rsync | onlyif, to, user, host, options           | error "A required parameter is missing: backup" |
+  

data/features/logfile.feature

@@ -0,0 +1,30 @@
+Feature: logfile
+  In order to have a log of the BackupMan's doings
+  BackupMan should write to a logfile
+    
+  Scenario: the logfile is writable
+    Given the logfile is writeable
+    And the user has not used option '-h'
+    When I start BackupMan
+    Then the logfile should become updated
+    
+  Scenario: the logfile is not writeable
+    Given the logfile is not writeable
+    And the user has not used option '-h'
+    When I start BackupMan
+    Then error "logfile not writable" should be printed
+    
+  Scenario: logfile parameter given, and writeable
+    When I start BackupMan with parameter "-l /path/to/logfile"
+    And the file "path/to/logfile" is writeable
+    Then the logfile should become updated
+    
+  Scenario: logfile parameter given, and not writeable
+    When I start BackupMan with parameter "-l /path/to/logfile"
+    And the file "path/to/logfile" is not writeable
+    And the directory "path/to" is not writeable
+    Then error "logfile not writable" should be printed
+
+  Scenario: no logfile parameter given
+    When I start BackupMan
+    Then "/var/log/backup_man.log" should be used as the default logfile

data/features/overview.feature

@@ -0,0 +1,16 @@
+### Primary features
+Feature: BackupMan can do tar backups from remote hosts
+Feature: BackupMan can do rsync backups from remote hosts
+Feature: BackupMan can do mysql dumps from remote hosts
+# Feature: BackupMan can cleanup backups it has created
+# Feature: BackupMan keeps a database of all backups it has created in order to make safe cleanups
+Feature: BackupMan per default is completely silent when everything runs smoothly
+# Feature: BackupMan can do "dry runs" in order for the user to know that the program will do
+
+### Secondary features
+Feature: BackupMan can print its usage
+Feature: BackupMan uses a log file
+Feature: BackupMan can be configured to use a custom logfile
+Feature: BackupMan can print debug messages on screen and in the logfile when requested
+Feature: BackupMan uses convention over configuration, has reasonable defaults whenever possible
+# Feature: To provide reasonable defaults, BackupMan evaluates what kind of OS the remote is

data/features/step_definitions/common_steps.rb

@@ -0,0 +1,163 @@
+Given /^this project is active project folder/ do
+  @active_project_folder = File.expand_path(File.dirname(__FILE__) + "/../..")
+end
+
+Given /^env variable \$([\w_]+) set to "(.*)"/ do |env_var, value|
+  ENV[env_var] = value
+end
+
+Given /"(.*)" folder is deleted/ do |folder|
+  in_project_folder { FileUtils.rm_rf folder }
+end
+
+When /^I invoke "(.*)" generator with arguments "(.*)"$/ do |generator, arguments|
+  @stdout = StringIO.new
+  in_project_folder do
+    if Object.const_defined?("APP_ROOT")
+      APP_ROOT.replace(FileUtils.pwd)
+    else 
+      APP_ROOT = FileUtils.pwd
+    end
+    run_generator(generator, arguments.split(' '), SOURCES, :stdout => @stdout)
+  end
+  File.open(File.join(@tmp_root, "generator.out"), "w") do |f|
+    @stdout.rewind
+    f << @stdout.read
+  end
+end
+
+When /^I run executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "#{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run project executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I run local executable "(.*)" with arguments "(.*)"/ do |executable, arguments|
+  @stdout = File.expand_path(File.join(@tmp_root, "executable.out"))
+  executable = File.expand_path(File.join(File.dirname(__FILE__), "/../../bin", executable))
+  in_project_folder do
+    system "ruby #{executable} #{arguments} > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+When /^I invoke task "rake (.*)"/ do |task|
+  @stdout = File.expand_path(File.join(@tmp_root, "tests.out"))
+  in_project_folder do
+    system "rake #{task} --trace > #{@stdout} 2> #{@stdout}"
+  end
+end
+
+Then /^folder "(.*)" (is|is not) created/ do |folder, is|
+  in_project_folder do
+    File.exists?(folder).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file "(.*)" (is|is not) created/ do |file, is|
+  in_project_folder do
+    File.exists?(file).should(is == 'is' ? be_true : be_false)
+  end
+end
+
+Then /^file with name matching "(.*)" is created/ do |pattern|
+  in_project_folder do
+    Dir[pattern].should_not be_empty
+  end
+end
+
+Then /^file "(.*)" contents (does|does not) match \/(.*)\// do |file, does, regex|
+  in_project_folder do
+    actual_output = File.read(file)
+    (does == 'does') ?
+      actual_output.should(match(/#{regex}/)) :
+      actual_output.should_not(match(/#{regex}/))
+  end
+end
+
+Then /gem file "(.*)" and generated file "(.*)" should be the same/ do |gem_file, project_file|
+  File.exists?(gem_file).should be_true
+  File.exists?(project_file).should be_true
+  gem_file_contents = File.read(File.dirname(__FILE__) + "/../../#{gem_file}")
+  project_file_contents = File.read(File.join(@active_project_folder, project_file))
+  project_file_contents.should == gem_file_contents
+end
+
+Then /^(does|does not) invoke generator "(.*)"$/ do |does_invoke, generator|
+  actual_output = File.read(@stdout)
+  does_invoke == "does" ?
+    actual_output.should(match(/dependency\s+#{generator}/)) :
+    actual_output.should_not(match(/dependency\s+#{generator}/))
+end
+
+Then /help options "(.*)" and "(.*)" are displayed/ do |opt1, opt2|
+  actual_output = File.read(@stdout)
+  actual_output.should match(/#{opt1}/)
+  actual_output.should match(/#{opt2}/)
+end
+
+Then /^I should see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should contain(text)
+end
+
+Then /^I should not see$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should_not contain(text)
+end
+
+Then /^I should see exactly$/ do |text|
+  actual_output = File.read(@stdout)
+  actual_output.should == text
+end
+
+Then /^I should see all (\d+) tests pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} tests, \d+ assertions, 0 failures, 0 errors}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^I should see all (\d+) examples pass/ do |expected_test_count|
+  expected = %r{^#{expected_test_count} examples?, 0 failures}
+  actual_output = File.read(@stdout)
+  actual_output.should match(expected)
+end
+
+Then /^yaml file "(.*)" contains (\{.*\})/ do |file, yaml|
+  in_project_folder do
+    yaml = eval yaml
+    YAML.load(File.read(file)).should == yaml
+  end
+end
+
+Then /^Rakefile can display tasks successfully/ do
+  @stdout = File.expand_path(File.join(@tmp_root, "rakefile.out"))
+  in_project_folder do
+    system "rake -T > #{@stdout} 2> #{@stdout}"
+  end
+  actual_output = File.read(@stdout)
+  actual_output.should match(/^rake\s+\w+\s+#\s.*/)
+end
+
+Then /^task "rake (.*)" is executed successfully/ do |task|
+  @stdout.should_not be_nil
+  actual_output = File.read(@stdout)
+  actual_output.should_not match(/^Don't know how to build task '#{task}'/)
+  actual_output.should_not match(/Error/i)
+end
+
+Then /^gem spec key "(.*)" contains \/(.*)\// do |key, regex|
+  in_project_folder do
+    gem_file = Dir["pkg/*.gem"].first
+    gem_spec = Gem::Specification.from_yaml(`gem spec #{gem_file}`)
+    spec_value = gem_spec.send(key.to_sym)
+    spec_value.to_s.should match(/#{regex}/)
+  end
+end

data/features/step_definitions/dsl_parameters_steps.rb

@@ -0,0 +1,81 @@
+
+def defaults
+  {
+    "onlyif" => "'true'",
+    "backup" => "['/']",
+    "to"     => "'to'",
+    "user"   => "'user'",
+    "host"   => "'host'",
+    "filename" => "'filename'",
+    "options"  => "'options'"
+  }
+end
+
+Given /^the task is "([^\"]*)"$/ do |task|
+  @subject = task
+end
+
+Given /^the parameters are "([^\"]*)"$/ do |parameters|
+  @parameters = parameters.split(",").map{ |p| p.strip }
+end
+
+Given /^that goes into file "([^\"]*)"$/ do |configfile|
+  f = File.open(configfile, "w") do |f|
+    f.puts "#{@subject}.new('test') do |b|"
+    @parameters.each { |par| f.puts "  b.#{par} #{defaults[par]}"}
+    f.puts "end"
+  end
+end
+
+Then /^the result should be ok$/ do
+  steps %Q{
+    Then I should not see any output
+    And the exit code should be 0
+  }
+end
+
+Then /^the result should be error$/ do
+  steps %Q{
+    Then I should see some output
+  }
+end
+
+Then /^the result should be fatal$/ do
+  steps %Q{
+    Then I should see some output
+    And the exit code should not be 0
+  }
+end
+
+Then /^the result should be error "([^\"]*)"$/ do |error|
+  steps %Q{
+    Then I should see
+      """
+      #{error}
+      """
+  }
+end
+
+Then /^the result should be fatal "([^\"]*)"$/ do |error|
+  steps %Q{
+    Then I should see
+      """
+      #{error}
+      """
+    And the exit code should not be 0
+  }
+end
+
+Then /^the exit code (should|should not) be (.+)$/ do |should, code|
+  $?.method(:should) == code
+end
+
+Then /^Then I should see some output$/ do
+  actual_output = File.read(@stdout)
+  actual_output.should_not == ""
+end
+
+Then /^I should not see any output$/ do
+  actual_output = File.read(@stdout)
+  actual_output.should == ""
+end

data/features/support/common.rb

@@ -0,0 +1,29 @@
+module CommonHelpers
+  def in_tmp_folder(&block)
+    FileUtils.chdir(@tmp_root, &block)
+  end
+
+  def in_project_folder(&block)
+    project_folder = @active_project_folder || @tmp_root
+    FileUtils.chdir(project_folder, &block)
+  end
+
+  def in_home_folder(&block)
+    FileUtils.chdir(@home_path, &block)
+  end
+
+  def force_local_lib_override(project_name = @project_name)
+    rakefile = File.read(File.join(project_name, 'Rakefile'))
+    File.open(File.join(project_name, 'Rakefile'), "w+") do |f|
+      f << "$:.unshift('#{@lib_path}')\n"
+      f << rakefile
+    end
+  end
+
+  def setup_active_project_folder project_name
+    @active_project_folder = File.join(@tmp_root, project_name)
+    @project_name = project_name
+  end
+end
+
+World(CommonHelpers)

data/features/support/env.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + "/../../lib/backup_man"
+
+gem 'cucumber'
+require 'cucumber'
+gem 'rspec'
+require 'spec'
+
+Before do
+  @tmp_root = File.dirname(__FILE__) + "/../../tmp"
+  @home_path = File.expand_path(File.join(@tmp_root, "home"))
+  FileUtils.rm_rf   @tmp_root
+  FileUtils.mkdir_p @home_path
+  ENV['HOME'] = @home_path
+end

data/features/support/matchers.rb

@@ -0,0 +1,11 @@
+module Matchers
+  def contain(expected)
+    simple_matcher("contain #{expected.inspect}") do |given, matcher|
+      matcher.failure_message = "expected #{given.inspect} to contain #{expected.inspect}"
+      matcher.negative_failure_message = "expected #{given.inspect} not to contain #{expected.inspect}"
+      given.index expected
+    end
+  end
+end
+
+World(Matchers)

data/lib/backup_man/backup.rb

@@ -1,10 +1,11 @@
 require 'backup_man/backup_man'
 require 'backup_man/dsl'
+require 'fileutils'
 
 module BackupMan
 
   def self.log_end_of_operation
-    Log.instance.info( "Finished #{self}." )
+    Log.info( "Finished #{self}." )
   end
 
   # we wanna log when the program ends
@@ -13,30 +14,32 @@ module BackupMan
 
   # References: _Design Patterns in Ruby_ by Russ Olsen
   class Backup
-    
+
     # the name of our backup set; this is used for generating a default
     # backup_directory; e.g. use the hostname of the machine to backup
     attr_reader   :name
-    
+
     # where shall our backup data go (directory path)
     attr_reader   :backup_directory
-    
+
     # user name of the remote machine (defaults to 'root')
     attr_accessor :user
-    
+
     # hostname of the remote machine (defaults to job definition name)
     attr_accessor :host
-    
+
     # DSL for conditional execution
     include DSL
-    
+
     def_dsl :onlyif
+    def_dsl_required :onlyif
+
     def_dsl :backup, :data_sources
-    def_dsl :to, :backup_directory
-    def_dsl :user
-    def_dsl :host
-    
-    
+    def_dsl :to, :backup_directory, true
+    def_dsl :user, :user, true
+    def_dsl :host, :user, true
+
+
     # this method sets all the default values but does not overwrite existing
     # settings; this method cannot be called in the initializer of Backup
     # because the default values are not available at that time;
@@ -55,50 +58,63 @@ module BackupMan
       yield(self) if block_given?
       BackupMan.instance.register_backup( self )
     end
-    
+
     # calling this actually runs the backup; DO NOT override this; override
     # _run instead
     def run
       log_begin_of_run
       set_defaults
       debug_log_dsl_info
+      unless missing_required_parameters.empty?
+        Log.error( "#{self}: A required parameter is missing: #{missing_required_parameters.join ' '}")
+        return
+      end
       onlyif = eval( @onlyif )
-      Log.instance.debug( "onlyif = { #{@onlyif} } evaluates #{onlyif}" )
+      Log.debug( "onlyif = { #{@onlyif} } evaluates #{onlyif}" )
       if onlyif
         unless @backup_directory
-          Log.instance.error( "#{self}: No backup directory. Don't know where to store all this stuff.")
+          Log.error( "#{self}: No backup directory. Don't know where to store all this stuff.")
         else
           FileUtils.mkdir_p @backup_directory
           _run
         end
       else
-        Log.instance.info( "#{self}: Preconditions for backup run not fulfilled.")
+        Log.info( "#{self}: Preconditions for backup run not fulfilled.")
       end
       log_end_of_run
     end
-    
+
     # @return [String]
     def to_s
       "#{self.class} #{self.name}"
     end
 
 
-    
+
     private
-    
+
     # @abstract override this to implement the actual backup commands
     def _run
       throw "Hey. Cannot run just 'Backup'."
     end
-    
+
+    # @return [Array of Strings] of missing parameters
+    def missing_required_parameters
+      missing = []
+      self.class.dsl_methods.each do |name, var, mandatory|      
+        missing << name if mandatory && self.instance_variable_get("@#{var}").empty?
+      end
+      missing
+    end
+
     # not used acutally
     def log_begin_of_run
-      Log.instance.info( "Starting #{self.class} run for #{@name}." )
+      Log.info( "Starting #{self.class} run for #{@name}." )
     end
-    
+
     # simply logs that the program terminates
     def log_end_of_run
-      Log.instance.info( "Finished #{self.class} run for #{@name}." )
+      Log.info( "Finished #{self.class} run for #{@name}." )
     end
 
     # @return [String] the ssh command string including user@host

data/lib/backup_man/backup_man.rb

@@ -7,7 +7,7 @@ module BackupMan
 
     include Singleton
     
-    attr_accessor :destdir, :ssh_app, :logfile, :lockdir
+    attr_accessor :destdir, :ssh_app, :logfile, :lockdir, :testing
 
     def initialize
       @backups = []
@@ -22,7 +22,7 @@ module BackupMan
         begin
           backup.run
         rescue Interrupt
-          Log.instance.warn( "Interrupt: Cancelling remaining operations.")
+          Log.warn( "Interrupt: Cancelling remaining operations.")
           return
         end
       end        

data/lib/backup_man/cli.rb

@@ -16,6 +16,7 @@ module BackupMan
 
       options = {
         :debug     => false,
+        :testing   => false,
         :logpath   => '/var/log/backup_man.log'
       }
       mandatory_options = %w(  )
@@ -37,6 +38,9 @@ module BackupMan
         }
         opts.on("-h", "--help",
                 "Show this help message.") { stdout.puts opts; exit }
+        opts.on("-t", "--test", "Testing mode.", "No actions will be performed. Just to test if the config parses fine." ) {
+          options[:testing] = true
+        }
         opts.parse!(arguments)
 
         if mandatory_options && mandatory_options.find { |option| options[option.to_sym].nil? }
@@ -45,27 +49,28 @@ module BackupMan
       end
 
       # doing our stuff here
+      BackupMan.instance.testing = options[:testing]
       
       # first we check if our logfile is writeable; if not, we give a warning
       logfile = Pathname.new( options[:logpath] )
       if (logfile.exist? && logfile.writable?) || logfile.parent.writable?
         BackupMan.instance.logfile = logfile.to_s
       else
-        Log.instance.warn( "Log file is not writeable: #{logfile}.")
+        Log.warn( "Log file is not writeable: #{logfile}.")
       end
       
       # root-warning
-      Log.instance.warn( "Please do not run this program as root.") if `id -u`.strip == '0'
+      Log.warn( "Please do not run this program as root.") if `id -u`.strip == '0'
 
       # reconfigure our Logger for debugging if necessary
       if options[:debug]
-        Log.instance.enable_debugmode
-        Log.instance.debug( "Debugging mode enabled.")
+        Log.enable_debugmode
+        Log.debug( "Debugging mode enabled.")
       end
       
 
       unless ARGV[0]
-        Log.instance.fatal( "No config file given." )
+        Log.fatal( "No config file given." )
         stdout.puts parser
         exit 1
       else
@@ -73,24 +78,30 @@ module BackupMan
         config_filepath = Pathname.new "/etc/backup_man/#{config_filepath}" unless config_filepath.file?
         
         unless config_filepath.file?
-          Log.instance.fatal( "Config file not found [#{config_filepath}].")
+          Log.fatal( "Config file not found [#{config_filepath}].")
           exit 2
         end
 
         # get and evaluate the config file; errors in the config file may be
         # difficult to debug, so be careful
-        Log.instance.debug( "Reading file '#{config_filepath}'.")
-        eval( File.read( config_filepath ) )
+        Log.debug( "Reading file '#{config_filepath}'.")
+        
+        begin
+          eval( File.read( config_filepath ) )
+        rescue NoMethodError
+          Log.fatal( $! )
+          exit 3
+        end
 
         # configure global defaults
         BackupMan.instance.set_default( :destdir, '/var/backups/backup_man')
         BackupMan.instance.set_default( :lockdir, '/var/lock/backup_man')
         BackupMan.instance.set_default( :ssh_app, 'ssh')
         
-        Log.instance.debug( "Global settings:")
-        Log.instance.debug( "  DESTDIR = #{BackupMan.instance.destdir}")
-        Log.instance.debug( "  LOCKDIR = #{BackupMan.instance.lockdir}")
-        Log.instance.debug( "  SSH_APP = #{BackupMan.instance.ssh_app}")
+        Log.debug( "Global settings:")
+        Log.debug( "  DESTDIR = #{BackupMan.instance.destdir}")
+        Log.debug( "  LOCKDIR = #{BackupMan.instance.lockdir}")
+        Log.debug( "  SSH_APP = #{BackupMan.instance.ssh_app}")
 
         # run the whole thing
         BackupMan.instance.run

data/lib/backup_man/command.rb

@@ -37,16 +37,16 @@ module BackupMan
       unless locked?
         lock
         begin
-          Log.instance.info( "#{self}: Running.")
-          print `#{cmd}` unless TESTING
+          Log.info( "#{self}: Running.")
+          print `#{cmd}` unless BackupMan.instance.testing
         rescue Interrupt
-          Log.instance.warn( "#{self}: Operation interrupted.")
+          Log.warn( "#{self}: Operation interrupted.")
           raise
         ensure
           unlock
         end
       else
-        Log.instance.warn( "Command already running: #{self}." )
+        Log.warn( "Command already running: #{self}." )
       end
     end
 
@@ -54,19 +54,19 @@ module BackupMan
     private
 
     def lock
-      Log.instance.debug( "Locking command " + self.cmd )
+      Log.debug( "Locking command " + self.cmd )
       unless locked?
         f = File.new( self.lockfile, "w" )
         # FIXME: command output shall go into the correct logging lvl (eg ERROR)
         f.write(self.cmd)
         f.close
       else
-        Log.instance.info( "Lockfile exists: " + lockfile )
+        Log.info( "Lockfile exists: " + lockfile )
       end
     end
 
     def unlock
-      Log.instance.debug( "Unlocking command " + self.cmd )
+      Log.debug( "Unlocking command " + self.cmd )
       FileUtils.remove_file( self.lockfile )
     end
 

data/lib/backup_man/dsl.rb

@@ -1,43 +1,62 @@
+class Array
+  # @return [Array] a deep copy of self
+  def dclone
+    Marshal.load( Marshal.dump( self ) )
+  end
+end
+
+
 module BackupMan
 
   # use "include DSL" to use this module
   module DSL
-
+    
     # extend host class with class methods when we're included
     def self.included(host_class)
       host_class.extend(ClassMethods)
     end
     
     def debug_log_dsl_info
-      Log.instance.debug( "Job settings:")
+      Log.debug( "Job settings:")
       self.class.dsl_methods.each do |method, var|
-        Log.instance.debug( "  #{method} = #{self.instance_variable_get("@#{var}")}" )
+        Log.debug( "  #{method} = #{self.instance_variable_get("@#{var}")}" )
       end
     end
     
     module ClassMethods
-                  
-      def def_dsl( name, var = name )
+      
+      # @param [String] name
+      # @param [String] variable name, used for internal storage
+      # @param [Boolean] mandatory, true if this var is a required parameter
+      def def_dsl( name, var = name, mandatory = false )
         class_eval( %Q{
           def #{name}( #{var} )
             @#{var} = #{var}
           end
           })
-        register_dsl( name, var )
+        register_dsl( name, var, mandatory )
+      end
+      
+      # @param [Symbol] name of required parameter
+      def def_dsl_required( required_name )
+        self.dsl_methods.each_index do |i|
+          if self.dsl_methods[i][0] == required_name
+            self.dsl_methods[i][2] = true
+          end
+        end
       end
 
-      def register_dsl( name, var )
+      def register_dsl( name, var, mandatory )
         @dsl_methods = [] if @dsl_methods.nil?
-        @dsl_methods << [name, var]
+        @dsl_methods << [name, var, mandatory]
       end
       
       # returns an array of all dsl methods of this and all superclasses
       def dsl_methods
-        dsl_methods = []
-        if self.superclass != Object
-          dsl_methods = dsl_methods | self.superclass.dsl_methods
-        end
-        dsl_methods | @dsl_methods
+        # if we dont have anything yet, we copy from superclass (copying is
+        # necessary beacause we might change the :required setting)
+        @dsl_methods ||= self.superclass.dsl_methods.dclone
+        @dsl_methods
       end
 
 

data/lib/backup_man/log.rb

@@ -39,10 +39,19 @@ module BackupMan
       end
     end
     
+    # globally enable debugmode for all outputters
     def enable_debugmode
       Log4r::Outputter.each_outputter { |outputter| outputter.level = DEBUG }
     end
-
+    
+    # we send all missing methods to our single logger instance
+    def self.method_missing(name, *args)
+      unless args.empty?
+        self.instance.send( name, args )
+      else
+        self.instance.send( name )
+      end
+    end
   end
 
 end

data/lib/backup_man/mysql.rb

@@ -6,9 +6,11 @@ module BackupMan
 
     # we need a name for our backup-file (DSL)
     def_dsl :filename
+    def_dsl_required :filename
     
     # options for the mysqldump run (DSL)
     def_dsl :options
+    def_dsl_required :options
 
     def set_defaults
       super

data/lib/backup_man/rsync.rb

@@ -5,7 +5,10 @@ module BackupMan
   class Rsync < Backup
 
     # options for the rsync run (DSL)
+    def_dsl_required :backup
+    
     def_dsl :options
+    def_dsl_required :options
 
     def set_defaults
       @backup_directory = "#{BackupMan.instance.destdir}/#{@name}/rsync" unless @backup_directory

data/lib/backup_man/tar.rb

@@ -5,8 +5,13 @@ require 'backup_man/dsl'
 module BackupMan
   class Tar < Backup
 
+    def_dsl_required :backup
+    
     def_dsl :filename
+    def_dsl_required :filename
+    
     def_dsl :options
+    def_dsl_required :options
     
     def set_defaults
       super

data/lib/backup_man.rb

@@ -14,5 +14,5 @@ def require_relative(relative_feature)
 end
 
 module BackupMan
-  TESTING = false
+  ::Version = File.read('VERSION')    # used by optparse
 end

data/spec/BackupMan_spec.rb

@@ -16,10 +16,10 @@ module BackupMan
         argv = ["-l", "/tmp/does/not/exist.log"]
         out = StringIO.new
         $stderr = StringIO.new
-        lambda { ::BackupMan::CLI.execute( out, ARGV) }.should_not raise_error SystemExit
+        lambda { ::BackupMan::CLI.execute( out, argv) }.should_not raise_error SystemExit
         $stderr.string.should include("Log file is not writeable")
       end
-            
+
     end
   end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: BackupMan
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Markus Strauss
@@ -9,39 +14,65 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-20 00:00:00 +01:00
+date: 2010-02-26 00:00:00 +01:00
 default_executable: backup_man
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 9
         version: 1.2.9
-    version: 
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
+        segments: 
+        - 0
+        - 4
+        - 4
+        version: 0.4.4
+  type: :development
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: log4r
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 2
         version: 1.1.2
-    version: 
+  type: :runtime
+  version_requirements: *id004
 description: A tool for system administrators to easily configure pull-over-SSH backups. Install this gem on your backup server. Configure your backups definitions in /etc/backup_man and run backup_man from cron to securely pull your data over SSH.
 email: Markus@ITstrauss.eu
 executables: 
@@ -61,6 +92,16 @@ files:
 - VERSION
 - bin/backup_man
 - examples/example-host-config
+- features/development.feature
+- features/dsl_parameters.feature
+- features/logfile.feature
+- features/overview.feature
+- features/step_definitions/common_steps.rb
+- features/step_definitions/dsl_parameters_steps.rb
+- features/step_definitions/logfile_steps.rb
+- features/support/common.rb
+- features/support/env.rb
+- features/support/matchers.rb
 - lib/backup_man.rb
 - lib/backup_man/backup.rb
 - lib/backup_man/backup_man.rb
@@ -87,18 +128,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: backupman
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A tool for system administrators to easily configure pull-over-SSH backups.