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

import time

    11

    12

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

    13

    14

# default snapshot size

    15

LVM_SNAPSHOT_SIZE   = '5G'

    16

    17

# number of seconds to wait for lvm snapshot to settle after unmount..

    18

LVM_SNAPSHOT_WAIT   = 5

    19

    20

# number of times to retry removal, due to lvm/udev bug..

    21

LVM_SNAPSHOT_RETRY  = 5

    22

    23

class LVMError (Exception) :

    24

    pass

    25

    26

class LVM (object) :

    27

    """

    28

        LVM VolumeGroup

    29

    """

    30

    31

    # path to lvm2 binary

    32

    LVM = '/sbin/lvm'

    33

    34

    35

    # VG name

    36

    name = None

    37

    38

    def __init__ (self, name, sudo=None) :

    39

        """

    40

            name    - VG name

    41

            sudo    - invoke sudo

    42

        """

    43

    44

        self.name = name

    45

        self.sudo = sudo

    46

    47

    def lv_name (self, lv) :

    48

        """

    49

            vg/lv name.

    50

        """

    51

    52

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

    53

    54

    def lv_path (self, lv) :

    55

        """

    56

            /dev/vg/lv path.

    57

        """

    58

    59

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

    60

    61

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

    62

        """

    63

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

    64

        """

    65

    66

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

    67

    68

        # invoke

    69

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

    70

    71

    def volume (self, name) :

    72

        """

    73

            Return an LVMVolume for given named LV.

    74

        """

    75

    76

        return LVMVolume(self, name)

    77

    78

    @contextlib.contextmanager

    79

    def snapshot (self, base, wait=LVM_SNAPSHOT_WAIT, retry=LVM_SNAPSHOT_RETRY, **opts) :

    80

        """

    81

            A Context Manager for handling an LVMSnapshot.

    82

    83

            See LVMSnapshot.create()

    84

    85

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

    86

    87

                wait        - wait given interval for the snapshot device to settle before unmounting it

    88

                retry       - retry removal given number of times

    89

                **opts      - LVMSnapshot.create() options (e.g. size)

    90

        """

    91

    92

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

    93

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

    94

    95

        try :

    96

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

    97

            yield snapshot

    98

    99

        finally:

   100

            # XXX: there's some common udev bug with removing lvm snapshots

   101

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

   102

            #       http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=618016

   103

            #       possibly fixed in lvm2 2.02.86?

   104

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

   105

            while True :

   106

                # wait..

   107

                if wait :

   108

                    log.debug("%s: cleanup: waiting %.2f seconds for snapshot volume to settle...", snapshot, wait)

   109

                    time.sleep(wait)

   110

   111

                # lvremove

   112

                try :

   113

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

   114

                    snapshot.close()

   115

   116

                except InvokeError as ex :

   117

                    if ex.exit != 5 :

   118

                        # lvremove sez "Can't remove open logical volume ..." -> exit(5);

   119

                        raise

   120

   121

                    # retry counter?

   122

                    if retry :

   123

                        log.warn("%s: cleanup: lvremove failed, retrying...", snapshot)

   124

                        retry -= 1

   125

   126

                        # retry

   127

                        continue

   128

   129

                    else :

   130

                        # failed

   131

                        log.error("%s: cleanup: lvremove failed, aborting...", snapshot)

   132

                        raise

   133

   134

                else :

   135

                    # done

   136

                    break

   137

   138

    def __str__ (self) :

   139

        return self.name

   140

   141

    def __repr__ (self) :

   142

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

   143

   144

class LVMVolume (object) :

   145

    """

   146

        LVM Logical Volume.

   147

    """

   148

   149

    # VG

   150

    lvm = None

   151

   152

    # name

   153

    name = None

   154

   155

    def __init__ (self, lvm, name) :

   156

        self.lvm = lvm

   157

        self.name = name

   158

   159

    @property

   160

    def lvm_path (self) :

   161

        return self.lvm.lv_name(self.name)

   162

   163

    @property

   164

    def dev_path (self) :

   165

        return self.lvm.lv_path(self.name)

   166

   167

    def verify_exists (self) :

   168

        """

   169

            Verify that the LV exists.

   170

   171

            Raises an LVMError otherwise.

   172

        """

   173

   174

        # lvdisplay

   175

        try :

   176

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

   177

   178

        except InvokeError :

   179

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

   180

   181

        # dev

   182

        if not self.test_dev() :

   183

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

   184

   185

    def verify_missing (self) :

   186

        """

   187

            Verify that the LV does NOT exist.

   188

   189

            Raises an LVMError otherwise.

   190

        """

   191

   192

        if self.test_dev() :

   193

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

   194

   195

    def test_dev (self) :

   196

        """

   197

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

   198

        """

   199

   200

        return os.path.exists(self.dev_path)

   201

   202

    def __str__ (self) :

   203

        return self.lvm_path

   204

   205

    def __repr__ (self) :

   206

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

   207

                lvm     = repr(self.lvm),

   208

                name    = repr(self.name),

   209

        )

   210

   211

class LVMSnapshot (LVMVolume) :

   212

    """

   213

        LVM snapshot

   214

    """

   215

   216

    # base lv

   217

    base = None

   218

   219

    @classmethod

   220

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

   221

        """

   222

            Create a new LVM snapshot of the given LV.

   223

   224

            Returns a (snapshot_name, dev_path) tuple.

   225

        """

   226

   227

        # snapshot name

   228

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

   229

   230

        # snapshot instance

   231

        snapshot = cls(lvm, base, name, size=size)

   232

   233

        ## verify

   234

        # base should exist

   235

        base.verify_exists()

   236

   237

        # snapshot should not

   238

        snapshot.verify_missing()

   239

   240

        ## create

   241

        snapshot.open()

   242

   243

        # verify

   244

        if not snapshot.test_dev() :

   245

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

   246

   247

        # yay

   248

        return snapshot

   249

   250

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

   251

        LVMVolume.__init__(self, lvm, name)

   252

   253

        self.base = base

   254

        self.size = size

   255

   256

    def open (self) :

   257

        """

   258

            Create snapshot volume.

   259

        """

   260

   261

        # create

   262

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

   263

   264

    def close (self) :

   265

        """

   266

            Remove snapshot volume.

   267

        """

   268

   269

        # don't typo me!

   270

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

   271

   272

    def __repr__ (self) :

   273

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

   274

                lvm     = str(self.lvm),

   275

                base    = str(self.base),

   276

                name    = repr(self.name),

   277

        )

   278

   279