Top Level Namespace

Includes:
SSH_Utils

Defined Under Namespace

Modules: SSH_Utils Classes: Array, Hash, LookupAmbigError, LookupError, LookupNotFoundError

Instance Attribute Summary

Attributes included from SSH_Utils

#server, #servers

Instance Method Summary collapse

Methods included from SSH_Utils

#_show_cmd, #as, #merge_env, #merge_opts, #merge_opts_with_env, #on, #remote_run, #remote_run_with_output, #ssh_command, #with

Instance Method Details

#_fmtargs(args, flag) ⇒ Object

_fmtargs(args, block_given?) { yield }

merge args with any block results provide default format string if only one argument



45
46
47
48
49
 
# File 'lib/arg-utils.rb', line 45

def _fmtargs args, flag
  args.concat([yield].flatten) if flag
  args.unshift('%s') if args.size < 2
  args
end

#_msgargs(args, flag) ⇒ Object

_msgargs(args, block_given?) { yield }

merge args with any block results



34
35
36
37
 
# File 'lib/arg-utils.rb', line 34

def _msgargs args, flag
  args.concat([yield].flatten) if flag
  args
end

#_prefix_arg0(args, prefix) ⇒ Object

_prefix_arg0( args, prefix )

Prefix args if the prefix is not already there, and if the args value is not nill.



194
195
196
197
198
199
 
# File 'lib/talk-utils.rb', line 194

def _prefix_arg0(args, prefix)
  if args.size > 0 && !args[0].nil? && !args[0].include?(prefix)
    args[0] = prefix + args[0]
  end
  args
end

#cmd_run(*args) ⇒ Object Also known as: run 



67
68
69
70
71
72
73
74
 
# File 'lib/run-utils.rb', line 67

def cmd_run *args
  args = _msgargs(args, block_given?) { yield }
  if $norun
    nrvtalk(args.first)
  elsif args.size > 0
    safe_run(*args)
  end
end

#dtalk(*args) ⇒ Object

dtalk - “debug talk” Print msg on STDERR only if ‘$debug` is set

:call-seq:

dtalk   msg
dtalk { msg }
dtalkf fmt,    args ..
dtalkf fmt { [ args .. ] }
dtalkf { [ fmt, args ..  ] }



58
59
60
61
62
 
# File 'lib/talk-utils.rb', line 58

def dtalk *args
  if $debug && (args.size > 0 || block_given?)
    $stderr.puts(*_msgargs(args, block_given?) { yield })
  end
end

#dtalkf(*args) ⇒ Object 



64
65
66
67
68
 
# File 'lib/talk-utils.rb', line 64

def dtalkf *args
  if $debug && (args.size> 0 || block_given?)
    $stderr.printf(*_fmtargs(args, block_given?) { yield })
  end
end

#error(*args) ⇒ Object

error – print an error message on STDERR, and then exit. :call-seq:

error   [code],   msg
error(  [code]) { msg }
error {[[code],   msg ] }

Code defaults to 1 if not given.



29
30
31
32
33
34
35
 
# File 'lib/error-utils.rb', line 29

def error *args
  args = _msgargs(args, block_given?) { yield }
  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
  $stderr.puts(*args)
  $stderr.flush
  exit code
end

#errorf(*args) ⇒ Object

errorf – print a formatted message on STDERR, and then exit

:call-seq:

errorf   [code],   fmt,   args ..
errorf(  [code],   fmt) { args .. }
errorf(  [code]) { fmt,   args .. }
errorf {[[code],   fmt,   args .. ] }



46
47
48
49
50
51
52
53
 
# File 'lib/error-utils.rb', line 46

def errorf *args
  args = _fmtargs(args, block_given?) { yield }
  # default the error code to 1 unless the first argument is a Fixnum
  code = args.size > 0 && args[0].class == Fixnum ? args.shift : 1
  $stderr.printf(*args)
  $stderr.flush
  exit code
end

#key_lookup(list, key, err_notfound = "%s not found\n", err_ambig = "%s is ambiguous\n") ⇒ Object Also known as: lookup 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/lookup.rb', line 37

def key_lookup list, key, err_notfound="%s not found\n", err_ambig="%s is ambiguous\n"
  keylist = list.is_a?(Hash) ? list.keys : list
  if exact = keylist.grep(/^#{key}$/i)         # exact match?
    return exact.shift if exact && exact.size == 1
  end
  keys = keylist.grep(/^#{key}/i)
  case keys.size
  when 0
    unless err_notfound.nil?
      raise LookupNotFoundError, sprintf(err_notfound, key)
    end
    return nil
  when 1
    return keys[0]
  else
    unless err_ambig.nil?
      raise LookupAmbigError, sprintf(err_ambig, key)
    end
    return keys
  end
end

#nrtalk(*args) ⇒ Object

nrtalk – “no run” talk Print msg, prefixed with “(norun) ”, on STDERR only if ‘$norun` is set

:call-seq:

nrtalk        msg
nrtalk      { msg }
nrtalkf fmt,  msg
nrtalkf fmt { msg }
nrtalkf { [ fmt, msg ] }



147
148
149
150
151
 
# File 'lib/talk-utils.rb', line 147

def nrtalk *args
  if $norun && (args.size > 0 || block_given?)
    $stderr.puts(*_prefix_arg0(_msgargs(args, block_given?){yield},'(norun) '))
  end
end

#nrtalkf(*args) ⇒ Object 



153
154
155
156
157
 
# File 'lib/talk-utils.rb', line 153

def nrtalkf *args
  if $norun && (args.size > 0 || block_given?)
    $stderr.printf(*_prefix_arg0(_fmtargs(args, block_given?){yield},'(norun) '))
  end
end

#nrvtalk(*args) ⇒ Object

nrvtalk – “no run” or verbose talk

Print msg, possibly prefixed with “(norun)” or “>>” (verbose), on STDERR only if $norun or $verbose are set.

:call-seq:

nrvtalk          msg
nrvtalk        { msg }
nrvtalkf   fmt,    args, ..
nrvtalkf   fmt { [ args, ..] }
nrvtalkf { [ fmt,  args .. ] }



171
172
173
174
175
176
177
178
 
# File 'lib/talk-utils.rb', line 171

def nrvtalk *args
  _args = _msgargs(args, block_given?) { yield }
  if $norun && _args.size > 0
    nrtalk(*_args)
  elsif $verbose && _args.size > 0
    vtalk(*_prefix_arg0(_args, '>> '))
  end
end

#nrvtalkf(*args) ⇒ Object 



180
181
182
183
184
185
186
187
 
# File 'lib/talk-utils.rb', line 180

def nrvtalkf *args
  _args = _fmtargs(args, block_given?) { yield }
  if $norun && _args.size > 0
    nrtalkf(*_args)
  elsif $verbose && _args.size > 0
    vtalkf(*_prefix_arg0(_args, '>> '))
  end
end

#nvtalk(*args) ⇒ Object

nvtalk – “non-verbose” talk Print msg on STDERR unless ‘$verbose` is set

:call-seq:

nvtalk msg
nvtalk { msg }



124
125
126
127
128
 
# File 'lib/talk-utils.rb', line 124

def  nvtalk *args
  unless $verbose && (args.size > 0 || block_given?)
    $stderr.puts(*_msgargs(args, block_given?) { yield })
  end
end

#nvtalkf(*args) ⇒ Object 



130
131
132
133
134
 
# File 'lib/talk-utils.rb', line 130

def nvtalkf *args
  unless $verbose && (args.size > 0 || block_given?)
    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
  end
end

#qtalk(*args) ⇒ Object

qtalk - “quiet talk” print msg on STDERR only if ‘$quiet` is set

:call-seq:

qtalk   msg
qtalk { msg }
qtalkf fmt,    args ..
qtalkf fmt { [ args .. ] }
qtalkf { [ fmt, args, ... ] }



81
82
83
84
85
 
# File 'lib/talk-utils.rb', line 81

def qtalk *args
  if $quiet && (args.size > 0 || block_given?)
    $stderr.puts(*_msgargs(args, block_given?) { yield })
  end
end

#qtalkf(*args) ⇒ Object 



87
88
89
90
91
 
# File 'lib/talk-utils.rb', line 87

def qtalkf *args
  if $quiet && (args.size > 0 || block_given?)
    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
  end
end

#safe_run(*args) ⇒ Object

run – run a command with support for testing, diagnostics and verbosity safe_run – run a command with support for diagnostics and verbosity

Both may be given optional errmsg and okmsg, which are printed if given for the corresponding condition.

:call-seq:

run         cmd
run      {  cmd }
run         cmd, errmsg
run      { [cmd, errmsg] }
run      { [cmd, errmsg, okmg] }
run         cmd, errmsg, okmsg

safe_run    cmd
safe_run    cmd, errmsg
safe_run    cmd, errmsg, okmsg
safe_run {  cmd }
safe_run { [cmd, errmsg] }
safe_run { [cmd, errmsg, okmsg] }

if ‘$norun` is set, print `(norun) ` followed by cmd on STDERR, and return.

if ‘$verbose` is set, print `>> ` followed by cmd on STDERR.

Invoke the cmd with the ‘system()` call.

If there is an error, show the command (preceded by ‘>> `) if `$verbose` is not set, then show the error code, followed by the given errmsg or the default error message.

The cmd can be given either as an argument, or as the returned value from a block. Important: the block should return a string value to be passed to the system call.



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/run-utils.rb', line 49

def safe_run *args
  args = _msgargs(args, block_given?) { yield }
  cmd, errmsg, okmsg = args
  vtalkf ">> %s\n", cmd
  if cmd
    if system cmd              # invoke the command
      talk okmsg if okmsg
      return true
    else                        # an error occured
      qtalkf ">> %s\n", cmd
      erm = sprintf(errmsg ? errmsg : "Command failed with code %d", $?>>8)
      talk erm
      $stderr.flush
      raise SystemCallError, erm            # instead of exit, use raise
    end
  end
end

#talk(*args) ⇒ Object

talk - Print msg on STDERR unless ‘$quiet` is set

:call-seq:

talk        msg ..
talk      { msg .. }
talkf fmt, args ...
talkf fmt { [ args ... ] }



35
36
37
38
39
 
# File 'lib/talk-utils.rb', line 35

def talk *args
  if !$quiet && (args.size > 0 || block_given?)
    $stderr.puts(*_msgargs(args, block_given?) { yield })
  end
end

#talkf(*args) ⇒ Object 



41
42
43
44
45
 
# File 'lib/talk-utils.rb', line 41

def talkf *args
  if !$quiet && (args.size > 0 || block_given?)
    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
  end
end

#vtalk(*args) ⇒ Object

vtalk - “verbose talk” Print msg on STDERR if ‘$verbose` is set

:call-seq:

vtalk   msg
vtalk { msg }
vtalkf fmt, args ..
vtalkf fmt { args .. }
vtalkf { [ fmt, args ... ] }



104
105
106
107
108
 
# File 'lib/talk-utils.rb', line 104

def vtalk *args
  if $verbose && (args.size > 0 || block_given?)
    $stderr.puts(*_msgargs(args, block_given?) { yield })
  end
end

#vtalkf(*args) ⇒ Object 



110
111
112
113
114
 
# File 'lib/talk-utils.rb', line 110

def vtalkf *args
  if $verbose && (args.size > 0 || block_given?)
    $stderr.printf(*_fmtargs(args, block_given?) { yield } )
  end
end