Class: Rush::Connection::Local

Inherits:
Object
  • Object
show all
Defined in:
lib/rush/local.rb

Overview

Rush::Box uses a connection object to execute all rush commands. If the box is local, Rush::Connection::Local is created. The local connection is the heart of rush’s internals. (Users of the rush shell or library need never access the connection object directly, so the docs herein are intended for developers wishing to modify rush.)

The local connection has a series of methods which do the actual work of modifying files, getting process lists, and so on. RushServer creates a local connection to handle incoming requests; the translation from a raw hash of parameters to an executed method is handled by Rush::Connection::Local#receive.

Defined Under Namespace

Classes: UnknownAction

Instance Method Summary collapse

Instance Method Details

#alive? ⇒ Boolean

Local connections are always alive.

Returns:

  • (Boolean) 


374
375
376
 
# File 'lib/rush/local.rb', line 374

def alive?
  true
end

#append_to_file(full_path, contents) ⇒ Object

Append contents to a file



25
26
27
28
 
# File 'lib/rush/local.rb', line 25

def append_to_file(full_path, contents)
  ::File.open(full_path, 'a') { |f| f.write contents }
  true
end

#bash(command, user = nil, background = false, reset_environment = false) ⇒ Object

Raises:



297
298
299
300
301
302
303
304
305
306
 
# File 'lib/rush/local.rb', line 297

def bash(command, user=nil, background=false, reset_environment=false)
  return bash_background(command, user, reset_environment) if background
  sh = Session::Bash.new
  shell = reset_environment ? "env -i bash" : "bash"
  out, err = sh.execute sudo(user, shell), :stdin => command
  retval = sh.status
  sh.close!
  raise(Rush::BashFailed, err) if retval != 0
  out
end

#bash_background(command, user, reset_environment) ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/rush/local.rb', line 308

def bash_background(command, user, reset_environment)
  pid = fork do
    inpipe, outpipe = IO.pipe
    outpipe.write command
    outpipe.close
    STDIN.reopen(inpipe)
    close_all_descriptors([inpipe.to_i])
    shell = reset_environment ? "env -i bash" : "bash"
    exec sudo(user, shell)
  end
  Process::detach pid
  pid
end

#chown(full_path, user = nil, group = nil, options = {}) ⇒ Object

A frontend for FileUtils::chown



134
135
136
137
138
139
140
 
# File 'lib/rush/local.rb', line 134

def chown( full_path, user=nil, group=nil, options={} )
  if options[:recursive]
    FileUtils.chown_R(user, group, full_path, options)
  else
    FileUtils.chown(user, group, full_path, options)
  end
end

#close_all_descriptors(keep_open = []) ⇒ Object 



327
328
329
330
331
332
 
# File 'lib/rush/local.rb', line 327

def close_all_descriptors(keep_open = [])
  3.upto(256) do |fd|
    next if keep_open.include?(fd)
    IO::new(fd).close rescue nil
  end
end

#copy(src, dst) ⇒ Object

Copy ane entry from one path to another.

Raises:



72
73
74
75
76
77
 
# File 'lib/rush/local.rb', line 72

def copy(src, dst)
  raise(Rush::DoesNotExist, src) unless File.exists?(src)
  raise(Rush::DoesNotExist, File.dirname(dst)) unless File.exists?(File.dirname(dst))
  FileUtils.cp_r(src, dst)
  true
end

#create_dir(full_path) ⇒ Object

Create a dir.



56
57
58
59
 
# File 'lib/rush/local.rb', line 56

def create_dir(full_path)
  FileUtils.mkdir_p(full_path)
  true
end

#destroy(full_path) ⇒ Object

Destroy a file or dir.



38
39
40
41
42
 
# File 'lib/rush/local.rb', line 38

def destroy(full_path)
  raise "No." if full_path == '/'
  FileUtils.rm_rf(full_path)
  true
end

#ensure_tunnel(options = {}) ⇒ Object

No-op for duck typing with remote connection.



370
371
 
# File 'lib/rush/local.rb', line 370

def ensure_tunnel(options={})
end

#file_contents(full_path) ⇒ Object

Read raw bytes from a file.



31
32
33
34
35
 
# File 'lib/rush/local.rb', line 31

def file_contents(full_path)
  ::File.read(full_path)
rescue Errno::ENOENT
  raise Rush::DoesNotExist, full_path
end

#index(base_path, glob) ⇒ Object

Get an index of files from the given path with the glob. Could return nested values if the glob contains a doubleglob. The return value is an array of full paths, with directories listed first.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/rush/local.rb', line 96

def index(base_path, glob)
  glob = '*' if glob == '' or glob.nil?
  dirs = []
  files = []
  ::Dir.chdir(base_path) do
    ::Dir.glob(glob).each do |fname|
      if ::File.directory?(fname)
        dirs << fname + '/'
      else
        files << fname
      end
    end
  end
  dirs.sort + files.sort
rescue Errno::ENOENT
  raise Rush::DoesNotExist, base_path
end

#kill_process(pid, options = {}) ⇒ Object

Terminate a process, by pid.



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
 
# File 'lib/rush/local.rb', line 271

def kill_process(pid, options={})
  # time to wait before terminating the process, in seconds
  wait = options[:wait] || 3

  if wait > 0
    ::Process.kill('TERM', pid)

    # keep trying until it's dead (technique borrowed from god)
    begin
      Timeout.timeout(wait) do
        loop do
          return if !process_alive(pid)
          sleep 0.5
          ::Process.kill('TERM', pid) rescue nil
        end
      end
    rescue Timeout::Error
    end
  end

  ::Process.kill('KILL', pid) rescue nil

rescue Errno::ESRCH
  # if it's dead, great - do nothing
end

#linux_processes ⇒ Object

Process list on Linux using /proc.



160
161
162
163
164
 
# File 'lib/rush/local.rb', line 160

def linux_processes
  ::Dir["/proc/*/stat"].
    select     { |file| file =~ /\/proc\/\d+\// }.
    inject([]) { |list, file| (list << read_proc_file(file)) rescue list }
end

#os_x_processes ⇒ Object

Process list on OS X or other unixes without a /proc.



214
215
216
217
218
219
 
# File 'lib/rush/local.rb', line 214

def os_x_processes
  raw = os_x_raw_ps.split("\n").slice(1, 99999)
  raw.map do |line|
    parse_ps(line)
  end
end

#os_x_raw_ps ⇒ Object

ps command used to generate list of processes on non-/proc unixes.



222
223
224
 
# File 'lib/rush/local.rb', line 222

def os_x_raw_ps
  `COLUMNS=9999 ps ax -o "pid uid ppid rss cpu command"`
end

#parse_oleprocinfo(proc_info) ⇒ Object

Parse the Windows OLE process info.



251
252
253
254
255
256
257
258
259
260
 
# File 'lib/rush/local.rb', line 251

def parse_oleprocinfo(proc_info)
  {
    pid: proc_info.ProcessId,
    uid: 0,
    command: proc_info.Name,
    cmdline: proc_info.CommandLine,
    mem: proc_info.MaximumWorkingSetSize,
    cpu: proc_info.KernelModeTime.to_i + proc_info.UserModeTime.to_i
  }
end

#parse_ps(line) ⇒ Object

Parse a single line of the ps command and return the values in a hash suitable for use in the Rush::Process#new.



228
229
230
231
232
233
234
235
236
237
238
239
 
# File 'lib/rush/local.rb', line 228

def parse_ps(line)
  m = line.split(" ", 6)
  {
    pid: m[0],
    uid: m[1],
    parent_pid: m[2].to_i,
    mem: m[3].to_i,
    cpu: m[4].to_i,
    cmdline: m[5],
    command: m[5].split(' ').first
  }
end

#process_alive(pid) ⇒ Object

Returns true if the specified pid is running.



263
264
265
266
267
268
 
# File 'lib/rush/local.rb', line 263

def process_alive(pid)
  ::Process.kill(0, pid)
  true
rescue Errno::ESRCH
  false
end

#processes ⇒ Object

Get the list of processes as an array of hashes.



149
150
151
152
153
154
155
156
157
 
# File 'lib/rush/local.rb', line 149

def processes
  if ::File.directory? "/proc"
    resolve_unix_uids(linux_processes)
  elsif ::File.directory? "C:/WINDOWS"
    windows_processes
  else
    os_x_processes
  end
end

#purge(full_path) ⇒ Object

Purge the contents of a dir.



45
46
47
48
49
50
51
52
53
 
# File 'lib/rush/local.rb', line 45

def purge(full_path)
  raise "No." if full_path == '/'
  Dir.chdir(full_path) do
    all = Dir.glob("*", File::FNM_DOTMATCH).
      reject { |f| f == '.' or f == '..' }
    FileUtils.rm_rf all
  end
  true
end

#read_archive(full_path) ⇒ Object

Create an in-memory archive (tgz) of a file or dir, which can be transmitted to another server for a copy or move. Note that archive operations have the dir name implicit in the archive.



82
83
84
 
# File 'lib/rush/local.rb', line 82

def read_archive(full_path)
  `cd #{Rush.quote(::File.dirname(full_path))}; tar c #{Rush.quote(::File.basename(full_path))}`
end

#read_proc_file(file) ⇒ Object

Read a single file in /proc and store the parsed values in a hash suitable for use in the Rush::Process#new.



187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/rush/local.rb', line 187

def read_proc_file(file)
  stat_contents = ::File.read(file)
  stat_contents.gsub!(/\((.*)\)/, "")
  command = $1
  data = stat_contents.split(" ")
  uid = ::File.stat(file).uid
  pid = data[0]
  cmdline = ::File.read("/proc/#{pid}/cmdline").gsub(/\0/, ' ')
  parent_pid = data[2].to_i
  utime = data[12].to_i
  ktime = data[13].to_i
  vss = data[21].to_i / 1024
  rss = data[22].to_i * 4
  time = utime + ktime

  {
    :pid => pid,
    :uid => uid,
    :command => command,
    :cmdline => cmdline,
    :parent_pid => parent_pid,
    :mem => rss,
    :cpu => time
  }
end

#receive(params) ⇒ Object

RushServer uses this method to transform a hash (:action plus parameters specific to that action type) into a method call on the connection. The returned value must be text so that it can be transmitted across the wire as an HTTP response.



343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/rush/local.rb', line 343

def receive(params)
  case params[:action]
    when 'write_file'     then write_file(params[:full_path], params[:payload])
    when 'append_to_file' then append_to_file(params[:full_path], params[:payload])
    when 'file_contents'  then file_contents(params[:full_path])
    when 'destroy'        then destroy(params[:full_path])
    when 'purge'          then purge(params[:full_path])
    when 'create_dir'     then create_dir(params[:full_path])
    when 'rename'         then rename(params[:path], params[:name], params[:new_name])
    when 'copy'           then copy(params[:src], params[:dst])
    when 'read_archive'   then read_archive(params[:full_path])
    when 'write_archive'  then write_archive(params[:payload], params[:dir])
    when 'index'          then index(params[:base_path], params[:glob]).join("\n") + "\n"
    when 'stat'           then YAML.dump(stat(params[:full_path]))
    when 'set_access'     then set_access(params[:full_path], Rush::Access.from_hash(params))
    when 'chown'          then chown(params[:full_path], params[:user], params[:group], params[:options])
    when 'size'           then size(params[:full_path])
    when 'processes'      then YAML.dump(processes)
    when 'process_alive'  then process_alive(params[:pid]) ? '1' : '0'
    when 'kill_process'   then kill_process(params[:pid].to_i, YAML.load(params[:payload]))
    when 'bash'           then bash(params[:payload], params[:user], params[:background] == 'true', params[:reset_environment] == 'true')
  else
    raise UnknownAction
  end
end

#rename(path, name, new_name) ⇒ Object

Rename an entry within a dir.

Raises:



62
63
64
65
66
67
68
69
 
# File 'lib/rush/local.rb', line 62

def rename(path, name, new_name)
  raise(Rush::NameCannotContainSlash, "#{path} rename #{name} to #{new_name}") if new_name.match(/\//)
  old_full_path = "#{path}/#{name}"
  new_full_path = "#{path}/#{new_name}"
  raise(Rush::NameAlreadyExists, "#{path} rename #{name} to #{new_name}") if ::File.exists?(new_full_path)
  FileUtils.mv(old_full_path, new_full_path)
  true
end

#resolve_unix_uid_to_user(uid) ⇒ Object

resolve uid to user



175
176
177
178
179
180
181
182
183
 
# File 'lib/rush/local.rb', line 175

def resolve_unix_uid_to_user(uid)
  uid = uid.to_i
  require 'etc'
  @uid_map ||= {}
  return @uid_map[uid] if @uid_map[uid]
  record = Etc.getpwuid(uid) rescue (return nil)
  @uid_map.merge uid => record.name
  record.name
end

#resolve_unix_uids(list) ⇒ Object 



166
167
168
169
170
171
172
 
# File 'lib/rush/local.rb', line 166

def resolve_unix_uids(list)
  @uid_map = {} # reset the cache between uid resolutions.
  list.each do |process|
    process[:user] = resolve_unix_uid_to_user(process[:uid])
  end
  list
end

#set_access(full_path, access) ⇒ Object 



128
129
130
 
# File 'lib/rush/local.rb', line 128

def set_access(full_path, access)
  access.apply(full_path)
end

#size(full_path) ⇒ Object

Fetch the size of a dir, since a standard file stat does not include the size of the contents.



144
145
146
 
# File 'lib/rush/local.rb', line 144

def size(full_path)
  `du -sb #{Rush.quote(full_path)}`.match(/(\d+)/)[1].to_i
end

#stat(full_path) ⇒ Object

Fetch stats (size, ctime, etc) on an entry. Size will not be accurate for dirs.



115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/rush/local.rb', line 115

def stat(full_path)
  s = ::File.stat(full_path)
  {
    :size => s.size,
    :ctime => s.ctime,
    :atime => s.atime,
    :mtime => s.mtime,
    :mode => s.mode
  }
rescue Errno::ENOENT
  raise Rush::DoesNotExist, full_path
end

#sudo(user, shell) ⇒ Object 



322
323
324
325
 
# File 'lib/rush/local.rb', line 322

def sudo(user, shell)
  return shell if user.nil? || user.empty?
  "cd /; sudo -H -u #{user} \"#{shell}\""
end

#windows_processes ⇒ Object

Process list on Windows.



242
243
244
245
246
247
248
 
# File 'lib/rush/local.rb', line 242

def windows_processes
  require 'win32ole'
  wmi = WIN32OLE.connect("winmgmts://")
  wmi.ExecQuery("select * from win32_process").map do |proc_info|
    parse_oleprocinfo(proc_info)
  end
end

#write_archive(archive, dir) ⇒ Object

Extract an in-memory archive to a dir.



87
88
89
90
91
 
# File 'lib/rush/local.rb', line 87

def write_archive(archive, dir)
  IO.popen("cd #{Rush::quote(dir)}; tar x", "w") do |p|
    p.write archive
  end
end

#write_file(full_path, contents) ⇒ Object

Write raw bytes to a file.



19
20
21
22
 
# File 'lib/rush/local.rb', line 19

def write_file(full_path, contents)
  ::File.open(full_path, 'w') { |f| f.write contents }
  true
end