1

#!/usr/bin/python

     2

     3

import subprocess

     4

import os, os.path

     5

     6

import contextlib

     7

import logging

     8

     9

logging.basicConfig(

    10

    format  = '%(processName)s: %(name)s: %(levelname)s %(funcName)s : %(message)s',

    11

    level   = logging.DEBUG,

    12

)

    13

log = logging.getLogger()

    14

    15

LVM                 = '/sbin/lvm'

    16

LVM_VG              = 'asdf'

    17

LVM_SNAPSHOT_SIZE   = '5G'

    18

    19

def lvm_name (vg, lv) :

    20

    """

    21

        LVM vg/lv name.

    22

    """

    23

    24

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

    25

    26

def lvm_path (vg, lv) :

    27

    """

    28

        Map LVM VG+LV to /dev path.

    29

    """

    30

    31

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

    32

    33

def lvm_invoke (cmd, args) :

    34

    """

    35

        Invoke LVM command directly.

    36

    37

        Doesn't give any data on stdin, and keeps process stderr.

    38

        Returns stdout.

    39

    """

    40

    41

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

    42

    43

    p = subprocess.Popen([LVM, cmd] + args, stdin=subprocess.PIPE, stdout=subprocess.PIPE)

    44

    45

    # get output

    46

    stdout, stderr = p.communicate(input=None)

    47

    48

    if p.returncode :

    49

        raise Exception("LVM ({cmd}) failed: {returncode}".format(cmd=cmd, returncode=p.returncode))

    50

    51

    return stdout

    52

    53

def lvm (cmd, *args, **opts) :

    54

    """

    55

        Invoke simple LVM command with options/arguments, and no output.

    56

    """

    57

    58

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

    59

    60

    # process

    61

    opts = [('--{opt}'.format(opt=opt), value if value != True else None) for opt, value in opts.iteritems() if value]

    62

    63

    # flatten

    64

    opts = [str(opt_part) for opt_parts in opts for opt_part in opt_parts if opt_part]

    65

    66

    args = [str(arg) for arg in args if arg]

    67

    68

    # invoke

    69

    lvm_invoke(cmd, opts + args)

    70

    71

def lvm_snapshot_create (vg, lv, size=LVM_SNAPSHOT_SIZE) :

    72

    """

    73

        Create a new LVM snapshot of the given LV.

    74

    75

        Returns a (snapshot_name, dev_path) tuple.

    76

    """

    77

    78

    # path to device

    79

    lv_name = lvm_name(vg, lv)

    80

    lv_path = lvm_path(vg, lv)

    81

    82

    # snapshot name

    83

    snap_lv = '{lv}-backup'.format(lv=lv)

    84

    snap_name = lvm_name(vg, snap_lv)

    85

    snap_path = lvm_path(vg, snap_lv)

    86

    87

    # verify LV exists

    88

    lvm('lvs', lv_name)

    89

    90

    if not os.path.exists(lv_path) :

    91

        raise Exception("lvm_snapshot: source LV does not exist: {path}".format(path=lv_path))

    92

    93

    if os.path.exists(snap_path) :

    94

        raise Exception("lvm_snapshot: target LV snapshot already exists: {path}".format(path=snap_path))

    95

    96

    # create

    97

    lvm('lvcreate', lv_name, snapshot=True, name=snap_lv, size=size)

    98

    99

    # verify

   100

    if not os.path.exists(snap_path) :

   101

        raise Exception("lvm_snapshot: target LV snapshot did not appear: {path}".format(path=snap_path))

   102

   103

    # yay

   104

    return snap_name, snap_path

   105

   106

def lvm_snapshot_remove (name) :

   107

    """

   108

        Remove given snapshot volume.

   109

    """

   110

   111

    # XXX: can't deactivate snapshot volume

   112

    #lvm('lvchange', name, available='n')

   113

   114

    # XXX: risky!

   115

    lvm('lvremove', '-f', name)

   116

   117

@contextlib.contextmanager

   118

def lvm_snapshot (*args, **kwargs) :

   119

    """

   120

        A Context Manager for handling an LVM snapshot.

   121

   122

        with lvm_snapshot(vg, lv) as (snapshot_name, snapshot_path) : ...

   123

    """

   124

   125

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

   126

    name, path = lvm_snapshot_create(*args, **kwargs)

   127

   128

    log.debug("got name={0}, path={1}".format(name, path))

   129

    yield name, path

   130

   131

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

   132

    lvm_snapshot_remove(name)

   133

   134

def main (argv) :

   135

    # XXX: get LV from rsync command

   136

    lvm_vg='asdf'

   137

    backup_lv='test'

   138

   139

    # snapshot

   140

    log.info("Open snapshot...")

   141

   142

    with lvm_snapshot(lvm_vg, backup_lv) as (snapshot_name, snapshot_path):

   143

        log.info("Snapshot opened: {name}".format(name=snapshot_name))

   144

   145

        # ...

   146

   147

   148

        log.info("Done, cleaning up")

   149

   150

    return 1

   151

   152

if __name__ == '__main__' :

   153

    import sys

   154

   155

    sys.exit(main(sys.argv))

   156