rubble 0.0.1

data/lib/rubble/executor/remote.rb

@@ -0,0 +1,81 @@
+require 'rubble/executor/base'
+require 'rye'
+require 'rubble/logging'
+require 'tempfile'
+
+module Rubble
+    module Executor
+        class Remote < Base
+            attr_reader :box
+            attr_reader :server
+            attr_reader :local_executor
+
+            def initialize(server, local_executor)
+                super()
+
+                @server = server
+                @local_executor = local_executor
+                @box = Rye::Box.new(server.name, :safe => false)
+            end
+
+            def rsync_remote_prefix
+                "#{server.name}:"
+            end
+
+            def file_exists?(file_name)
+                box.file_exists?(file_name)
+            end
+
+            def mkdir(directory)
+                @log.info("Creating directory '#{directory}'.")
+                exec('mkdir', '-p', directory.to_s)
+            end
+
+            def cd(directory, create)
+                @log.info("Changing directory to #{directory}.")
+                if create then
+                    mkdir directory
+                end
+                box.cd(directory.to_s)
+            end
+
+            def symlink(source, target)
+                @log.info("Symlinking #{source} to #{target}.")
+                run('ln', '-s', '-f', '-T', source.to_s, target.to_s)
+            end
+
+            def run(*command)
+                Logging.context(:server => server.name) do
+                    command_str = Shellwords.join(command)
+                    @log.debug(command_str)
+                    box.execute(command_str)
+                end
+            end
+
+            def close
+                if not @box.nil? then
+                    @box.disconnect
+                end
+            end
+
+            def sync_up(filesets, target_dir, *options)
+                includes = rsync_includes(filesets)
+                parameters = includes.dirs.dup << (rsync_remote_prefix + target_dir).to_s
+                @local_executor.rsync(*parameters, :includes => includes.files, :recursive => true, :delete => true,
+                :delete_excluded => true)
+            end
+
+            def sync_down(filesets, target_dir, *options)
+                files = rsync_includes(filesets).map {|f| rsync_remote_prefix + f}
+                parameters = [target_dir].concat(files)
+                parameters.concat(options)
+                @local_executor.rsync *parameters
+            end
+
+            def sync_remote(source_dir, target_dir, *options)
+                parameters = [source_dir, target_dir, *options]
+                rsync *parameters
+            end
+        end
+    end
+end

data/lib/rubble/file_set.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+
+module Rubble
+    class FileSet
+        attr_reader :dir
+        attr_reader :files
+
+        def initialize(dir, *files)
+            @dir = Pathname.pwd + Pathname(dir)
+            if files.nil? then
+                @files = []
+            else
+                flattened_files = (files || []).collect {|f| Array(f)}.flatten
+
+                @files = flattened_files.map do |f|
+                    p = (@dir + Pathname(f)).relative_path_from(@dir)
+                    if p.to_s.start_with?('../') or p.to_s == '.' then
+                        raise ArgumentError, "File name '#{f}' must be relative to base directory #{@dir} of the file set."
+                    end
+                    p
+                end
+
+                @files.sort!
+            end
+
+            @files.freeze
+        end
+
+        def paths
+            @files.map {|f| @dir + f}
+        end
+
+        def empty?
+            @files.empty?
+        end
+
+        def to_s
+            to_yaml
+        end
+    end
+end

data/lib/rubble/logging.rb

@@ -0,0 +1,23 @@
+require 'logging'
+
+module Logging
+    class << self
+        def context(*options)
+            options.each do |option|
+                option.each do |k, v|
+                    Logging.mdc[k] = v
+                end
+            end
+
+            if block_given? then
+                yield
+            end
+        ensure
+            options.each do |option|
+                option.each do |k, v|
+                    Logging.mdc.delete(k)
+                end
+            end
+        end
+    end
+end

data/lib/rubble/plan/base.rb

@@ -0,0 +1,21 @@
+require 'rubble/dsl'
+require 'docile'
+
+module Rubble
+    module Plan
+        class Base
+            attr_reader :env
+            attr_reader :target
+            attr_reader :resource
+            attr_reader :server
+            def initialize(env, server, params)
+                @env = env
+                @server = server
+                params.each do |k, v|
+                    @resource = k
+                    @target = v
+                end
+            end
+        end
+    end
+end

data/lib/rubble/plan/deploy.rb

@@ -0,0 +1,11 @@
+require 'rubble/plan/base'
+
+module Rubble
+    module Plan
+        class Deploy < Base
+            def execute(context)
+                @target.deploy(context, env, server, @resource)
+            end
+        end
+    end
+end

data/lib/rubble/resource/base.rb

@@ -0,0 +1,43 @@
+require 'rubble/dsl'
+require 'rubble/snapshot'
+require 'digest'
+require 'yaml'
+
+module Rubble
+    module Resource
+        class Base
+            attr_reader :name
+            def initialize(name, *params)
+                @name = name
+            end
+
+            def type
+                self.class.name.split('::').last.downcase
+            end
+
+            def get_version(filesets)
+                md = Digest::SHA1.new
+                filesets.each do |fileset|
+                    fileset.paths.each do |path|
+                        md.file(path)
+                    end
+                end
+                md.hexdigest.force_encoding('UTF-8')
+            end
+
+            def get_filesets
+                []
+            end
+
+            def snapshot
+                filesets = get_filesets
+                version = get_version(filesets)
+                Snapshot.new(version, *filesets)
+            end
+
+            def to_s
+                to_yaml
+            end
+        end
+    end
+end

data/lib/rubble/resource/database.rb

@@ -0,0 +1,8 @@
+require 'rubble/resource/base'
+
+module Rubble
+    module Resource
+        class Database < Base
+        end
+    end
+end

data/lib/rubble/resource/fileset.rb

@@ -0,0 +1,93 @@
+require 'rubble/resource/base'
+require 'rubble/file_set'
+require 'find'
+require 'docile'
+
+module Rubble
+    module Resource
+        class Directory
+            attr_reader :includes
+            attr_reader :excludes
+            dsl_accessor :hidden
+
+            def initialize(name)
+                @name = name
+                @includes = []
+                @excludes = []
+                @default_includes = ['**/*']
+                @default_excludes = ['**/*~', '**/#*#']
+                @flags = File::FNM_PATHNAME
+            end
+
+            def includes(*pattern)
+                @includes.concat(Array(pattern))
+            end
+
+            def excludes(*pattern)
+                @excludes.concat(Array(pattern))
+            end
+
+            def hidden(*values)
+                if values.empty? then
+                    (@flags & File.FNM_DOTMATCH) != 0
+                else
+                    if values[0] then
+                        @flags |= File.FNM_DOTMATCH
+                    else
+                        @flags &= ~File.FNM_DOTMATCH
+                    end
+                end
+            end
+
+            def get_fileset
+                files = []
+                dir = Pathname.new(@name)
+
+                Find.find(dir) do |path|
+                    pathname = Pathname.new(path).relative_path_from(dir).to_s
+
+                    if pathname != '.' then
+                        match = (@includes.empty? ? @default_includes : @includes).any? {|p| File.fnmatch?(p, pathname, @flags)}
+                        match = match and not (@excludes.empty? ? @default_excludes : @excludes).any? {|p| File.fnmatch?(p, pathname, @flags)}
+
+                        if match then
+                            if not File.directory?(path) then
+                                files << pathname
+                            end
+                        else
+                            if File.directory?(path) then
+                                Find.prune
+                            end
+                        end
+                    end
+                end
+
+                FileSet.new(dir.to_s, files)
+            end
+        end
+
+        class Fileset < Base
+            def initialize(name, *params)
+                super(name, *params)
+
+                @directories = []
+            end
+
+            def directory(name, &block)
+                dir = Directory.new(name)
+                if not block.nil? then
+                    Docile.dsl_eval(dir, &block)
+                end
+                @directories << dir
+            end
+
+            def get_filesets
+                filesets = []
+                @directories.each do |directory|
+                    filesets << directory.get_fileset
+                end
+                filesets
+            end
+        end
+    end
+end

data/lib/rubble/resource/webapp.rb

@@ -0,0 +1,22 @@
+require 'rubble/resource/base'
+require 'rubble/file_set'
+
+module Rubble
+    module Resource
+        class Webapp < Base
+            dsl_accessor :war
+
+            def initialize(name, *params)
+                super(name, *params)
+
+                @war = "target/#{name}.war"
+            end
+
+            def get_filesets
+                dir = File.dirname(@war)
+                files = [File.basename(@war)]
+                [FileSet.new(dir, files)]
+            end
+        end
+    end
+end

data/lib/rubble/scope.rb

@@ -0,0 +1,44 @@
+module Rubble
+    class Scope
+        attr_reader :environment
+        attr_reader :server
+        def initialize(environment, server)
+            @environment = environment
+            @server = server
+        end
+
+        def tool
+            @environment.tool
+        end
+
+        def configure_plan(type, *params, &block)
+            plan = tool.create_plan(type, @environment, @server, *params)
+
+            if not block.nil? then
+                Docile.dsl_eval(plan, &block)
+            end
+
+            @environment.add_plan(plan)
+        end
+
+        def method_missing(symbol, *arguments, &block)
+            if tool.is_plan?(symbol) then
+                configure_plan(symbol, *arguments, &block)
+            elsif tool.is_target?(symbol) then
+                @server.provide_target(symbol, arguments[0])
+            elsif tool.is_resource?(symbol) then
+                tool.provide_resource(symbol, arguments[0])
+            else
+                super
+            end
+        end
+
+        def respond_to?(symbol, include_private = false)
+            if tool.is_plan?(symbol) or tool.is_resource?(symbol) or tool.is_target?(symbol) then
+                true
+            else
+                super
+            end
+        end
+    end
+end

data/lib/rubble/server.rb

@@ -0,0 +1,61 @@
+require 'logging'
+require 'shellwords'
+require 'rubble/dsl'
+
+module Rubble
+    class Server
+        attr_reader :tool
+        attr_reader :name
+        attr_reader :targets
+        dsl_accessor :rubble_dir
+        dsl_accessor :deploy_dir
+        dsl_accessor :user
+        dsl_accessor :group
+
+        def initialize(tool, name)
+            @tool = tool
+            @name = name
+
+            @log = Logging.logger[self]
+            @targets = {}
+            @rubble_dir = "/var/rubble"
+            @user = 'root'
+            @group = 'root'
+            @deploy_dir = '#{env.name}/#{resource.type}/#{resource.name}'
+        end
+
+        def provide_target(type, name)
+            group = @targets.fetch(type) do |k|
+                @targets[type] = {}
+            end
+            group.fetch(name) do |k|
+                group[name] = block_given? ? yield : @tool.create_target(type, name)
+            end
+        end
+
+        def configure_target(type, name, *params, &block)
+            target = provide_target(type, name) do
+                @tool.create_target(type, name, *params)
+            end
+            if not block.nil? then
+                Docile.dsl_eval(target, &block)
+            end
+        end
+
+        def method_missing(symbol, *arguments, &block)
+            if not @tool.nil? and @tool.is_target?(symbol) then
+                configure_target(symbol, *arguments, &block)
+            else
+                super
+            end
+        end
+
+        def respond_to?(symbol, include_private = false)
+            if not @tool.nil? and @tool.is_target?(symbol) then
+                true
+            else
+                super
+            end
+        end
+    end
+end