eventhub-command 0.2.1 → 0.2.2

data/lib/deployer/mule_deployer.rb

@@ -1,85 +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
+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

@@ -1,37 +1,37 @@
-class Net::SSH::Connection::Session
-
-  def exec_sc!(command)
-    stdout_data,stderr_data = "",""
-    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
-
-        channel.on_data do |_, data|
-          stdout_data += data
-        end
-
-        channel.on_extended_data do |_, _, data|
-          stderr_data += data
-        end
-
-        channel.on_request("exit-status") do |_, data|
-          exit_code = data.read_long
-        end
-
-        channel.on_request("exit-signal") do |_, data|
-          exit_signal = data.read_long
-        end
-      end
-    end
-    self.loop
-    raise stderr_data unless exit_code == 0
-
-    {
-      stdout: stdout_data,
-      stderr: stderr_data,
-      exit_code: exit_code,
-      exit_signal: exit_signal
-    }
-  end
-end
+class Net::SSH::Connection::Session
+
+  def exec_sc!(command)
+    stdout_data,stderr_data = "",""
+    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
+
+        channel.on_data do |_, data|
+          stdout_data += data
+        end
+
+        channel.on_extended_data do |_, _, data|
+          stderr_data += data
+        end
+
+        channel.on_request("exit-status") do |_, data|
+          exit_code = data.read_long
+        end
+
+        channel.on_request("exit-signal") do |_, data|
+          exit_signal = data.read_long
+        end
+      end
+    end
+    self.loop
+    raise stderr_data unless exit_code == 0
+
+    {
+      stdout: stdout_data,
+      stderr: stderr_data,
+      exit_code: exit_code,
+      exit_signal: exit_signal
+    }
+  end
+end

data/lib/deployer/ruby_deployer.rb

@@ -1,111 +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
+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(shared_dir, 'logs')
+  end
+
+  def pids_dir
+    File.join(shared_dir, '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,27 +1,27 @@
-class Deployer::Stage
-  attr_reader :name, :hosts
-
-  def initialize(name)
-    @name = name
-    @hosts = []
-  end
-
-  def host(host, port, user)
-    @hosts << {
-      host: host,
-      port: port,
-      user: user
-    }
-  end
-
-  def self.load(file)
-    data = YAML.load_file(file)
-    data.map do |name, config|
-      stage = Deployer::Stage.new(name)
-      config['hosts'].each do |host|
-        stage.host(host['host'], host['port'], host['user'])
-      end
-      stage
-    end.first
-  end
-end
+class Deployer::Stage
+  attr_reader :name, :hosts
+
+  def initialize(name)
+    @name = name
+    @hosts = []
+  end
+
+  def host(host, port, user)
+    @hosts << {
+      host: host,
+      port: port,
+      user: user
+    }
+  end
+
+  def self.load(file)
+    data = YAML.load_file(file)
+    data.map do |name, config|
+      stage = Deployer::Stage.new(name)
+      config['hosts'].each do |host|
+        stage.host(host['host'], host['port'], host['user'])
+      end
+      stage
+    end.first
+  end
+end

data/lib/deployer.rb

@@ -1,11 +1,11 @@
-module Deployer
-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'
+module Deployer
+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/eh/commands/copy_config.rb

@@ -1,51 +1,51 @@
-desc 'Copies the config directory of a given processor to remote'
-command :copy_config do |c|
-  c.flag([:s, :source], :desc => "Source config directory", :default_value => Eh::Settings.current.source_config_dir, :long_desc => "A local directory containing subfolders for each of the processors")
-  c.flag([:p, :processors], :desc => "Specify what processors' configs to copy", :type => Array, :long_desc => "You can specify multiple processors by providing a comma-separated list.")
-
-  c.action do |global_options, options, args|
-    source_config_dir = options['s']
-    repository_deployment_dir = File.join(Eh::Settings.current.repository_root_dir, "branches", "master", "src", "deployment")
-
-    processor_names = Dir["#{source_config_dir}/*"].map do |dir|
-      File.basename(dir)
-    end
-
-    included_processor_names = processor_names
-
-    # only include processors specified by -p option, if option is given
-    if options['p']
-      included_processor_names = included_processor_names.select do |processor_name|
-        options['p'].include?(processor_name)
-      end
-    end
-
-    # make sure we have at least one processor
-    if included_processor_names.empty?
-      raise "There are no processor configs to copy. Either there is nothing in #{source_config_dir} or the processor(s) specified with -p don't exist."
-    end
-
-    included_processor_names.each do |processor_name|
-      processor_config_source_dir = File.join(source_config_dir, processor_name)
-
-      cmd = "cd #{repository_deployment_dir} && COPY_FROM_DIR=#{processor_config_source_dir} bundle exec cap event_hub:scp_copy_config"
-
-      puts "Will copy config files from #{processor_config_source_dir} to remote."
-      puts "WARNING: This will overwrite any existing files with the same name!"
-      puts "Do you really want to do this?"
-      input = STDIN.gets.chomp
-
-      unless ['y', 'Y'].include?(input)
-        raise "Not confirmed. Stop."
-      end
-
-      puts "Command: #{cmd}" if global_options['v']
-
-      Bundler.with_clean_env do
-        system cmd
-      end
-    end
-
-    puts "Done."
-  end
-end
+desc 'Copies the config directory of a given processor to remote'
+command :copy_config do |c|
+  c.flag([:s, :source], :desc => "Source config directory", :default_value => Eh::Settings.current.source_config_dir, :long_desc => "A local directory containing subfolders for each of the processors")
+  c.flag([:p, :processors], :desc => "Specify what processors' configs to copy", :type => Array, :long_desc => "You can specify multiple processors by providing a comma-separated list.")
+
+  c.action do |global_options, options, args|
+    source_config_dir = options['s']
+    repository_deployment_dir = File.join(Eh::Settings.current.repository_root_dir, "branches", "master", "src", "deployment")
+
+    processor_names = Dir["#{source_config_dir}/*"].map do |dir|
+      File.basename(dir)
+    end
+
+    included_processor_names = processor_names
+
+    # only include processors specified by -p option, if option is given
+    if options['p']
+      included_processor_names = included_processor_names.select do |processor_name|
+        options['p'].include?(processor_name)
+      end
+    end
+
+    # make sure we have at least one processor
+    if included_processor_names.empty?
+      raise "There are no processor configs to copy. Either there is nothing in #{source_config_dir} or the processor(s) specified with -p don't exist."
+    end
+
+    included_processor_names.each do |processor_name|
+      processor_config_source_dir = File.join(source_config_dir, processor_name)
+
+      cmd = "cd #{repository_deployment_dir} && COPY_FROM_DIR=#{processor_config_source_dir} bundle exec cap event_hub:scp_copy_config"
+
+      puts "Will copy config files from #{processor_config_source_dir} to remote."
+      puts "WARNING: This will overwrite any existing files with the same name!"
+      puts "Do you really want to do this?"
+      input = STDIN.gets.chomp
+
+      unless ['y', 'Y'].include?(input)
+        raise "Not confirmed. Stop."
+      end
+
+      puts "Command: #{cmd}" if global_options['v']
+
+      Bundler.with_clean_env do
+        system cmd
+      end
+    end
+
+    puts "Done."
+  end
+end