1

"""

     2

    Mount filesystems.

     3

"""

     4

     6

     7

import contextlib

     8

import os, os.path

     9

import logging

    10

import tempfile

    11

    12

log = logging.getLogger('pvl.backup.mount')

    13

    14

    15

class MountError (Exception) :

    16

    pass

    17

    18

class Mount (object) :

    19

    """

    20

        Trivial filesystem mounting

    21

    """

    22

    23

    MOUNT   = '/bin/mount'

    24

    UMOUNT  = '/bin/umount'

    25

    26

    28

        """

    29

            dev         - device path

    30

            mnt         - mount path

    31

            readonly    - mount readonly

    33

        """

    34

    35

        self.dev = dev

    36

        self.mnt = mnt

    37

        self.readonly = readonly

    39

    40

    @property

    41

    def path (self) :

    42

        return self.mnt

    43

    44

    def options (self) :

    45

        """

    46

            Mount options as a comma-separated string.

    47

        """

    48

    49

        options = [

    50

                ('ro' if self.readonly else None),

    51

        ]

    52

    53

        return ','.join(option for option in options if option)

    54

    55

    def open (self) :

    56

        """

    57

            Mount

    58

        """

    59

    60

        # check

    61

        if not os.path.isdir(self.mnt) :

    62

            raise MountError("Mountpoint is not a directory: {mnt}".format(mnt=self.mnt))

    63

    64

        if os.path.ismount(self.mnt) :

    65

            raise MountError("Mountpoint is already mounted: {mnt}".format(mnt=self.mnt))

    66

    67

        if not os.path.exists(self.dev) :

    68

            raise MountError("Device does not exist: {dev}".format(dev=self.dev))

    69

    70

        # mount

    72

    73

    def close (self) :

    74

        """

    75

            Un-mount

    76

        """

    77

    78

        # check

    79

        if not os.path.ismount(self.mnt):

    80

            raise MountError("Mountpoint is not mounted: {mnt}".format(mnt=self.mnt))

    81

    82

        # umount

    84

    85

    def __repr__ (self) :

    86

        return "Mount(dev={dev}, mnt={mnt})".format(

    87

                dev     = repr(self.dev),

    88

                mnt     = repr(self.mnt),

    89

        )

    90

    91

    def __str__ (self) :

    92

        return self.mnt

    93

    94

@contextlib.contextmanager

    95

def mount (dev, mnt=None, name_hint='tmp', **kwargs) :

    96

    """

    97

        Use a temporary mount:

    98

    99

        with mount('/dev/...', readonly=True) as mount:

   100

            ...

   101

   102

        Mounts at the given mountpoint path, or a tempdir

   103

    """

   104

   105

    if mnt is None :

   106

        mnt = tmpdir = tempfile.mkdtemp(suffix='.mnt', prefix=name_hint)

   107

   108

        log.debug("using tmp mnt: %s", tmpdir)

   109

   110

    else :

   111

        tmpdir = None

   112

   113

    log.debug("mount: %s -> %s", dev, mnt)

   114

   115

    # with tempdir

   116

    try :

   117

        mount = Mount(dev, mnt, **kwargs)

   118

   119

        # open

   120

        log.debug("open: %s", mount)

   121

        mount.open()

   122

   123

        try :

   124

            log.debug("got: %s", mount)

   125

            yield mount

   126

   127

        finally:

   128

            # cleanup

   129

            log.debug("cleanup: %s", mount)

   130

            mount.close()

   131

   132

    finally:

   133

        if tmpdir :

   134

            # cleanup

   135

            log.debug("cleanup tmp mnt: %s", tmpdir)

   136

            os.rmdir(tmpdir)

   137