Module: ShellHelpers::SysUtils

Extended by:
SysUtils
Included in:
ShellHelpers, SysUtils
Defined in:
lib/shell_helpers/sysutils.rb

Constant Summary collapse

SysError = 
Class.new(StandardError)

Instance Method Summary collapse

Instance Method Details

#blkid(*args, sudo: false) ⇒ Object

output should be the result of blkid -o export ... return a list of things like :label=>"swap", :uuid=>"82af0d2f-5ef6-418a-8656-bdfe843f19e1", :type=>"swap", :partlabel=>"swap", :partuuid=>"f4eef373-0803-4701-bd47-b968c44065a6" SH.blkid => {:devname=>"/dev/sda1", :sec_type=>"msdos", :label_fatboot=>"boot", :label=>"boot", :uuid=>"D906-BEB0", :partlabel=>"boot", :partuuid=>"...",:fstype=>"vfat", ...}



105
106
107
108
109
 
# File 'lib/shell_helpers/sysutils.rb', line 105

def blkid(*args, sudo: false)
	# get devname, (part)label/uuid, fstype
	fsoptions=Run.run_simple("blkid -o export #{args.shelljoin}", fail_mode: :empty, chomp: true, sudo: sudo)
	parse_blkid(fsoptions)
end

#find_device(props) ⇒ Object

like find_devices but warn out if the result is of length > 1



226
227
228
229
230
231
232
233
 
# File 'lib/shell_helpers/sysutils.rb', line 226

def find_device(props)
	devs=find_devices(props)
	devs=yield(devs) if block_given?
	devs=[devs].flatten
	warn "Device #{props} not found" if devs.empty?
	warn "Several devices for #{props} found: #{devs.map {|d| d&.fetch(:devname)}}" if devs.length >1
	return devs.first&.fetch(:devname)
end

#find_devices(props, method: :all) ⇒ Object

find devices matching props SH.find_devices("boot") => [:label=>"boot", :uuid=>"D906-BEB0", :partlabel=>"boot", :partuuid=>"...", :parttype=>"c12a7328-f81f-11d2-ba4b-00a0c93ec93b", :devtype=>"part", :fstype=>"vfat"]



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
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
212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/shell_helpers/sysutils.rb', line 172

def find_devices(props, method: :all)
	props=props.clone
	return [{devname: props[:devname]}] unless props[:devname].nil?
	# name is both for label and partlabel
	if props.key?(:name)
		props[:label] = props[:name] unless props.key?(:label)
		props[:partlabel] = props[:name] unless props.key?(:partlabel)
	end

	if method==:blkid
		# try with UUID, then LABEL, then PARTUUID
		# as soon as we have a non empty label, we return the result of
		# blkid on it.
		#
		# Warning, since 'blkid' can only test one label, we cannot check
		# that all parameters are valid
		# search from most discriminant to less discriminant
		%i(uuid label partuuid partlabel).each do |key|
			if (label=props[key])
				return parse_blkid(%x/blkid -o export -t #{key.to_s.upcase}=#{label.shellescape}/).values
			end
		end
		# unfortunately `blkid PARTTYPE=...` does not work, so we need to parse
		# ourselves
		if props[:parttype]
			find_devices(props, method: :all)
		end
	else #method=:all
		fs=fs_infos
		# here we check all parameters (ie all defined labels are correct)
		# however, if none are defined, this return true, so we check that at least one is defined
		return [] unless %i(uuid label partuuid partlabel parttype).any? {|k| props[k]}
		return fs.keys.select do |k|
			fsprops=fs[k]
			next false if (disk=props[:disk]) && !fsprops[:devname].start_with?(disk.to_s)
			# all defined labels should match
			next false unless %i(uuid label partuuid partlabel parttype).all? do |key|
				ptype=props[key]
				ptype=partition_type(ptype) if key==:parttype and ptype.is_a?(Symbol)
				!ptype or !fsprops[key] or ptype==fsprops[key]
			end
			# their should at least be one matching label
			next false unless %i(uuid label partuuid partlabel parttype).select do |key|
				ptype=props[key]
				ptype=partition_type(ptype) if key==:parttype and ptype.is_a?(Symbol)
				ptype and fsprops[key] and ptype==fsprops[key]
			end.length > 0
			true
		end.map {|k| fs[k]}
	end
	return []
end

#findmnt(sudo: false) ⇒ Object

use findmnt to get infos about mount points SH.findmnt => {:mountpoint=>"/", :devname=>"/dev/bcache0[/slash]", :fstype=>"btrfs", :mountoptions=> ["rw", "noatime", "compress=lzo", "ssd", "space_cache", "autodefrag", "subvolid=257", "subvol=/slash"], :label=>"rootleaf", :uuid=>"1db5b600-df3e-4d1e-9eef-6a0a7fda491d", :partlabel=>"", :partuuid=>"", :fsroot=>"/slash", ...}



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/shell_helpers/sysutils.rb', line 139

def findmnt(sudo: false)
	# get devname, mountpoint, mountoptions, (part)label/uuid, fsroot
	# only looks at mounted devices (but in comparison to lsblk also show
	# virtual mounts and bind mounts)
	fsoptions=SH::Run.run_simple("findmnt --raw -o SOURCE,TARGET,FSTYPE,OPTIONS,LABEL,UUID,PARTLABEL,PARTUUID,FSROOT", fail_mode: :empty, chomp: true, sudo: sudo)
	fs={}
	fsoptions.each_line.to_a[1..-1]&.each do |l|
		#two '	' means a missing option, so we want to split on / /, not on ' '
		source,target,fstype,options,label,uuid,partlabel,partuuid,fsroot=l.chomp.split(/ /)
		next unless source=~%r(^/dev/) #skip non dev mountpoints
		options=options.split(',')
		fs[source]={mountpoint: target, devname: source, fstype: fstype, mountoptions: options, label: label, uuid: uuid, partlabel: partlabel, partuuid: partuuid, fsroot: fsroot}
	end
	fs
end

#fs_infos(mode: :devices) ⇒ Object

we default to lsblk findmnt adds the subvolumes, the fsroot and the mountoptions



157
158
159
160
161
162
 
# File 'lib/shell_helpers/sysutils.rb', line 157

def fs_infos(mode: :devices)
	return findmnt if mode == :mount
	return lsblk.merge(findmnt) if mode == :all
	# :devname, :devtype, :mountpoint, [:mountoptions], :label, :uuid, :partlabel, :partuuid, :parttype, :fstype, [:fsroot]
	lsblk
end

#losetup(img) ⇒ Object

runs losetup, and returns the created disk, and a lambda to close



475
476
477
478
479
480
481
482
483
484
485
486
487
488
 
# File 'lib/shell_helpers/sysutils.rb', line 475

def losetup(img)
	disk = Run.run_simple("losetup -f --show #{img.shellescape}", sudo: true, chomp: true, error_mode: :nil)
	close=lambda do
		SH.sh("losetup -d #{disk.shellescape}", sudo: true) if disk
	end
	if block_given?
		begin
			yield disk
		ensure
			close.call
		end
	end
	return disk, close
end

#lsblk(sudo: false) ⇒ Object

use lsblk to get infos about devices SH.lsblk => :devtype=>"disk", "/dev/sda1"=> :label=>"boot", :uuid=>"D906-BEB0", :partlabel=>"boot", :partuuid=>"00000000-0000-0000-0000-000000000000", :parttype=>"c12a7328-f81f-11d2-ba4b-00a0c93ec93b", :devtype=>"part", :fstype=>"vfat",...}



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/shell_helpers/sysutils.rb', line 114

def lsblk(sudo: false)
	# get devname, mountpoint, (part)label/uuid, (part/dev/fs)type
	fsoptions=Run.run_simple("lsblk -l -J -o NAME,MOUNTPOINT,LABEL,UUID,PARTLABEL,PARTUUID,PARTTYPE,TYPE,FSTYPE", fail_mode: :empty, chomp: true, sudo: sudo)
	require 'json'
	json=JSON.parse(fsoptions)
	fs={}
	json["blockdevices"]&.each do |props|
		r={}
		props.each do |k,v|
			k=k.to_sym
			k=:devtype if k==:type
			if k==:name
				k=:devname
				v="/dev/#{v}"
			end
			r[k]=v unless v.nil?
		end
		fs[r[:devname]]=r
	end
	fs
end

#make_btrfs_subvolume(dir, check: true) ⇒ Object

makes a btrfs subvolume



450
451
452
453
454
455
456
457
458
 
# File 'lib/shell_helpers/sysutils.rb', line 450

def make_btrfs_subvolume(dir, check: true)
	if check and dir.directory?
		raise SysError("Subvolume already exists at #{dir}") if check==:raise
		warn "Subvolume already exists at #{dir}, skipping..."
	else
		SH.sh("btrfs subvolume create #{dir.shellescape}", sudo: true)
		dir
	end
end

#make_dir_or_subvolume(dir) ⇒ Object

try to make a subvolume, else fallsback to a dir



461
462
463
464
465
466
467
468
469
470
471
472
 
# File 'lib/shell_helpers/sysutils.rb', line 461

def make_dir_or_subvolume(dir)
	dir=Pathname.new(dir)
	return :directory if dir.directory?
	fstype=stat_filesystem(dir, up: true)
	if fstype[:fstype]=="btrfs"
		make_btrfs_subvolume(dir)
		return :subvol
	else
		dir.sudo_mkpath
		return :directory
	end
end

#make_fs(fs, check: true) ⇒ Object

make filesystems takes a list of fs infos (where the device is specified like before, via devname, label, ...)



412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
 
# File 'lib/shell_helpers/sysutils.rb', line 412

def make_fs(fs, check: true)
	fs=fs.values if fs.is_a?(Hash)
	fs.each do |partfs|
		dev=SH.find_device(partfs)
		if dev and (fstype=partfs[:fstype])
			opts=partfs[:fsoptions]||[]
			bin="mkfs.#{fstype.to_s.shellescape}"
			bin="mkswap" if fstype.to_s=="swap"
			label=partfs[:label]||partfs[:name]
			if label
				labelkey="-L"
				labelkey="-n" if fstype.to_s=="vfat"
				opts+=[labelkey, label]
			end
			if check
				diskinfos=blkid(dev, sudo: true)
				unless diskinfos.dig(dev,:fstype).nil?
					raise SysError("Device #{dev} already has a filesystem: #{diskinfos[dev]}") if check==:raise
					warn "Device #{dev} already has a filesystem: #{diskinfos[dev]}"
					next
				end
			end
			SH.sh("#{bin} #{opts.shelljoin} #{dev.shellescape}", sudo: true)
		end
	end
end

#make_partitions(partitions, check: true, partprobe: true) ⇒ Object

@options:

  • check => check that no partitions exist first
  • partprobe: run partprobe if we made partitions SH.make_partitions( {:parttype=>:boot, :partlength=>"+100M", :fstype=>"vfat", :rel_mountpoint=>"boot", :mountoptions=>["fmask=133"], :slash=> :fstype=>"ext4", :rel_mountpoint=>".", ...})


354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/shell_helpers/sysutils.rb', line 354

def make_partitions(partitions, check: true, partprobe: true)
	partitions=partitions.values if partitions.is_a?(Hash)
	done=[]
	disk_partitions=partitions.group_by {|p| p[:disk]}
	disk_partitions.each do |disk, dpartitions|
		next if disk.nil?
		if check
			partinfos=blkid(disk, sudo: true)
			# gpt partitions: PTUUID="652121ab-7935-403c-8b87-65a149a415ac" PTTYPE="gpt"
			# dos partitions: PTUUID="17a4a006" PTTYPE="dos"
			# others: PTTYPE="PMBR"
			unless partinfos.empty?
				raise SysError("Disk #{disk} is not empty: #{partinfos}") if check==:raise
				warn "Disk #{disk} is not empty: #{partinfos}, skipping..."
				next
			end
		end
		opts=[]
		dpartitions.each do |partition|
			next unless %i(partnum partstart partlength partlabel partattributes parttype).any? {|k| partition.key?(k)}
			num=partition[:partnum]&.to_i || 0
			start=partition[:partstart] || 0
			length=partition[:partlength] || 0
			name=partition[:partlabel] || partition[:name]
			attributes=partition[:partattributes]
			type=partition[:parttype]
			attributes=2 if type==:boot
			type=partition_type(type, mode: :hexa) if type.is_a?(Symbol)
			uuid=partition[:partuuid]
			alignment=partition[:partalignment]
			opts += ["-n", "#{num}:#{start}:#{length}"]
			opts += ["-c", "#{num}:#{name}"] if name
			opts += ["-t", "#{num}:#{type}"] if type
			opts += ["-u", "#{num}:#{uuid}"] if uuid
			opts << "--attributes=#{num}:set:#{attributes}" if attributes
			opts << ["--set-alignment=#{alignment}"] if alignment
		end
		unless opts.empty?
			Sh.sh!("sgdisk #{opts.shelljoin} #{disk.shellescape}", sudo: true)
			done << disk
		end
	end
	SH.sh("partprobe #{done.shelljoin}", sudo: true) unless done.empty? or !partprobe
	done
end

#make_raw_image(name, size = "1G") ⇒ Object

use fallocate to make a raw image



440
441
442
443
444
445
446
447
 
# File 'lib/shell_helpers/sysutils.rb', line 440

def make_raw_image(name, size="1G")
	raw=Pathname.new(name)
	raw.touch
	rawfs=stat_filesystem(raw)
	raw.chattr("+C") if rawfs[:fstype]=="btrfs"
	Sh.sh("fallocate -l #{size} #{raw.shellescape}")
	raw
end

#mount(paths, mkpath: true, abort_on_error: true, sort: true) ⇒ Object

Mount devices on paths

  • paths: Array (or Hash) of path => path: "/mnt", mountoptions: [], fstype: "ext4", subvol: ..., device_info where device_info is used to find the device via find_device so can be set via :devname, or uuid label partuuid partlabel parttype
  • sort: sort the mountpoints
  • abort_on_error: fail if a mount failt
  • mkpath: mkpath the mountpoints the paths and a lambda to unmount


248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/shell_helpers/sysutils.rb', line 248

def mount(paths, mkpath: true, abort_on_error: true, sort: true)
	paths=paths.values if paths.is_a?(Hash)
	paths=paths.select {|p| p[:mountpoint]}
	# sort so that the mounts are in correct order
	paths=paths.sort { |p1, p2| Pathname.new(p1[:mountpoint]) <=> Pathname.new(p2[:mountpoint]) } if sort
	close=lambda do
		umount(paths, sort: sort)
	end
	paths.each do |path|
		dev=find_device(path)
		raise SysError.new("Device #{path} not found") unless dev
		options=path[:mountoptions]||[]
		options=options.split(',') if options.is_a?(String)
		options<<"subvol=#{path[:subvol].shellescape}" if path[:subvol]
		#options=options.join(',') if options.is_a?(Array)
		mntpoint=Pathname.new(path[:mountpoint])
		mntpoint.sudo_mkpath if mkpath
		cmd="mount #{(fs=path[:fstype]) && "-t #{fs.shellescape}"} #{options.empty? ? "" : "-o #{options.join(',').shellescape}"} #{dev.shellescape} #{mntpoint.shellescape}"
		abort_on_error ? Sh.sh!(cmd, sudo: true) : Sh.sh(cmd, sudo: true)
	end
	if block_given?
		begin
			yield paths
		ensure
			close.call
		end
	end
	return paths, close
end

#parse_blkid(output) ⇒ Object 



73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/shell_helpers/sysutils.rb', line 73

def parse_blkid(output)
	devs={}
	r=[]
	convert=lambda do |h|
		h[:type] && h[:fstype]=h.delete(:type)
		name=h[:devname]
		devs[name]=h
	end
	output=output.each_line if output.is_a?(String)
	output.each do |l|
		l=l.chomp
		if l.empty?
			convert.(Export.import_parse(r))
			r=[]
		else
			r<<l
		end
	end
	convert.(Export.import_parse(r)) unless r.empty?
	devs
end

#partition_infos(device, sudo: false) ⇒ Object

SH.partition_infos("/dev/sda", sudo: true) => [:partattributes=>"0000000000000004", :partuuid=>"00000000-0000-0000-0000-000000000000", :parttype=>"c12a7328-f81f-11d2-ba4b-00a0c93ec93b", :partattributes=>"0000000000000000", :partuuid=>"f4eef373-0803-4701-bd47-b968c44065a6", :parttype=>"0fc63daf-8483-4772-8e79-3d69d8477de4", :partattributes=>"0000000000000000", :partuuid=>"31b4cd66-39ab-4c5b-a229-d5d2010d53dd", :parttype=>"0fc63daf-8483-4772-8e79-3d69d8477de4"]



321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
 
# File 'lib/shell_helpers/sysutils.rb', line 321

def partition_infos(device, sudo: false)
	parts = Run.run_simple("partx -o NR --show #{device.shellescape}", sudo: sudo) { return nil }
	infos=[]
	nums=parts.each_line.count - 1
	(1..nums).each do |i|
		infos[i-1]={}
		part_options=Run.run_simple("sgdisk -i#{i} #{device.shellescape}", chomp: true, sudo: sudo)
		part_options.match(/^Partition name: '(.*)'/) do |m|
			infos[i-1][:partlabel]=m[1]
		end
		part_options.match(/^Attribute flags: (.*)/) do |m|
			infos[i-1][:partattributes]=m[1]
		end
		part_options.match(/^Partition unique GUID: (.*)/) do |m|
			infos[i-1][:partuuid]=m[1].downcase
		end
		part_options.match(/^Partition GUID code: (\S*)/) do |m|
			infos[i-1][:parttype]=m[1].downcase
		end
	end
	infos
end

#partition_type(type, mode: :guid) ⇒ Object

by default give symbol => guid can also give symbol => hexa (mode: :hexa) or hexa/guid => symbol (mode: :symbol)



291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
 
# File 'lib/shell_helpers/sysutils.rb', line 291

def partition_type(type, mode: :guid)
	if mode==:symbol
		%i(boot swap home x86_root x86-64_root arm64_root arm32_root linux).each do |symb|
			%i(hexa guid).each do |mode|
				partition_type(symb, mode: mode) == type.downcase and return symb
			end
		end
	end
	case type
	when :boot
		mode == :hexa ? "ef00" : "c12a7328-f81f-11d2-ba4b-00a0c93ec93b"
	when :swap
		mode == :hexa ? "8200" : "0657fd6d-a4ab-43c4-84e5-0933c84b4f4f"
	when :home
		mode == :hexa ? "8302" : "933ac7e1-2eb4-4f13-b844-0e14e2aef915"
	when :x86_root
		mode == :hexa ? "8303" : "44479540-f297-41b2-9af7-d131d5f0458a"
	when :"x86-64_root"
		mode == :hexa ? "8304" : "4f68bce3-e8cd-4db1-96e7-fbcaf984b709"
	when :arm64_root
		mode == :hexa ? "8305" : "b921b045-1df0-41c3-af44-4c6f280d3fae"
	when :arm32_root
		mode == :hexa ? "8307" : "69dad710-2ce4-4e3c-b16c-21a1d49abed3"
	when :linux
		mode == :hexa ? "8300" : "0fc63daf-8483-4772-8e79-3d69d8477de4"
	end
end

#refresh_blkid_cache ⇒ Object 



164
165
166
 
# File 'lib/shell_helpers/sysutils.rb', line 164

def refresh_blkid_cache
	Sh.sh("blkid", sudo: true)
end

#stat_file(file) ⇒ Object

wrap 'stat' SH.stat_file("mine") => :blocknumber=>0,...



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/shell_helpers/sysutils.rb', line 15

def stat_file(file)
	require 'time'
	opts=%w(a b B f F g G h i m n N o s u U w x y z)
	stats=Run.run_simple("stat --format='#{opts.map{|o| "%#{o}\n"}.join}' #{file.shellescape}", chomp: :lines)
	r={}
	r[:access]=stats[0]
	r[:blocknumber]=stats[1].to_i
	r[:blocksize]=stats[2].to_i
	r[:rawmode]=stats[3]
	r[:filetype]=stats[4]
	r[:gid]=stats[5].to_i
	r[:group]=stats[6]
	r[:hardlinks]=stats[7].to_i
	r[:inode]=stats[8].to_i
	r[:mountpoint]=stats[9]
	r[:filename]=stats[10]
	r[:quotedfilename]=stats[11]
	r[:optimalsize]=stats[12]
	r[:size]=stats[13].to_i
	r[:uid]=stats[14].to_i
	r[:user]=stats[15]
	r[:birthtime]  = begin Time.parse(stats[16]) rescue nil end
	r[:accesstime] = begin Time.parse(stats[17]) rescue nil end
	r[:changedtime]= begin Time.parse(stats[18]) rescue nil end
	r[:statustime] = begin Time.parse(stats[19]) rescue nil end
	r
end

#stat_filesystem(file, up: true) ⇒ Object

wrap stat --file-system SH.stat_filesystem("mine") => fstype=>"btrfs"



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/shell_helpers/sysutils.rb', line 46

def stat_filesystem(file, up: true)
	if up #output the fs info of the first ascending path that exist
		# usefull to get infos of the filesystem of a file we want to create
		# but does not yet exist
		file=Pathname.new(file)
		file.ascend.each do |f|
			return stat_filesystem(f, up: false) if f.exist?
		end
	end
	opts=%w(a b c d f i l n s S T)
	stats=Run.run_simple("stat --file-system --format='#{opts.map{|o| "%#{o}\n"}.join}' #{file.shellescape}", chomp: :lines)
	#stats=stats.each_line.map {|l| l.chomp}
	r={}
	r[:userfreeblocks]=stats[0].to_i
	r[:totalblocks]=stats[1].to_i
	r[:totalnodes]=stats[2].to_i
	r[:freenodes]=stats[3].to_i
	r[:freeblocks]=stats[4].to_i
	r[:fsid]=stats[5]
	r[:maxlength]=stats[6].to_i
	r[:name]=stats[7]
	r[:blocksize]=stats[8].to_i
	r[:innerblocksize]=stats[9].to_i
	r[:fstype]=stats[10]
	r
end

#umount(paths, sort: true) ⇒ Object 



278
279
280
281
282
283
284
285
286
 
# File 'lib/shell_helpers/sysutils.rb', line 278

def umount(paths, sort: true)
	paths=paths.values if paths.is_a?(Hash)
	paths=paths.select {|p| p[:mountpoint]}
	paths=paths.sort { |p1, p2| Pathname.new(p1[:mountpoint]) <=> Pathname.new(p2[:mountpoint]) } if sort
	paths.reverse.each do |path|
		mntpoint=path[:mountpoint]
		Sh.sh("umount #{mntpoint.shellescape}", sudo: true)
	end
end

#wipefs(disk) ⇒ Object 



404
405
406
407
 
# File 'lib/shell_helpers/sysutils.rb', line 404

def wipefs(disk)
	# wipe all signatures
	Sh.sh("wipefs -a #{disk.shellescape}", sudo: true)
end

#zap_partitions(disk) ⇒ Object 



400
401
402
403
 
# File 'lib/shell_helpers/sysutils.rb', line 400

def zap_partitions(disk)
	# Zap (destroy) the GPT and MBR data  structures  and  then  exit.
	Sh.sh("sgdisk --zap-all #{disk.shellescape}", sudo: true)
end