summaryrefslogtreecommitdiffstats
path: root/src/utils/image.py
blob: a12c221d1681d1e6f47ed26151b336dc6d11106d (plain)
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
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
224
225
226
227
228
229
230
231
232
233
234
235
236
#
# Copyright (C) 2023 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 ipaddress
import logging
import os
import stat
import subprocess
import shlex
import shutil

from subprocess import PIPE, DEVNULL, STDOUT, CalledProcessError

from src.utils.fs import umount
from src.log import OgError


class ImageInfo:
    """
    Class that stores the OpenGnsys partition image information.
    """
    def __init__(self, filesystem=None, datasize=None):
        self.filesystem = filesystem
        self.datasize = datasize
        self.size = 0
        self.mtime = 0
        self.perms = 0
        self.clonator = 'PARTCLONE'
        self.compressor = 'LZOP'
        self.checksum = 0


def human_to_kb(size, unit):
    """
    Returns the KB conversion of a human readable string size and unit.
    """
    size = float(size.replace(',', '.'))
    if unit == 'GB':
        return size * 1000000
    if unit == 'MB':
        return size * 1000
    return 0


def fill_imageinfo(line, image_info):
    """
    Updates ImageInfo object with information processed from
    a single partclone.info output line.

    ImageInfo object may not be updated if the line is invalid or does not
    contain filesystem or device size information.
    """
    if 'File system' in line:
        filesystem = line.rstrip().split(' ')[-1]
        image_info.filesystem = filesystem
    elif 'Device size' in line:
        l = [word for word in line.rstrip().split(' ') if word][2:4]
        device_size = human_to_kb(*l)
        image_info.datasize = device_size


def image_info_from_partclone(partclone_output):
    """
    Return an ImageInfo object from partclone.info output.
    """
    image_info = ImageInfo()
    for n, line in enumerate(partclone_output.split('\n')):
        # Ignore first two lines of partclone.info output
        if n < 2:
            continue
        if image_info.datasize and image_info.filesystem:
            break
        fill_imageinfo(line, image_info)

    if not image_info.datasize:
        raise OgError("Missing device size from partclone.info output")
    elif not image_info.filesystem:
        raise OgError("Missing filesystem from partclone.info output")

    return image_info


def run_lzop_partcloneinfo(image_path):
    """
    Run lzop to decompress an OpenGnsys partition image, feed
    lzop output to a partclone.info subprocess.

    Return the partclone.info subprocess output.
    """
    cmd1 = f'{shutil.which("lzop")} -dc {image_path}'
    cmd2 = f'{shutil.which("partclone.info")} -s -'
    args1 = shlex.split(cmd1)
    args2 = shlex.split(cmd2)
    p1 = subprocess.Popen(args1, stdout=PIPE, stderr=DEVNULL)
    p2 = subprocess.Popen(args2, stdout=PIPE, stdin=p1.stdout,
                          stderr=STDOUT, encoding='utf-8')
    p1.stdout.close()
    p2_out, p2_err = p2.communicate()

    if p2.returncode != 0:
        raise OgError(f'Unable to process image {image_path}')

    return p2_out


def get_image_info(image_path):
    """
    Obtain filesystem and device size information of an OpenGnsys partition
    image.

    This method supports compressed images with lzop that have been created
    with partclone.

    Returns an ImageInfo object.

    >>> image_info = get_image_info('/opt/opengnsys/images/foobar.img')
    >>> image_info.filesystem
    >>> 'NTFS'
    >>> image_info.datasize
    >>> 140000000
    >>> image_info.compressor
    >>> 'LZOP'
    >>> image_info.clonator
    >>> 'PARTCLONE'
    """
    partclone_output = run_lzop_partcloneinfo(image_path)
    image_info = image_info_from_partclone(partclone_output)

    try:
        st = os.stat(image_path)
        image_info.size = st.st_size
        image_info.perms = st.st_mode & (stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO)
        image_info.mtime = int(st.st_mtime)
    except Exception as e:
        logging.info(f'cannot retrieve stats from {image_path}: {e}')

    return image_info


def change_access(mode='rw', user='opengnsys', pwd='og'):
    """
    'CambiarAcceso' (admin/Interface/CambiarAcceso) rewrite into native Python.

    Remount the (remote) samba directory that contains the OpenGnsys images.
    Specify access mode ('rw', or 'ro') with mode parameter (default 'rw').
    Specify samba credentials with user and pwd parameter.

    Return 0 if exit-code was 0. Return -1 otherwise.
    """
    assert mode in ['rw', 'ro'], 'Invalid remount mode option'

    cmd = shlex.split(f'mount -o remount,{mode},username={user},password={pwd} /opt/opengnsys/images')
    p = subprocess.run(cmd, stdout=DEVNULL, stderr=DEVNULL)

    return 0 if p.returncode == 0 else -1

def ogChangeRepo(ip, smb_user='opengnsys', smb_pass='og'):
    """
    Umount current Samba directory of OpenGnsys images and mount new Samba
    directory (preserving previous access mode).

    If the mount fails, fallback to the image directory that was mounted before
    calling this function.

    If there is no previous image directory mount, then simply try mounting the
    new Samba directory with readonly mode option.

    Any CalledProcessError raised by the fallback mount subprocess should be
    handled by the caller of this function.
    """
    def fsopts_mode(fsopts):
        for opt in fsopts.split(','):
            if opt in ['rw', 'ro']:
                return opt

    def process_mntent(line):
        name, mntdir, fstype, opts, freq, passno = line.split(' ')
        mode = fsopts_mode(opts)
        return name, mntdir, fsopts_mode(opts)

    try:
        ipaddr = ipaddress.ip_address(ip)
    except ValueError as e:
        raise OgError(f'Invalid IP address {ip} received') from e

    mounted = False
    with open('/etc/mtab') as f:
        for line in f:
            if 'ogimages' in line:
                orig_name, mntdir, mode = process_mntent(line)
                mounted = True
                break

    new_name = f'//{ip}/ogimages'
    if not mounted:
        orig_name = new_name
        mntdir = '/opt/opengnsys/images'
        mode = 'ro'
    else:
        umount(mntdir)

    err = 0
    cmd = f'mount.cifs -o {mode},username={smb_user},password={smb_pass} {new_name} /opt/opengnsys/images'
    result = subprocess.run(shlex.split(cmd))
    if result.returncode != 0:
        err = -1
        logging.error(f'Error mounting {new_name} in /opt/opengnsys/images with error {result.returncode}')

    cmd = f'mount.cifs -o {mode},username={smb_user},password={smb_pass} {orig_name} /opt/opengnsys/images'
    subprocess.run(shlex.split(cmd))

    return err


def restoreImageCustom(repo_ip, image_name, disk, partition, method):
    """
    """
    if not shutil.which('restoreImageCustom'):
        raise OgError('restoreImageCustom not found')

    cmd = f'restoreImageCustom {repo_ip} {image_name} {disk} {partition} {method}'
    with open('/tmp/command.log', 'wb', 0) as logfile:
        try:
            proc = subprocess.run(cmd,
                                  stdout=logfile,
                                  encoding='utf-8',
                                  shell=True,
                                  check=True)
        except OSError as e:
            raise OgError(f'Error processing restoreImageCustom: {e}') from e
    return proc.returncode