eventhub-command 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f66abed175efcdc6ba3009737a7a8c8fa1672c4
-  data.tar.gz: 7c74829f7b39de27229d96770d4de564a653b908
+  metadata.gz: 5e59a6239b908a41811a317418219b8a4760792e
+  data.tar.gz: 1ed264c65607cfeed2698851870da30f7a1c99bf
 SHA512:
-  metadata.gz: 0c7bc9272b01e836f9d418e392c9cfd5ca255f56ce8b9cfffa89d7c450d03fdca9a6827d4b16b8dd078681c8b8c082b76cb4c2f4cda01a9452f508f4cd57b0d3
-  data.tar.gz: 152dc8f8fc1fe2cabc65441f050ba71143460e18a57e1be8e3f4fd4eddd62be6edf39cf4b320bb25f0839224659d66a90b9da5f7cf35a38912db9af8b3a5a495
+  metadata.gz: 1733d17688b953e82fe07afa35d1c9a0fd304b78b451463a3217f34ce9c2fd62d7244c88fb2e7cccbd9fe700164cae18d4037298ff880529f479ddbbfbadb998
+  data.tar.gz: 322c3ddd44488f03cdd01095b6b95bc2a632930879e92c0007765b2c1e2586673dc103c05398214d0434cccbe3676fffaffb0c7e1a6245acbb4b6dee80cdf71e

data/README.md

@@ -19,34 +19,73 @@ $ rbenv rehash
 First time running the command
 ~~~ sh
 $ eh
-Config file missing: ~/.eh, will create it now...
-Please specify the Eventhub SVN root directory (i.e. the directory which contains the 'src', 'release', ... directories
-/Users/username/dev/event_hub
-Config file written to /Users/username/.eh. Please try again.
+Created empty config file. Please run 'eh repository add'
 $
 ~~~
 
-For some deploy commands you'll need a file describing the target servers (stages).
-Put them into
-
-~~~
-~/.eh-stages
+Run again:
+~~~ sh
+$ eh repository add http://something.com/project/svn /Users/foo/eventhub/branches/master username password
+$
 ~~~
 
+NOTE: username and password you specify here are from the deploy user.
+
+### Stages
+
+Some commands (e.g. deploy commands) will use stages to determine where to deploy. Those stage files are now
+stored in the eventhub SVN repository under config/ directory
+
 The file name is the name of the stage, the content describes environments, hosts, ports and users to use.
 Content looks like this:
 
 ~~~
 localhost:
-  node_env: development
   hosts:
     - host: localhost
       port: 2222
-      user: s_cme
+      user: some_user
 ~~~
 
 
+## Usage
 
+Help and description for the commands can be obtained through:
+
+~~~
+eh --help
+~~~
+and more specific for a single command
+~~~
+eh <COMMAND> --help
+~~~
+
+### Common options
+
+Some common options are:
+
+* --stage (one of the names that are listed from list_stages command)
+* --deploy_via (use svn or scp for deployment. If scp, then the local release directory is used, otherwise svn)
+* --branch/--tag (specify a branch or tag to use for "deploy_via scp")
+* --verbose (enable verbose output)
+
+### Commands
+
+* deploy_ruby: deploy a ruby processor to a stage. You can specify:
+  * a processor name
+  * multiple processor names spearated via commas
+  * a pattern like something.*
+  * a combination of above
+* deploy_mule: deploy a mule adapter to a stage
+  * a adapter name
+  * multiple adapter names spearated via commas
+  * a pattern like something.*
+  * a combination of above
+* deploy_config: checkout the latest version of config on target stage and copy to the config folder on stage.
+Those config files will be used uppon next deployment.
+* list_stages: list stages that are available for deploy_* commands
+* package_ruby: package ruby processors to zip files and copy to release directory on local machines. Those packages
+will be used upon next "deploy_via scp" or if you commit them to SVN then upon next "deploy_via svn"
+* generate_processor: generate a processor from a basic template
 
 
-## Usage

data/bin/eh

@@ -14,14 +14,10 @@ if File.readable?(config_file)
   settings = Eh::Settings.load(config_file)
   Eh::Settings.current = settings
 else
-  puts "Config file missing: ~/.eh, will create it now..."
-  puts "Please specify the Eventhub SVN root directory (i.e. the directory which contains the 'src', 'release', ... directories"
-  input = STDIN.gets.chomp
-  data = {'repository_root_dir' => input}
   File.open(config_file, 'w') do |file|
-    file.write(JSON.dump(data))
+    file.write(JSON.dump({}))
   end
-  puts "Config file written to #{config_file}. Please try again."
+  puts "Created empty config file. Please run 'eh repository add'"
   exit
 end
 

data/lib/deployer.rb

@@ -4,3 +4,8 @@ end
 require_relative 'deployer/executor'
 require_relative 'deployer/net_ssh_extension'
 require_relative 'deployer/stage'
+
+require_relative 'deployer/base_deployer'
+require_relative 'deployer/mule_deployer'
+require_relative 'deployer/ruby_deployer'
+require_relative 'deployer/config_deployer'

data/lib/deployer/base_deployer.rb

@@ -0,0 +1,136 @@
+class Deployer::BaseDeployer
+  attr_reader :options, :stage_path, :stage
+
+  def initialize(options)
+    @options = options
+
+    @stage_path = File.join(Eh::Settings.current.stages_dir, "#{options[:stage]}.yml")
+    @stage = Deployer::Stage.load(stage_path)
+  end
+
+  private
+
+  def config_source_dir(*extra_paths)
+    File.join(base_dir, 'config', *extra_paths)
+  end
+
+  def log_deployment(executor, message)
+    executor.execute("echo $(date): #{message} - #{ENV['USER']} >> #{deploy_log_file}")
+  end
+
+  def base_dir
+    "/apps/compoundbank/s_cme/apps/event_hub"
+  end
+
+  def deploy_log_file
+    File.join(base_dir, 'shared', 'logs', 'deploy.log')
+  end
+
+  def deploy_via
+    options[:deploy_via]
+  end
+
+  def verbose?
+    options[:verbose]
+  end
+
+  def via_scp?
+    deploy_via == 'scp'
+  end
+
+  def cached_copy_dir(*extra_paths)
+    dir = if via_scp?
+      File.join(base_dir, 'shared', 'cached-copy-scp')
+    else
+      if options[:tag]
+        File.join(base_dir, 'shared', 'cached-copy-svn', 'tags', options[:tag], 'releases')
+      elsif options[:branch]
+        File.join(base_dir, 'shared', 'cached-copy-svn', 'branches', options[:branch], 'releases')
+      else
+        File.join(base_dir, 'shared', 'cached-copy-svn', 'branches', 'master', 'releases')
+      end
+    end
+    File.join(dir, *extra_paths)
+  end
+
+  def scm_username
+    'deploy'
+  end
+
+  def scm_password
+    'deploy2014!'
+  end
+
+  def scm_base_url
+    "https://whistler.plan.io/svn/eventhub"
+  end
+
+  def repository
+    "#{scm_base_url}/branches/master/releases"
+  end
+
+
+  def create_base_dirs(executor)
+    dirs = [
+      File.join(base_dir, 'config'),
+      File.join(base_dir, 'ruby'),
+      File.join(base_dir, 'mule'),
+      File.join(base_dir, 'rails'),
+      File.join(base_dir, 'shared'),
+      File.join(base_dir, 'shared', 'pids'),
+      File.join(base_dir, 'shared', 'logs'),
+      File.join(base_dir, 'shared', 'cached-copy-scp')
+    ]
+    cmds = dirs.map do |dir|
+      "mkdir -p #{dir}"
+    end
+    executor.execute(cmds.join(" && "))
+  end
+  def update_scm(executor)
+    dir = File.join(base_dir, 'shared/cached-copy-svn')
+    cmd = <<-EOS
+      if [[ -d #{dir} ]]
+      then
+        cd #{dir}
+        svn up --trust-server-cert --non-interactive --username #{scm_username} --password #{scm_password}
+      else
+        svn co --trust-server-cert --non-interactive --username #{scm_username} --password #{scm_password} #{scm_base_url} #{dir}
+      fi
+    EOS
+    executor.execute(cmd)
+  end
+
+  private
+
+
+  # Executes an ls on all hosts and returns the combined
+  # list of files or dirs.
+  def remote_ls(executor, options, pattern)
+    results = executor.execute("ls #{pattern}", options)
+    results.map do |result|
+      if result[:stdout]
+        result[:stdout].split("\n")
+      end
+    end.flatten.compact.uniq
+  end
+
+  def verify_deployment_list!(requested, available)
+    # remove requested that are not available
+    puts 'Deployment List'.light_blue.on_blue
+    abort = false
+    requested.each do |name|
+      if available.include?(name)
+        puts "#{name}: AVAILABLE".green
+      else
+        abort = true
+        puts "#{name}: UNAVAILABLE".red
+      end
+    end
+    if abort
+      puts 'Not all requested components are available in #{cached_copy_dir}. Will abort.'.red
+      raise
+    end
+
+  end
+
+end

data/lib/deployer/config_deployer.rb

@@ -0,0 +1,29 @@
+class Deployer::ConfigDeployer < Deployer::BaseDeployer
+  def initialize(options = {})
+    options[:deploy_via] = 'svn'
+    super(options)
+  end
+
+  def deploy!
+    puts "deploying to #{stage.name} via #{deploy_via}".light_blue.on_blue
+    Deployer::Executor.new(stage, verbose: verbose?) do |executor|
+      create_base_dirs(executor)
+      update_scm(executor)
+
+      source = cached_copy_dir('..', 'config', "%{stagename}", "%{hostname}", '')
+      target = config_source_dir
+
+      cmd = "rsync -r --exclude=.svn #{source} #{target}"
+      executor.execute(cmd)
+      # stage.hosts.each do |host|
+      #   hostname = host[:host]
+      #   source = cached_copy_dir('..', 'config', stage.name, hostname, '')
+      #   target = config_source_dir
+
+      #   # we use rsync to copy without .svn folders
+      #   cmd = "mkdir -p #{target} && rsync -r --exclude=.svn #{source} #{target}"
+      #   executor.execute_on(host, cmd)
+      # end
+    end
+  end
+end

data/lib/deployer/executor.rb

@@ -10,32 +10,47 @@ class Deployer::Executor
     yield(self) if block_given?
   end
 
-
+  # execute a command on all hosts of a stage
+  # commands are expanded with :hostname, :port and :stagename
   def execute(command, options = {})
-    log_command("Execute: '#{command}'", options[:comment])
-    stage.hosts.each_with_index do |host, index|
+    log_command("Execute: '#{command.strip}'", options[:comment])
+    stage.hosts.each_with_index.map do |host, index|
+      expand_options = {hostname: host[:host], stagename: stage.name, port: host[:port]}
+
+      expanded_command = command % expand_options
+      if expanded_command != command
+        log_command("Expanded command to #{expanded_command}")
+      end
       log_host(host, index)
-      result = execute_on(host, command)
+      result = execute_on(host, expanded_command)
       log_result(result)
+      result
     end
 
   rescue => e
     handle_exception(e, options)
   end
 
+
+  def execute_on(host, command)
+    Net::SSH.start(host[:host], host[:user], port: host[:port]) do |ssh|
+      ssh.exec_sc!(command)
+    end
+  end
+
   def upload(source, target, options = {})
     log_command("Execute: scp #{source} to #{target}", options[:comment])
     stage.hosts.each_with_index do |host, index|
       log_host(host, index)
       result = upload_on(host, source, target)
       log_result(result)
+      result
     end
 
   rescue => e
     handle_exception(e, options)
   end
 
-
   private
   def handle_exception(e, options)
     if options[:abort_on_error] == false
@@ -73,11 +88,7 @@ class Deployer::Executor
     execute_local "scp -P #{host[:port]} #{source} #{host[:user]}@#{host[:host]}:#{target}"
   end
 
-  def execute_on(host, command)
-    Net::SSH.start(host[:host], host[:user], port: host[:port]) do |ssh|
-      ssh.exec_sc!(command)
-    end
-  end
+
 
   def execute_local(command)
     output = nil

data/lib/deployer/mule_deployer.rb

@@ -0,0 +1,85 @@
+class Deployer::MuleDeployer < Deployer::BaseDeployer
+  attr_reader :adapter_names
+
+  def initialize(adapter_names, options)
+    super(options)
+    @adapter_names = adapter_names
+  end
+
+  def adapter_cached_copy(adapter_name)
+    cached_copy_dir('mule', "#{adapter_name}.zip")
+  end
+
+  def config_source_dir(adapter_name)
+    super('mule', adapter_name)
+  end
+
+  def deploy!
+    puts "deploying to #{stage.name} via #{deploy_via}".light_blue.on_blue
+
+    Deployer::Executor.new(stage, verbose: verbose?) do |executor|
+      create_base_dirs(executor)
+
+      # update
+      update_cached_copy(executor)
+
+      adapter_names_to_deploy = resolve_adapter_names(executor, options)
+
+      adapter_names_to_deploy.each do |adapter_name|
+        puts
+        puts "Deploying #{adapter_name}".light_blue.on_blue
+        log_deployment(executor, "Deploying #{adapter_name} via #{deploy_via} from #{cached_copy_dir}")
+        # make a copy of the zip files to merge them with config
+        cached_copy_source = adapter_cached_copy(adapter_name)
+        configuration_target = File.join(base_dir, 'mule', "#{adapter_name}.zip")
+        executor.execute("cp #{cached_copy_source} #{configuration_target}")
+
+        # copy config
+        config_source = config_source_dir(adapter_name)
+        executor.execute("if [[ -d #{config_source} ]] ; then cd #{config_source} ; zip -r #{configuration_target} . ; fi")
+
+        # deploy
+        executor.execute("cp #{adapter_cached_copy(adapter_name)} $MULE_HOME/apps")
+      end
+    end
+  end
+
+
+  private
+
+  def resolve_adapter_names(executor, options)
+    available = remote_ls(executor, options, cached_copy_dir('mule', '*.zip')).map do |name|
+      File.basename(name, '.zip')
+    end
+
+    fetched = Array(adapter_names).map do |name|
+      if name.include?('*') # resolve pattern on remote machine
+        remote_ls(executor, options, cached_copy_dir('mule', "#{name}.zip"))
+      else
+        name
+      end
+    end
+    if fetched.empty? # then fetch all
+      fetched = available
+    end
+
+    fetched = fetched.flatten.map do |name|
+      File.basename(name, '.zip')
+    end
+
+    verify_deployment_list!(fetched, available)
+
+    fetched
+  end
+
+  def update_cached_copy(executor)
+    if via_scp?
+      source = Eh::Settings.current.releases_dir('mule', '*.zip')
+      target_dir = cached_copy_dir('mule')
+      executor.execute("rm -rf #{target_dir}/*.zip && mkdir -p #{target_dir}")
+      executor.upload(source, target_dir)
+    else
+      update_scm(executor)
+    end
+  end
+end

data/lib/deployer/net_ssh_extension.rb

@@ -2,7 +2,7 @@ class Net::SSH::Connection::Session
 
   def exec_sc!(command)
     stdout_data,stderr_data = "",""
-    exit_code,exit_signal = nil,nil
+    exit_code, exit_signal = nil,nil
     self.open_channel do |channel|
       channel.exec(command) do |_, success|
         raise "Command \"#{command}\" was unable to execute" unless success

data/lib/deployer/ruby_deployer.rb

@@ -0,0 +1,111 @@
+class Deployer::RubyDeployer < Deployer::BaseDeployer
+  attr_accessor :processor_names
+
+  def initialize(processor_names, options)
+    super(options)
+    @processor_names = processor_names
+  end
+
+  def deploy!
+    puts "deploying to #{stage.name} via #{deploy_via}".light_blue.on_blue
+
+    Deployer::Executor.new(stage, verbose: verbose?) do |executor|
+      create_base_dirs(executor)
+
+
+      update_cached_copy(executor)
+
+
+      # fetch processor_names unless they have been passed as an argument to the initializer
+      processor_names_to_deploy = resolve_processor_names(executor, options)
+      processor_names_to_deploy.each do |processor_name|
+        puts
+        puts "Deploying #{processor_name}".light_blue.on_blue
+        log_deployment(executor, "Deploying #{processor_name} via #{deploy_via} from #{cached_copy_dir}")
+        # stop old one
+        executor.execute("kill -s TERM $(cat #{File.join(pids_dir, processor_name)}.pid)", abort_on_error: false, comment: "This is not sooo important")
+
+        # unzip package
+        target = deploy_dir('ruby')
+        source = cached_copy_dir('ruby',"#{processor_name}.zip")
+        executor.execute("rm -rf #{processor_dir(processor_name)} && unzip -o -d #{target} #{source}")
+
+        # copy config
+        executor.execute("if [[ -d #{config_source_dir(processor_name)} ]] ; then cp -r #{config_source_dir(processor_name)}/* #{processor_dir(processor_name)}; fi")
+
+        # symlink log dir
+        executor.execute("ln -s #{logs_dir} #{processor_dir(processor_name, 'logs')}")
+
+        # symlink pids dir
+        executor.execute("ln -s #{pids_dir} #{processor_dir(processor_name, 'pids')}")
+
+        # install gems
+        executor.execute("cd #{processor_dir(processor_name)} && bundle install --without test")
+
+        # start new one
+        executor.execute("cd #{processor_dir(processor_name)} && bundle exec ruby #{processor_name}.rb -d -e $EH_ENV")
+      end
+    end
+  end
+
+  private
+
+  def update_cached_copy(executor)
+    if via_scp?
+      source = Eh::Settings.current.releases_dir('ruby', '*.zip')
+      target_dir = File.join(cached_copy_dir, 'ruby')
+      executor.execute("rm -rf #{target_dir}/*.zip && mkdir -p #{target_dir}")
+      executor.upload(source, target_dir)
+    else
+      update_scm(executor)
+    end
+  end
+
+  def logs_dir
+    File.join(base_dir, 'shared', 'logs')
+  end
+
+  def pids_dir
+    File.join(base_dir, 'shared', 'pids')
+  end
+
+  def deploy_dir(*extra_paths)
+    File.join(base_dir, *extra_paths)
+  end
+
+  def processor_dir(*extra_paths)
+    File.join(deploy_dir, 'ruby', *extra_paths)
+  end
+
+  def config_source_dir(processor_name)
+    super('ruby', processor_name)
+  end
+
+  # Detect what processors to deploy
+  #
+  def resolve_processor_names(executor, options)
+    available = remote_ls(executor, options, File.join(cached_copy_dir, 'ruby', '*.zip')).map do |name|
+      File.basename(name, '.zip')
+    end
+
+    fetched = Array(processor_names).map do |name|
+      if name.include?('*') # resolve pattern on remote machine
+        remote_ls(executor, options, File.join(cached_copy_dir, 'ruby', "#{name}.zip"))
+      else
+        name
+      end
+    end
+    if fetched.empty? # then fetch all
+      fetched = available
+    end
+
+    fetched = fetched.flatten.map do |name|
+      File.basename(name, '.zip')
+    end
+
+    verify_deployment_list!(fetched, available)
+
+    fetched
+  end
+
+end

data/lib/deployer/stage.rb

@@ -1,9 +1,8 @@
 class Deployer::Stage
-  attr_reader :name, :node_env, :hosts
+  attr_reader :name, :hosts
 
-  def initialize(name, node_env)
+  def initialize(name)
     @name = name
-    @node_env = node_env
     @hosts = []
   end
 
@@ -18,7 +17,7 @@ class Deployer::Stage
   def self.load(file)
     data = YAML.load_file(file)
     data.map do |name, config|
-      stage = Deployer::Stage.new(name, config['node_env'])
+      stage = Deployer::Stage.new(name)
       config['hosts'].each do |host|
         stage.host(host['host'], host['port'], host['user'])
       end

data/lib/eh-commands.rb

@@ -1,8 +1,17 @@
 # All commands are required here
-require 'eh/commands/deploy'
-require 'eh/commands/copy_config'
-require 'eh/commands/generate_processor'
-require 'eh/commands/package_rails'
-require 'eh/commands/package'
-require 'eh/commands/deploy_ruby'
-require 'eh/commands/deploy_mule'
+if Eh::Settings.current.repository
+  require 'eh/commands/deploy'
+  require 'eh/commands/generate_processor'
+  require 'eh/commands/package_ruby'
+  require 'eh/commands/list_stages'
+  require 'eh/commands/deploy_config'
+  require 'eh/commands/deploy_ruby'
+  require 'eh/commands/deploy_mule'
+else
+  # remove unused settings for this version
+  Eh::Settings.current.data.delete('repository_root_dir')
+  Eh::Settings.current.write
+  puts "No current repository defined. Please run 'eh repository add' and/or 'eh repository select'"
+end
+
+require 'eh/commands/repository'

data/lib/eh/commands/deploy.rb

@@ -1,7 +1,7 @@
 desc 'Deploys the app'
 arg_name 'stage', optional: true
-command :deploy do |c|
 
+command :deploy do |c|
   c.flag([:deploy_via], :desc => "One of 'copy' or 'scm'", :default_value => 'scm')
   c.flag([:copy_from_dir], :desc => "Source directory for copy operation", :default_value => Eh::Settings.current.releases_dir)
   c.flag([:tag], :desc => "The tag to deploy")

data/lib/eh/commands/deploy_config.rb

@@ -0,0 +1,18 @@
+desc 'distribute the configs to the nodes'
+
+command :deploy_config do |c|
+  c.flag([:stage], desc: 'stage', type: String, long_desc: 'Stage where processor is deployed to', default_value: 'development')
+  c.flag([:branch], desc: 'branch', type: String, long_desc: 'What branch to deploy. Only when deploy_via=scm', default_value: 'master')
+  c.flag([:tag], desc: 'tag', type: String, long_desc: 'What tag to deploy. Only when deploy_via=scm', default_value: nil)
+
+  c.switch([:v, :verbose], :desc => 'Show additional output.')
+
+  c.action do |global_options, options, args|
+    begin
+      Deployer::ConfigDeployer.new(options).deploy!
+    rescue => e
+      puts e.message
+      puts e.backtrace.join("\n")
+    end
+  end
+end

data/lib/eh/commands/deploy_mule.rb

@@ -1,68 +1,23 @@
-
 desc 'deploy a single channel adapter'
-arg_name 'channel_adapter stage'
+arg_name '[channel_adapter[,other_channel_adapter,pattern*]]'
 
 command :deploy_mule do |c|
-  c.flag([:s, :stage], desc: "stage", type: String, long_desc: "Stage where channel adapter is deployed to", default_value: 'localhost')
-  c.flag([:deploy_via], desc: "how to get hold of the channel adapter: scm or scp", type: String, long_desc: "copy the channel adapter zip file via scp from this machine or check it out from scm", default_value: 'scp')
+  c.flag([:stage], desc: 'stage', type: String, long_desc: 'Stage where channel adapter is deployed to', default_value: 'development')
+  c.flag([:deploy_via], desc: 'how to get hold of the channel adapter: scm or scp', type: String, long_desc: 'copy the channel adapter zip file via scp from this machine or check it out from scm', default_value: 'scp')
 
-  c.switch([:v, :verbose], :desc => "Show additional output.")
+  c.switch([:v, :verbose], :desc => 'Show additional output.')
 
   c.action do |global_options, options, args|
-    if args.size < 1
-      puts "Needs at least one argument: channel_adapter"
-      exit -1
-    end
-
-    adapter_name = args[0]
-
-
-    stage_path = File.join(Eh::Settings.current.stages_dir, "#{options[:stage]}.yml")
-    stage = Deployer::Stage.load(stage_path)
-
-    puts "deploying #{adapter_name} to #{stage.name} for environment #{stage.node_env}"
-    puts "deploying via: #{options[:deploy_via]}"
-
-
-    base_dir = "/apps/compoundbank/s_cme/apps/event_hub"
-
-
-    if options[:deploy_via] == 'scp'
-      cached_copy_dir = File.join(base_dir, 'eh-cached-copy-scp')
-    else
-      cached_copy_dir = File.join(base_dir, 'eh-cached-copy-scm')
-    end
-
-    adapter_cached_copy = File.join(cached_copy_dir, 'mule', "#{adapter_name}.zip")
-    config_source_dir = File.join(base_dir, 'config', 'mule', adapter_name)
-
-    # TODO: move to common place for all commands
-    scm_username = 'deploy'
-    scm_password = 'deploy2014!'
-    scm_base_url = "https://whistler.plan.io/svn/eventhub"
-    repository = "#{scm_base_url}/branches/master/releases"
-
-    Deployer::Executor.new(stage, verbose: options[:verbose]) do |executor|
-      # create required directories
-      executor.execute("mkdir -p #{base_dir}")
-      executor.execute("rm -rf #{cached_copy_dir}")
-
-      if options[:deploy_via] == 'scp'
-        # upload pre-packaged processor via scp
-        source = "#{Eh::Settings.current.releases_dir}/mule/#{adapter_name}.zip"
-        raise ArgumentError, "#{adapter_name} does not seem to exist, no file to read at #{source}" if !File.readable?(source)
-        executor.upload(source, adapter_cached_copy)
+    begin
+      if args[0]
+        adapter_names = args[0].split(',').map(&:strip)
       else
-        co_line = "svn co --trust-server-cert --non-interactive --username #{scm_username} --password #{scm_password} #{repository} #{cached_copy_dir}"
-        executor.execute(co_line)
+        adapter_names = nil
       end
-
-      # copy config
-      source = File.join(config_source_dir, adapter_name)
-      executor.execute("if [[ -d #{config_source_dir} ]] ; then cd #{config_source_dir} ; zip -r #{adapter_cached_copy} . ; fi")
-
-      # deploy
-      executor.execute("cp #{adapter_cached_copy} $MULE_HOME/apps")
+      Deployer::MuleDeployer.new(adapter_names, options).deploy!
+    rescue => e
+      puts e.message
+      puts e.backtrace.join("\n")
     end
   end
 end

data/lib/eh/commands/deploy_ruby.rb

@@ -1,87 +1,25 @@
 desc 'deploy a single ruby processor'
-arg_name 'processor_name stage'
+arg_name '[processor_name,[other_processor_name,pattern*]]'
 
 command :deploy_ruby do |c|
-  c.flag([:s, :stage], desc: "stage", type: String, long_desc: "Stage where processor is deployed to", default_value: 'localhost')
-  c.flag([:deploy_via], desc: "how to get hold of the processor: scm or scp", type: String, long_desc: "copy the processor zip file via scp from this machine or check it out from scm", default_value: 'scp')
+  c.flag([:stage], desc: 'stage', type: String, long_desc: 'Stage where processor is deployed to', default_value: 'development')
+  c.flag([:deploy_via], desc: 'how to get hold of the processor: scm or scp', type: String, long_desc: 'copy the processor zip file via scp from this machine or check it out from scm', default_value: 'scp')
+  c.flag([:branch], desc: 'branch', type: String, long_desc: 'What branch to deploy. Only when deploy_via=scm', default_value: 'master')
+  c.flag([:tag], desc: 'tag', type: String, long_desc: 'What tag to deploy. Only when deploy_via=scm', default_value: nil)
 
-  c.switch([:v, :verbose], :desc => "Show additional output.")
+  c.switch([:v, :verbose], :desc => 'Show additional output.')
 
   c.action do |global_options, options, args|
-
-    if args.size < 1
-      puts "Needs at least one argument: processor_name"
-      exit -1
-    end
-
-    processor_name = args[0]
-    stage_path = File.join(Eh::Settings.current.stages_dir, "#{options[:stage]}.yml")
-    stage = Deployer::Stage.load(stage_path)
-
-
-    puts "deploying #{processor_name} to #{stage.name} for environment #{stage.node_env}"
-    puts "deploying via: #{options[:deploy_via]}"
-
-
-    base_dir = "/apps/compoundbank/s_cme/apps/event_hub"
-    logs_dir = File.join(base_dir, 'shared', 'logs')
-    pids_dir = File.join(base_dir, 'shared', 'pids')
-
-
-    if options[:deploy_via] == 'scp'
-      cached_copy_dir = File.join(base_dir, 'eh-cached-copy-scp')
-    else
-      cached_copy_dir = File.join(base_dir, 'eh-cached-copy-scm')
-    end
-
-    current_dir = File.join(base_dir, 'eh-current')
-
-    processor_dir = File.join(current_dir, 'ruby', processor_name)
-    config_source_dir = File.join(base_dir, 'config', 'ruby', processor_name)
-
-    # TODO: move to common place
-    scm_username = 'deploy'
-    scm_password = 'deploy2014!'
-    scm_base_url = "https://whistler.plan.io/svn/eventhub"
-    repository = "#{scm_base_url}/branches/master/releases"
-
-    Deployer::Executor.new(stage, verbose: options[:verbose]) do |executor|
-      # create required directories
-      executor.execute("mkdir -p #{base_dir} ; mkdir -p #{logs_dir} ; mkdir -p #{File.join(current_dir, 'ruby')} ; mkdir -p #{File.join(cached_copy_dir, 'ruby')}")
-
-      if options[:deploy_via] == 'scp'
-        # upload pre-packaged processor via scp
-        source = "#{Eh::Settings.current.releases_dir}/ruby/#{processor_name}.zip"
-        target = File.join(cached_copy_dir, 'ruby', "#{processor_name}.zip")
-        executor.upload(source, target)
+    begin
+      if args[0]
+        processor_names = args[0].split(',').map(&:strip)
       else
-        co_line = "svn co --trust-server-cert --non-interactive --username #{scm_username} --password #{scm_password} #{repository} #{cached_copy_dir}"
-        executor.execute(co_line)
+        processor_names = nil
       end
-
-      # unzip package
-      source = File.join(current_dir, 'ruby')
-      target = "#{File.join(cached_copy_dir, 'ruby', processor_name)}.zip"
-      executor.execute("unzip -o -d #{source} #{target}")
-
-      # copy config
-      executor.execute("if [[ -d #{config_source_dir} ]] ; then cp -r #{config_source_dir}/* #{processor_dir}; fi")
-
-      # symlink log dir
-      executor.execute("ln -s #{logs_dir} #{File.join(processor_dir, 'logs')}")
-
-      # symlink pids dir
-      executor.execute("ln -s #{pids_dir} #{File.join(processor_dir, 'pids')}")
-
-      # install gems
-      executor.execute("cd #{processor_dir} && bundle install --without test")
-
-      # stop old one
-      executor.execute("kill -s TERM $(cat #{File.join(pids_dir, processor_name)}.pid)", abort_on_error: false, comment: "This is not sooo important")
-
-      # start new one
-      executor.execute("cd #{processor_dir} && bundle exec ruby #{processor_name}.rb -d --environment=#{stage.node_env}")
+      Deployer::RubyDeployer.new(processor_names, options).deploy!
+    rescue => e
+      puts e.message
+      puts e.backtrace.join("\n")
     end
-
   end
 end

data/lib/eh/commands/list_stages.rb

@@ -0,0 +1,17 @@
+desc 'list the available stages'
+
+command :list_stages do |c|
+  #c.flag([:branch], desc: 'branch', type: String, long_desc: 'What branch to deploy. Only when deploy_via=scm', default_value: 'master')
+  #c.flag([:tag], desc: 'tag', type: String, long_desc: 'What tag to deploy. Only when deploy_via=scm', default_value: nil)
+
+  c.switch([:v, :verbose], :desc => 'Show additional output.')
+
+  c.action do |global_options, options, args|
+    dir = Eh::Settings.current.stages_dir
+    puts "Checking in #{dir}".green if options[:verbose]
+    puts "Available stages are:".blue
+    Dir.glob(File.join(dir, '*.yml')) do |name|
+      puts "#{File.basename(name, '.*')}".light_blue
+    end
+  end
+end

data/lib/eh/commands/{package.rb → package_ruby.rb}

@@ -1,5 +1,5 @@
 desc 'Packages processors to zip files'
-command :package do |c|
+command :package_ruby do |c|
   c.flag([:x, :exclude], :desc => "Exclude processors by name.", :type => Array, :long_desc => "You can specify multiple processors by providing a comma-separated list.")
   c.flag([:p, :processors], :desc => "Specify what processors to package", :type => Array, :long_desc => "You can specify multiple processors by providing a comma-separated list.")
   c.flag([:d, :destination], :desc => "Destination directory to place created zip files.", :default_value => Eh::Settings.current.ruby_release_dir)

data/lib/eh/commands/repository.rb

@@ -0,0 +1,71 @@
+desc "manage repositories"
+
+command :repository do |command|
+  command.desc "Lists all avaiable repositories"
+  command.command :list do |command|
+    command.action do |global_options,options,args|
+      Eh::Settings.current.repositories.each_with_index do |repository, index|
+        if repository.current?
+          puts "#{index + 1}: #{repository.url} (current)"
+        else
+          puts "#{index + 1}: #{repository.url}"
+        end
+      end
+    end
+  end
+
+  command.desc "selects a repository: eh repository select INDEX"
+  command.command :select do |command|
+    command.action do |global_options,options,args|
+      if Eh::Settings.current.repositories.length == 0
+        raise "No repository configured so far"
+      end
+      if args.length != 1
+        raise "Need exactly 1 arguments: index"
+      end
+      selected = args[0].to_i
+      puts "Will select #{args[0]}"
+      Eh::Settings.current.data['repositories'].each_with_index do |repository, index|
+        repository['current'] = (index + 1) == selected
+      end
+      Eh::Settings.current.write
+    end
+  end
+
+  command.desc 'add a repository to the config: eh repository add URL DIR USERNAME PASSWORD'
+  command.command :add do |command|
+    command.action do |global_options, options, args|
+      if args.length != 4
+        raise "Need exactly 4 arguments: URL, DIR, USERNAME, PASSWORD"
+      end
+      Eh::Settings.current.data['repositories'] ||= []
+      Eh::Settings.current.data['repositories'] << {
+        'url' => args[0],
+        'dir' => args[1],
+        'deploy_username' => args[2],
+        'deploy_password' => args[3],
+        'current' => (Eh::Settings.current.data['repositories'].length == 0)
+      }
+      Eh::Settings.current.write
+    end
+  end
+
+
+  command.desc 'remove a repository from the config: eh repository remove INDEX'
+  command.command :remove do |command|
+    command.action do |global_options, options, args|
+
+      if args.length != 1
+        raise "Need exactly 1 arguments: index"
+      end
+      selected = args[0].to_i
+
+      if Eh::Settings.current.repositories[selected - 1].nil?
+        raise "No repository with index #{selected}"
+      end
+
+      Eh::Settings.current.data['repositories'].delete_at(selected - 1)
+      Eh::Settings.current.write
+    end
+  end
+end

data/lib/eh/settings.rb

@@ -1,9 +1,46 @@
 class Eh::Settings
-  attr_reader :data
+
+  attr_reader :data, :file
+
+  class Repository
+    def initialize(json)
+      @json = json
+    end
+
+    def url
+      @json['url']
+    end
+
+    def deploy_username
+      @json['deploy_username']
+    end
+
+    def deploy_password
+      @json['deploy_password']
+    end
+
+    def dir
+      @json['dir']
+    end
+
+    def current?
+      @json['current']
+    end
+  end
+
+  def initialize(file)
+    @file = file
+    @data = JSON.parse(File.read(file))
+  end
+
   def self.load(file)
-    data = File.read(file)
-    json = JSON.parse(data)
-    Eh::Settings.new(json)
+    Eh::Settings.new(file)
+  end
+
+  def write
+    File.open(file,"w") do |f|
+      f.write(data.to_json)
+    end
   end
 
   def self.current=(value)
@@ -14,40 +51,44 @@ class Eh::Settings
     Thread.current[:eh_settings]
   end
 
-  def initialize(data)
-    @data = data
+  def repository
+    repositories.find do |repository|
+      repository.current?
+    end if repositories
   end
 
-  def repository_root_dir
-    File.expand_path(data['repository_root_dir'])
+  def repositories
+    data["repositories"].map do |json|
+      Eh::Settings::Repository.new(json)
+    end if data["repositories"]
   end
 
-  def releases_dir
-    File.join(repository_root_dir, 'releases')
+  def releases_dir(*extra_paths)
+    File.join(repository.dir, 'releases', *extra_paths)
   end
 
   def rails_release_dir
-    File.join(releases_dir, 'rails')
+    releases_dir('rails')
   end
 
   def ruby_release_dir
-    File.join(releases_dir, 'ruby')
+    releases_dir('ruby')
   end
 
   def processors_src_dir
-    File.join(repository_root_dir, 'src', 'ruby')
+    File.join(repository.dir, 'src', 'ruby')
   end
 
   def deployment_dir
-    File.join(repository_root_dir, 'src', 'deployment')
+    File.join(repository.dir, 'src', 'deployment')
   end
 
   def rails_src_dir
-    File.join(repository_root_dir, 'src', 'rails', 'console')
+    File.join(repository.dir, 'src', 'rails', 'console')
   end
 
   def source_config_dir
-    File.join(repository_root_dir, 'config')
+    File.join(repository.dir, 'config')
   end
 
   def processor_template_repository_url
@@ -67,6 +108,6 @@ class Eh::Settings
   end
 
   def stages_dir
-    File.expand_path("~/.eh-stages")
+    File.join(repository.dir, 'config', 'stages')
   end
 end

data/lib/eh/version.rb

@@ -1,3 +1,3 @@
 module Eh
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventhub-command
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Pascal Betz
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-19 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -142,22 +142,25 @@ files:
 - bin/eh
 - eh.gemspec
 - eh.rdoc
-- features/eh.feature
-- features/step_definitions/eh_steps.rb
-- features/support/env.rb
 - lib/deployer.rb
+- lib/deployer/base_deployer.rb
+- lib/deployer/config_deployer.rb
 - lib/deployer/executor.rb
+- lib/deployer/mule_deployer.rb
 - lib/deployer/net_ssh_extension.rb
+- lib/deployer/ruby_deployer.rb
 - lib/deployer/stage.rb
 - lib/eh-commands.rb
 - lib/eh.rb
 - lib/eh/commands/copy_config.rb
 - lib/eh/commands/deploy.rb
+- lib/eh/commands/deploy_config.rb
 - lib/eh/commands/deploy_mule.rb
 - lib/eh/commands/deploy_ruby.rb
 - lib/eh/commands/generate_processor.rb
-- lib/eh/commands/package.rb
-- lib/eh/commands/package_rails.rb
+- lib/eh/commands/list_stages.rb
+- lib/eh/commands/package_ruby.rb
+- lib/eh/commands/repository.rb
 - lib/eh/settings.rb
 - lib/eh/version.rb
 - test/default_test.rb

data/features/eh.feature

@@ -1,8 +0,0 @@
-Feature: My bootstrapped app kinda works
-  In order to get going on coding my awesome app
-  I want to have aruba and cucumber setup
-  So I don't have to do it myself
-
-  Scenario: App just runs
-    When I get help for "eh"
-    Then the exit status should be 0

data/features/step_definitions/eh_steps.rb

@@ -1,6 +0,0 @@
-When /^I get help for "([^"]*)"$/ do |app_name|
-  @app_name = app_name
-  step %(I run `#{app_name} help`)
-end
-
-# Add more step definitions here

data/features/support/env.rb

@@ -1,15 +0,0 @@
-require 'aruba/cucumber'
-
-ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
-LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
-
-Before do
-  # Using "announce" causes massive warnings on 1.9.2
-  @puts = true
-  @original_rubylib = ENV['RUBYLIB']
-  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
-end
-
-After do
-  ENV['RUBYLIB'] = @original_rubylib
-end

data/lib/eh/commands/package_rails.rb

@@ -1,68 +0,0 @@
-desc 'Packages Rails Console to zip file'
-command :package_rails do |c|
-  c.flag([:d, :destination], :desc => "Destination directory to place created zip file.", :default_value => Eh::Settings.current.rails_release_dir)
-  c.flag([:s, :source], :desc => "Source directory to read rails console from.", :default_value => Eh::Settings.current.rails_src_dir)
-
-  c.action do |global_options, options, args|
-    source_dir = options['s']
-    destination_dir = options['d']
-
-    skip_files = ["#{source_dir}/config/database.yml"]
-
-    puts "Will package rails console from #{source_dir} to #{destination_dir}"
-
-    console = Dir["#{source_dir}"]
-
-    FileUtils.mkdir_p(destination_dir)
-
-    zipfile_name = File.join(destination_dir, "console.zip")
-    directory = source_dir
-
-    # remove zip before we create a new one
-    FileUtils.rm zipfile_name, :force => true
-
-    Zip::File.open(zipfile_name, Zip::File::CREATE) do |zipfile|
-
-      #zipfile.add(processor_name, directory)
-      [directory].each do |file_to_be_zipped|
-        if File.directory?(file_to_be_zipped)
-          # should skip directories
-          next if options["directories-skip"]
-
-          directory = file_to_be_zipped
-          puts "zipper: archiving directory: #{directory}"
-          directory_chosen_pathname = options["directories-recursively-splat"] ? directory : File.dirname(directory)
-          directory_pathname = Pathname.new(directory_chosen_pathname)
-          files = Dir[File.join(directory, '**', '**')]
-
-          files.delete_if do |filename|
-            ["#{source_dir}/log", "#{source_dir}/logs", "#{source_dir}/exceptions", "#{source_dir}/tmp"].any? do |prefix|
-              filename.start_with?(prefix)
-            end
-          end
-
-          files.each do |file|
-            if skip_files.include? file
-              puts "skipping #{file}"
-              next
-            end
-
-            file_pathname = Pathname.new(file)
-            file_relative_pathname = file_pathname.relative_path_from(directory_pathname)
-            zipfile.add(file_relative_pathname,file)
-          end
-
-          next
-        end
-
-        filename = File.basename(file_to_be_zipped)
-
-        puts "zipper: archiving #{file_to_be_zipped} as #{filename} into #{zipfile}"
-
-        zipfile.add(filename,file_to_be_zipped)
-      end
-    end
-
-    puts "Done packaging rails"
-  end
-end