class SSHKit::Backend::Netssh

Constants

BUNDLER_PATHS
CRON_DIRS
SUDO_PASSWORD_KEY
SUDO_PROMPT

Public Instance Methods

_execute(*args) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 13
def _execute(*args)
  options = args.last.kind_of?(Hash) ? args.last : {}
  orig_output = output

  begin
    if options[:sniffer]
      @output = Cronicle::LogSniffer.new(orig_output) do |obj|
        options[:sniffer].call(obj)
      end
    end

    _execute_orig(*args)
  rescue => e
    log_for_cronicle(:error, args.join(' '), :color => :red)
    raise e
  ensure
    @output = orig_output
  end
end
Also aliased as: _execute_orig
_execute_orig(*args)
Alias for: _execute
add_cron_entry(user, name, schedule, temp_dir, bundle_gems = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 104
def add_cron_entry(user, name, schedule, temp_dir, bundle_gems = nil)
  script = script_path(user, name)
  temp_entry = [temp_dir, name + '.entry'].join('/')

  cron_entry = "#{schedule}\\t"

  if bundle_gems
    cron_entry << "cd #{gemfile_dir(user, name)} && #{bundler_path} exec "
  end

  cron_entry << "#{script} 2>&1 | logger -t cronicle/#{user}/#{name}"
  cron_entry = Shellwords.shellescape(cron_entry)
  sudo(:execute, :echo, '-e', cron_entry, '>', temp_entry)

  entry_cat = "cat #{temp_entry} >> #{user_crontab(user)}"
  entry_cat = Shellwords.shellescape(entry_cat)
  sudo(:execute, :bash, '-c', entry_cat)
end
bundle(user, name, temp_dir = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 169
def bundle(user, name, temp_dir = nil)
  with_bundle(user, name, temp_dir) do |bundler_opts|
    unless sudo(:execute, bundler_path, :check, *bundler_opts, :raise_on_non_zero_exit => false)
      sudo(:execute, bundler_path, :install, *bundler_opts)
    end
  end
end
bundle_dir() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 192
def bundle_dir
  host.options.fetch(:var_dir) + '/bundle'
end
bundler_path() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 201
def bundler_path
  @bundler_path ||= BUNDLER_PATHS.find {|path|
    execute(:test, '-f', path, :raise_on_non_zero_exit => false)
  }

  path = capture(:which, :bundle, '2>', '/dev/null', :raise_on_non_zero_exit => false) || ''
  path.strip!

  if path.empty?
    log_for_cronicle(:error, 'cannot find bundler', :color => :red, :host => host.hostname)
  else
    @bundler_path = path
  end

  @bundler_path
end
delete_cron_entry(user, name = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 97
def delete_cron_entry(user, name = nil)
  sed_cmd = '/' + Cronicle::Utils.sed_escape(script_path(user, name)) + ' /d'
  sed_cmd = Shellwords.shellescape(sed_cmd)

  sudo(:execute, :sed, '-i', sed_cmd, user_crontab(user), :raise_on_non_zero_exit => false)
end
fetch_crontabs() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 68
def fetch_crontabs
  return @crontabs if @crontabs

  @crontabs = {}

  list_crontabs.each do |path|
    user = File.basename(path)
    crontab = sudo(:capture, :cat, path)
    @crontabs[user] = crontab
  end

  @crontabs
end
fetch_libexec_scripts() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 87
def fetch_libexec_scripts
  script_contents = {}

  list_libexec_scripts.each do |script|
    script_contents[script] = crlf_to_lf(capture(:cat, script))
  end

  script_contents
end
find_cron_dir() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 49
def find_cron_dir
  @cron_dir ||= CRON_DIRS.find do |path|
    execute(:test, '-d', path, :raise_on_non_zero_exit => false)
  end

  unless @cron_dir
    raise "Cannot find cron directory: #{CRON_DIRS.join(', ')}"
  end

  @cron_dir
end
gemfile(user, name, temp_dir = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 234
def gemfile(user, name, temp_dir = nil)
  [gemfile_dir(user, name, temp_dir), 'Gemfile'].join('/')
end
gemfile_dir(user, name, temp_dir = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 226
def gemfile_dir(user, name, temp_dir = nil)
  if temp_dir
    [temp_dir, user, name].join('/')
  else
    [user_run_dir(user), name].join('/')
  end
end
libexec_dir() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 184
def libexec_dir
  host.options.fetch(:var_dir) + '/libexec'
end
list_crontabs() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 61
def list_crontabs
  cron_dir = find_cron_dir
  @crontab_list ||= sudo(:capture, :bash, '-c',
                      Shellwords.shellescape("find #{cron_dir} -type f 2> /dev/null"),
                      :raise_on_non_zero_exit => false).each_line.map(&:strip)
end
list_libexec_scripts() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 82
def list_libexec_scripts
  @libexec_scripts ||= capture(:find, libexec_dir, '-type', :f, '2> /dev/null',
                         :raise_on_non_zero_exit => false).each_line.map(&:strip)
end
log_for_cronicle(level, message, opts = {}) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 247
def log_for_cronicle(level, message, opts = {})
  opts = host.options.merge(opts)
  Cronicle::Logger.log(level, message, opts)
end
mkgemfile(user, name, bundle_gems, temp_dir = nil) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 150
def mkgemfile(user, name, bundle_gems, temp_dir = nil)
  sudo(:execute, :mkdir, '-p', gemfile_dir(user, name, temp_dir))
  sudo(:execute, :bash, '-c',
    Shellwords.shellescape(
      [:echo, Shellwords.shellescape("source 'https://rubygems.org'"), '>', gemfile(user, name, temp_dir)].join(' ')
    )
  )

  bundle_gems.each do |gem_name, version|
    line = "gem '#{gem_name}'"
    line << ", #{version.inspect}" if version
    sudo(:execute, :bash, '-c',
      Shellwords.shellescape(
        [:echo, Shellwords.shellescape(line), '>>', gemfile(user, name, temp_dir)].join(' ')
      )
    )
  end
end
mktemp(user = nil) { |*block_args| ... } click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 130
def mktemp(user = nil)
  temp_dir = capture(:mktemp, '-d', '/var/tmp/cronicle.XXXXXXXXXX')
  block_args = [temp_dir]

  begin
    execute(:chmod, 755, temp_dir)

    if user
      user_temp_dir = [temp_dir, user].join('/')
      execute(:mkdir, '-p', user_temp_dir)
      execute(:chmod, 755, user_temp_dir)
      block_args << user_temp_dir
    end

    yield(*block_args)
  ensure
    sudo(:execute, :rm, '-rf', temp_dir, :raise_on_non_zero_exit => false) rescue nil
  end
end
output() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 9
def output
  @output ||= SSHKit.config.output
end
run_dir() click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 188
def run_dir
  host.options.fetch(:var_dir) + '/run'
end
script_path(user, name) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 243
def script_path(user, name)
  [libexec_dir, user, name].join('/')
end
sudo(command, *args) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 33
def sudo(command, *args)
  opts = args.last.kind_of?(Hash) ? args.pop : {}

  retval = with_sudo_password(host.options[:sudo_password] || '') do
    with_sudo = [:sudo, '-p', SUDO_PROMPT, '-S']
    with_sudo << :sudo << '-u' << opts[:user] if opts[:user]
    with_sudo.concat(args)
    send(command, *with_sudo, opts)
  end

  Cronicle::Utils.remove_prompt!(retval) if retval.kind_of?(String)
  retval
end
upload_script(temp_dir, name, content) { |temp_script| ... } click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 123
def upload_script(temp_dir, name, content)
  temp_script = [temp_dir, name].join('/')
  upload!(StringIO.new(content), temp_script)
  execute(:chmod, 755, temp_script)
  yield(temp_script)
end
user_crontab(user) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 238
def user_crontab(user)
  cron_dir = find_cron_dir
  [cron_dir, user].join('/')
end
user_libexec_dir(user) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 218
def user_libexec_dir(user)
  [libexec_dir, user].join('/')
end
user_run_dir(user) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 222
def user_run_dir(user)
  [run_dir, user].join('/')
end
with_bundle(user, name, temp_dir = nil) { |bundler_opts| ... } click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 177
def with_bundle(user, name, temp_dir = nil)
  within gemfile_dir(user, name, temp_dir) do
    bundler_opts = ['--no-color', '--gemfile', gemfile(user, name, temp_dir), '--path', bundle_dir]
    yield(bundler_opts)
  end
end

Private Instance Methods

crlf_to_lf(str) click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 254
def crlf_to_lf(str)
  str.gsub("\r\n", "\n")
end
with_sudo_password(password) { || ... } click to toggle source
# File lib/cronicle/ext/sshkit_ext.rb, line 258
def with_sudo_password(password)
  begin
    Thread.current[SUDO_PASSWORD_KEY] = password
    yield
  ensure
    Thread.current[SUDO_PASSWORD_KEY] = nil
  end
end