vop-plugins 0.3.1 → 0.3.5

data/standard/ssh/commands/clear_ssh_cache.rb

@@ -0,0 +1,9 @@
+param! :machine
+
+run do |machine|
+  # TODO not working (user)
+  key = "#{user}@#{host}:#{port}"
+  $logger.debug("clearing ssh connection cache for #{key}")
+  pool = plugin.state[:ssh_connections]
+  pool.delete(key)
+end

data/standard/ssh/commands/get_ssh_connection.rb

@@ -0,0 +1,36 @@
+require "timeout"
+
+param! :machine
+param "force", default: false
+param "timeout", description: "in seconds", default: 10
+
+run do |machine, force|
+  seconds = seconds.to_i
+  connection = nil
+  begin
+    Timeout::timeout(seconds) do
+      tried_with_force = false
+      done = false
+      until tried_with_force || done do
+        connection = machine.ssh_connection(force: force)
+        tried_with_force = true if force
+        begin
+          connection.exec! "hostname"
+          done = true
+        rescue => e
+          if force
+            state = force ? "fresh " : ""
+            raise "problem while testing #{state}ssh connection to #{machine.name} : #{e.message}"
+          else
+            $logger.debug "SSH check failed (#{e.message}), requesting fresh connection to #{machine.name}"
+            force = true
+          end
+        end
+      end
+    end
+  rescue => detail
+    raise "timed out while connecting to #{machine.name} : #{detail.message}"
+  end
+
+  connection
+end

data/standard/ssh/commands/scp_down.rb

@@ -0,0 +1,9 @@
+param! :machine
+param! "remote_path"
+param! "local_path"
+
+run do |machine, remote_path, local_path|
+  ssh = machine.ssh_connection(force: true, dont_cache: true)
+  $logger.debug "[#{machine.name}] scp #{remote_path} -> #{local_path}"
+  ssh.scp.download! remote_path, local_path
+end

data/standard/ssh/commands/scp_up.rb

@@ -0,0 +1,9 @@
+param! :machine
+param! "local_path"
+param! "remote_path"
+
+run do |machine, local_path, remote_path|
+  ssh = machine.ssh_connection(force: true, dont_cache: true)
+  $logger.debug "[#{machine.name}] scp #{local_path} -> #{remote_path}"
+  ssh.scp.upload! local_path, remote_path
+end

data/standard/ssh/commands/ssh.rb

@@ -0,0 +1,20 @@
+# TODO params_as ssh_call ?
+
+param! "machine"
+param! "command", :default_param => true
+
+param "request_pty", :default => false
+
+param "show_output", default: false
+
+run do |params|
+  result = @op.ssh_call(params)
+
+  unless result["result_code"].to_i == 0
+    exception_with_backtrace = StandardError.new("SSH result code not zero")
+    exception_with_backtrace.set_backtrace(result["combined"])
+    raise exception_with_backtrace
+  end
+
+  result["combined"]
+end

data/standard/ssh/commands/ssh_call.rb

@@ -0,0 +1,98 @@
+param! :machine
+
+param! "command", default_param: true
+
+param "on_data", default: nil
+param "on_stderr", default: nil
+param "request_pty", default: false
+
+param "show_output", default: false
+
+run do |machine, params, show_output|
+  connection = machine.get_ssh_connection
+
+  $logger.debug "request_pty ? #{params["request_pty"]}"
+
+  stdout = ""
+  stderr = ""
+  combined = ""
+  result_code = nil
+  connection.open_channel do |channel|
+    if params.has_key?('request_pty') && params['request_pty'].to_s == "true"
+      $logger.debug "requesting pty"
+      channel.request_pty do |ch, success|
+        unless success
+          raise Exception.new("could not obtain pty!")
+        end
+      end
+    end
+
+    channel.on_request('exit-status') do |c, data|
+      result_code = data.read_long
+      $logger.debug "read exit code : #{result_code}"
+    end
+
+    params["on_data"] ||= lambda do |c, data|
+      stdout += data
+      combined += data
+
+      puts data if show_output
+      $logger.debug "got data on STDOUT #{data}"
+    end
+    channel.on_data do |c, data|
+      params["on_data"].call(c, data)
+    end
+
+    params["on_stderr"] ||= lambda do |c, data|
+      stderr += data
+      combined += data
+
+      puts data if show_output
+      $logger.debug "got data on STDERR #{data}"
+    end
+    channel.on_extended_data do |c, type, data|
+      params["on_stderr"].call(c, data)
+    end
+
+    #channel.on_close { $logger.debug "done" }
+
+    command = params["command"]
+
+    channel.exec(command) do |ch, success|
+      if success
+        $logger.debug "executed command successfully."
+      else
+        $logger.warn "could not execute command #{command}"
+        raise RuntimeError.new("could not execute #{command}")
+      end
+    end
+  end
+
+  if params.has_key?('dont_loop') and params['dont_loop'] == "true"
+    $logger.debug "not waiting for process to finish"
+    {
+      "combined" => combined,
+      "stdout" => stdout,
+      "stderr" => stderr,
+      "connection" => connection
+    }
+  else
+    connection.loop
+
+    lines = params["command"].lines
+    first_line = lines.first
+    short_command = first_line.strip[0..49]
+    if lines.size > 1 || first_line.size > 50
+      short_command += "[...]"
+    end
+    $logger.info "ssh [#{params["machine"]}] #{first_line}, result : #{result_code}"
+    $logger.debug "full command : #{params["command"].lines.join("\n")}"
+
+    {
+      "combined" => combined,
+      "stdout" => stdout,
+      "stderr" => stderr,
+      "result_code" => result_code
+    }
+  end
+end

data/standard/ssh/commands/ssh_connection.rb

@@ -0,0 +1,55 @@
+param! :machine
+param "force", default: false
+param "dont_cache", default: false
+
+run do |plugin, machine, force, dont_cache|
+  ssh_opts = @op.ssh_options("machine" => machine.name)
+  $logger.debug "ssh options for #{machine.name} : #{ssh_opts.pretty_inspect}"
+  if ssh_opts.nil? || ssh_opts.empty?
+    raise "no SSH options for machine #{machine.name}"
+  end
+
+  host = ssh_opts["host_or_ip"] || machine.name
+  user = ssh_opts["user"] || ENV["USER"]
+  port = ssh_opts["port"] || 22
+  options = ssh_opts.has_key?("options") ? ssh_opts["options"] : {}
+
+  options[:port] = port
+
+  if ssh_opts.has_key? "password"
+    options[:password] = ssh_opts["password"]
+  end
+
+  key = "#{user}@#{host}:#{port}"
+  $logger.debug("ssh connection to #{key}")
+
+  pool = plugin.state[:ssh_connections]
+  connection = nil
+  connection = pool[key] unless force
+
+  if connection.nil?
+    if ssh_opts["jump_host"]
+      jump_host_name = ssh_opts["jump_host"]
+      jump_host = @op.ssh_options(jump_host_name)
+      $logger.debug "using jump host #{jump_host_name}"
+      jump_pool = plugin.state[:jump_connections]
+      jump_target = "#{jump_host["user"]}@#{jump_host["host_or_ip"]}"
+      cached_jump_host = jump_pool[jump_target] unless force
+      proxy = if cached_jump_host
+        cached_jump_host
+      else
+        $logger.debug "new connection to jump host #{jump_target}"
+        new_proxy = Net::SSH::Proxy::Jump.new(jump_target)
+        jump_pool[jump_target] = new_proxy unless dont_cache
+        new_proxy
+      end
+      options[:proxy] = proxy
+    end
+
+    $logger.debug "new SSH connection as #{user} to #{host} (#{options.pretty_inspect})"
+    connection = Net::SSH.start(host, user, options)
+    pool[key] = connection unless dont_cache #unless ssh_opts["jump_host"]
+  end
+
+  connection
+end

data/standard/ssh/commands/ssh_extended.rb

@@ -0,0 +1,6 @@
+param :machine
+param! "command", default_param: true
+
+run do |params|
+  @op.ssh_call(params)
+end

data/standard/ssh/commands/ssh_options.rb

@@ -0,0 +1,12 @@
+param! "machine"
+
+show :display_type => :hash
+
+read_only
+
+run do |params|
+  @op.collect_contributions(
+    "command_name" => "ssh_options",
+    "raw_params" => params
+  )
+end

data/standard/ssh/commands/sudo.rb

@@ -0,0 +1,12 @@
+param! :machine
+param! "command", default_param: true
+
+run do |machine, params|
+  sudo_options = ""
+  distro = machine.distro.split("_").first
+  if %w|debian ubuntu|.include? distro
+    sudo_options += "--non-interactive"
+  end
+
+  machine.ssh("command" => "sudo #{sudo_options} #{params["command"]}", "request_pty" => true)
+end

data/standard/ssh/commands/test_ssh.rb

@@ -0,0 +1,43 @@
+require "timeout"
+
+param! "machine"
+param "seconds", default: 10
+
+read_only
+
+KNOWN_MESSAGES = [
+  "execution expired",
+  "No route to host",
+  "Connection refused",
+  "closed stream",
+  "getaddrinfo: Name or service not known",
+  "Broken pipe",
+  "timed out while connecting to"
+]
+run do |params, seconds|
+  result = nil
+
+  seconds = seconds.to_i
+  begin
+    Timeout::timeout(seconds) do
+      @op.ssh("machine" => params["machine"], "command" => "id")
+      result = true
+    end
+  rescue => detail
+    matched = nil
+    KNOWN_MESSAGES.each do |text|
+      pattern = Regexp.new(text)
+      if matched = pattern.match(detail.message)
+        $logger.debug "known error #{pattern}"
+        result = false
+        break
+      end
+    end
+    unless matched
+      $logger.warn "unknown error : #{detail.message}"
+      raise detail
+    end
+  end
+
+  result
+end

data/standard/ssh/ssh.plugin

@@ -0,0 +1,10 @@
+require "net/ssh"
+require "net/ssh/proxy/jump"
+require "net/scp"
+
+depends_on :machines
+
+on :init do |plugin|
+  plugin.state[:ssh_connections] = {}
+  plugin.state[:jump_connections] = {}
+end

data/standard/ssh_keys/commands/add_authorized_key.rb

@@ -0,0 +1,14 @@
+description "adds a public key to the SSH directory of a user on a machine so that it is authorized to login"
+
+param :machine
+param! "public_key", description: "the public key that should be added", :default_param => true
+
+run do |machine, public_key|
+  machine.mkdirs("dir" => ".ssh", "permissions" => "700")
+
+  unless machine.file_exists(".ssh/authorized_keys")
+    machine.ssh("touch .ssh/authorized_keys")
+    machine.chmod("file" => ".ssh/authorized_keys", "permissions" => "600")
+  end
+  machine.ssh("echo \"#{public_key}\" >> .ssh/authorized_keys")
+end

data/standard/ssh_keys/commands/disable_ssh_key_check.rb

@@ -0,0 +1,11 @@
+description "modifies the local ssh configuration so that no host key checks are performed"
+
+param :machine
+param "home_dir", "the home directory into which the ssh configuration should be written"
+
+run do |machine, params|
+  params["home_dir"] ||= machine.home
+  file_name = params["home_dir"] + "/.ssh/config"
+
+  machine.append_to_file("file_name" => file_name, "content" => 'StrictHostKeyChecking no')  
+end

data/standard/ssh_keys/commands/generate_keypair.rb

@@ -0,0 +1,17 @@
+description "generates a new key pair on the selected machine"
+#
+param :machine
+param "ssh_dir", "the ssh configuration directory (defaults to $HOME/.ssh)"
+
+run do |machine, params|
+  ssh_dir = params.has_key?("ssh_dir") ? params["ssh_dir"] : ".ssh"
+  private_keyfile = ssh_dir + "/id_rsa"
+
+  unless machine.file_exists(private_keyfile)
+    machine.mkdirs ssh_dir
+    machine.ssh "ssh-keygen -N '' -f #{private_keyfile}"
+    machine.ssh "cd #{ssh_dir} && cat id_rsa.pub >> authorized_keys"
+  end
+
+  #machine.file_exists! private_keyfile
+end

data/standard/systemd/commands/disable_systemd_service.rb

@@ -0,0 +1,8 @@
+param! :machine
+param_service
+
+run do |machine, service|
+  machine.sudo("systemctl disable #{service}")
+
+  machine.list_systemd_services!
+end

data/standard/systemd/commands/enable_systemd_service.rb

@@ -0,0 +1,8 @@
+param! :machine
+param_service
+
+run do |machine, service|
+  machine.sudo("systemctl enable #{service}")
+
+  machine.list_systemd_services!
+end

data/standard/systemd/commands/list_systemd_services.rb

@@ -0,0 +1,23 @@
+param! :machine
+
+read_only
+
+run do |machine|
+  result = []
+
+  input = machine.ssh "systemctl list-unit-files --type=service"
+  input.split("\n").each_with_index do |line, idx|
+    # skip one header line
+    next if idx == 0
+
+    # stop at the first empty line
+    break if line =~ /^$/
+
+    parts = line.split
+    result << {
+      name: parts.first,
+      state: parts.last
+    }
+  end
+  result
+end

data/standard/systemd/commands/start_systemd_service.rb

@@ -0,0 +1,6 @@
+param! :machine
+param_service
+
+run do |machine, service|
+  machine.sudo("systemctl start #{service}")
+end

data/standard/systemd/commands/stop_systemd_service.rb

@@ -0,0 +1,6 @@
+param! :machine
+param_service
+
+run do |machine, service|
+  machine.sudo("systemctl stop #{service}")
+end