+#!/usr/bin/python2.6
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+import sys
+import os
+import subprocess
+import threading
+import util
+import smf
+from autosnapsmf import enable_default_schedules, disable_default_schedules
+
+from os.path import abspath, dirname, join, pardir
+sys.path.insert(0, join(dirname(__file__), pardir, "plugin"))
+import plugin
+sys.path.insert(0, join(dirname(__file__), pardir, "plugin", "rsync"))
+import rsyncsmf
+
+try:
+ import pygtk
+ pygtk.require("2.4")
+except:
+ pass
+try:
+ import gtk
+ import gtk.glade
+ gtk.gdk.threads_init()
+except:
+ sys.exit(1)
+
+import glib
+import gobject
+import gio
+import dbus
+import dbus.service
+import dbus.mainloop
+import dbus.mainloop.glib
+import dbussvc
+
+
+# This is the rough guess ratio used for rsync backup device size
+# vs. the total size of the pools it's expected to backup.
+RSYNCTARGETRATIO = 2
+
+# here we define the path constants so that other modules can use it.
+# this allows us to get access to the shared files without having to
+# know the actual location, we just use the location of the current
+# file and use paths relative to that.
+SHARED_FILES = os.path.abspath(os.path.join(os.path.dirname(__file__),
+ os.path.pardir,
+ os.path.pardir))
+LOCALE_PATH = os.path.join('/usr', 'share', 'locale')
+RESOURCE_PATH = os.path.join(SHARED_FILES, 'res')
+
+# the name of the gettext domain. because we have our translation files
+# not in a global folder this doesn't really matter, setting it to the
+# application name is a good idea tough.
+GETTEXT_DOMAIN = 'time-slider'
+
+# set up the glade gettext system and locales
+gtk.glade.bindtextdomain(GETTEXT_DOMAIN, LOCALE_PATH)
+gtk.glade.textdomain(GETTEXT_DOMAIN)
+
+import zfs
+from timeslidersmf import TimeSliderSMF
+from rbac import RBACprofile
+
+
+class FilesystemIntention:
+
+ def __init__(self, name, selected, inherited):
+ self.name = name
+ self.selected = selected
+ self.inherited = inherited
+
+ def __str__(self):
+ return_string = "Filesystem name: " + self.name + \
+ "\n\tSelected: " + str(self.selected) + \
+ "\n\tInherited: " + str(self.inherited)
+ return return_string
+
+ def __eq__(self, other):
+ if self.name != other.name:
+ return False
+ if self.inherited and other.inherited:
+ return True
+ elif not self.inherited and other.inherited:
+ return False
+ if (self.selected == other.selected) and \
+ (self.inherited == other.inherited):
+ return True
+ else:
+ return False
+
+class SetupManager:
+
+ def __init__(self, execpath):
+ self._execPath = execpath
+ self._datasets = zfs.Datasets()
+ self._xml = gtk.glade.XML("%s/../../glade/time-slider-setup.glade" \
+ % (os.path.dirname(__file__)))
+
+ # Tell dbus to use the gobject mainloop for async ops
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+ dbus.mainloop.glib.threads_init()
+
+ # Register a bus name with the system dbus daemon
+ systemBus = dbus.SystemBus()
+ busName = dbus.service.BusName("org.opensolaris.TimeSlider.config",
+ systemBus)
+ self._dbus = dbussvc.Config(systemBus,
+ '/org/opensolaris/TimeSlider/config')
+ # Used later to trigger a D-Bus notification of select configuration
+ # changes made
+ self._configNotify = False
+
+ # These variables record the initial UI state which are used
+ # later to compare against the UI state when the OK or Cancel
+ # button is clicked and apply the minimum set of necessary
+ # configuration changes. Prevents minor changes taking ages
+ # to be applied by the GUI.
+ self._initialEnabledState = None
+ self._initialRsyncState = None
+ self._initialRsyncTargetDir = None
+ self._initialCleanupLevel = None
+ self._initialCustomSelection = False
+ self._initialSnapStateDic = {}
+ self._initialRsyncStateDic = {}
+ self._initialFsIntentDic = {}
+ self._initialRsyncIntentDic = {}
+
+ # Currently selected rsync backup device via the GUI.
+ self._newRsyncTargetDir = None
+ # Used to store GUI filesystem selection state and the
+ # set of intended properties to apply to zfs filesystems.
+ self._snapStateDic = {}
+ self._rsyncStateDic = {}
+ self._fsIntentDic = {}
+ self._rsyncIntentDic = {}
+ # Dictionary that maps device ID numbers to zfs filesystem objects
+ self._fsDevices = {}
+
+ topLevel = self._xml.get_widget("toplevel")
+ self._pulseDialog = self._xml.get_widget("pulsedialog")
+ self._pulseDialog.set_transient_for(topLevel)
+
+ # gio.VolumeMonitor reference
+ self._vm = gio.volume_monitor_get()
+ self._vm.connect("mount-added", self._mount_added)
+ self._vm.connect("mount-removed" , self._mount_removed)
+
+ self._fsListStore = gtk.ListStore(bool,
+ bool,
+ str,
+ str,
+ gobject.TYPE_PYOBJECT)
+ filesystems = self._datasets.list_filesystems()
+ for fsname,fsmountpoint in filesystems:
+ if (fsmountpoint == "legacy"):
+ mountpoint = _("Legacy")
+ else:
+ mountpoint = fsmountpoint
+ fs = zfs.Filesystem(fsname, fsmountpoint)
+ # Note that we don't deal with legacy mountpoints.
+ if fsmountpoint != "legacy" and fs.is_mounted():
+ self._fsDevices[os.stat(fsmountpoint).st_dev] = fs
+ snap = fs.get_auto_snap()
+ rsyncstr = fs.get_user_property(rsyncsmf.RSYNCFSTAG)
+ if rsyncstr == "true":
+ rsync = True
+ else:
+ rsync = False
+ # Rsync is only performed on snapshotted filesystems.
+ # So treat as False if rsync is set to true independently
+ self._fsListStore.append([snap, snap & rsync,
+ mountpoint, fs.name, fs])
+ self._initialSnapStateDic[fs.name] = snap
+ self._initialRsyncStateDic[fs.name] = snap & rsync
+ del filesystems
+
+ for fsname in self._initialSnapStateDic:
+ self._refine_filesys_actions(fsname,
+ self._initialSnapStateDic,
+ self._initialFsIntentDic)
+ self._refine_filesys_actions(fsname,
+ self._initialRsyncStateDic,
+ self._initialRsyncIntentDic)
+
+ self._fsTreeView = self._xml.get_widget("fstreeview")
+ self._fsTreeView.set_sensitive(False)
+ self._fsTreeView.set_size_request(10, 200)
+
+ self._fsTreeView.set_model(self._fsListStore)
+
+ cell0 = gtk.CellRendererToggle()
+ cell1 = gtk.CellRendererToggle()
+ cell2 = gtk.CellRendererText()
+ cell3 = gtk.CellRendererText()
+
+ radioColumn = gtk.TreeViewColumn(_("Select"),
+ cell0, active=0)
+ self._fsTreeView.insert_column(radioColumn, 0)
+
+ self._rsyncRadioColumn = gtk.TreeViewColumn(_("Replicate"),
+ cell1, active=1)
+ nameColumn = gtk.TreeViewColumn(_("Mount Point"),
+ cell2, text=2)
+ self._fsTreeView.insert_column(nameColumn, 2)
+ mountPointColumn = gtk.TreeViewColumn(_("File System Name"),
+ cell3, text=3)
+ self._fsTreeView.insert_column(mountPointColumn, 3)
+ cell0.connect('toggled', self._row_toggled)
+ cell1.connect('toggled', self._rsync_cell_toggled)
+ advancedBox = self._xml.get_widget("advancedbox")
+ advancedBox.connect('unmap', self._advancedbox_unmap)
+
+ self._rsyncSMF = rsyncsmf.RsyncSMF("%s:rsync" \
+ %(plugin.PLUGINBASEFMRI))
+ state = self._rsyncSMF.get_service_state()
+ self._initialRsyncTargetDir = self._rsyncSMF.get_target_dir()
+ # Check for the default, unset value of "" from SMF.
+ if self._initialRsyncTargetDir == '""':
+ self._initialRsyncTargetDir = ''
+ self._newRsyncTargetDir = self._initialRsyncTargetDir
+ self._smfTargetKey = self._rsyncSMF.get_target_key()
+ self._newRsyncTargetSelected = False
+ sys,self._nodeName,rel,ver,arch = os.uname()
+
+ # Model columns:
+ # 0 Themed icon list (python list)
+ # 1 device root
+ # 2 volume name
+ # 3 Is gio.Mount device
+ # 4 Is separator (for comboBox separator rendering)
+ self._rsyncStore = gtk.ListStore(gobject.TYPE_PYOBJECT,
+ gobject.TYPE_STRING,
+ gobject.TYPE_STRING,
+ gobject.TYPE_BOOLEAN,
+ gobject.TYPE_BOOLEAN)
+ self._rsyncCombo = self._xml.get_widget("rsyncdevcombo")
+ mounts = self._vm.get_mounts()
+ for mount in mounts:
+ self._mount_added(self._vm, mount)
+ if len(mounts) > 0:
+ # Add a separator
+ self._rsyncStore.append((None, None, None, None, True))
+ del mounts
+
+ if len(self._newRsyncTargetDir) == 0:
+ self._rsyncStore.append((['folder'],
+ _("(None)"),
+ '',
+ False,
+ False))
+ # Add a separator
+ self._rsyncStore.append((None, None, None, None, True))
+ self._rsyncStore.append((None, _("Other..."), "Other", False, False))
+ self._iconCell = gtk.CellRendererPixbuf()
+ self._nameCell = gtk.CellRendererText()
+ self._rsyncCombo.clear()
+ self._rsyncCombo.pack_start(self._iconCell, False)
+ self._rsyncCombo.set_cell_data_func(self._iconCell,
+ self._icon_cell_render)
+ self._rsyncCombo.pack_end(self._nameCell)
+ self._rsyncCombo.set_attributes(self._nameCell, text=1)
+ self._rsyncCombo.set_row_separator_func(self._row_separator)
+ self._rsyncCombo.set_model(self._rsyncStore)
+ self._rsyncCombo.connect("changed", self._rsync_combo_changed)
+ # Force selection of currently configured device
+ self._rsync_dev_selected(self._newRsyncTargetDir)
+
+ # signal dictionary
+ dic = {"on_ok_clicked" : self._on_ok_clicked,
+ "on_cancel_clicked" : gtk.main_quit,
+ "on_snapshotmanager_delete_event" : gtk.main_quit,
+ "on_enablebutton_toggled" : self._on_enablebutton_toggled,
+ "on_rsyncbutton_toggled" : self._on_rsyncbutton_toggled,
+ "on_defaultfsradio_toggled" : self._on_defaultfsradio_toggled,
+ "on_selectfsradio_toggled" : self._on_selectfsradio_toggled,
+ "on_deletesnapshots_clicked" : self._on_deletesnapshots_clicked}
+ self._xml.signal_autoconnect(dic)
+
+ if state != "disabled":
+ self._rsyncEnabled = True
+ self._xml.get_widget("rsyncbutton").set_active(True)
+ self._initialRsyncState = True
+ else:
+ self._rsyncEnabled = False
+ self._rsyncCombo.set_sensitive(False)
+ self._initialRsyncState = False
+
+ # Initialise SMF service instance state.
+ try:
+ self._sliderSMF = TimeSliderSMF()
+ except RuntimeError,message:
+ self._xml.get_widget("toplevel").set_sensitive(False)
+ dialog = gtk.MessageDialog(self._xml.get_widget("toplevel"),
+ 0,
+ gtk.MESSAGE_ERROR,
+ gtk.BUTTONS_CLOSE,
+ _("Snapshot manager service error"))
+ dialog.format_secondary_text(_("The snapshot manager service does "
+ "not appear to be installed on this "
+ "system."
+ "\n\nSee the svcs(1) man page for more "
+ "information."
+ "\n\nDetails:\n%s")%(message))
+ dialog.set_icon_name("time-slider-setup")
+ dialog.run()
+ sys.exit(1)
+
+ if self._sliderSMF.svcstate == "disabled":
+ self._xml.get_widget("enablebutton").set_active(False)
+ self._initialEnabledState = False
+ elif self._sliderSMF.svcstate == "offline":
+ self._xml.get_widget("toplevel").set_sensitive(False)
+ errors = ''.join("%s\n" % (error) for error in \
+ self._sliderSMF.find_dependency_errors())
+ dialog = gtk.MessageDialog(self._xml.get_widget("toplevel"),
+ 0,
+ gtk.MESSAGE_ERROR,
+ gtk.BUTTONS_CLOSE,
+ _("Snapshot manager service dependency error"))
+ dialog.format_secondary_text(_("The snapshot manager service has "
+ "been placed offline due to a dependency "
+ "problem. The following dependency problems "
+ "were found:\n\n%s\n\nRun \"svcs -xv\" from "
+ "a command prompt for more information about "
+ "these dependency problems.") % errors)
+ dialog.set_icon_name("time-slider-setup")
+ dialog.run()
+ sys.exit(1)
+ elif self._sliderSMF.svcstate == "maintenance":
+ self._xml.get_widget("toplevel").set_sensitive(False)
+ dialog = gtk.MessageDialog(self._xml.get_widget("toplevel"),
+ 0,
+ gtk.MESSAGE_ERROR,
+ gtk.BUTTONS_CLOSE,
+ _("Snapshot manager service error"))
+ dialog.format_secondary_text(_("The snapshot manager service has "
+ "encountered a problem and has been "
+ "disabled until the problem is fixed."
+ "\n\nSee the svcs(1) man page for more "
+ "information."))
+ dialog.set_icon_name("time-slider-setup")
+ dialog.run()
+ sys.exit(1)
+ else:
+ # FIXME: Check transitional states
+ self._xml.get_widget("enablebutton").set_active(True)
+ self._initialEnabledState = True
+
+
+ # Emit a toggled signal so that the initial GUI state is consistent
+ self._xml.get_widget("enablebutton").emit("toggled")
+ # Check the snapshotting policy (UserData (default), or Custom)
+ self._initialCustomSelection = self._sliderSMF.is_custom_selection()
+ if self._initialCustomSelection == True:
+ self._xml.get_widget("selectfsradio").set_active(True)
+ # Show the advanced controls so the user can see the
+ # customised configuration.
+ if self._sliderSMF.svcstate != "disabled":
+ self._xml.get_widget("expander").set_expanded(True)
+ else: # "false" or any other non "true" value
+ self._xml.get_widget("defaultfsradio").set_active(True)
+
+ # Set the cleanup threshhold value
+ spinButton = self._xml.get_widget("capspinbutton")
+ critLevel = self._sliderSMF.get_cleanup_level("critical")
+ warnLevel = self._sliderSMF.get_cleanup_level("warning")
+
+ # Force the warning level to something practical
+ # on the lower end, and make it no greater than the
+ # critical level specified in the SVC instance.
+ spinButton.set_range(70, critLevel)
+ self._initialCleanupLevel = warnLevel
+ if warnLevel > 70:
+ spinButton.set_value(warnLevel)
+ else:
+ spinButton.set_value(70)
+
+ def _icon_cell_render(self, celllayout, cell, model, iter):
+ iconList = self._rsyncStore.get_value(iter, 0)
+ if iconList != None:
+ gicon = gio.ThemedIcon(iconList)
+ cell.set_property("gicon", gicon)
+ else:
+ root = self._rsyncStore.get_value(iter, 2)
+ if root == "Other":
+ cell.set_property("gicon", None)
+
+ def _row_separator(self, model, iter):
+ return model.get_value(iter, 4)
+
+ def _mount_added(self, volume_monitor, mount):
+ icon = mount.get_icon()
+ iconList = icon.get_names()
+ if iconList == None:
+ iconList = ['drive-harddisk', 'drive']
+ root = mount.get_root()
+ path = root.get_path()
+ mountName = mount.get_name()
+ volume = mount.get_volume()
+ if volume == None:
+ volName = mount.get_name()
+ if volName == None:
+ volName = os.path.split(path)[1]
+ else:
+ volName = volume.get_name()
+
+ # Check to see if there is at least one gio.Mount device already
+ # in the ListStore. If not, then we also need to add a separator
+ # row.
+ iter = self._rsyncStore.get_iter_first()
+ if iter and self._rsyncStore.get_value(iter, 3) == False:
+ self._rsyncStore.insert(0, (None, None, None, None, True))
+
+ self._rsyncStore.insert(0, (iconList, volName, path, True, False))
+ # If this happens to be the already configured backup device
+ # and the user hasn't tried to change device yet, auto select
+ # it.
+ if self._initialRsyncTargetDir == self._newRsyncTargetDir:
+ if self._validate_rsync_target(path) == True:
+ self._rsyncCombo.set_active(0)
+
+ def _mount_removed(self, volume_monitor, mount):
+ root = mount.get_root()
+ path = root.get_path()
+ iter = self._rsyncStore.get_iter_first()
+ mountIter = None
+ numMounts = 0
+ # Search gio.Mount devices
+ while iter != None and \
+ self._rsyncStore.get_value(iter, 3) == True:
+ numMounts += 1
+ compPath = self._rsyncStore.get_value(iter, 2)
+ if compPath == path:
+ mountIter = iter
+ break
+ else:
+ iter = self._rsyncStore.iter_next(iter)
+ if mountIter != None:
+ if numMounts == 1:
+ # Need to remove the separator also since
+ # there will be no more gio.Mount devices
+ # shown in the combo box
+ sepIter = self._rsyncStore.iter_next(mountIter)
+ if self._rsyncStore.get_value(sepIter, 4) == True:
+ self._rsyncStore.remove(sepIter)
+ self._rsyncStore.remove(mountIter)
+ iter = self._rsyncStore.get_iter_first()
+ # Insert a custom folder if none exists already
+ if self._rsyncStore.get_value(iter, 2) == "Other":
+ path = self._initialRsyncTargetDir
+ length = len(path)
+ if length > 1:
+ name = os.path.split(path)[1]
+ elif length == 1:
+ name = path
+ else: # Indicates path is unset: ''
+ name = _("(None)")
+ iter = self._rsyncStore.insert_before(iter,
+ (None,
+ None,
+ None,
+ None,
+ True))
+ iter = self._rsyncStore.insert_before(iter,
+ (['folder'],
+ name,
+ path,
+ False,
+ False))
+ self._rsyncCombo.set_active_iter(iter)
+
+ def _monitor_setup(self, pulseBar):
+ if self._enabler.isAlive() == True:
+ pulseBar.pulse()
+ return True
+ else:
+ gtk.main_quit()
+
+ def _row_toggled(self, renderer, path):
+ model = self._fsTreeView.get_model()
+ iter = model.get_iter(path)
+ state = renderer.get_active()
+ if state == False:
+ self._fsListStore.set_value(iter, 0, True)
+ else:
+ self._fsListStore.set_value(iter, 0, False)
+ self._fsListStore.set_value(iter, 1, False)
+
+ def _rsync_cell_toggled(self, renderer, path):
+ model = self._fsTreeView.get_model()
+ iter = model.get_iter(path)
+ state = renderer.get_active()
+ rowstate = self._fsListStore.get_value(iter, 0)
+ if rowstate == True:
+ if state == False:
+ self._fsListStore.set_value(iter, 1, True)
+ else:
+ self._fsListStore.set_value(iter, 1, False)
+
+ def _rsync_config_error(self, msg):
+ topLevel = self._xml.get_widget("toplevel")
+ dialog = gtk.MessageDialog(topLevel,
+ 0,
+ gtk.MESSAGE_ERROR,
+ gtk.BUTTONS_CLOSE,
+ _("Unsuitable Backup Location"))
+ dialog.format_secondary_text(msg)
+ dialog.set_icon_name("time-slider-setup")
+ dialog.run()
+ dialog.hide()
+ return
+
+ def _rsync_dev_selected(self, path):
+ iter = self._rsyncStore.get_iter_first()
+ while iter != None:
+ # Break out when we hit a non gio.Mount device
+ if self._rsyncStore.get_value(iter, 3) == False:
+ break
+ compPath = self._rsyncStore.get_value(iter, 2)
+ if compPath == path:
+ self._rsyncCombo.set_active_iter(iter)
+ self._newRsyncTargetDir = path
+ return
+ else:
+ iter = self._rsyncStore.iter_next(iter)
+
+ # Not one of the shortcut RMM devices, so it's
+ # some other path on the filesystem.
+ # iter may be pointing at a separator. Increment
+ # to next row iter if so.
+ if self._rsyncStore.get_value(iter, 4) == True:
+ iter = self._rsyncStore.iter_next(iter)
+
+ if iter != None:
+ if len(path) > 1:
+ name = os.path.split(path)[1]
+ elif len(path) == 1:
+ name = path
+ else: # Indicates path is unset: ''
+ name = _("(None)")
+ # Could be either the custom folder selection
+ # row or the "Other" row if the custom row
+ # was not created. If "Other" then create the
+ # custom row and separator now at this position
+ if self._rsyncStore.get_value(iter, 2) == "Other":
+ iter = self._rsyncStore.insert_before(iter,
+ (None,
+ None,
+ None,
+ None,
+ True))
+ iter = self._rsyncStore.insert_before(iter,
+ (['folder'],
+ name,
+ path,
+ False,
+ False))
+ else:
+ self._rsyncStore.set(iter,
+ 1, name,
+ 2, path)
+ self._rsyncCombo.set_active_iter(iter)
+ self._newRsyncTargetDir = path
+
+ def _rsync_combo_changed(self, combobox):
+ newIter = combobox.get_active_iter()
+ if newIter != None:
+ root = self._rsyncStore.get_value(newIter, 2)
+ if root != "Other":
+ self._newRsyncTargetDir = root
+ else:
+ msg = _("Select A Back Up Device")
+ fileDialog = \
+ gtk.FileChooserDialog(
+ msg,
+ self._xml.get_widget("toplevel"),
+ gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
+ (gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,
+ gtk.STOCK_OK,gtk.RESPONSE_OK),
+ None)
+ self._rsyncCombo.set_sensitive(False)
+ response = fileDialog.run()
+ fileDialog.hide()
+ if response == gtk.RESPONSE_OK:
+ gFile = fileDialog.get_file()
+ self._rsync_dev_selected(gFile.get_path())
+ else:
+ self._rsync_dev_selected(self._newRsyncTargetDir)
+ self._rsyncCombo.set_sensitive(True)
+
+ def _rsync_size_warning(self, zpools, zpoolSize,
+ rsyncTarget, targetSize):
+ # Using decimal "GB" instead of binary "GiB"
+ KB = 1000
+ MB = 1000 * KB
+ GB = 1000 * MB
+ TB = 1000 * GB
+
+ suggestedSize = RSYNCTARGETRATIO * zpoolSize
+ if suggestedSize > TB:
+ sizeStr = "%.1f TB" % round(suggestedSize / float(TB), 1)
+ elif suggestedSize > GB:
+ sizeStr = "%.1f GB" % round(suggestedSize / float(GB), 1)
+ else:
+ sizeStr = "%.1f MB" % round(suggestedSize / float(MB), 1)
+
+ if targetSize > TB:
+ targetStr = "%.1f TB" % round(targetSize / float(TB), 1)
+ elif targetSize > GB:
+ targetStr = "%.1f GB" % round(targetSize / float(GB), 1)
+ else:
+ targetStr = "%.1f MB" % round(targetSize / float(MB), 1)
+
+
+ msg = _("Time Slider suggests a device with a capacity of at "
+ "least <b>%s</b>.\n"
+ "The device: \'<b>%s</b>\'\nonly has <b>%s</b>\n"
+ "Do you want to use it anyway?") \
+ % (sizeStr, rsyncTarget, targetStr)
+
+ topLevel = self._xml.get_widget("toplevel")
+ dialog = gtk.MessageDialog(topLevel,
+ 0,
+ gtk.MESSAGE_QUESTION,
+ gtk.BUTTONS_YES_NO,
+ _("Time Slider"))
+ dialog.set_default_response(gtk.RESPONSE_NO)
+ dialog.set_transient_for(topLevel)
+ dialog.set_markup(msg)
+ dialog.set_icon_name("time-slider-setup")
+
+ response = dialog.run()
+ dialog.hide()
+ if response == gtk.RESPONSE_YES:
+ return True
+ else:
+ return False
+
+ def _check_rsync_config(self):
+ """
+ Checks rsync configuration including, filesystem selection,
+ target directory validation and capacity checks.
+ Returns True if everything is OK, otherwise False.
+ Pops up blocking error dialogs to notify users of error
+ conditions before returning.
+ """
+ def _get_mount_point(path):
+ if os.path.ismount(path):
+ return path
+ else:
+ return _get_mount_point(abspath(join(path, pardir)))
+
+ if self._rsyncEnabled != True:
+ return True
+
+ if len(self._newRsyncTargetDir) == 0:
+ msg = _("No backup device was selected.\n"
+ "Please select an empty device.")
+ self._rsync_config_error(msg)
+ return False
+ # There's little that can be done if the device is from a
+ # previous configuration and currently offline. So just
+ # treat it as being OK based on the assumption that it was
+ # previously deemed to be OK.
+ if self._initialRsyncTargetDir == self._newRsyncTargetDir and \
+ not os.path.exists(self._newRsyncTargetDir):
+ return True
+ # Perform the required validation checks on the
+ # target directory.
+ newTargetDir = self._newRsyncTargetDir
+
+ # We require the whole device. So find the enclosing
+ # mount point and inspect from there.
+ targetMountPoint = abspath(_get_mount_point(newTargetDir))
+
+ # Check that it's writable.
+ f = None
+ testFile = os.path.join(targetMountPoint, ".ts-test")
+ try:
+ f = open(testFile, 'w')
+ except (OSError, IOError):
+ msg = _("\'%s\'\n"
+ "is not writable. The backup device must "
+ "be writable by the system administrator."
+ "\n\nPlease use a different device.") \
+ % (targetMountPoint)
+ self._rsync_config_error(msg)
+ return False
+ f.close()
+
+ # Try to create a symlink. Rsync requires this to
+ # do incremental backups and to ensure it's posix like
+ # enough to correctly set file ownerships and perms.
+ os.chdir(targetMountPoint)
+ try:
+ os.link(testFile, ".ts-test-link")
+ except OSError:
+ msg = _("\'%s\'\n"
+ "contains an incompatible file system. "
+ "The selected device must have a Unix "
+ "style file system that supports file "
+ "linking, such as UFS"
+ "\n\nPlease use a different device.") \
+ % (targetMountPoint)
+ self._rsync_config_error(msg)
+ return False
+ finally:
+ os.unlink(testFile)
+ os.unlink(".ts-test-link")
+
+ # Check that selected directory is either empty
+ # or already preconfigured as a backup target
+ sys,nodeName,rel,ver,arch = os.uname()
+ basePath = os.path.join(targetMountPoint,
+ rsyncsmf.RSYNCDIRPREFIX)
+ nodePath = os.path.join(basePath,
+ nodeName)
+ configPath = os.path.join(basePath,
+ rsyncsmf.RSYNCCONFIGFILE)
+ self._newRsyncTargetSelected = True
+ targetDirKey = None
+
+ contents = os.listdir(targetMountPoint)
+ os.chdir(targetMountPoint)
+
+ # The only other exception to an empty directory is
+ # "lost+found".
+ for item in contents:
+ if (item != rsyncsmf.RSYNCDIRPREFIX and \
+ item != "lost+found") or \
+ not os.path.isdir(item) or \
+ os.path.islink(item):
+ msg = _("\'%s\'\n is not an empty device.\n\n"
+ "Please select an empty device.") \
+ % (newTargetDir)
+ self._rsync_config_error(msg)
+ return False
+
+ # Validate existing directory structure
+ if os.path.exists(basePath):
+ # We only accept a pre-existing directory if
+ # 1. It has a config key that matches that stored by
+ # the rsync plugin's SMF configuration
+ # 2. It has a single subfolder that matches the nodename
+ # of this system,
+
+ # Check for previous config key
+ if os.path.exists(configPath):
+ f = open(configPath, 'r')
+ for line in f.readlines():
+ key, val = line.strip().split('=')
+ if key.strip() == "target_key":
+ targetDirKey = val.strip()
+ break
+
+ # Examine anything else in the directory
+ self._targetSelectionError = None
+ dirList = [d for d in os.listdir(basePath) if
+ d != '.rsync-config']
+ os.chdir(basePath)
+ if len(dirList) > 0:
+ msg = _("\'%s\'\n is not an empty device.\n\n"
+ "Please select an empty device.") \
+ % (newTargetDir)
+ # No config key or > 1 directory:
+ # User specified a non empty directory.
+ if targetDirKey == None or len(dirList) > 1:
+ self._rsync_config_error(msg)
+ return False
+ # Make sure the single item is not a file or symlink.
+ elif os.path.islink(dirList[0]) or \
+ os.path.isfile(dirList[0]):
+ self._rsync_config_error(msg)
+ return False
+ else:
+ # Has 1 other item and a config key. Other
+ # item must be a directory and must match the
+ # system nodename and SMF's key value respectively
+ # respectively
+ if dirList[0] != nodeName and \
+ targetDirKey != self._smfTargetKey:
+ msg = _("\'%s\'\n"
+ "is a Time Slider external backup device "
+ "that is already in use by another system. "
+ "Backup devices may not be shared between "
+ "systems."
+ "\n\nPlease use a different device.") \
+ % (newTargetDir)
+ self._rsync_config_error(msg)
+ return False
+ else:
+ if dirList[0] == nodeName and \
+ targetDirKey != self._smfTargetKey:
+ # Looks like a device that we previously used,
+ # but discontinued using in favour of some other
+ # device.
+ msg = _("\'<b>%s</b>\' appears to be a a device "
+ "previously configured for use by this "
+ "system.\n\nDo you want resume use of "
+ "this device for backups?") \
+ % (newTargetDir)
+
+ topLevel = self._xml.get_widget("toplevel")
+ dialog = gtk.MessageDialog(topLevel,
+ 0,
+ gtk.MESSAGE_QUESTION,
+ gtk.BUTTONS_YES_NO,
+ _("Time Slider"))
+ dialog.set_default_response(gtk.RESPONSE_NO)
+ dialog.set_transient_for(topLevel)
+ dialog.set_markup(msg)
+ dialog.set_icon_name("time-slider-setup")
+
+ response = dialog.run()
+ dialog.hide()
+ if response == gtk.RESPONSE_NO:
+ return False
+ else:
+ # Appears to be our own pre-configured directory.
+ self._newRsyncTargetSelected = False
+
+ # Compare device ID against selected ZFS filesystems
+ # and their enclosing Zpools. The aim is to avoid
+ # a vicous circle caused by backing up snapshots onto
+ # the same pool the snapshots originate from
+ targetDev = os.stat(newTargetDir).st_dev
+ try:
+ fs = self._fsDevices[targetDev]
+
+ # See if the filesystem itself is selected
+ # and/or any other fileystem on the pool is
+ # selected.
+ fsEnabled = self._snapStateDic[fs.name]
+ if fsEnabled == True:
+ # Definitely can't use this since it's a
+ # snapshotted filesystem.
+ msg = _("\'%s\'\n"
+ "belongs to the ZFS filesystem \'%s\' "
+ "which is already selected for "
+ "regular ZFS snaphots."
+ "\n\nPlease select a drive "
+ "not already in use by "
+ "Time Slider") \
+ % (newTargetDir, fs.name)
+ self._rsync_config_error(msg)
+ return False
+ else:
+ # See if there is anything else on the pool being
+ # snapshotted
+ poolName = fs.name.split("/", 1)[0]
+ for name,mount in self._datasets.list_filesystems():
+ if name.find(poolName) == 0:
+ try:
+ otherEnabled = self._snapStateDic[name]
+ radioBtn = self._xml.get_widget("defaultfsradio")
+ snapAll = radioBtn.get_active()
+ if snapAll or otherEnabled:
+ msg = _("\'%s\'\n"
+ "belongs to the ZFS pool \'%s\' "
+ "which is already being used "
+ "to store ZFS snaphots."
+ "\n\nPlease select a drive "
+ "not already in use by "
+ "Time Slider") \
+ % (newTargetDir, poolName)
+ self._rsync_config_error(msg)
+ return False
+ except KeyError:
+ pass
+ except KeyError:
+ # No match found - good.
+ pass
+
+
+ # Figure out if there's a reasonable amount of free space to
+ # store backups. This is a vague guess at best.
+ allPools = zfs.list_zpools()
+ snapPools = []
+ # FIXME - this is for custom selection. There is a short
+ # circuit case for default (All) configuration. Don't forget
+ # to implement this short circuit.
+ for poolName in allPools:
+ try:
+ snapPools.index(poolName)
+ except ValueError:
+ pool = zfs.ZPool(poolName)
+ # FIXME - we should include volumes here but they
+ # can only be set from the command line, not via
+ # the GUI, so not crucial.
+ for fsName,mount in pool.list_filesystems():
+ # Don't try to catch exception. The filesystems
+ # are already populated in self._snapStateDic
+ enabled = self._snapStateDic[fsName]
+ if enabled == True:
+ snapPools.append(poolName)
+ break
+
+ sumPoolSize = 0
+ for poolName in snapPools:
+ pool = zfs.ZPool(poolName)
+ # Rough calcualation, but precise enough for
+ # estimation purposes
+ sumPoolSize += pool.get_used_size()
+ sumPoolSize += pool.get_available_size()
+
+
+ # Compare with available space on rsync target dir
+ targetAvail = util.get_available_size(targetMountPoint)
+ targetUsed = util.get_used_size(targetMountPoint)
+ targetSum = targetAvail + targetUsed
+
+ # Recommended Minimum:
+ # At least double the combined size of all pools with
+ # fileystems selected for backup. Variables include,
+ # frequency of data changes, how much efficiency rsync
+ # sacrifices compared to ZFS' block level diff tracking,
+ # whether compression and/or deduplication are enabled
+ # on the source pool/fileystem.
+ # We don't try to make calculations based on individual
+ # filesystem selection as there are too many unpredictable
+ # variables to make an estimation of any practical use.
+ # Let the user figure that out for themselves.
+
+ # The most consistent measurement is to use the sum of
+ # available and used size on the target fileystem. We
+ # assume based on previous checks that the target device
+ # is only being used for rsync backups and therefore the
+ # used value consists of existing backups and is. Available
+ # space can be reduced for various reasons including the used
+ # value increasing or for nfs mounted zfs fileystems, other
+ # zfs filesystems on the containing pool using up more space.
+
+
+ targetPoolRatio = targetSum/float(sumPoolSize)
+ if (targetPoolRatio < RSYNCTARGETRATIO):
+ response = self._rsync_size_warning(snapPools,
+ sumPoolSize,
+ targetMountPoint,
+ targetSum)
+ if response == False:
+ return False
+
+ self._newRsyncTargetDir = targetMountPoint
+ return True
+
+ def _on_ok_clicked(self, widget):
+ # Make sure the dictionaries are empty.
+ self._fsIntentDic = {}
+ self._snapStateDic = {}
+ self._rsyncStateDic = {}
+ enabled = self._xml.get_widget("enablebutton").get_active()
+ self._rsyncEnabled = self._xml.get_widget("rsyncbutton").get_active()
+ if enabled == False:
+ if self._rsyncEnabled == False and \
+ self._initialRsyncState == True:
+ self._rsyncSMF.disable_service()
+ if self._initialEnabledState == True:
+ self._sliderSMF.disable_service()
+ # Ignore other changes to the snapshot/rsync configuration
+ # of filesystems. Just broadcast the change and exit.
+ self._configNotify = True
+ self.broadcast_changes()
+ gtk.main_quit()
+ else:
+ model = self._fsTreeView.get_model()
+ snapalldata = self._xml.get_widget("defaultfsradio").get_active()
+
+ if snapalldata == True:
+ model.foreach(self._set_fs_selection_state, True)
+ if self._rsyncEnabled == True:
+ model.foreach(self._set_rsync_selection_state, True)
+ else:
+ model.foreach(self._get_fs_selection_state)
+ model.foreach(self._get_rsync_selection_state)
+ for fsname in self._snapStateDic:
+ self._refine_filesys_actions(fsname,
+ self._snapStateDic,
+ self._fsIntentDic)
+ if self._rsyncEnabled == True:
+ self._refine_filesys_actions(fsname,
+ self._rsyncStateDic,
+ self._rsyncIntentDic)
+ if self._rsyncEnabled and \
+ not self._check_rsync_config():
+ return
+
+ self._pulseDialog.show()
+ self._enabler = EnableService(self)
+ self._enabler.start()
+ glib.timeout_add(100,
+ self._monitor_setup,
+ self._xml.get_widget("pulsebar"))
+
+ def _on_enablebutton_toggled(self, widget):
+ expander = self._xml.get_widget("expander")
+ enabled = widget.get_active()
+ self._xml.get_widget("filesysframe").set_sensitive(enabled)
+ expander.set_sensitive(enabled)
+ if (enabled == False):
+ expander.set_expanded(False)
+
+ def _on_rsyncbutton_toggled(self, widget):
+ self._rsyncEnabled = widget.get_active()
+ if self._rsyncEnabled == True:
+ self._fsTreeView.insert_column(self._rsyncRadioColumn, 1)
+ self._rsyncCombo.set_sensitive(True)
+ else:
+ self._fsTreeView.remove_column(self._rsyncRadioColumn)
+ self._rsyncCombo.set_sensitive(False)
+
+ def _on_defaultfsradio_toggled(self, widget):
+ if widget.get_active() == True:
+ self._xml.get_widget("fstreeview").set_sensitive(False)
+
+ def _on_selectfsradio_toggled(self, widget):
+ if widget.get_active() == True:
+ self._xml.get_widget("fstreeview").set_sensitive(True)
+
+ def _advancedbox_unmap(self, widget):
+ # Auto shrink the window by subtracting the frame's height
+ # requistion from the window's height requisition
+ myrequest = widget.size_request()
+ toplevel = self._xml.get_widget("toplevel")
+ toprequest = toplevel.size_request()
+ toplevel.resize(toprequest[0], toprequest[1] - myrequest[1])
+
+ def _get_fs_selection_state(self, model, path, iter):
+ fsname = self._fsListStore.get_value(iter, 3)
+ enabled = self._fsListStore.get_value(iter, 0)
+ self._snapStateDic[fsname] = enabled
+
+ def _get_rsync_selection_state(self, model, path, iter):
+ fsname = self._fsListStore.get_value(iter, 3)
+ enabled = self._fsListStore.get_value(iter, 1)
+ self._rsyncStateDic[fsname] = enabled
+
+ def _set_fs_selection_state(self, model, path, iter, selected):
+ fsname = self._fsListStore.get_value(iter, 3)
+ self._snapStateDic[fsname] = selected
+
+ def _set_rsync_selection_state(self, model, path, iter, selected):
+ fsname = self._fsListStore.get_value(iter, 3)
+ self._rsyncStateDic[fsname] = selected
+
+ def _refine_filesys_actions(self, fsname, inputdic, actions):
+ selected = inputdic[fsname]
+ try:
+ fstag = actions[fsname]
+ # Found so we can skip over.
+ except KeyError:
+ # Need to check parent value to see if
+ # we should set explicitly or just inherit.
+ path = fsname.rsplit("/", 1)
+ parentName = path[0]
+ if parentName == fsname:
+ # Means this filesystem is the root of the pool
+ # so we need to set it explicitly.
+ actions[fsname] = \
+ FilesystemIntention(fsname, selected, False)
+ else:
+ parentIntent = None
+ inherit = False
+ # Check if parent is already set and if so whether to
+ # inherit or override with a locally set property value.
+ try:
+ # Parent has already been registered
+ parentIntent = actions[parentName]
+ except:
+ # Parent not yet set, so do that recursively to figure
+ # out if we need to inherit or set a local property on
+ # this child filesystem.
+ self._refine_filesys_actions(parentName,
+ inputdic,
+ actions)
+ parentIntent = actions[parentName]
+ if parentIntent.selected == selected:
+ inherit = True
+ actions[fsname] = \
+ FilesystemIntention(fsname, selected, inherit)
+
+ def _validate_rsync_target(self, path):
+ """
+ Tests path to see if it is the pre-configured
+ rsync backup device path.
+ Returns True on success, otherwise False
+ """
+ # FIXME - this is duplicate in applet.py and rsync-backup.py
+ # It should be moved into a shared module
+ if not os.path.exists(path):
+ return False
+ testDir = os.path.join(path,
+ rsyncsmf.RSYNCDIRPREFIX,
+ self._nodeName)
+ testKeyFile = os.path.join(path,
+ rsyncsmf.RSYNCDIRPREFIX,
+ rsyncsmf.RSYNCCONFIGFILE)
+ if os.path.exists(testDir) and \
+ os.path.exists(testKeyFile):
+ testKeyVal = None
+ f = open(testKeyFile, 'r')
+ for line in f.readlines():
+ key, val = line.strip().split('=')
+ if key.strip() == "target_key":
+ targetKey = val.strip()
+ break
+ f.close()
+ if targetKey == self._smfTargetKey:
+ return True
+ return False
+
+
+ def commit_filesystem_selection(self):
+ """
+ Commits the intended filesystem selection actions based on the
+ user's UI configuration to disk. Compares with initial startup
+ configuration and applies the minimum set of necessary changes.
+ """
+ for fsname,fsmountpoint in self._datasets.list_filesystems():
+ fs = zfs.Filesystem(fsname, fsmountpoint)
+ try:
+ initialIntent = self._initialFsIntentDic[fsname]
+ intent = self._fsIntentDic[fsname]
+ if intent == initialIntent:
+ continue
+ fs.set_auto_snap(intent.selected, intent.inherited)
+
+ except KeyError:
+ pass
+
+ def commit_rsync_selection(self):
+ """
+ Commits the intended filesystem selection actions based on the
+ user's UI configuration to disk. Compares with initial startup
+ configuration and applies the minimum set of necessary changes.
+ """
+ for fsname,fsmountpoint in self._datasets.list_filesystems():
+ fs = zfs.Filesystem(fsname, fsmountpoint)
+ try:
+ initialIntent = self._initialRsyncIntentDic[fsname]
+ intent = self._rsyncIntentDic[fsname]
+ if intent == initialIntent:
+ continue
+ if intent.inherited == True and \
+ initialIntent.inherited == False:
+ fs.unset_user_property(rsyncsmf.RSYNCFSTAG)
+ else:
+ if intent.selected == True:
+ value = "true"
+ else:
+ value = "false"
+ fs.set_user_property(rsyncsmf.RSYNCFSTAG,
+ value)
+ except KeyError:
+ pass
+
+ def setup_rsync_config(self):
+ if self._rsyncEnabled == True:
+ if self._newRsyncTargetSelected == True:
+ sys,nodeName,rel,ver,arch = os.uname()
+ basePath = os.path.join(self._newRsyncTargetDir,
+ rsyncsmf.RSYNCDIRPREFIX,)
+ nodePath = os.path.join(basePath,
+ nodeName)
+ configPath = os.path.join(basePath,
+ rsyncsmf.RSYNCCONFIGFILE)
+ newKey = generate_random_key()
+ try:
+ origmask = os.umask(0222)
+ if not os.path.exists(nodePath):
+ os.makedirs(nodePath, 0755)
+ f = open(configPath, 'w')
+ f.write("target_key=%s\n" % (newKey))
+ f.close()
+ os.umask(origmask)
+ except OSError as e:
+ self._pulseDialog.hide()
+ sys.stderr.write("Error configuring external " \
+ "backup device:\n" \
+ "%s\n\nReason:\n %s") \
+ % (self._newRsyncTargetDir, str(e))
+ sys.exit(-1)
+ self._rsyncSMF.set_target_dir(self._newRsyncTargetDir)
+ self._rsyncSMF.set_target_key(newKey)
+ # Applet monitors rsyncTargetDir so make sure to notify it.
+ self._configNotify = True
+ return
+
+ def setup_services(self):
+ # Take care of the rsync plugin service first since time-slider
+ # will query it.
+ # Changes to rsync or time-slider SMF service State should be
+ # broadcast to let notification applet refresh.
+ if self._rsyncEnabled == True and \
+ self._initialRsyncState == False:
+ self._rsyncSMF.enable_service()
+ self._configNotify = True
+ elif self._rsyncEnabled == False and \
+ self._initialRsyncState == True:
+ self._rsyncSMF.disable_service()
+ self._configNotify = True
+ customSelection = self._xml.get_widget("selectfsradio").get_active()
+ if customSelection != self._initialCustomSelection:
+ self._sliderSMF.set_custom_selection(customSelection)
+ if self._initialEnabledState == False:
+ enable_default_schedules()
+ self._sliderSMF.enable_service()
+ self._configNotify = True
+
+ def set_cleanup_level(self):
+ """
+ Wrapper function to set the warning level cleanup threshold
+ value as a percentage of pool capacity.
+ """
+ level = self._xml.get_widget("capspinbutton").get_value_as_int()
+ if level != self._initialCleanupLevel:
+ self._sliderSMF.set_cleanup_level("warning", level)
+
+ def broadcast_changes(self):
+ """
+ Blunt instrument to notify D-Bus listeners such as notification
+ applet to rescan service configuration
+ """
+ if self._configNotify == False:
+ return
+ self._dbus.config_changed()
+
+ def _on_deletesnapshots_clicked(self, widget):
+ cmdpath = os.path.join(os.path.dirname(self._execPath), \
+ "../lib/time-slider-delete")
+ p = subprocess.Popen(cmdpath, close_fds=True)
+
+
+class EnableService(threading.Thread):
+
+ def __init__(self, setupManager):
+ threading.Thread.__init__(self)
+ self._setupManager = setupManager
+
+ def run(self):
+ try:
+ # Set the service state last so that the ZFS filesystems
+ # are correctly tagged before the snapshot scripts check them
+ self._setupManager.commit_filesystem_selection()
+ self._setupManager.commit_rsync_selection()
+ self._setupManager.set_cleanup_level()
+ self._setupManager.setup_rsync_config()
+ self._setupManager.setup_services()
+ self._setupManager.broadcast_changes()
+ except RuntimeError, message:
+ sys.stderr.write(str(message))
+
+def generate_random_key(length=32):
+ """
+ Returns a 'length' byte character composed of random letters and
+ unsigned single digit integers. Used to create a random
+ signature key to identify pre-configured backup directories
+ for the rsync plugin
+ """
+ from string import letters, digits
+ from random import choice
+ return ''.join([choice(letters + digits) \
+ for i in range(length)])
+
+def main(argv):
+ rbacp = RBACprofile()
+ # The setup GUI needs to be run as root in order to ensure
+ # that the rsync backup target directory is accessible by
+ # root and to perform validation checks on it.
+ # This GUI can be launched with an euid of root in one of
+ # the following 3 ways;
+ # 0. Run by the superuser (root)
+ # 1. Run via gksu to allow a non priviliged user to authenticate
+ # as the superuser (root)
+
+ if os.geteuid() == 0:
+ manager = SetupManager(argv)
+ gtk.gdk.threads_enter()
+ gtk.main()
+ gtk.gdk.threads_leave()
+ elif os.path.exists(argv) and os.path.exists("/usr/bin/gksu"):
+ # Run via gksu, which will prompt for the root password
+ os.unsetenv("DBUS_SESSION_BUS_ADDRESS")
+ os.execl("/usr/bin/gksu", "gksu", argv)
+ # Shouldn't reach this point
+ sys.exit(1)
+ else:
+ dialog = gtk.MessageDialog(None,
+ 0,
+ gtk.MESSAGE_ERROR,
+ gtk.BUTTONS_CLOSE,
+ _("Insufficient Priviliges"))
+ dialog.format_secondary_text(_("The snapshot manager service requires "
+ "administrative privileges to run. "
+ "You have not been assigned the necessary"
+ "administrative priviliges."
+ "\n\nConsult your system administrator "))
+ dialog.set_icon_name("time-slider-setup")
+ dialog.run()
+ sys.exit(1)
+
git://git.camperquake.de / time-slider.git / commitdiff
