Module: RunSSHLib::SshBackend

Defined in:
lib/runsshlib/ssh_backend.rb

Overview

A collection of ssh procedures.

Defined Under Namespace

Classes: KnownHostsUtils

Class Method Summary collapse

Class Method Details

.copy_id(options) ⇒ Object

Copy ssh identity file to remote host according to options

options

A hash containing host definition (:host_name, etc) and optionally identity_file path.



84
85
86
87
88
89
90
 
# File 'lib/runsshlib/ssh_backend.rb', line 84

def copy_id(options)
  command = "ssh-copy-id "
  command << "-i #{options[:identity_file]} " if options[:identity_file]
  command << "#{options[:login]}@" if options[:login]
  command << "#{options[:host_name]}"
  exec command
end

.normalize_scp_targets(targets, host_name) ⇒ Object

Prepend the remote target with supplied host_name.

Raises ParametersError if no target is indicated as remote (with ‘:’) or if the number of targets is not 2.

Raises:



105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/runsshlib/ssh_backend.rb', line 105

def normalize_scp_targets(targets, host_name)
  raise ParametersError, "Invalid targets: #{targets.join(' ')}" unless
        targets.length == 2
  raise "no hostname" unless host_name # should never happen

  if targets[0].start_with?(':')
    targets[0] = host_name + targets[0]
  elsif targets[1].start_with?(':')
    targets[1] = host_name + targets[1]
  else
    raise ParametersError, "The remote path should be prefixed with ':'!"
  end
  targets
end

.normalize_tunnel_definition(tunnel_definition) ⇒ Object

Accepts abbriviated or full definition of ssh tunnel definition and converts it to full tunnel definition. If only port is supplied (abbriviated form) it uses localhost as the hostname and the same port on both end of the tunnel definition.



96
97
98
99
 
# File 'lib/runsshlib/ssh_backend.rb', line 96

def normalize_tunnel_definition(tunnel_definition)
  tunnel_definition =~ /(^\d+$)/ ? "#{$1}:localhost:#{$1}" :
                       tunnel_definition
end

.scp(definition) ⇒ Object

Copy files to/from remote host using scp. definition: A hash containig a merge between host definition and

user input.



65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/runsshlib/ssh_backend.rb', line 65

def scp(definition)
  raise "no hostname" unless definition[:host_name] # should never happen
  command = "scp"
  arguments = []
  arguments << '-r' if definition[:recurssive_given]
  arguments += ['-l', definition[:limit]] if definition[:limit]
  definition[:option].each do |option|
    arguments += ['-o', option]
  end if definition[:option]
  host_name = definition[:login] ?
              "#{definition[:login]}@#{definition[:host_name]}" :
              definition[:host_name]
  arguments += normalize_scp_targets(definition[:targets], host_name)
  exec command, *arguments
end

.shell(definition) ⇒ Object

run shell on remote host.

definition

A Hash containing required data for making shell connection (e.g., :host_name, :login).

For running remote commands add to the definition hash the entire remote command as a string with a :remote_cmd key.



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/runsshlib/ssh_backend.rb', line 46

def shell(definition)
  raise "no hostname" unless definition[:host_name] # should never happen
  rmtcmd_flag = (definition[:remote_cmd] && (!definition[:remote_cmd].empty?))
  command = "ssh "
  command << "-t " if (rmtcmd_flag && (!definition[:no_pseudo_terminal]))
  command << "-l #{definition[:login]} " if definition[:login]
  command << "#{definition[:host_name]}"
  command << " -L #{normalize_tunnel_definition definition[:local_tunnel]}" if
             definition[:local_tunnel]
  definition[:option].each do |option|
    command << " -o #{option}"
  end if definition[:option]
  command << %( -- "#{definition[:remote_cmd]}") if rmtcmd_flag
  exec command
end