| #!/usr/bin/env python |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| |
| ''' |
| gpsnap -- snapshot a gpdb array |
| |
| Usage: gpsnap [-Vvlfz?] [-u user] {-crdiI} snapshot_name |
| |
| -c: create a snapshot |
| -r: restore a snapshot |
| -d: delete a snapshot |
| -i: show information on snapshot |
| -I: show detailed info on snapshot |
| |
| -z: use zfs snapshot mechanism |
| -l: list snapshots |
| -v: verbose |
| -V: very verbose |
| -f: force |
| -?: print help |
| |
| ''' |
| |
| import os, sys |
| progname = os.path.split(sys.argv[0])[-1] |
| if sys.version_info < (2,5,0): |
| sys.exit( |
| '''Error %s is supported on Python version 2.5 or greater |
| Please upgrade python installed on this machine.''' % progname) |
| |
| import subprocess, time, datetime, threading, Queue, random, pickle |
| |
| |
| ############ |
| MASTER_DATA_DIRECTORY = os.getenv('MASTER_DATA_DIRECTORY') |
| if not MASTER_DATA_DIRECTORY: |
| sys.exit('MASTER_DATA_DIRECTORY env not defined') |
| |
| |
| |
| # we always connect to localhost for snapshot ... must run on master machine |
| os.putenv('PGHOST', '') |
| os.putenv("PGOPTIONS", '-c gp_session_role=utility') |
| os.putenv('PGDATABASE', 'template1') |
| |
| class __globals__: |
| opt = {} |
| for o in 'vVcrdiIflzu': opt['-' + o] = False |
| opt['-u'] = '' |
| snapname = '' |
| |
| |
| GV = __globals__() |
| |
| ############ |
| def usage(exitarg): |
| print __doc__ |
| sys.exit(exitarg) |
| |
| ############ |
| def humantime(td): |
| d = td.days > 0 and td.days or 0 |
| h = int(td.seconds / 60 / 60) |
| m = int(td.seconds / 60) % 60 |
| s = td.seconds % 60 |
| ret = '' |
| if d: ret = ret + '%dD ' % d |
| if h: ret = ret + '%dh ' % h |
| ret = ret + ('%dm %ds' % (m, s)) |
| return ret |
| |
| ############ |
| def tstamp(): |
| return datetime.datetime.now().strftime('[%Y-%m-%d %H:%M:%S]') |
| |
| |
| ############ |
| def msg(s): |
| print '%s %s' % (tstamp(), s) |
| |
| def vmsg(s): |
| if GV.opt['-v']: msg(s) |
| |
| def vvmsg(s): |
| if GV.opt['-V']: msg(s) |
| |
| ############ |
| def die(s): |
| sys.exit('%s ERROR: %s' % (tstamp(), s)) |
| |
| ############ |
| def strip_trailing_slash(dir): |
| return dir.rstrip('/') if dir else None |
| |
| ############ |
| def ssh(hostname, cmd, input=''): |
| proxy = ['ssh', '-o', 'BatchMode yes', '-o', 'StrictHostKeyChecking no', hostname, |
| '''bash -c 'exec python -c "import os,sys,pickle,subprocess; (prog, cmd, input) = pickle.load(sys.stdin); exec prog" ' '''] |
| prog = """ |
| p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) |
| p.stdin.write(input) |
| p.stdin.close() |
| sys.stdout.write(p.stdout.read()) |
| sys.exit(p.wait())""" |
| vvmsg(' - ssh ' + hostname + ' ' + str(cmd)) |
| p = subprocess.Popen(proxy, stdin=subprocess.PIPE, stdout=subprocess.PIPE) |
| if type(cmd) == type(''): |
| cmd = ['bash', '-c', cmd] |
| pickle.dump( (prog, cmd, input), p.stdin ) |
| p.stdin.close() |
| out = p.stdout.read() |
| rc = p.wait() |
| return (rc, out) |
| |
| |
| |
| ############ |
| def confirm(s): |
| if not GV.opt['-f'] and sys.stdin.isatty(): |
| ok = raw_input('%s\n ... proceed (y/n)? ' % s) |
| print |
| ok = ok.strip().lower() |
| return ok and ok[0] == 'y' |
| return True |
| |
| ############ |
| def parseCommandLine(): |
| import getopt |
| try: |
| (options, args) = getopt.getopt(sys.argv[1:], '?VvlcrdiIfzu:') |
| except Exception, e: |
| usage('Error: ' + str(e)) |
| |
| for (switch, val) in options: |
| if switch == '-?': usage(0) |
| elif switch[1] in 'VvlcrdiIfz': GV.opt[switch] = True |
| elif switch == '-u': GV.opt[switch] = val |
| |
| if GV.opt['-V']: GV.opt['-v'] = True |
| |
| if 1 == reduce(lambda x,y: x+y, [GV.opt['-'+s] and 1 or 0 for s in "crdiI"]): |
| pass |
| else: |
| if not GV.opt['-l']: |
| usage('Error: please specify one of -c / -r / -d / -i / -I') |
| |
| if 1 == len(args): |
| GV.snapname = args[0] |
| import re |
| if not re.match('\A[a-zA-Z0-9][a-zA-Z0-9\-\_\:]*\Z', GV.snapname): |
| usage("\n".join(["Error: invalid snapshot name", |
| "Hint: valid name like 'thursday_2009-03_19:00'"])) |
| else: |
| if not GV.opt['-l']: |
| usage('Error: missing snapshot_name') |
| |
| |
| |
| ############ |
| def run(cmd): |
| vvmsg(cmd) |
| p = os.popen(cmd) |
| out = p.readlines() |
| if GV.opt['-V']: |
| for line in out: vvmsg(line[:-1]) |
| rc = p.close() |
| return (rc, out) |
| |
| def runas(cmd): |
| if GV.opt['-u']: |
| x = ['su', '-', GV.opt['-u'], '-c', 'bash'] |
| vvmsg(" ".join(x)) |
| p = subprocess.Popen(x, |
| stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE) |
| path = os.getenv('PATH') |
| ld_library_path = os.getenv('LD_LIBRARY_PATH') |
| dyld_library_path = os.getenv('DYLD_LIBRARY_PATH') |
| cmd1 = ('export PATH="%s"\n' % path + |
| 'export LD_LIBRARY_PATH="%s"\n' % ld_library_path + |
| 'export DYLD_LIBRARY_PATH="%s"\n' % dyld_library_path) |
| p.stdin.write(cmd1) |
| p.stdin.write(cmd) |
| p.stdin.close() |
| out = p.stdout.readlines() |
| if GV.opt['-V']: |
| for line in out: vvmsg(line[:-1]) |
| return (p.wait(), out) |
| else: |
| return run(cmd) |
| |
| |
| |
| def getZfsMountpoint(hostname, datapath): |
| |
| cmd = "echo hostname $(hostname); zfs list -t filesystem " + datapath |
| (rc, out) = ssh(hostname, cmd) |
| if rc: |
| return (None, None) |
| |
| (hname, mpoint) = (None, None) |
| for line in out.split('\n'): |
| t = map(lambda x: x.strip(), line.split()) |
| if not t: continue |
| if t[0] == 'hostname': hname = t[1]; continue |
| if len(t) != 5: break |
| if datapath.find(t[4]) == 0: mpoint = t[0]; continue |
| |
| return (hname, mpoint) |
| |
| |
| class Segment: |
| def __init__(self, line): |
| row = [x.strip() for x in line.split('|')] |
| (self.content, self.definedprimary, self.dbid, |
| self.isprimary, self.valid, self.hostname, |
| self.port, self.datapath) = row |
| (self.toppath, self.dbdir) = os.path.split(strip_trailing_slash(self.datapath)) |
| def __str__(self): |
| return "|".join([self.content, self.definedprimary, self.dbid, |
| self.isprimary, self.valid, self.hostname, |
| self.port, self.datapath]) |
| |
| |
| class SnapshotMethod: |
| def __init__(self, type, name, seg): |
| (self.type, self.name, self.seg) = (type, name, seg) |
| self.fullname = '' |
| |
| def set_fullname(self,fn): self.fullname = fn |
| def createSnapshot(self): return -1 |
| def deleteSnapshot(self): return -1 |
| def checkSnapshot(self): return (-1, None) |
| def restoreSnapshot(self): return -1 |
| |
| def type(self): return self.type |
| |
| class TgzSnapshot(SnapshotMethod): |
| |
| def __init__(self, name, seg): |
| SnapshotMethod.__init__(self, 'tgz', name, seg) |
| self.prefix = '%s@%s' % (seg.dbdir, self.name) |
| self.tgzname = self.prefix + '.tgz' |
| self.tgzpath = os.path.join(self.seg.toppath, self.tgzname) |
| self.set_fullname( (self.seg.hostname, self.tgzpath) ) |
| |
| def createSnapshot(self): |
| msg('Creating snapshot %s:%s' % self.fullname) |
| cmd = ('cd %s && ' % self.seg.toppath) |
| cmd = cmd + ('rm -f %s && ' % self.tgzname) |
| cmd = cmd + ('({ which gtar > /dev/null && TAR=gtar || TAR=tar; } ; $TAR cfz %s %s)' |
| % (self.tgzname, self.seg.dbdir)) |
| (rc, out) = ssh(self.seg.hostname, cmd) |
| if rc: |
| # some errors occurred ... clean up |
| self.deleteSnapshot() |
| else: |
| msg(' ... created %s:%s' % self.fullname) |
| return rc |
| |
| |
| def deleteSnapshot(self): |
| msg('Deleting snapshot %s:%s' % self.fullname) |
| cmd = 'rm -f %s' % (self.tgzpath) |
| (rc, out) = ssh(self.seg.hostname, cmd) |
| return rc |
| |
| |
| def checkSnapshot(self): |
| msg('Checking snapshot %s:%s' % self.fullname) |
| cmd = ('({ which gtar > /dev/null && TAR=gtar || TAR=tar; } ; $TAR tfz %s > /dev/null && ls -l %s) 2>&1' |
| % (self.tgzpath, self.tgzpath)) |
| (rc, out) = ssh(self.seg.hostname, cmd) |
| lines = out.split('\n') |
| return (rc, lines) |
| |
| def restoreSnapshot(self): |
| msg('Restoring snapshot %s:%s' % self.fullname) |
| cmd = ('rm -rf %s; cd %s && ({ which gtar > /dev/null && TAR=gtar || TAR=tar; } ; $TAR xfz %s) 2> /dev/null' |
| % (self.seg.datapath, self.seg.toppath, self.tgzname)) |
| (rc, out) = ssh(self.seg.hostname, cmd) |
| return rc |
| |
| |
| class ZfsSnapshot(SnapshotMethod): |
| '''Redefine the operations on segments using ZFS snapshots.''' |
| |
| def __init__(self, name, seg): |
| SnapshotMethod.__init__(self, 'zfs', name, seg) |
| (hname, mpoint) = getZfsMountpoint(self.seg.hostname, self.seg.datapath) |
| if not hname or not mpoint: |
| msg('Error: unable to find zfs mountpoint for %s:%s' |
| % (self.seg.hostname, self.seg.datapath)) |
| return None |
| |
| # note: hname is slightly different from self.seg.hostname(). |
| # hname is what the shell 'hostname' command returned. |
| self.set_fullname( (hname, mpoint + '@' + self.name) ) |
| |
| |
| def createSnapshot(self): |
| (hname, sname) = self.fullname |
| cmd = 'zfs snapshot ' + sname |
| (rc, out) = ssh(hname, cmd) |
| if not rc: |
| msg('Created snapshot %s:%s' % self.fullname) |
| return rc |
| |
| def deleteSnapshot(self): |
| (hname, sname) = self.fullname |
| msg('Deleting snapshot of %s:%s' % self.fullname) |
| cmd = 'zfs destroy %s' % (sname) |
| (rc, out) = ssh(hname, cmd) |
| return rc |
| |
| |
| def checkSnapshot(self): |
| (hname, sname) = self.fullname |
| msg('Checking snapshot of %s:%s' % self.fullname) |
| cmd = 'zfs list -t snapshot %s 2>&1' % sname |
| (rc, out) = ssh(hname, cmd) |
| return (rc, out.split('\n')) |
| |
| def restoreSnapshot(self): |
| (hname, sname) = self.fullname |
| msg('Restoring snapshot of %s:%s' % self.fullname) |
| cmd = 'zfs rollback ' + sname |
| (rc, out) = ssh(hname, cmd) |
| return rc |
| |
| |
| |
| ############ |
| def pmap(func, jlist, numThreads = 16): |
| if (numThreads > len(jlist)): |
| numThreads = len(jlist) |
| |
| inq = Queue.Queue(len(jlist)) |
| for i in jlist: inq.put(i) |
| |
| outq = Queue.Queue(len(jlist)) |
| def work(): |
| try: |
| while True: |
| outq.put((None, func(inq.get_nowait()))) |
| except Queue.Empty: pass |
| except: |
| outq.put( (sys.exc_info(), None) ) |
| # drain |
| try: |
| while True: inq.get_nowait() |
| except Queue.Empty: pass |
| |
| thread = [threading.Thread(target=work) for i in xrange(numThreads)] |
| for t in thread: t.start() |
| for t in thread: t.join() |
| |
| ret = [] |
| try: |
| while True: |
| (ex, result) = outq.get_nowait() |
| if ex: |
| raise ex[0], ex[1], ex[2] |
| ret.append(result) |
| except Queue.Empty: pass |
| return ret |
| |
| |
| def test_pmap(): |
| import random, time |
| def p(x): time.sleep(random.random()); print x; return x |
| jlist = [x for x in "abcdefghijklmnopqrstuvwxyz"] |
| return pmap(p, jlist) |
| |
| def ctlpath(dbdir, name): |
| home = "~%s" % GV.opt['-u'] |
| dir = ".gpsnap" |
| fname = "%s@%s.sn2" % (dbdir, name) |
| return (home, dir, fname) |
| |
| |
| ############ |
| class ControlInfo: |
| def __init__(self, name, snapshots, type, etime): |
| (self.name, self.snapshots, self.etime) = (name, snapshots, etime) |
| self.etime = self.etime.replace(microsecond=0) |
| self.type = type; |
| |
| def delete(self, master): |
| fpath = ctlpath(master.dbdir, self.name) |
| fpath = os.path.join(fpath[0], fpath[1], fpath[2]) |
| cmd = 'rm -f %s' % fpath |
| (rc, out) = ssh(master.hostname, cmd) |
| return rc |
| |
| def write(self, master): |
| (home, dir, fname) = ctlpath(master.dbdir, self.name) |
| cmd = ('cd %s && mkdir -p %s && cd %s && cat > %s' |
| % (home, dir, dir, fname)) |
| line = [] |
| line.append('name: ' + self.name) |
| line.append('type: ' + self.type) |
| line.append('etime: ' + str(self.etime)) |
| for i in xrange(len(self.snapshots)): |
| line.append('segment' + str(i) + ': ' + str(self.snapshots[i].seg)) |
| line.append('') |
| |
| (rc, out) = ssh(master.hostname, cmd, '\n'.join(line)) |
| if not rc: |
| msg('Control file at %s:%s/%s/%s' % (master.hostname, home, dir, fname)) |
| return rc |
| |
| @staticmethod |
| def parse(f): |
| dict = {} |
| for line in f: |
| line = line.strip() |
| if len(line) > 0 and line[0] == '#': continue |
| line = line.split(':', 1) |
| if len(line) != 2: continue |
| dict[line[0].strip()] = line[1].strip() |
| if not dict.get('name'): return None |
| if not dict.get('type'): return None |
| if not dict.get('etime'): return None |
| if not dict.get('segment0'): return None |
| segments = [] |
| i = 0 |
| while True: |
| n = dict.get('segment' + str(i)) |
| if not n: break |
| segments.append(Segment(n)) |
| i = i + 1 |
| |
| etime = datetime.datetime.strptime(dict['etime'], '%Y-%m-%d %H:%M:%S') |
| snapshots = mkSnapshots(segments, dict['name'], dict['type']) |
| return ControlInfo(dict['name'], snapshots, |
| dict['type'], etime) |
| |
| @staticmethod |
| def read(name): |
| (toppath, dbdir) = os.path.split(MASTER_DATA_DIRECTORY) |
| (home, dir, fname) = ctlpath(dbdir, name) |
| cmd = ('cd %s && test -d %s && cd %s && test -e %s && cat %s' |
| % (home, dir, dir, fname, fname)) |
| (rc, out) = ssh('localhost', cmd) |
| ctl = ControlInfo.parse(out.split('\n')) |
| return ctl |
| |
| |
| @staticmethod |
| def list(): |
| (toppath, dbdir) = os.path.split(MASTER_DATA_DIRECTORY) |
| fpath = ctlpath(dbdir, '') |
| fpath = os.path.join(fpath[0], fpath[1], '*@*.sn2') |
| p = os.popen('''bash -c 'ls -1 %s 2> /dev/null' ''' % fpath) |
| out = p.readlines() |
| p.close() |
| |
| ret = [] |
| for fpath in out: |
| fpath = fpath.strip() |
| f = None |
| try: |
| f = open(fpath); |
| x = ControlInfo.parse(f) |
| if x: ret.append(x) |
| except IOError: pass |
| finally: f and f.close() |
| |
| return ret |
| |
| |
| |
| def mkSnapshots(segments, name, type): |
| segments = segments[:] |
| random.shuffle(segments) |
| if type == 'zfs': |
| snapshots = pmap(lambda s: ZfsSnapshot(name, s), segments) |
| else: |
| snapshots = map(lambda s: TgzSnapshot(name, s), segments) |
| |
| htab = {} |
| for (fn, s) in map(lambda s: (s.fullname, s), snapshots): |
| htab[fn] = s |
| |
| return map(lambda k: htab[k], htab.keys()) |
| |
| |
| ############ |
| def pstop(segments): |
| def action(hostname): |
| cmd = "ps -ef | grep postgres | grep -v grep | awk '{print $2}' | xargs pstop" |
| (rc, out) = ssh(hostname, cmd) |
| return rc |
| |
| masters = filter(lambda s: s.content == '-1', segments) |
| segments = filter(lambda s: s.content != '-1', segments) |
| vmsg('Suspending Masters') |
| pmap(lambda s: action(s.hostname), masters) |
| vmsg('Suspending Segments') |
| pmap(lambda s: action(s.hostname), segments) |
| msg('GPDB suspended.') |
| |
| ############ |
| def prun(segments): |
| def action(hostname): |
| cmd = "ps -ef | grep postgres | grep -v grep | awk '{print $2}' | xargs prun" |
| (rc, out) = ssh(hostname, cmd) |
| return rc |
| |
| masters = filter(lambda s: s.content == '-1', segments) |
| segments = filter(lambda s: s.content != '-1', segments) |
| vmsg('Resuming Segments') |
| pmap(lambda s: action(s.hostname), segments) |
| vmsg('Resuming Masters') |
| pmap(lambda s: action(s.hostname), masters) |
| msg('GPDB resumed.') |
| |
| |
| ############ |
| def createSnapshot(name): |
| ctlInfo = ControlInfo.read(name) |
| if ctlInfo: |
| die("Snapshot '%s' exists." % name) |
| |
| # need gp_configuration |
| print 'Create a %s snapshot.' % (GV.opt['-z'] and 'zfs' or 'tgz') |
| print 'Retrieving gp_configuration ... ' |
| stime = datetime.datetime.now() |
| CMD = ("python %s -f -d %s %s" |
| % (os.path.join(sys.path[0], 'gpgetconfig.py'), |
| MASTER_DATA_DIRECTORY, |
| GV.opt['-u'] and '-u ' + GV.opt['-u'] or '')) |
| (rc, out) = runas(CMD) |
| if rc: |
| die("Unable to retrieve gp_configuration") |
| |
| vvmsg(out) |
| out = filter(lambda x: x.find('[gpgetconfig]') == 0, out) |
| segments = [Segment(line.split(']', 1)[1]) for line in out] |
| |
| # shut it down |
| suspend = GV.opt['-z'] |
| if suspend: |
| if not confirm('This will suspend the database.'): |
| die('Aborted by user.') |
| vmsg('Suspending gpdb ...') |
| pstop(segments) |
| else: |
| if not confirm('This will shutdown the database'): |
| die('Aborted by user.') |
| vmsg("Stopping gpdb ...") |
| runas('gpstop -af') |
| |
| try: |
| # make the snapshots objects |
| snapshots = mkSnapshots(segments, name, GV.opt['-z'] and 'zfs' or 'tgz') |
| |
| # take the snapshots in parallel |
| erows = filter(lambda (s, rc): rc, |
| pmap(lambda s: (s, s.createSnapshot()), snapshots)) |
| # if error -> rollback |
| if erows: |
| emsg = (["Create failed:"] + |
| [" unable to create %s:%s" % s.fullname for (s, rc) in erows]) |
| # delete the snapshots |
| map(lambda s: (s, s.deleteSnapshot()), snapshots) |
| #pmap(lambda s: (s, s.deleteSnapshot()), snapshots) |
| die("\n".join(emsg)) |
| |
| # create control file |
| etime = datetime.datetime.now() |
| ctlInfo = ControlInfo(name, snapshots, GV.opt['-z'] and 'zfs' or 'tgz', etime) |
| |
| # write the control file to the masters |
| masters = filter(lambda s: s.content == '-1', segments) |
| erows = filter(lambda (m, rc): rc, |
| [(m, ctlInfo.write(m)) for m in masters]) |
| # if error -> rollback |
| if erows: |
| emsg = (["Create failed:"] + |
| [" cannot create control file %s:%s" |
| % (m.hostname, "/".join(ctlpath(m.dbdir, name))) for (m, rc) in erows]) |
| # delete the snapshots |
| pmap(lambda s: (s, s.deleteSnapshot()), snapshots) |
| pmap(lambda m: (m, ctlInfo.delete(m)), masters) |
| die("\n".join(emsg)) |
| |
| msg("Created. Elapsed %s." % humantime(etime - stime)) |
| finally: |
| if suspend: |
| prun(segments) |
| |
| ############ |
| def restoreSnapshot(name): |
| ctlInfo = ControlInfo.read(name) |
| if not ctlInfo: |
| die("Unable to find snapshot '%s'" % name) |
| |
| if not confirm("Restore snapshot '%s'.\nThis will shutdown the database." % name): |
| die("Aborted by user.") |
| |
| stime = datetime.datetime.now() |
| |
| # shut it down |
| runas('gpstop -af') |
| |
| snapshots = ctlInfo.snapshots[:] |
| random.shuffle(snapshots) |
| erows = filter(lambda (s,(rc,lines)): rc, |
| pmap(lambda s: (s, s.checkSnapshot()), snapshots)) |
| |
| if erows: |
| emsg = (["Snapshot failure"] + |
| [" Bad/missing snapshot of %s:%s" % s.fullname for (s, rc) in erows]) |
| die("\n".join(emsg)) |
| |
| if not confirm("\n".join(["\nContinue to *DELETE* database and restore snapshot.", |
| "THIS IS THE POINT OF NO RETURN."])): |
| die("Aborted by user.") |
| |
| erows = filter(lambda (s,rc): rc, |
| pmap(lambda s: (s, s.restoreSnapshot()), snapshots)) |
| if erows: |
| emsg = (["Restore failed:"] + |
| [" unable to restore %s:%s" % s.fullname for (s, rc) in erows]) |
| die("\n".join(emsg)) |
| |
| etime = datetime.datetime.now() |
| msg("Restored. Elapsed %s." % humantime(etime - stime)) |
| |
| |
| ############ |
| def infoSnapshot(name): |
| ctlInfo = ControlInfo.read(name) |
| if not ctlInfo: |
| die("Unable to find snapshot '%s'" % name) |
| msg('Snapshot name: ' + ctlInfo.name) |
| msg('Created : ' + str(ctlInfo.etime)) |
| msg('Atoms : %s:%s' % ctlInfo.snapshots[0].fullname) |
| for s in ctlInfo.snapshots[1:]: msg(" %s:%s" % s.fullname) |
| return ctlInfo |
| |
| ############ |
| def infoSnapshotDetailed(name): |
| ctlInfo = infoSnapshot(name) |
| msg('') |
| msg('Obtaining for detailed info ...') |
| snapshots = ctlInfo.snapshots[:] |
| random.shuffle(snapshots) |
| |
| erows = [] |
| for (s, (rc, lines)) in pmap(lambda s: (s, s.checkSnapshot()), snapshots): |
| if rc: erows.append( (s, (rc, lines))) |
| else: |
| for x in lines: msg(' [%s:%s info] ' % s.fullname + x.strip()) |
| |
| for (s, (rc, lines)) in erows: |
| for x in lines: msg(' [%s:%s error] ' % s.fullname + x.strip()) |
| |
| if erows: |
| die("Error(s) detected. Snapshot is not valid.") |
| |
| |
| ############ |
| def deleteSnapshot(name): |
| ctlInfo = ControlInfo.read(name) |
| if not ctlInfo: |
| msg("Snapshot '%s' does not exist" % name) |
| return # assume there isn't any snapshots available |
| |
| if not confirm("Delete snapshot '%s'" % name): |
| die("Aborted by user.") |
| |
| stime = datetime.datetime.now() |
| |
| snapshots = ctlInfo.snapshots[:] |
| random.shuffle(snapshots) |
| |
| erows = filter(lambda (s,rc): rc, |
| pmap(lambda s: (s, s.deleteSnapshot()), snapshots)) |
| if erows: |
| emsg = (["Delete failed:"] + |
| [" unable to delete %s:%s" % s.fullname for (s, rc) in erows]) |
| die("\n".join(emsg)) |
| |
| master_snapshots = filter(lambda s: s.seg.content == '-1', snapshots) |
| pmap(lambda m: (m.seg, ctlInfo.delete(m.seg)), master_snapshots) |
| etime = datetime.datetime.now() |
| msg("Deleted. Elapsed %s." % humantime(etime - stime)) |
| |
| |
| ############ |
| def listSnapshots(name): |
| ctlInfoList = ControlInfo.list() |
| if not ctlInfoList: |
| msg("No snapshot exists") |
| return |
| ctlInfoList.sort(lambda x,y: x.etime > y.etime) |
| for i in ctlInfoList: |
| if not name or name == i.name: |
| print '%s %s %s' % (i.type, str(i.etime), i.name) |
| |
| |
| ############ |
| def main(): |
| global MASTER_DATA_DIRECTORY |
| MASTER_DATA_DIRECTORY = strip_trailing_slash(MASTER_DATA_DIRECTORY) |
| parseCommandLine() |
| if GV.opt['-c']: createSnapshot(GV.snapname) |
| elif GV.opt['-r']: restoreSnapshot(GV.snapname) |
| elif GV.opt['-d']: deleteSnapshot(GV.snapname) |
| elif GV.opt['-i']: infoSnapshot(GV.snapname) |
| elif GV.opt['-I']: infoSnapshotDetailed(GV.snapname) |
| elif GV.opt['-l']: listSnapshots(GV.snapname) |
| else: |
| usage('Error: invalid flags and/or arguments') |
| |
| if __name__ == '__main__': |
| main() |
