ZFS est un système de fichier de nouvelle génération. Il regroupe en effet les fonctionnalités d’un système de fichier classique, mais aussi celles fournies par les gestionnaires de volumes (volume manager) tel que SVM et VxVM.

Un zpool est un ensemble (composé au moins d’un élémént) de périphérique de stockage, généralement un disque ou un slice. On peut également utiliser un fichier pour des fins de tests.

Voici un petit bout de code python qui vous fera des snapshots journaliers. Ça peut être utile pour faire des sauvegardes, en utilisant le plus petit espace disque possible!

#!/usr/bin/env python
 
import os, sys, datetime
import re
 
ZFS = "/usr/sbin/zfs"
 
class NotRootException(Exception):                   pass
class ZFS_Exception(Exception):                     pass
class ZFS_FatalException(ZFS_Exception):            pass
class ZFS_CommandExecutionFailed(ZFS_Exception):    pass
 
def log(mystr): print mystr
 
class ZFSBackup(object):
    def __init__(self, node):
        global log
        self.node           = node
        self.myday          = datetime.date.today().strftime("%A")
        self.log            = log
 
        self._checkregexp   = re.compile("^%s@%s" % (self.node, self.myday))
        self.check_uid()
 
    def check_uid(self):
        uid = os.geteuid()
        if uid != 0:
            raise NotRootException(uid)
 
    def getSnapName(self):
        return "%s@%s" % (self.node, self.myday)
 
    def do_destroy(self):
        global ZFS
 
        command = "%s destroy %s" % (ZFS, self.getSnapName())
        try:
            self.execute_command(command)
        except ZFS_CommandExecutionFailed, msg:
            log("Execution failed. Can't continue.")
            raise ZFS_FatalExeption("Unable to execute %s: %s" % (command, msg))
        else:
            log("Successfully destroyed snapshot: %s" % (self.getSnapName()))
 
    def do_snapshot(self):
        global ZFS
 
        if (self.is_existant()):
            self.log("Snapshot %s already exists." % (self.getSnapName()))
            self.do_destroy()
 
        command = "%s snapshot %s" % (ZFS, self.getSnapName())
        try:
            self.execute_command(command)
        except ZFS_CommandExecutionFailed, msg:
            log("Execution failed. Can't continue.")
            raise ZFS_FatalExeption("Unable to execute %s: %s" % (command, msg))
        else:
            log("Successfully made snapshot: %s" % (self.getSnapName()))
 
    def is_existant(self):
        global ZFS
        command = "%s list -H -t snapshot" % (ZFS)
 
        try:
            data = self.execute_command(command)
        except ZFS_CommandExecutionFailed, msg:
            log("Execution failed. Can't continue.")
            raise ZFS_FatalExeption("Unable to execute %s: %s" % (command, msg))
        
        return(self._checkregexp.match(data))
 
    def execute_command(self, command):
        log("Command to be executed: %s" % (command))
        (stdin, stdout, stderr) = os.popen3(command)
        stdin.close()
        stdout_data = stdout.read()
        stdout.close()
 
        stderr_data = stderr.read()
        stderr.close()
 
        if (stderr_data):
            log("stderr was not empty: `%s'" % (stderr_data))
            raise ZFS_CommandExecutionFailed(stderr_data)
 
        return stdout_data
 
 
if __name__ == "__main__":
    nodename = "zeid/backup"
 
    try:
        zfs = ZFSBackup(nodename)
    except NotRootException:
        print "You must run this script as root."
        sys.exit(1)
 
    zfs.do_snapshot()
    sys.exit(0)