1

"""

     2

    Simple /sbin/lvm wrapper for handling snapshots.

     3

"""

     4

     5

from pvl.backup.invoke import invoke, optargs, InvokeError

     6

     7

import contextlib

     8

import os.path

     9

import logging

    10

    11

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

    12

    13

class LVMError (Exception) :

    14

    pass

    15

    16

class LVM (object) :

    17

    """

    18

        LVM VolumeGroup

    19

    """

    20

    21

    # path to lvm2 binary

    22

    LVM = '/sbin/lvm'

    23

    24

    25

    # VG name

    26

    name = None

    27

    28

    def __init__ (self, name) :

    29

        self.name = name

    30

    31

    def lv_name (self, lv) :

    32

        """

    33

            vg/lv name.

    34

        """

    35

    36

        return '{vg}/{lv}'.format(vg=self.name, lv=lv)

    37

    38

    def lv_path (self, lv) :

    39

        """

    40

            /dev/vg/lv path.

    41

        """

    42

    43

        return '/dev/{vg}/{lv}'.format(vg=self.name, lv=lv)

    44

    45

    def command (self, cmd, *args, **opts) :

    46

        """

    47

            Invoke a command with options/arguments, given via Python arguments/keyword arguments

    48

        """

    49

    50

        log.debug("{cmd} {opts} {args}".format(cmd=cmd, args=args, opts=opts))

    51

    52

        # invoke

    53

        invoke(self.LVM, [cmd] + optargs(*args, **opts))

    54

    55

    def volume (self, name) :

    56

        """

    57

            Return an LVMVolume for given named LV.

    58

        """

    59

    60

        return LVMVolume(self, name)

    61

    62

    @contextlib.contextmanager

    63

    def snapshot (self, base, **kwargs) :

    64

        """

    65

            A Context Manager for handling an LVMSnapshot.

    66

    67

            See LVMSnapshot.create()

    68

    69

            with lvm.snapshot(lv) as snapshot : ...

    70

        """

    71

    72

        log.debug("creating snapshot from {base}: {opts}".format(base=base, opts=kwargs))

    73

        snapshot = LVMSnapshot.create(self, base, **kwargs)

    74

    75

        try :

    76

            log.debug("got: {0}".format(snapshot))

    77

            yield snapshot

    78

    79

        finally:

    80

            # XXX: there's some timing bug with an umount leaving the LV open, do we need to wait for it to get closed after mount?

    81

            #       https://bugzilla.redhat.com/show_bug.cgi?id=577798

    82

            #       some udev event bug, possibly fixed in lvm2 2.02.86?

    83

            # try to just patiently wait for it to settle down... if this isn't enough, we need some dmremove magic

    84

            log.debug("cleanup: waiting for snapshot volume to settle...")

    85

            import time

    86

            time.sleep(1)

    87

    88

            # cleanup

    89

            log.debug("cleanup: {0}".format(snapshot))

    90

            snapshot.close()

    91

    92

    def __str__ (self) :

    93

        return self.name

    94

    95

    def __repr__ (self) :

    96

        return "LVM(name={name})".format(name=repr(self.name))

    97

    98

class LVMVolume (object) :

    99

    """

   100

        LVM Logical Volume.

   101

    """

   102

   103

    # VG

   104

    lvm = None

   105

   106

    # name

   107

    name = None

   108

   109

    def __init__ (self, lvm, name) :

   110

        self.lvm = lvm

   111

        self.name = name

   112

   113

    @property

   114

    def lvm_path (self) :

   115

        return self.lvm.lv_name(self.name)

   116

   117

    @property

   118

    def dev_path (self) :

   119

        return self.lvm.lv_path(self.name)

   120

   121

    def verify_exists (self) :

   122

        """

   123

            Verify that the LV exists.

   124

   125

            Raises an LVMError otherwise.

   126

        """

   127

   128

        # lvdisplay

   129

        try :

   130

            self.lvm.command('lvs', self.lvm_path)

   131

   132

        except InvokeError :

   133

            raise LVMError("Unable to lvdisplay LV: {path}".format(path=self.lvm_path))

   134

   135

        # dev

   136

        if not self.test_dev() :

   137

            raise LVMError("LV dev does not exist: {path}".format(path=self.dev_path))

   138

   139

    def verify_missing (self) :

   140

        """

   141

            Verify that the LV does NOT exist.

   142

   143

            Raises an LVMError otherwise.

   144

        """

   145

   146

        if self.test_dev() :

   147

            raise Exception("LV already exists: {path}".format(path=self.dev_path))

   148

   149

    def test_dev (self) :

   150

        """

   151

            Tests for existance of device file, returning True/False.

   152

        """

   153

   154

        return os.path.exists(self.dev_path)

   155

   156

    def __str__ (self) :

   157

        return self.lvm_path

   158

   159

    def __repr__ (self) :

   160

        return "LVMVolume(lvm={lvm}, name={name})".format(

   161

                lvm     = repr(self.lvm),

   162

                name    = repr(self.name),

   163

        )

   164

   165

class LVMSnapshot (LVMVolume) :

   166

    """

   167

        LVM snapshot

   168

    """

   169

   170

    # default snapshot size

   171

    LVM_SNAPSHOT_SIZE   = '5G'

   172

   173

    # base lv

   174

    base = None

   175

   176

    @classmethod

   177

    def create (cls, lvm, base, tag, size=LVM_SNAPSHOT_SIZE) :

   178

        """

   179

            Create a new LVM snapshot of the given LV.

   180

   181

            Returns a (snapshot_name, dev_path) tuple.

   182

        """

   183

   184

        # snapshot name

   185

        name = '{name}-{tag}'.format(name=base.name, tag=tag)

   186

   187

        # snapshot instance

   188

        snapshot = cls(lvm, base, name)

   189

   190

        ## verify

   191

        # base should exist

   192

        base.verify_exists()

   193

   194

        # snapshot should not

   195

        snapshot.verify_missing()

   196

   197

        ## create

   198

        snapshot.open()

   199

   200

        # verify

   201

        if not snapshot.test_dev() :

   202

            raise LVMError("Failed to find new snapshot LV device: {path}".format(path=snapshot.dev_path))

   203

   204

        # yay

   205

        return snapshot

   206

   207

    def __init__ (self, lvm, base, name, size=LVM_SNAPSHOT_SIZE) :

   208

        LVMVolume.__init__(self, lvm, name)

   209

   210

        self.base = base

   211

        self.size = size

   212

   213

    def open (self) :

   214

        """

   215

            Create snapshot volume.

   216

        """

   217

   218

        # create

   219

        self.lvm.command('lvcreate', self.base.lvm_path, snapshot=True, name=self.name, size=self.size)

   220

   221

    def close (self) :

   222

        """

   223

            Remove snapshot volume.

   224

        """

   225

   226

        # XXX: can't deactivate snapshot volume

   227

        #self.lvm.command('lvchange', name, available='n')

   228

   229

        # XXX: risky!

   230

        self.lvm.command('lvremove', '-f', self.lvm_path)

   231

   232

    def __repr__ (self) :

   233

        return "LVMSnapshot(lvm={lvm}, base={base}, name={name})".format(

   234

                lvm     = str(self.lvm),

   235

                base    = str(self.base),

   236

                name    = repr(self.name),

   237

        )

   238

   239