1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
42
43
44
45
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
#
# Copyright (C) 2022 Soleta Networks <info@soleta.eu>
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the
# Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
import logging
import os
import subprocess
import shlex
from subprocess import DEVNULL, PIPE, STDOUT
import psutil
from src.utils.disk import get_partition_device
def find_mountpoint(path):
"""
Returns mountpoint of a given path
"""
path = os.path.abspath(path)
while not os.path.ismount(path):
path = os.path.dirname(path)
return path
def mount_mkdir(source, target):
"""
Mounts and creates the mountpoint directory if it's not present.
Return True if mount is sucessful or if target is already a mountpoint.
"""
if not os.path.exists(target):
os.mkdir(target)
if not os.path.ismount(target):
return mount(source, target)
else:
return True
return False
def mount(source, target):
"""
Mounts source into target directoru using mount(8).
Return true if exit code is 0. False otherwise.
"""
cmd = f'mount {source} {target}'
proc = subprocess.run(cmd.split(), stderr=DEVNULL)
return not proc.returncode
def umount(target):
"""
Umounts target using umount(8).
Return true if exit code is 0. False otherwise.
"""
cmd = f'umount {target}'
proc = subprocess.run(cmd.split(), stderr=DEVNULL)
return not proc.returncode
def get_usedperc(mountpoint):
"""
Returns percetage of used filesystem as decimal number.
"""
try:
total, used, free, perc = psutil.disk_usage(mountpoint)
except FileNotFoundError:
return '0'
return str(perc)
def ogReduceFs(disk, part):
"""
Bash function 'ogReduceFs' wrapper
"""
proc = subprocess.run(f'ogReduceFs {disk} {part}',
shell=True, stdout=PIPE,
encoding='utf-8')
if proc.returncode != 0:
logging.warn(f'ogReduceFS exited with non zero code: {proc.returncode}')
subprocess.run(f'ogUnmount {disk} {part}',
shell=True)
def ogExtendFs(disk, part):
"""
Bash function 'ogExtendFs' wrapper
"""
subprocess.run(f'ogMount {disk} {part}',
shell=True)
proc = subprocess.run(f'ogExtendFs {disk} {part}',
shell=True)
if proc.returncode != 0:
logging.warn(f'ogExtendFs exited with non zero code: {proc.returncode}')
def mkfs(fs, disk, partition, label=None):
"""
Install any supported filesystem. Target partition is specified a disk
number and partition number. This function uses utility functions to
translate disk and partition number into a partition device path.
If filesystem and partition are correct, calls the corresponding mkfs_*
function with the partition device path. If not, ValueError is raised.
"""
logging.debug(f'mkfs({fs}, {disk}, {partition}, {label})')
fsdict = {
'ext4': mkfs_ext4,
'ntfs': mkfs_ntfs,
'fat32': mkfs_fat32,
}
if fs not in fsdict:
logging.warn(f'mkfs aborted, invalid target filesystem.')
raise ValueError('Invalid target filesystem')
try:
partdev = get_partition_device(disk, partition)
except ValueError as e:
logging.warn(f'mkfs aborted, invalid partition.')
raise e
fsdict[fs](partdev, label)
def mkfs_ext4(partdev, label=None):
if label:
cmd = shlex.split(f'mkfs.ext4 -L {label} -F {partdev}')
else:
cmd = shlex.split(f'mkfs.ext4 -F {partdev}')
with open('/tmp/command.log', 'wb', 0) as logfile:
subprocess.run(cmd,
stdout=logfile,
stderr=STDOUT)
def mkfs_ntfs(partdev, label=None):
if label:
cmd = shlex.split(f'mkfs.ntfs -f -L {label} {partdev}')
else:
cmd = shlex.split(f'mkfs.ntfs -f {partdev}')
with open('/tmp/command.log', 'wb', 0) as logfile:
subprocess.run(cmd,
stdout=logfile,
stderr=STDOUT)
def mkfs_fat32(partdev, label=None):
if label:
cmd = shlex.split(f'mkfs.vfat -n {label} -F32 {partdev}')
else:
cmd = shlex.split(f'mkfs.vfat -F32 {partdev}')
with open('/tmp/command.log', 'wb', 0) as logfile:
subprocess.run(cmd,
stdout=logfile,
stderr=STDOUT)
def get_filesystem_type(partdev):
"""
Get filesystem type from a partition device path.
Raises RuntimeError when blkid exits with non-zero return code.
"""
cmd = shlex.split(f'blkid -o value -s TYPE {partdev}')
proc = subprocess.run(cmd, stdout=PIPE, encoding='utf-8')
if proc.returncode != 0:
raise RuntimeError(f'Error getting filesystem from {partdev}')
return proc.stdout.strip()
|
