eventhub-command 0.0.22 → 0.1.0

data/lib/deployer/executor.rb

@@ -0,0 +1,102 @@
+require 'net/ssh'
+require 'colorize'
+
+class Deployer::Executor
+  attr_reader :stage
+
+  def initialize(stage, options = {})
+    @stage = stage
+    @options = options
+    yield(self) if block_given?
+  end
+
+
+  def execute(command, options = {})
+    log_command("Execute: '#{command}'", options[:comment])
+    stage.hosts.each_with_index do |host, index|
+      log_host(host, index)
+      result = execute_on(host, command)
+      log_result(result)
+    end
+
+  rescue => e
+    handle_exception(e, options)
+  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)
+    end
+
+  rescue => e
+    handle_exception(e, options)
+  end
+
+
+  private
+  def handle_exception(e, options)
+    if options[:abort_on_error] == false
+      puts "warning".black.on_yellow
+      puts "    #{e.message}".yellow
+    else
+      puts "failure".black.on_red
+      puts "    #{e.message}".red
+    end
+    raise unless options[:abort_on_error] == false
+
+  end
+
+  def verbose?
+    @options[:verbose]
+  end
+
+  def log_result(result)
+    puts "success".black.on_green
+    if verbose? && result[:stdout] && result[:stdout].length > 0
+      puts "    -> #{result[:stdout].chomp}".light_blue
+    end
+  end
+
+  def log_host(host, index)
+    print "  #{host[:host]} (#{index + 1}/#{stage.hosts.size}): "
+  end
+
+  def log_command(cmd, comment = nil)
+    puts cmd.blue
+    puts "  (#{comment})" if verbose? && comment
+  end
+
+  def upload_on(host, source, target)
+    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
+    exit_code = nil
+
+    Bundler.with_clean_env do
+      output = `#{command}`
+      exit_code = $?
+    end
+
+    raise "Command \"#{command}\" returned exit code #{exit_code}" unless exit_code.success?
+
+    result = {
+      stdout: output,
+      stderr: '',
+      exit_code: 0,
+    }
+
+    result
+  end
+
+end

data/lib/deployer/net_ssh_extension.rb

@@ -0,0 +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

data/lib/deployer/stage.rb

@@ -0,0 +1,28 @@
+class Deployer::Stage
+  attr_reader :name, :node_env, :hosts
+
+  def initialize(name, node_env)
+    @name = name
+    @node_env = node_env
+    @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['node_env'])
+      config['hosts'].each do |host|
+        stage.host(host['host'], host['port'], host['user'])
+      end
+      stage
+    end.first
+  end
+end

data/lib/eh-commands.rb

@@ -1,6 +1,8 @@
-# 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'
+# 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'

data/lib/eh.rb

@@ -1,7 +1,11 @@
-module Eh
-end
-require 'zip'
-require 'pathname'
-
-require 'eh/version'
-require 'eh/settings'
+module Eh
+end
+
+require 'zip'
+require 'pathname'
+
+require 'eh/version'
+require 'eh/settings'
+require 'yaml'
+
+require_relative '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

data/lib/eh/commands/deploy.rb

@@ -1,38 +1,38 @@
-desc 'Deploys the app'
-arg_name 'stage', optional: true
-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")
-  c.flag([:branch], :desc => "The branch to deploy", :default_value => "master")
-
-  c.action do |global_options, options, args|
-    stage = args[0] || "development"
-
-    deployment_dir = Eh::Settings.current.deployment_dir
-
-    env_variables = []
-    env_variables << "DEPLOY_VIA=#{options[:deploy_via]}"
-
-    if options[:tag]
-      env_variables << "TAG=#{options[:tag]}"
-    else
-      env_variables << "BRANCH=#{options[:branch]}"
-    end
-
-    if options[:deploy_via] == "copy"
-      env_variables << "COPY_FROM_DIR=#{options[:copy_from_dir]}"
-    end
-
-    cmd = "cd #{deployment_dir} && #{env_variables.join(' ')} bundle exec cap #{stage} event_hub"
-
-    puts "Command: #{cmd}" if global_options['v']
-
-    Bundler.with_clean_env do
-      system cmd
-    end
-
-    puts "Done."
-  end
-end
+desc 'Deploys the app'
+arg_name 'stage', optional: true
+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")
+  c.flag([:branch], :desc => "The branch to deploy", :default_value => "master")
+
+  c.action do |global_options, options, args|
+    stage = args[0] || "development"
+
+    deployment_dir = Eh::Settings.current.deployment_dir
+
+    env_variables = []
+    env_variables << "DEPLOY_VIA=#{options[:deploy_via]}"
+
+    if options[:tag]
+      env_variables << "TAG=#{options[:tag]}"
+    else
+      env_variables << "BRANCH=#{options[:branch]}"
+    end
+
+    if options[:deploy_via] == "copy"
+      env_variables << "COPY_FROM_DIR=#{options[:copy_from_dir]}"
+    end
+
+    cmd = "cd #{deployment_dir} && #{env_variables.join(' ')} bundle exec cap #{stage} event_hub"
+
+    puts "Command: #{cmd}" if global_options['v']
+
+    Bundler.with_clean_env do
+      system cmd
+    end
+
+    puts "Done."
+  end
+end

data/lib/eh/commands/deploy_mule.rb

@@ -0,0 +1,67 @@
+
+desc 'deploy a single channel adapter'
+arg_name 'channel_adapter stage'
+
+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.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} ; mkdir -p #{File.join(cached_copy_dir, 'mule')}")
+
+      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)
+      else
+        co_line = "svn co --trust-server-cert --non-interactive --username #{scm_username} --password #{scm_password} #{repository} #{cached_copy_dir}"
+        executor.execute(co_line)
+      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")
+    end
+  end
+end