rubble 0.0.1

data/README.md

@@ -0,0 +1,29 @@
+# Rubble
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rubble'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rubble
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/deploy_tool/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/bin/rubble

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubble/application'
+
+# Run application
+Rubble::Application.new.run

data/demo/applique/qed_test.rb

@@ -0,0 +1,82 @@
+require 'ae'
+
+# Add bin directory to path
+ENV['PATH'] = File.join(QED::Utils.root, 'bin') + ":" + ENV['PATH']
+
+# Redirect stdout and return output
+#
+# @yield Execute block with redirected stdout
+# @return [String] Output
+def redirect
+    begin
+        old_stdout = $stdout
+        old_stderr = $stderr
+        $stdout = StringIO.new('', 'w')
+        $stderr = $stdout
+        yield
+        $stdout.string
+    ensure
+        $stdout = old_stdout
+        $stderr = old_stderr
+    end
+end
+
+# Execute a registered command
+#
+# @param command [String] Command string
+# @return [String] Command output
+def execute_command(command)
+    if command.nil? then
+        raise(ArgumentError, 'Please supply a block with the command to run')
+    end
+
+    command.gsub!(/^#\s*/, '')
+    arguments = Shellwords.shellsplit(command)
+    method_name = "run_#{arguments[0]}_command".to_sym
+    method = method(method_name)
+
+    if method.nil? then
+        raise(ArgumentError, "Please define a method named #{method_name} to test running the #{command[0]} command.")
+    end
+
+    @output = redirect do
+        method.call(arguments[1..-1])
+    end
+end
+
+# Remove empty lines and leading and trailing spaces from text
+#
+# @param text [String] Text to clean
+# @return [String] cleaned text
+def clean(text)
+    raise(ArgumentError, 'Text must not be nil.') if text.nil?
+
+    text.gsub(/\n+/, "\n").gsub(/^\s+|\s+$/, '')
+end
+
+# Save the following block as script
+When /\buse\b[^.]+\bscript in (?:file )?`([a-z]+\.[a-z]+)`/i do |file_name, text|
+    raise(ArgumentError, 'Please supply a block with a script.') if text.nil?
+
+    File.open(file_name, 'w') do |f|
+        f.write(text)
+    end
+end
+
+# Expect the following block as text output
+When /\bproduces\b[^.]+\btext output\b/i do |text|
+    raise(ArgumentError, 'Please supply a block with the text') if text.nil?
+    clean(@output).assert == clean(text)
+end
+
+# Execute the command in the following block
+When /\bexecute\b[^.]+\bcommand\b/i do |command|
+    execute_command(command)
+end
+
+# Execute the command in the following block and expect it to fail
+When /\bexecuting\b[^.]+\bfails\b/i do |command|
+    SystemExit.expect do
+        execute_command(command)
+    end
+end

data/demo/applique/rubble_test.rb

@@ -0,0 +1,33 @@
+require 'rubble/application'
+
+include Rubble
+
+def run_rubble_command(arguments)
+    Commander::Runner.instance_variable_set :"@singleton", Commander::Runner.new(arguments)
+    app = Rubble::Application.new
+    app.run
+end
+
+# Create a Tool object for testing
+When /create a new test tool/i do |configuration|
+    raise(ArgumentError, 'Please supply a block with configuration.') if configuration.nil?
+
+    @tool = Tool.new
+    @tool.instance_eval(configuration)
+end
+
+# Create an Environment object for testing
+When /create a new test environment/i do |configuration|
+    raise(ArgumentError, 'Please supply a block with configuration.') if configuration.nil?
+
+    @environment = Environment.new(Tool.new, 'test')
+    @environment.instance_eval(configuration)
+end
+
+# Create a Server object for testing
+When /create a new test server/i do |configuration|
+    raise(ArgumentError, 'Please supply a block with configuration.') if configuration.nil?
+
+    @server = Server.new(Tool.new, 'test')
+    @server.instance_eval(configuration)
+end

data/demo/environment.md

@@ -0,0 +1,32 @@
+# Environment
+
+## Configure plans
+
+An environment allows the configuration of plans.
+
+Create a new test environment and configure it as follows:
+
+    server 'test' do
+        deploy fileset('test') => directory('test')
+    end
+
+Now check the configuration.
+
+    @environment.plans.size.assert == 1
+    @environment.plans[0].assert.is_a? Plan::Deploy
+
+## Configure plans for multiple servers at once
+
+An environment allows the configuration of multiple servers.
+
+Create a new test environment and configure it as follows:
+
+    server 'test1', 'test2' do
+        deploy fileset('test') => directory('test')
+    end
+
+Now check the configuration.
+
+    @environment.plans.size.assert == 2
+    @environment.plans[0].assert.is_a? Plan::Deploy
+    @environment.plans[1].assert.is_a? Plan::Deploy

data/demo/file_set.md

@@ -0,0 +1,65 @@
+# File Set
+
+## Converts paths to Pathname
+
+A file set converts the base directory to a pathname.
+
+    fileset = FileSet.new('/tmp')
+    fileset.dir.assert.is_a? Pathname
+
+A file set converts the files to pathnames.
+
+    fileset = FileSet.new('/tmp', 'test.txt')
+    fileset.files[0].assert.is_a? Pathname
+
+## Reports when it is empty
+
+A file set reports when it is empty
+
+    fileset = FileSet.new('/tmp')
+    fileset.assert.empty?
+
+A file set reports when it is not empty
+
+    fileset = FileSet.new('/tmp', 'test.txt')
+    fileset.assert.not.empty?
+
+## Readonly
+
+A file set freezes its files
+
+    fileset = FileSet.new('/tmp')
+    RuntimeError.assert.raised? do
+        fileset.files << 'test.txt'
+    end
+
+## Sorts content
+
+A file set sorts the contained files
+
+    fileset = FileSet.new('/tmp', 'b.txt', 'a.txt')
+    fileset.files.assert == [Pathname('a.txt'), Pathname('b.txt')]
+
+## Ensures files are relative
+
+A file set ensures all files are in the base directory
+
+    FileSet.new('/tmp', 'test.txt').assert != nil
+    FileSet.new('/tmp', '../tmp/test.txt').assert != nil
+
+    ArgumentError.assert.raised? do
+        FileSet.new('/tmp', '.')
+    end
+
+    ArgumentError.assert.raised? do
+        FileSet.new('/tmp', '../usr/test.txt')
+    end
+
+    ArgumentError.assert.raised? do
+        FileSet.new('/tmp', '/test.txt')
+    end
+
+A file set can return the full paths of the files
+
+    fileset = FileSet.new('/tmp', 'test.txt')
+    fileset.paths.first.assert == Pathname('/tmp/test.txt')

data/demo/logging.md

@@ -0,0 +1,11 @@
+# Logging
+
+## Set the MDC
+
+The context method allows code to be executed with specific values in the MDC.
+
+    Logging.mdc['test'].assert == nil
+    Logging.context(:test => 'test') do
+        Logging.mdc['test'].assert == 'test'
+    end
+    Logging.mdc['test'].assert == nil

data/demo/server.md

@@ -0,0 +1,53 @@
+# Server
+
+## Configure the Rubble directory
+
+Create a new test server and configure it as follows:
+
+    rubble_dir '/var/test'
+
+Now check the configuration.
+
+    @server.rubble_dir.assert == '/var/test'
+
+## Configure the deploy directory
+
+Create a new test server and configure it as follows:
+
+    deploy_dir '/var/test'
+
+Now check the configuration.
+
+    @server.deploy_dir.assert == '/var/test'
+
+## Configure the user
+
+Create a new test server and configure it as follows:
+
+    user 'test'
+
+Now check the configuration.
+
+    @server.user.assert == 'test'
+
+## Configure the group
+
+Create a new test server and configure it as follows:
+
+    group 'test'
+
+Now check the configuration.
+
+    @server.group.assert == 'test'
+
+## Configure the targets
+
+Create a new test server and configure it as follows:
+
+    directory 'test'
+
+Now check the configuration.
+
+    @server.targets.size.assert == 1
+    @server.targets[:directory].size.assert == 1
+    @server.targets[:directory]['test'].assert.is_a? Target::Directory

data/demo/snapshot.md

@@ -0,0 +1,32 @@
+## Reports when it is empty
+
+A snapshot reports when it is empty because it does not contain any file sets.
+
+    snapshot = Snapshot.new('1')
+    snapshot.assert.empty?
+
+A snapshot reports when it is empty because all its file sets are empty.
+
+    snapshot = Snapshot.new('1', FileSet.new('/tmp'))
+    snapshot.assert.empty?
+
+A snapshot reports when it is not empty.
+
+    snapshot = Snapshot.new('1', FileSet.new('/tmp', 'a.txt'))
+    snapshot.assert.not.empty?
+
+## Read only
+
+A snapshot prevents modification of its version.
+
+    snapshot = Snapshot.new('1')
+    RuntimeError.assert.raised? do
+        snapshot.version << 'test'
+    end
+
+A snapshot prevents modification of its filesets.
+
+    snapshot = Snapshot.new('1')
+    RuntimeError.assert.raised? do
+        snapshot.filesets << FileSet.new('/tmp')
+    end

data/demo/tool.md

@@ -0,0 +1,36 @@
+# Tool
+
+## Configures the resources
+
+A tool allows the configuration of resources.
+
+Create a new test tool and configure it as follows:
+
+    fileset 'test'
+
+Now check the configuration.
+
+    @tool.resources.size.assert == 1
+    @tool.resources[:fileset]['test'].assert.is_a? Resource::Fileset
+
+## Configures the servers
+
+Create a new test tool and configure it as follows:
+
+    server 'test'
+
+Now check the configuration.
+
+    @tool.servers.size.assert == 1
+    @tool.servers['test'].assert.is_a? Server
+
+## Configures the environments
+
+Create a new test tool and configure it as follows:
+
+    environment 'test'
+
+Now check the configuration.
+
+    @tool.environments.size.assert == 1
+    @tool.environments['test'].assert.is_a? Environment

data/lib/rubble.rb

@@ -0,0 +1,15 @@
+require 'rubble/version'
+require 'rubble/tool'
+require 'rubble/file_set'
+require 'rubble/resource/database'
+require 'rubble/resource/webapp'
+require 'rubble/resource/fileset'
+require 'rubble/target/tomcat'
+require 'rubble/target/mysql'
+require 'rubble/target/directory'
+require 'rubble/plan/deploy'
+require 'rubble/command/upload'
+require 'rubble/command/activate'
+
+module Rubble
+end

data/lib/rubble/application.rb

@@ -0,0 +1,82 @@
+require 'rubygems'
+require 'commander'
+require 'rubble'
+require 'yaml'
+require 'logging'
+
+module Rubble
+    # Rubble application class
+    class Application
+        include Commander::Methods
+
+        def initialize
+            @config_file = 'config/deploy.rubble'
+        end
+
+        def tool
+            if @tool.nil? then
+                @tool = Rubble::Tool.new
+                @tool.read_config(@config_file)
+            end
+
+            @tool
+        end
+
+        def run
+            program :name, 'Rubble'
+            program :version, Rubble::VERSION
+            program :description, 'Rubble Deployment Tool'
+
+            Logging.color_scheme('bright',
+            :lines => {
+                :debug => :blue,
+                :warn => :yellow,
+                :error => :orange,
+                :fatal => :red
+            },
+            )
+
+            Logging.logger.root.level = :info
+            Logging.logger.root.appenders = Logging.appenders.stdout(
+            'stdout',
+            :layout => Logging.layouts.pattern(
+            :pattern => '==> %m %X{server}\n',
+            :color_scheme => 'bright'
+            )
+            )
+
+            log = Logging.logger[self]
+
+            global_option('-l', '--loglevel STRING', 'Log level') do |level|
+                Logging.logger.root.level = level.to_sym
+            end
+
+            global_option('-f', '--file FILE', 'Configuration file') do |file|
+                @config_file = file
+                @tool = nil
+            end
+
+            command :upload do |c|
+                c.description = 'Upload a release'
+                c.action do |args, options|
+                    tool.execute(args) do |plan, context|
+                        command = Rubble::Command::Upload.new(plan, context)
+                        command.execute
+                    end
+                end
+            end
+
+            command :activate do |c|
+                c.description = 'Activate a release'
+                c.action do |args, options|
+                    tool.execute(args) do |plan, context|
+                        command = Rubble::Command::Activate.new(plan, context)
+                        command.execute
+                    end
+                end
+            end
+
+            run!
+        end
+    end
+end