def __init__(self, host, user, password, name, port=3306): Borg.__init__(self) self.db_host = host self.db_user = user self.db_pass = password self.db_name = name self.port = port
def __init__(self): """Class initialiser""" Borg.__init__(self, self.__class__.__name__) self.prepare_attributes() self.load()
def __init__(self): """Class initialiser""" Borg.__init__(self, self.__class__.__name__) self.prepare_attributes() try: dbus.service.Object.__init__(self, self.bus_name, BUS_PATH) except: None
def test_update_state(self): a = Borg("Mark") c = ChildShare("Paul", color="red") self.assertIn("color", a.state) d = ChildNotShare("Andrew", age=5) a.name = "James" self.assertEqual(a.name, c.name) self.assertNotEqual(a.name, d.name)
def test_update_state(self): a = Borg('Mark') c = ChildShare('Paul', color='red') self.assertIn('color', a.state) d = ChildNotShare('Andrew', age=5) a.name = 'James' self.assertEqual(a.name, c.name) self.assertNotEqual(a.name, d.name)
def __init__(self): Borg.__init__(self) self.files = 0 self.folders = 0 self.found = 0 self.size = 0 self.minutes = 0 self.seconds = 0
def __init__(self): """Class initialiser""" Borg.__init__(self, self.__class__.__name__) self.prepare_attributes() import optionparse self.command_line_options = optionparse.options self.load()
def __init__(self): Borg.__init__(self, self.__class__.__name__) self.sessionEnding = False self.sessionBus = dbus.SessionBus() # self.smknown = SMKNOWN.keys() #self.smknown = [ 'mock' ] self.smknown = ['xfce'] # FIXME should we check for exact w/o trying one by one? self.ok = self.connect()
def __init__(self, nleaflets=None, HID=None, BAUD=None): """ Args: HID (str): USB hardware id, if present: only match exactly and fallback to EMULATOR_MODE otherwise BAUD (int): Serial baud rate - must match serial device baud exactly """ Borg.__init__(self) QObject.__init__(self) if self.__dict__.get('initialized', False): return self._tserial = None self.nleaflets = nleaflets self.init_serial_interface(HID, BAUD) self.initialized = True
def __init__(self, nleaflets=None, HID=None, BAUD=115200): """ Args: HID (str): USB hardware id, if present: only match exactly and fallback to EMULATOR_MODE otherwise BAUD (int): Serial baud rate - must match serial device baud exactly """ Borg.__init__(self) if '_fserial' in self.__dict__: return self._fserial = None self.EMULATOR_MODE = False self._USB_HID = HID self._BAUD = BAUD self._nleaflets = nleaflets self._init_hw()
def __init__ (self,dir_name=None,ignore_funs=None,elf_only=False): Borg.__init__(self) if not (dir_name): return try: self.f_text = open('%s/kernel.elf.txt' %dir_name) self.f_symtab = open('%s/kernel.elf.symtab' %dir_name) except : print "kernel.elf.* can't be opened at directory %s" %dir_name assert 0 self.elf_only = elf_only if not elf_only: self.asm_fs = dict ([(x,functions[x]) for x in functions_by_tag['ASM']]) asm_fs = self.asm_fs self.tcg = None #from original name to the cloned name self.to_clone_name = {} self.un_clone_name = {} for f in asm_fs: if 'clone' in f: match = re.search('(.*)(_clone).*',f) f_name = match.groups()[0] self.to_clone_name[f_name] = f self.un_clone_name[f] = f_name #print 'to_clone_name: %s' % self.to_clone_name #print 'un_clone_name: %s' % self.un_clone_name #self.insts = {} #funcs is a dict of func names to elfFunc objs self.funcs = {} #dict of sym names to sym objects self.syms = {} #dict of addresses to data self.literals = {} #addr -> line text self.lines = {} self.deadend_funcs = deadend_funcs self.dir_name = dir_name #maps addrs to fun name containing it self.addrs_to_f = {}
def test_initial_borg_state_shall_be_init(self): b = Borg() self.assertEqual(b.state, 'Init')
def setUpClass(self): self.b1 = Borg() self.b2 = Borg() self.ib1 = YourBorg()
def __init__(self): Borg.__init__(self)
def test_two_borgs_have_different_identity(self): a = Borg('Mark') b = Borg('Luke') self.assertIsNot(a, b)
def test_borg_and_childshare_share_common_state(self): a = Borg("Mark") c = ChildShare("Paul", color="red") self.assertEqual(a.state, c.state)
def test_two_borgs_share_common_state(self): a = Borg("Mark") b = Borg("Luke") self.assertEqual(a.state, b.state)
def test_two_borgs_share_common_state(self): a = Borg('Mark') b = Borg('Luke') self.assertEqual(a.state, b.state)
def __init__(self): print "Class created: %s" % self.__class__.__name__ Borg.__init__(self) self.gpg = gnupg.GPG(gnupghome=settings.PGPHOMEDIR)
class BorgDaemon(Daemon): @staticmethod def json_callback(obj, cmd, self): msg = '' if obj['type'] == 'archive_progress': msg = "Files processed: {}".format(obj['nfiles']) self.logger.debug(msg) self.notification.update(NOTIFICATION_TITLE, msg, 'process-working-symbolic') self.notification.show() elif obj['type'] == 'log_message' and obj[ 'name'] != 'borg.output.progress': msg = obj['message'].strip() self.logger.info(msg) if msg: self.log += msg + "\n" def run(self): self.config = configparser.ConfigParser( interpolation=configparser.ExtendedInterpolation(), inline_comment_prefixes=('#', ',')) self.config.read(configfile) log_count = self.config['Common'].getint('log-count', logcount) log_size = self.config['Common'].getint('log-size', logsize) log_level = self.config['Common'].get('log-level', loglevel) log_file = os.path.expanduser(self.config['Common'].get( 'log-file', logfile)) log_formatter = logging.Formatter( "%(asctime)s [%(levelname)-5.5s] %(message)s", "%Y-%m-%d %H:%M:%S") log_file_handler = RotatingFileHandler(log_file, maxBytes=log_size, backupCount=log_count) log_file_handler.setFormatter(log_formatter) log_console_handler = logging.StreamHandler() log_console_handler.setFormatter(log_formatter) self.logger = logging.getLogger("borg") self.logger.addHandler(log_file_handler) self.logger.addHandler(log_console_handler) # parse and set log level level = logging.getLevelName(log_level.upper()) if isinstance(level, int): self.logger.setLevel(level) else: self.logger.setLevel(logging.INFO) Notify.init("BorgBackup") self.notifications = [] self.log = {} # instantiate our borg wrapper self.borg = Borg(self.logger, self.json_callback, self) # setup schedule that will regularily execute backups self.sched = sched.scheduler() # extract all sections beginning with 'repo-' self.repos = [ self.config[repo] for repo in self.config.sections() if repo.startswith('repo-') ] for repo in self.repos: # schedule backups now, will reschedule itself self.handle_repo(repo) while True: Gtk.main_iteration_do(False) self.sched.run(blocking=False) time.sleep(1) """Check if a something is an absolute filesystem path and available""" def path_available(self, path): import os if not path: return False path_exp = os.path.expanduser(path) if os.path.isabs(path_exp): # not an SSH target if not os.path.isdir(path_exp): return False return True def handle_repo(self, repo): # if everything goes well, next backup will be in ... next = repo.getint('frequency') class NotFoundException(Exception): pass class TemporarilyNotAvailableException(Exception): pass class OperationFailedException(Exception): pass try: if not self.path_available(repo['repo']): if repo.getboolean('wait-repo', False): raise TemporarilyNotAvailableException( 'Repo {} not yet available'.format(repo['repo'])) else: raise NotFoundException('Repo {} not found'.format( repo['repo'])) for path in repo['paths'].split('\n'): if not path: continue if not self.path_available(path): if repo.getboolean('wait-paths', False): raise TemporarilyNotAvailableException( 'Path {} not yet available'.format(path)) else: raise NotFoundException( 'Path {} not found'.format(path)) if not self.backup(repo): raise OperationFailedException('Backup of {} failed'.format( repo['repo'])) if not self.prune(repo): raise OperationFailedException('Pruning of {} failed'.format( repo['repo'])) except TemporarilyNotAvailableException as e: # retry faster, we expect this to happen next = repo.getint('retry-frequency') # only log at level DEBUG to prevent spamming the log self.logger.debug(e) self.logger.warning('Repo {} will be retried shortly'.format( repo['repo'])) except NotFoundException as e: self.logger.critical(e) except OperationFailedException as e: self.logger.error(e) finally: self.logger.debug('Next backup of {} in {} minutes'.format( repo['repo'], next)) self.sched.enter(next * 60, 0, self.handle_repo, [repo]) def prune(self, repo): self.logger.info("Pruning {}".format(repo['repo'])) return self.borg.prune(repo) def backup(self, repo): self.logger.info("Create backup for {}".format(repo['repo'])) self.notification = Notify.Notification.new( NOTIFICATION_TITLE, "Starting backup for {}".format(repo['repo']), 'process-working-symbolic') self.notification.set_timeout(2000) self.notification.show() self.log = '' self.borg.create(repo) self.notification.close() notification_done = Notify.Notification.new(NOTIFICATION_TITLE, "Done", 'security-high-symbolic') notification_done.add_action('default', 'More info', click, self.log, None) notification_done.connect("closed", closed) notification_done.set_timeout(10 * 1000) notification_done.show() self.notifications.append(notification_done) return True
def test_borg_and_childnotshare_do_not_share_common_state(self): a = Borg("Mark") d = ChildNotShare("Andrew", age=5) self.assertNotEqual(a.state, d.state)
def __init__(self, name=None): Borg.__init__(self) if name is not None: self.name = name
def test_borg_and_childshare_share_common_state(self): a = Borg('Mark') c = ChildShare('Paul', color='red') self.assertEqual(a.state, c.state)
def run(self): self.config = configparser.ConfigParser( interpolation=configparser.ExtendedInterpolation(), inline_comment_prefixes=('#', ',')) self.config.read(configfile) log_count = self.config['Common'].getint('log-count', logcount) log_size = self.config['Common'].getint('log-size', logsize) log_level = self.config['Common'].get('log-level', loglevel) log_file = os.path.expanduser(self.config['Common'].get( 'log-file', logfile)) log_formatter = logging.Formatter( "%(asctime)s [%(levelname)-5.5s] %(message)s", "%Y-%m-%d %H:%M:%S") log_file_handler = RotatingFileHandler(log_file, maxBytes=log_size, backupCount=log_count) log_file_handler.setFormatter(log_formatter) log_console_handler = logging.StreamHandler() log_console_handler.setFormatter(log_formatter) self.logger = logging.getLogger("borg") self.logger.addHandler(log_file_handler) self.logger.addHandler(log_console_handler) # parse and set log level level = logging.getLevelName(log_level.upper()) if isinstance(level, int): self.logger.setLevel(level) else: self.logger.setLevel(logging.INFO) Notify.init("BorgBackup") self.notifications = [] self.log = {} # instantiate our borg wrapper self.borg = Borg(self.logger, self.json_callback, self) # setup schedule that will regularily execute backups self.sched = sched.scheduler() # extract all sections beginning with 'repo-' self.repos = [ self.config[repo] for repo in self.config.sections() if repo.startswith('repo-') ] for repo in self.repos: # schedule backups now, will reschedule itself self.handle_repo(repo) while True: Gtk.main_iteration_do(False) self.sched.run(blocking=False) time.sleep(1)
def test_two_borgs_have_different_identity(self): a = Borg("Mark") b = Borg("Luke") self.assertIsNot(a, b)