disloku 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 114b22aa9d4750cc34ec61df2eaa35db116d2019
+  data.tar.gz: e3ca011d1d3b297c073dec2a226fce5d290c6ef4
+SHA512:
+  metadata.gz: 405cdd36e1552d1504d660cb604ce12d3bb3c5e05507b593c710a4bd761b24f031b12d98f02cb3e81e06d5d85353457212deed90ad235ad5bd21acfd5cd7ba1a
+  data.tar.gz: a098da49f71bbec30fdc13b55572e6f7d19a640cf52c2d9408d6861b7fd5518399796de84dbb3707b35a719d7389f88982674ae459283f702fc1064c4de11a1e

data/bin/disloku

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require('disloku')
+DislokuCli.start()

data/lib/disloku/BaseTask.rb

@@ -0,0 +1,39 @@
+
+module Disloku
+	class BaseTask
+		attr_accessor :changesets
+
+		def initialize()
+			@result = {}
+		end
+
+		def getInputParam(input, name, klass)
+			if (!input.has_key?(name))
+				raise ArgumentError.new("Missing input argument '#{name}' of type '#{klass}'")
+			end
+			if (!input[name].kind_of?(klass))
+				raise ArgumentError.new("Input argument '#{name}' is not of type '#{klass}'")
+			end
+
+			return input[name]
+		end
+
+		def execute()
+			Log.instance.info("running task '#{self.class}'")
+			beforeExecute()
+			executeTask()
+			afterExecute()
+			return @result
+		end
+
+		def beforeExecute()
+		end
+
+		def executeTask()
+			raise NotImplementedError.new()
+		end
+
+		def afterExecute()
+		end
+	end
+end

data/lib/disloku/ChangeSet.rb

@@ -0,0 +1,14 @@
+require 'Forwardable'
+require 'Pathname'
+
+module Disloku
+	class ChangeSet
+		include Enumerable
+		extend Forwardable
+		def_delegators :@changes, :each, :<<
+		
+		def initialize()
+			@changes = Array.new()
+		end
+	end
+end

data/lib/disloku/ChangeSetProvider.rb

@@ -0,0 +1,13 @@
+
+module Disloku
+	class ChangeSetProvider
+		attr_accessor :repository
+		
+		def initialize(repository)
+			@repository = repository
+		end
+		
+		def getChangeSet(from, to)
+		end
+	end
+end

data/lib/disloku/Commit.rb

@@ -0,0 +1,7 @@
+
+module Disloku
+	class Commit
+		def initialize()
+		end
+	end
+end

data/lib/disloku/Config.rb

@@ -0,0 +1,52 @@
+require('YAML')
+require_relative('util/Hash')
+
+module Disloku
+	class Config
+		attr_accessor :yaml
+
+		def initialize(config, isFile = true)
+			if (isFile)
+				@yaml = YAML.load_file(config)
+			else
+				@yaml = config
+			end
+		end
+
+		def merge(base)
+			@yaml = base.yaml.recursive_merge(@yaml)
+		end
+
+		def has?(key)
+			return self[key] != nil
+		end
+
+		def get(keys)
+			if (keys.empty?())
+				return self
+			end
+			current = keys.shift()
+			return @yaml.has_key?(current) ? Config.new(@yaml[current], false).get(keys) : nil
+		end
+
+		def [](key)
+			return self.get(key.split('.'))
+		end
+
+		def value()
+			if (@yaml.kind_of?(Array))
+				return @yaml.map() { |item| Config.new(item, false) }
+			end
+			return @yaml
+		end
+
+		def to_s()
+			return value().to_s()
+		end
+
+		def to_yaml()
+			return @yaml.to_yaml()
+		end
+
+	end
+end

data/lib/disloku/Connection.rb

@@ -0,0 +1,31 @@
+require('net/sftp')
+require('digest/sha1')
+
+module Disloku
+	class Connection
+		attr_accessor :hash, :host, :user, :options
+
+		def initialize(config)
+			@host = config["host"].value()
+			@user = config["user"].value() if !config["user"].nil?
+			@options = {}
+			addOption(config, :password)
+			addOption(config, :port)
+			addOption(config, :keys, true)
+
+			@hash = Digest::SHA1.hexdigest([@host, @user, @options].join())
+		end
+
+		def addOption(config, key, unwrap = false)
+			value = config[key.to_s()]
+			if (!value.nil?)
+				if (unwrap)
+					@options[key] = value.value().map() { |e| e.value() }
+				else
+					@options[key] = value.value()
+				end
+			end
+		end
+
+	end
+end

data/lib/disloku/ConnectionStore.rb

@@ -0,0 +1,16 @@
+require_relative('NamedConfigStore')
+require_relative('Connection')
+
+module Disloku
+	class ConnectionStore < NamedConfigStore
+
+		def initialize(config = nil)
+			super(config)
+		end
+
+		def transformConfig(configObject)
+			return Connection.new(configObject)
+		end
+
+	end
+end

data/lib/disloku/Disloku.rb

@@ -0,0 +1,103 @@
+require_relative('DislokuError')
+require_relative('Config')
+require_relative('Options')
+require_relative('MappingStore')
+require_relative('ConnectionStore')
+require_relative('Target')
+require_relative('git/Repository')
+require_relative('tasks/FolderTask')
+require_relative('tasks/NetSftpTask')
+
+module Disloku
+	class Disloku
+		attr_accessor :repository, :config
+
+		def initialize(cliOptions)
+			@repository = Git::Repository.new(cliOptions[:dir])
+			@config = loadConfiguration()
+			@options = Options.new(@config["options"], cliOptions)
+			@mappingStore = MappingStore.new(@config["mappings"])
+			@connectionStore = ConnectionStore.new(@config["connections"])
+		end
+
+		def loadConfiguration()
+			repoConfig = File.join(repository.root, 'disloku.config')
+			if (!File.exists?(repoConfig))
+				raise DislokuError.new("There is no disloku.config file in #{repository.root}")
+			end
+
+			config = Config.new(repoConfig)
+
+			userHome = File.expand_path("~")
+			userConfig = File.join(userHome, ".disloku.config")
+			if (File.exists?(userConfig))
+				base = Config.new(userConfig)
+				config.merge(base)
+			end
+
+			return config
+		end
+
+		def buildPackage(from, to)
+			changeset = @repository.getChangeSet(from, to)
+
+			folderInput = {
+				:options => @options,
+				:allowOverride => false,
+				:changesets => [changeset],
+				:target => nil,
+			}
+
+			resolveTargets([@options.target]).each() do |t|
+				folderInput[:target] = t
+
+				result = Tasks::FolderTask.new(folderInput).execute()
+				p(result)
+			end
+		end
+
+		def deployPackage(from, to)
+			changeset = @repository.getChangeSet(from, to)
+
+			folderInput = {
+				:options => @options,
+				:allowOverride => false,
+				:changesets => [changeset],
+				:target => nil,
+			}
+
+			resolveTargets([@options.target]).each() do |t|
+				folderInput[:target] = t
+
+				result = Tasks::FolderTask.new(folderInput).execute()
+
+				sftpInput = result.merge({
+					:repository => @repository,
+					:options => @options,
+					:target => t,
+				})
+
+				result = Tasks::NetSftpTask.new(sftpInput).execute()
+			end
+		end
+
+		def resolveTargets(targets)
+			actualTargets = []
+
+			while (targets.count > 0)
+				current = targets.shift()
+				targetConfig = @config["targets"][current]
+				if (targetConfig != nil)
+					if (targetConfig["targets"] != nil)
+						targetConfig["targets"].value().each() { |x| targets.push(x.value()) }
+						next
+					end
+
+					actualTargets.push(Target.new(current, targetConfig, @mappingStore, @connectionStore))
+				end
+			end
+
+			return actualTargets
+		end
+	end
+end

data/lib/disloku/DislokuError.rb

@@ -0,0 +1,5 @@
+
+module Disloku
+	class DislokuError < StandardError
+	end
+end

data/lib/disloku/FileChange.rb

@@ -0,0 +1,17 @@
+require_relative('util/File')
+
+module Disloku
+	class FileChange
+		attr_accessor :repository, :changeType
+
+		def initialize(repository, fullPath, changeType)
+			@repository = repository
+			@fullPath = fullPath
+			@changeType = changeType
+		end
+
+		def getFile(target)
+			return Util::File.new(@fullPath, @repository.root, target, self)
+		end
+	end
+end

data/lib/disloku/Log.rb

@@ -0,0 +1,35 @@
+require('Singleton')
+require('Logger')
+
+module Disloku
+	class Log
+		include Singleton
+		
+		def initialize()
+			@logger = Logger.new(STDOUT)
+			@logger.formatter = proc { |severity, datetime, progname, msg|
+				"#{msg}\n"
+			}
+		end
+		
+		def debug(message)
+			@logger.debug(message)
+		end
+		
+		def info(message)
+			@logger.debug(message)
+		end
+		
+		def warn(message)
+			@logger.debug(message)
+		end
+		
+		def error(message)
+			@logger.debug(message)
+		end
+		
+		def fatal(message)
+			@logger.debug(message)
+		end
+	end
+end

data/lib/disloku/Mapping.rb

@@ -0,0 +1,81 @@
+require_relative('util/Hash')
+require_relative('util/File')
+
+module Disloku
+	class Mapping
+
+		def initialize(config, mappingStore = nil, allowDefault = true)
+			@mapping = {}
+
+			mappingConfig = config["mapping"]
+			if (!mappingConfig.nil?)
+				mappingConfig.value().each() do |m|
+					node = @mapping
+					src = m["src"].value()
+
+					if (src.kind_of?(Symbol))
+						segments = [src]
+					else
+						segments = src.split(/#{Util::SPLIT_EXP}/)
+
+						segments[0..-2].each() do |segment|
+							if (!node.has_key?(segment))
+								node[segment] = {}
+							end
+							node = node[segment]
+						end
+					end
+
+					if (!m["block"].nil? && m["block"].value())
+						node[segments[-1]] = :block
+					else
+						dst = m["dst"].value()
+						if (dst.kind_of?(Symbol))
+							node[segments[-1]] = dst
+						else
+							node[segments[-1]] = m["dst"].value().split(/#{Util::SPLIT_EXP}/)
+						end
+					end
+				end
+			elsif (allowDefault)
+				@mapping[:any] = :keep
+			end
+
+			baseMapping = config["baseMapping"].nil? ? nil : config["baseMapping"].value()
+
+			if (!baseMapping.nil?)
+				if (mappingStore.nil?)
+					raise ArgumentError.new("mapping has a base but no mapping manager was passed")
+				else
+					@mapping = mappingStore.get(baseMapping).getTree().recursive_merge(@mapping)
+				end
+			end
+		end
+
+		def getTree()
+			return @mapping
+		end
+
+		def mapPath(pathSegments)
+			node = @mapping
+			for i in 0..pathSegments.count
+				if (node.has_key?(pathSegments[i]))
+					node = node[pathSegments[i]]
+				elsif (node.has_key?(:any))
+					node = node[:any]
+				else
+					return nil
+				end
+
+				if (node == :block)
+					return nil
+				elsif (node == :keep)
+					return pathSegments
+				elsif (node.kind_of?(Array))
+					return Array.new(node).concat(pathSegments[(i + 1)..-1])
+				end
+			end
+		end
+
+	end
+end

data/lib/disloku/MappingStore.rb

@@ -0,0 +1,16 @@
+require_relative('NamedConfigStore')
+require_relative('Mapping')
+
+module Disloku
+	class MappingStore < NamedConfigStore
+
+		def initialize(config = nil)
+			super(config)
+		end
+
+		def transformConfig(configObject)
+			return Mapping.new(configObject, self, false)
+		end
+
+	end
+end

data/lib/disloku/NamedConfigStore.rb

@@ -0,0 +1,39 @@
+require_relative('DislokuError')
+require_relative('Connection')
+
+module Disloku
+	class NamedConfigStore
+
+		def initialize(config = nil)
+			@store = {}
+			if (!config.nil?)
+				load(config)
+			end
+		end
+
+		def get(name)
+			if (@store.has_key?(name))
+				return @store[name]
+			else
+				raise DislokuError.new("There is no stored object with the name '#{name}' in this store")
+			end
+		end
+
+		def add(name, configObject)
+			@store[name] = transformConfig(configObject)
+		end
+
+		def load(config)
+			if (!config.nil?)
+				config.value().each_key() do |key|
+					add(key, config[key])
+				end
+			end
+		end
+
+		def transformConfig(configObject)
+			return configObject
+		end
+
+	end
+end

data/lib/disloku/Options.rb

@@ -0,0 +1,38 @@
+require_relative('Config')
+require('fileutils')
+require('tmpdir')
+
+module Disloku
+	class Options
+
+		def initialize(config, cliOptions)
+			@options = {
+				:ignoreDeleteErrors => false,
+				:createDeletesFile => false,
+				:target => "default",
+				:packageDir => :temp,
+			}
+
+			@options.each_key() do |key|
+				if (cliOptions.has_key?(key.to_s()))
+					@options[key] = cliOptions[key.to_s()]
+				elsif (config[key.to_s()] != nil)
+					@options[key] = config[key.to_s()].value()
+				end
+			end
+
+			if (@options[:packageDir] == :temp)
+				puts("creating tempdir")
+				@options[:packageDir] = Dir.mktmpdir("disloku")
+			end
+		end
+
+		def method_missing(name, *args, &block)
+			if (!@options.has_key?(name))
+				raise ArgumentError.new("There's no option '#{name}' here")
+			end
+
+			return @options[name]
+		end
+	end
+end

data/lib/disloku/Repository.rb

@@ -0,0 +1,29 @@
+require_relative('util/File')
+
+module Disloku
+	class Repository
+		attr_accessor :location, :root
+
+		def initialize(location)
+			@location = location
+			@root = getRepositoryRoot()
+			@gitDir = File.join(@root, ".git")
+			@provider = getProvider()
+		end
+
+		def getRepositoryRoot()
+			raise NotImplementedError.new()
+		end
+
+		def getBranchName()
+			raise NotImplementedError.new()
+		end
+
+		def getProvider()
+		end
+
+		def getChangeSet(from = nil, to = nil)
+			return @provider.getChangeSet(from, to)
+		end
+	end
+end

data/lib/disloku/SessionManager.rb

@@ -0,0 +1,38 @@
+require_relative('Log')
+require('net/sftp')
+require('digest/sha1')
+
+module Disloku
+	class SessionManager
+
+		include Singleton
+
+		def initialize()
+			@sessions = {}
+
+			at_exit { shutdown!() }
+		end
+
+		def get(connection, &block)
+			connection = getConnection(connection)
+			block.call(connection)
+		end
+
+		def getConnection(connection)
+			if (!@sessions.has_key?(connection.hash))
+				Log.instance.info("creating new session #{connection.user}@#{connection.host} -> #{connection.hash}")
+				session = Net::SSH.start(connection.host, connection.user, connection.options)
+				sftp = Net::SFTP::Session.new(session).connect!
+				@sessions[connection.hash] = { :sftp => sftp, :ssh => session }
+			end
+
+			return @sessions[connection.hash][:sftp]
+		end
+
+		def shutdown!()
+			Log.instance.info("closing all open sessions")
+			@sessions.each {|key, value| value[:ssh].close() }
+		end
+
+	end
+end

data/lib/disloku/SysCmd.rb

@@ -0,0 +1,15 @@
+require_relative('Log');
+require_relative('SysCmdResult');
+
+module Disloku
+	class SysCmd
+		def initialize(cmd)
+			@cmd = cmd
+		end
+		
+		def execute()
+			Log.instance.info("executing '#{@cmd}'")
+			return SysCmdResult.new(%x(#{@cmd}), $?)
+		end
+	end
+end

data/lib/disloku/SysCmdResult.rb

@@ -0,0 +1,12 @@
+require_relative('Log');
+
+module Disloku
+	class SysCmdResult
+		attr_accessor :output, :exitCode, :result
+		def initialize(output, result)
+			@output = output
+			@result = result
+			@exitCode = result.to_i()
+		end
+	end
+end

data/lib/disloku/Target.rb

@@ -0,0 +1,35 @@
+require_relative('Mapping')
+require_relative('Connection')
+require_relative('util/File')
+
+module Disloku
+	class Target
+		attr_accessor :name, :connection
+
+		def initialize(name, targetConfig, mappingStore, connectionStore)
+			@name = name
+			@config = targetConfig
+
+			if (@config["connection"].value().kind_of?(String))
+				@connection = connectionStore.get(@config["connection"].value())
+			else
+				@connection = Connection.new(@config["connection"])
+			end
+
+			@mapping = Mapping.new(@config, mappingStore)
+		end
+
+		def mapPath(pathSegments)
+			return @mapping.mapPath(pathSegments)
+		end
+
+		def method_missing(name, *args, &block)
+			if (!@config.has?(name.to_s()))
+				return nil
+			end
+
+			return @config[name.to_s()].value()
+		end
+
+	end
+end

data/lib/disloku/git/ChangeSetProvider.rb

@@ -0,0 +1,48 @@
+require_relative('../ChangeSetProvider');
+require_relative('../ChangeSet');
+require_relative('../FileChange');
+require_relative('../SysCmd');
+
+module Disloku
+	module Git
+
+		CHANGE_MAP = {
+			' ' => :nochange,
+			'A' => :added,
+			'C' => :copied,
+			'D' => :deleted,
+			'M' => :modified,
+			'R' => :renamed,
+			'U' => :unmerged,
+			'T' => :typechange,
+			'X' => :unknown,
+			'B' => :broken,
+		}
+
+		class ChangeSetProvider < Disloku::ChangeSetProvider
+			def getChangeSet(from = nil, to = nil)
+				if (from == nil)
+					from = "HEAD"
+				end
+
+				if (to == nil)
+					status = SysCmd.new("git diff --name-status --staged #{from} #{repository.root}").execute()
+				else
+					status = SysCmd.new("git diff --name-status #{from} #{to} #{repository.root}").execute()
+				end
+
+				result = ChangeSet.new()
+				status.output.each_line do |line|
+					match = /^(.)\s+(.*)$/.match(line)
+					result << FileChange.new(repository, match[2], getChangeType(match[1]))
+				end
+
+				return result
+			end
+
+			def getChangeType(changeChar)
+				return CHANGE_MAP[changeChar]
+			end
+		end
+	end
+end

data/lib/disloku/git/Repository.rb

@@ -0,0 +1,31 @@
+require_relative('../Repository')
+require_relative('../SysCmd')
+require_relative('ChangeSetProvider')
+
+module Disloku
+	module Git
+		class Repository < Disloku::Repository
+			def initialize(location)
+				super(location)
+			end
+
+			def getRepositoryRoot()
+				old = Dir.pwd()
+				Dir.chdir(location)
+				status = SysCmd.new("git rev-parse --show-toplevel").execute()
+				Dir.chdir(old)
+
+				return status.output.strip()
+			end
+
+			def getBranchName()
+				branch = SysCmd.new("git --git-dir=\"#{@gitDir}\" rev-parse --abbrev-ref HEAD").execute()
+				return branch.output.strip()
+			end
+
+			def getProvider()
+				return ChangeSetProvider.new(self)
+			end
+		end
+	end
+end

data/lib/disloku/svn/ChangeSetProvider.rb

@@ -0,0 +1,41 @@
+require_relative('../ChangeSetProvider');
+require_relative('../ChangeSet');
+require_relative('../FileChange');
+require_relative('../SysCmd');
+
+module Disloku
+	module Svn
+
+		CHANGE_MAP = {
+			' ' => :nochange,
+			'A' => :added,
+			'C' => :conflicted,
+			'D' => :deleted,
+			'I' => :ignored,
+			'M' => :modified,
+			'R' => :replaced,
+			'X' => :external,
+			'?' => :unversioned,
+			'!' => :missing,
+			'~' => :obstructed,
+		}
+
+		class ChangeSetProvider < Disloku::ChangeSetProvider
+			def getChangeSet(from, to)
+				status = SysCmd.new("svn status #{repository.root}").execute()
+
+				result = ChangeSet.new()
+				status.output.each_line do |line|
+					match = /^(.)......\s+(.*)$/.match(line)
+					result << FileChange.new(repository, match[2], getChangeType(match[1]))
+				end
+
+				return result
+			end
+
+			def getChangeType(changeChar)
+				return CHANGE_MAP[changeChar]
+			end
+		end
+	end
+end

data/lib/disloku/svn/Repository.rb

@@ -0,0 +1,22 @@
+require_relative('../Repository')
+require_relative('ChangeSetProvider')
+
+module Disloku
+	module Svn
+		class Repository < Disloku::Repository
+			def initialize(location)
+				super(location)
+			end
+			
+			def getRepositoryRoot()
+				info = %x[svn info --xml #{location}]
+				m = /<wcroot-abspath>(.*)<\/wcroot-abspath>/.match(info)
+				return m[1]
+			end
+			
+			def getProvider()
+				return ChangeSetProvider.new(self)
+			end
+		end
+	end
+end

data/lib/disloku/tasks/FolderTask.rb

@@ -0,0 +1,79 @@
+require_relative('../Log')
+require_relative('../BaseTask')
+require('fileutils')
+require('stringio')
+
+module Disloku
+	module Tasks
+		class FolderTask < BaseTask
+
+			def initialize(input)
+				super()
+				@options = getInputParam(input, :options, Options)
+				@changesets = getInputParam(input, :changesets, Array)
+				@target = getInputParam(input, :target, Target)
+				@allowOverride = getInputParam(input, :allowOverride, Object)
+				@deletes = StringIO.new()
+
+				@targetDirectory = File.join(@options.packageDir, @target.name)
+			end
+
+			def beforeExecute()
+				if (!Dir.exists?(@targetDirectory))
+					FileUtils.mkpath(@targetDirectory)
+				elsif (Dir.exists?(@targetDirectory) and !@allowOverride)
+					raise Exception.new("Directory '#{@targetDirectory}' already exists")
+				elsif (Dir.exists?(@targetDirectory))
+					FileUtils.rm_r(@targetDirectory, :force => true)
+					Dir::mkdir(@targetDirectory)
+				end
+
+				@result[:directory] = @targetDirectory
+				@result[:files] = []
+			end
+
+			def executeTask()
+				@changesets.each() do |changeset|
+					changeset.each(&method(:executeOnFileChange))
+				end
+			end
+
+			def executeOnFileChange(change)
+				file = change.getFile(@target)
+				if (!file.hasMapping?())
+					return
+				end
+
+				destination = file.getAbsoluteDstPath(@targetDirectory)
+
+				case change.changeType
+					when :modified, :added
+						Log.instance.info("adding file #{file.srcPath}")
+						if (!Dir.exists?(File.dirname(destination)))
+							FileUtils.mkpath(File.dirname(destination))
+						end
+						FileUtils.cp(file.srcPath, destination)
+					when :deleted
+						Log.instance.info("adding file #{file.srcPath} to deletion list")
+						addDelete(file.getAbsoluteDstPath())
+					else
+						Log.instance.warn("ignoring change type #{change.changeType}")
+						return
+				end
+
+				@result[:files].push(file)
+			end
+
+			def afterExecute()
+				if (@options.createDeletesFile)
+					File.write(File.join(@targetDirectory, ".deletes"), @deletes.string)
+				end
+			end
+
+			def addDelete(fullPath)
+				@deletes << "#{fullPath}\n"
+			end
+
+		end
+	end
+end

data/lib/disloku/tasks/NetSftpTask.rb

@@ -0,0 +1,95 @@
+require_relative('../DislokuError')
+require_relative('../Log')
+require_relative('../BaseTask')
+require_relative('../SessionManager')
+
+module Net; module SFTP; module Operations
+	class Upload
+		alias old_on_mkdir on_mkdir
+		def on_mkdir(response)
+			begin
+				old_on_mkdir(response)
+			rescue
+				if (@options[:ignoreMkdirError])
+					process_next_entry
+				else
+					raise
+				end
+			end
+		end
+	end
+end; end; end
+
+module Disloku
+	module Tasks
+		class NetSftpTask < BaseTask
+
+			def initialize(input)
+				super()
+				@repository = getInputParam(input, :repository, Repository)
+				@options = getInputParam(input, :options, Options)
+				@directory = getInputParam(input, :directory, String)
+				@files = getInputParam(input, :files, Array)
+				@target = getInputParam(input, :target, Target)
+			end
+
+			def beforeExecute()
+				if (!@target.branchLock.nil?)
+					branch = @repository.getBranchName()
+					if (branch != @target.branchLock)
+						raise DislokuError.new("Target [#{@target.name}] is locked to branch #{@target.branchLock} but current branch is #{branch}")
+					end
+				end
+
+				puts()
+				puts("Target [#{@target.name}]: #{@target.user}@#{@target.host}:#{@target.targetDir}")
+				@files.each() do |file|
+					puts(file)
+				end
+				puts()
+				puts("Continue with deployment (Y/N)?")
+				response = STDIN.readline().chomp()
+				@skip = response.match(/^[Yy]/) == nil
+				puts("skipping: #{@skip}")
+			end
+
+			def executeTask()
+				if (@skip)
+					return
+				end
+
+				SessionManager.instance.get(@target.connection) do |sftp|
+					Log.instance.info("copying new files...")
+					sftp.upload!(@directory, @target.targetDir, { :ignoreMkdirError => true }) do |event, uploader, *args|
+						case event
+							when :open then
+								# args[0] : file metadata
+								# "starting upload: #{args[0].local} -> #{args[0].remote} (#{args[0].size} bytes}"
+								print(".")
+						end
+					end
+					puts()
+
+					@files.each() do |file|
+						if (file.change.changeType == :deleted)
+							path = file.getAbsoluteDstPath()
+							Log.instance.info("deleting file #{path}")
+							begin
+								sftp.remove!(path)
+							rescue
+								if (!@options.ignoreDeleteErrors)
+									raise
+								else
+									Log.instance.info("unable to delete file #{path} (it probably doesn't exist)")
+								end
+							end
+						end
+					end
+				end
+			end
+
+			def afterExecute()
+			end
+		end
+	end
+end

data/lib/disloku/tasks/PsFtpTask.rb

@@ -0,0 +1,58 @@
+require_relative('../Log')
+require_relative('../BaseTask')
+require('Open3')
+
+module Disloku
+	module Tasks
+		# class PsFtpTask < BaseTask
+		# 	def initialize(stream, config, changesets)
+		# 		super(stream, changesets)
+		# 		@config = config.yaml["psftp"]
+		# 	end
+
+		# 	def beforeExecute()
+		# 		Log.instance.info(@config["path"])
+		# 		env = @config["env"][0]
+		# 		Log.instance.info(env)
+		# 		cmd = "\"#{@config['path']}\""
+
+		# 		if (env.has_key?("key"))
+		# 			cmd += " -i \"#{env['key']}\""
+		# 		else
+		# 			cmd += " -pw #{env['password']}"
+		# 		end
+
+		# 		cmd += " #{env['user']}@#{env['host']}"
+
+		# 		Log.instance.info(cmd)
+
+		# 		@stream, @output = Open3.popen2(cmd)
+		# 		writeLine("cd #{env['targetDir']}")
+		# 	end
+
+		# 	def executeTask(changeset)
+		# 		changeset.each() do |change|
+		# 			destination = change.file.segments.join("/")
+		# 			case change.changeType
+		# 				when :modified, :added
+		# 					path = change.file.getPathSegments().join('/')
+		# 					Log.instance.info("mkdir \"#{path}\"")
+		# 					writeLine("mkdir \"#{path}\"")
+		# 					Log.instance.info("put \"#{change.file.filePath}\" \"#{destination}\"")
+		# 					writeLine("put \"#{change.file.filePath}\" \"#{destination}\"")
+		# 				when :deleted
+		# 					writeLine("del \"#{destination}\"")
+		# 				else
+		# 					Log.instance.info("ignoring change type #{change.changeType}")
+		# 			end
+		# 		end
+		# 	end
+
+		# 	def afterExecute()
+		# 		writeLine("quit")
+
+		# 		@output.readlines.each(&Log.instance.method(:info))
+		# 	end
+		# end
+	end
+end

data/lib/disloku/util/File.rb

@@ -0,0 +1,47 @@
+module Disloku
+	module Util
+
+		SPLIT_EXP = "\\#{File::SEPARATOR}|\\#{File::ALT_SEPARATOR}"
+
+		class File
+			attr_accessor :srcPath, :change
+
+			def initialize(filePath, basePath, target, change)
+				@srcPath = filePath
+				@target = target
+				@change = change
+
+				fileSegments = filePath.split(/#{SPLIT_EXP}/)
+				baseSegments = basePath.split(/#{SPLIT_EXP}/)
+				index = 0
+				while (fileSegments[index] == baseSegments[index])
+					index += 1
+				end
+
+				@relativeSrcSegments = fileSegments[index..-1]
+				@relativeDstSegments = target.mapPath(@relativeSrcSegments)
+			end
+
+			def getRelativeDstSegments()
+				return @segments
+			end
+
+			def getRelativeDirSegments()
+				return @segments[0..-2]
+			end
+
+			def hasMapping?()
+				return @relativeDstSegments != nil
+			end
+
+			def getAbsoluteDstPath(basePath = nil)
+				basePath = basePath || @target.targetDir
+				return ::File.join(basePath, *@relativeDstSegments)
+			end
+
+			def to_s()
+				return "#{srcPath} -> #{getAbsoluteDstPath()}"
+			end
+		end
+	end
+end

data/lib/disloku/util/Hash.rb

@@ -0,0 +1,12 @@
+
+class Hash
+	def recursive_merge(other)
+		return merge(other) do |key, oldv, newv|
+			if (oldv.kind_of?(Hash) && newv.kind_of?(Hash))
+				oldv.recursive_merge(newv)
+			else
+				newv
+			end
+		end
+	end
+end

data/lib/disloku.rb

@@ -0,0 +1,32 @@
+require_relative('disloku/Disloku')
+require_relative('disloku/SysCmd')
+require_relative('disloku/SessionManager')
+require('thor')
+
+class DislokuCli < Thor
+	desc "deploy [FROM] [TO]", "deploy changes"
+	method_option :dir, :default => ".", :aliases => "-d", :desc => "repository directory"
+	method_option :target, :aliases => "-t", :desc => "target"
+	def deploy(from = nil, to = nil)
+		puts "deploy #{options.inspect}"
+
+		disloku = Disloku::Disloku.new(options)
+		disloku.deployPackage(from, to)
+	end
+
+	desc "build [FROM] [TO]", "build change package"
+	method_option :dir, :default => ".", :aliases => "-d", :desc => "repository directory"
+	method_option :target, :aliases => "-t", :desc => "target"
+	def build(from = nil, to = nil)
+		p(options)
+		disloku = Disloku::Disloku.new(options)
+		dir = disloku.buildPackage(from, to)
+	end
+
+	desc "config", "show configuration"
+	method_option :dir, :default => ".", :aliases => "-d", :desc => "repository directory"
+	def config()
+		disloku = Disloku::Disloku.new(options)
+		puts(disloku.config.to_yaml())
+	end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: disloku
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lukas Angerer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-05 00:00:00.000000000 Z
+dependencies: []
+description: A deployment tool that allows copying of Git changesets via sftp
+email: executor.dev@gmail.com
+executables:
+- disloku
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/disloku/BaseTask.rb
+- lib/disloku/ChangeSet.rb
+- lib/disloku/ChangeSetProvider.rb
+- lib/disloku/Commit.rb
+- lib/disloku/Config.rb
+- lib/disloku/Connection.rb
+- lib/disloku/ConnectionStore.rb
+- lib/disloku/Disloku.rb
+- lib/disloku/DislokuError.rb
+- lib/disloku/FileChange.rb
+- lib/disloku/git/ChangeSetProvider.rb
+- lib/disloku/git/Repository.rb
+- lib/disloku/Log.rb
+- lib/disloku/Mapping.rb
+- lib/disloku/MappingStore.rb
+- lib/disloku/NamedConfigStore.rb
+- lib/disloku/Options.rb
+- lib/disloku/Repository.rb
+- lib/disloku/SessionManager.rb
+- lib/disloku/svn/ChangeSetProvider.rb
+- lib/disloku/svn/Repository.rb
+- lib/disloku/SysCmd.rb
+- lib/disloku/SysCmdResult.rb
+- lib/disloku/Target.rb
+- lib/disloku/tasks/FolderTask.rb
+- lib/disloku/tasks/NetSftpTask.rb
+- lib/disloku/tasks/PsFtpTask.rb
+- lib/disloku/util/File.rb
+- lib/disloku/util/Hash.rb
+- lib/disloku.rb
+- bin/disloku
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Disloku deployment tool
+test_files: []