rubble 0.0.1

data/lib/rubble/command/activate.rb

@@ -0,0 +1,13 @@
+require 'rubble/plan/base'
+
+module Rubble
+    module Plan
+        class Activate < Base
+            def execute
+                current_war = File.join(deploy_dir, 'current', target.war)
+                remote.cd(target.webapps_dir)
+                remote.symlink(current_war, File.basename(current_war))
+            end
+        end
+    end
+end

data/lib/rubble/command/base.rb

@@ -0,0 +1,57 @@
+require 'rubble/dsl'
+
+module Rubble
+    module Command
+        class Base
+            attr_reader :plan
+            attr_reader :context
+            attr_reader :local
+            attr_reader :remote
+
+            def initialize(plan, context)
+                @log = Logging.logger[self]
+                @plan = plan
+                @context = context
+            end
+
+            def server
+                @plan.server
+            end
+
+            def target
+                @plan.target
+            end
+
+            def resource
+                @plan.resource
+            end
+
+            def env
+                @plan.env
+            end
+
+            def local
+                if @local.nil? then
+                    @local = context.local_executor
+                end
+                @local
+            end
+
+            def remote
+                if @remote.nil? then
+                    @remote = context.remote_executor(server)
+                end
+                @remote
+            end
+
+            def resolve(string)
+                string = '"' << string.gsub('"', '\"') << '"'
+                eval(string, binding)
+            end
+
+            def deploy_dir
+                resolve(File.join(server.rubble_dir, server.deploy_dir))
+            end
+        end
+    end
+end

data/lib/rubble/command/upload.rb

@@ -0,0 +1,28 @@
+require 'rubble/command/base'
+require 'docile'
+
+module Rubble
+    module Command
+        class Upload < Base
+            def execute
+                snapshot = resource.snapshot
+                target_dir = File.join(deploy_dir, snapshot.version)
+
+                @log.debug("Uploading snapshot #{snapshot}")
+
+                remote.mkdir(target_dir)
+                remote.cd(deploy_dir, true)
+
+                if not snapshot.empty? then
+                    if remote.file_exists?('current') then
+                        # remote.rsync('current/', "#{snapshot.version}/")
+                    end
+
+                    remote.sync_up(snapshot.filesets, target_dir)
+                end
+
+                remote.symlink(snapshot.version, 'current')
+            end
+        end
+    end
+end

data/lib/rubble/context.rb

@@ -0,0 +1,33 @@
+require 'base32'
+require 'rubble/executor/local'
+require 'rubble/executor/remote'
+
+module Rubble
+    class Context
+        attr_reader :uuid
+        attr_reader :tool
+        attr_reader :local_executor
+
+        def initialize(tool)
+            @tool = tool
+            uuid_str = SecureRandom.uuid.gsub(/-/, '')
+            uuid_bytes = [uuid_str].pack('H*')
+            @uuid = Base32.encode(uuid_bytes).gsub(/=+$/, '')
+            @remote_executors = {}
+            @local_executor = Executor::Local.new
+        end
+
+        def remote_executor(server)
+            @remote_executors.fetch(server.name) do |k|
+                @remote_executors[server.name] = Executor::Remote.new(server, local_executor)
+            end
+        end
+
+        def close
+            @remote_executors.each_value do |executor|
+                executor.close
+            end
+            @remote_executors = {}
+        end
+    end
+end

data/lib/rubble/dsl.rb

@@ -0,0 +1,31 @@
+class Module
+    # Create a DSL style accessor
+    #
+    # Works like :attr_accessor, with the difference that the getter has an optional parameter that sets the property
+    # when present.
+    #
+    # @example Create a mutable DLS style property named 'plan'
+    #
+    # class Processor
+    #   dsl_accessor :plan
+    # end
+    #
+    # @param symbols [Array] names of the properties to create
+    def dsl_accessor(*symbols)
+        symbols.each do |symbol|
+            class_eval %{
+                def #{symbol}(value = nil)
+                    if value.nil?
+                        @#{symbol}
+                    else
+                        @#{symbol} = value
+                    end
+                end
+
+                def #{symbol}=(value)
+                    @#{symbol} = value
+                end
+            }
+        end
+    end
+end

data/lib/rubble/environment.rb

@@ -0,0 +1,38 @@
+require 'rubble/scope'
+require 'docile'
+
+module Rubble
+    class Environment
+        attr_reader :tool
+        attr_reader :name
+        attr_reader :plans
+
+        # Action statt plan
+
+        def initialize(tool, name)
+            @tool = tool
+            @name = name
+            @plans = []
+        end
+
+        def server(*names, &block)
+            names.each do |name|
+                server = @tool.provide_server(name)
+                scope = Scope.new(self, server)
+                if not block.nil? then
+                    Docile.dsl_eval(scope, &block)
+                end
+            end
+        end
+
+        def add_plan(plan)
+            @plans << plan
+        end
+
+        def execute(context)
+            @plans.each do |plan|
+                yield(plan, context)
+            end
+        end
+    end
+end

data/lib/rubble/executor/base.rb

@@ -0,0 +1,134 @@
+require 'logging'
+require 'tempfile'
+require 'pathname'
+require 'shellwords'
+require 'ostruct'
+
+module Rubble
+    module Executor
+        SyncList = Struct.new(:dirs, :files)
+
+        class Base
+            def initialize
+                @log = Logging.logger[self]
+            end
+
+            def exec(*command)
+                run(*command)
+            end
+
+            def convert_options(options)
+                switches = []
+
+                options.each do |k, v|
+                    if not v.nil? then
+                        switches << "--#{k.to_s.gsub(/_/, '-')}"
+                        if not v == true then
+                            switches << v
+                        end
+                    end
+                end
+
+                switches
+            end
+
+            def rsync_includes(filesets)
+                dirs = []
+                files = Set.new
+
+                filesets.each do |fileset|
+                    dirs << "#{fileset.dir.to_s}/"
+
+                    fileset.files.each do |file|
+                        until file.to_s == '.'
+                            files << "+ #{file.to_s}"
+                            file = file.parent
+                        end
+                    end
+                end
+
+                files = files.to_a.sort
+                files << '- *'
+
+                SyncList.new(dirs, files)
+            end
+
+            def rsync_remote_prefix
+                ''
+            end
+
+            def rsync(*parameters)
+                paths = []
+                options = {
+                    :recursive => nil,
+                    :dirs => nil,
+                    :delete => nil,
+                    :delete_excluded => nil,
+                    :include_from => nil,
+                    :rsh => 'ssh -o ClearAllForwardings=Yes',
+                    :verbose => nil
+                }
+                includes = []
+
+                parameters.each do |parameter|
+                    if parameter.is_a?(Hash) then
+                        parameter.each do |name, value|
+                            if name.to_s == 'includes' then
+                                Array(value).each do |v|
+                                    includes << v
+                                end
+                            elsif options.include?(name) then
+                                options[name] = value
+                            else
+                                raise "Unknown rsync parameter #{name}."
+                            end
+                        end
+                    else
+                        paths << parameter
+                    end
+                end
+
+                begin
+                    tempfile = nil
+
+                    if not includes.empty? then
+                        tempfile = Tempfile.new(['includes', '.rsync'])
+                        begin
+                            includes.each do |f|
+                                tempfile.puts f
+                            end
+                        end
+                        tempfile.close
+
+                        options[:include_from] = tempfile.path
+                    end
+
+                    command = ['rsync'].concat(['-vv']).concat(convert_options(options)).concat(paths)
+
+                    @log.info("Rsyncing #{paths[0..-2].join(', ')} to #{paths[-1]}.")
+                    run(*command)
+                ensure
+                    tempfile && tempfile.close!
+                end
+            end
+
+            # 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
+                    result = yield
+                    [result, $stdout.string]
+                ensure
+                    $stdout = old_stdout
+                    $stderr = old_stderr
+                end
+            end
+        end
+    end
+end

data/lib/rubble/executor/local.rb

@@ -0,0 +1,113 @@
+require 'rubble/executor/base'
+require 'open3'
+module Rubble
+    module Executor
+        class Local < Base
+            class StreamInfo
+                attr_accessor :data
+                attr_accessor :level
+                attr_reader :autoflush
+                def initialize(level, autoflush)
+                    @level = ::Logging::level_num(level)
+                    @data = ""
+                    @autoflush = autoflush
+                end
+            end
+
+            class Line
+                attr_reader :level
+                attr_reader :text
+                def initialize(level, text)
+                    @level = level
+                    @text = text.chomp
+                end
+            end
+
+            class Output
+                attr_reader :log
+                attr_reader :lines
+                def initialize(log)
+                    @log = log
+                    @lines = []
+                    @flushed = false
+                end
+                def <<(line)
+                    @lines << line
+                    if @flushed then
+                        @log.add(line.level, line.text)
+                    end
+                end
+                def flush
+                    @lines.each do |line|
+                        @log.add(line.level, line.text)
+                    end
+                    @flushed = true
+                end
+            end
+
+            def mkdir(directory_name)
+                Pathname(directory_name).mkpath
+            end
+
+            def symlink(source, target)
+                Pathname(target).make_symlink(Pathname(source))
+            end
+
+            def file_exists?(file)
+                Pathname(file).exists?
+            end
+
+            def run(*command)
+                command_str = Shellwords.join(command)
+                @log.debug(command_str)
+
+                status = nil
+                output = Output.new(@log)
+
+                Open3.popen3(command_str) do |stdin, stdout, stderr, thread|
+                    streams = {stdout => StreamInfo.new(:info, false), stderr => StreamInfo.new(:error, false)}
+
+                    until streams.empty? do
+                        selected, = IO::select(streams.keys, nil, nil, 0.1)
+
+                        if not selected.nil? then
+                            selected.each do |stream|
+                                info = streams[stream]
+
+                                if stream.eof? then
+                                    streams.delete(stream)
+
+                                    if not info.data.empty? then
+                                        output << Line.new(info.level, info.data)
+                                    end
+                                else
+                                    data = info.data + stream.readpartial(1024)
+
+                                    data.each_line do |line|
+                                        if line.end_with?("\n") then
+                                            output << Line.new(info.level, line)
+                                        else
+                                            info.data = line
+                                        end
+                                    end
+                                end
+
+                                if info.autoflush then
+                                    output.flush
+                                end
+                            end
+                        end
+                    end
+
+                    status = thread.value
+                end
+
+                if status.exitstatus != 0 then
+                    output.flush
+                    raise "Command failed with exit status #{status.exitstatus}."
+                end
+            end
+
+        end
+    end
+end