ui.py

#
# MacOS UI
#

import rumps
import time
import datetime
import logging
from threading import Lock

INACTIVE=0
ACTIVE=1
OFFLINE=2
ERRORS=3

traynames={
    INACTIVE: 'B.',
    ACTIVE: 'B!',
    OFFLINE: 'B⦙',
    ERRORS: 'B?'
}

def combine_state(state1, state2):
    return max(state1, state2)

# Based on code snatched from
# https://stackoverflow.com/questions/12523586/python-format-size-application-converting-b-to-kb-mb-gb-tb/37423778
def humanbytes(B):
   'Return the given bytes as a human friendly KB, MB, GB, or TB string'
   B = float(B)
   KB = float(1024)
   MB = float(KB ** 2) # 1,048,576
   GB = float(KB ** 3) # 1,073,741,824
   TB = float(KB ** 4) # 1,099,511,627,776

   if B < KB:
      return '{0} {1}B'.format(B)
   elif KB <= B < MB:
      return '{0:.2f}KB'.format(B/KB)
   elif MB <= B < GB:
      return '{0:.2f}MB'.format(B/MB)
   elif GB <= B < TB:
      return '{0:.2f}GB'.format(B/GB)
   elif TB <= B:
      return '{0:.2f}TB'.format(B/TB)

def make_title(status):
    state=INACTIVE

    if status['type']=='scheduled':
        # Operation scheduled
        when=status['when']
        now=time.time()
        if when<now:
            whenstr='overdue'
        else:
            diff=datetime.timedelta(seconds=when-now)
            if diff.days>0:
                whenday=datetime.date.fromtimestamp(when)
                whenstr='on %s' % whenday.isoformat()
            else:
                twhen=time.localtime(when)
                if twhen.tm_sec>30:
                    # Round up minute display to avoid user confusion
                    twhen=time.localtime(when+30)
                whenstr='at %02d:%02d' % (twhen.tm_hour, twhen.tm_min)
        detail=''
        if 'detail' in status and status['detail']:
            if status['detail']=='retry':
                state=ERRORS
            detail=status['detail']+' '
        title="%s (%s%s %s)" % (status['name'], detail, status['operation'], whenstr)
    elif status['type']=='current':
        # Operation running
        progress=''
        if 'progress_current' in status and 'progress_total' in status:
            progress=' %d%%' % (status.progress_current/status.progress_total)
        elif 'original_size' in status and 'deduplicated_size' in status:
            progress=' %s O %s D' % (humanbytes(status.original_size),
                                     humanbytes(status.deduplicated_size))
        title="%s (running: %s%s)" % (status['name'], status['operation'], progress)
        state=ACTIVE
    else: # status['type']=='nothing':
        # Should be unscheduled, nothing running
        title=status['name']

    if status['errors']:
        state=ERRORS

    return title, state


class BorgendTray(rumps.App):
    def __init__(self, name, backups):
        self.lock=Lock()
        self.backups=backups
        self.statuses=[None]*len(backups)

        with self.lock:
            # Initialise reporting callbacks and local status copy
            # (since rumps doesn't seem to be able to update menu items
            # without rebuilding the whole menu, and we don't want to lock
            # when calling Backup.status(), especially as we will be called
            # from Backup reporting its status, we keep a copy to allow
            # rebuilding the entire menu
            for index in range(len(backups)):
                b=backups[index]
                # Python closures suck dog's balls; hence the _index=index hack
                # See also http://math.andrej.com/2009/04/09/pythons-lambda-is-broken/
                cb=(lambda obj, status, _index=index:
                    self.__status_callback(obj, _index, status))
                b.set_status_update_callback(cb)
                self.statuses[index]=b.status()

            menu, state=self.__rebuild_menu()

            super().__init__(traynames[state], menu=menu, quit_button=None)

    def __rebuild_menu(self):
        menu=[]
        state=INACTIVE
        for index in range(len(self.backups)):
            b=self.backups[index]
            title, this_state=make_title(self.statuses[index])
            logging.info('TITLE: %s' % title)
            # Python closures suck dog's balls...
            # first and the last program I write in Python until somebody
            # fixes this brain damage
            cbm=lambda sender, _b=b: self.__menu_select_backup(sender, _b)
            item=rumps.MenuItem(title, callback=cbm)
            menu.append(item)
            state=combine_state(state, this_state)

        menu_quit=rumps.MenuItem("Quit...", callback=self.my_quit)
        menu.append(menu_quit)

        return menu, state


    def my_quit(self, _):
        rumps.quit_application()

    def __menu_select_backup(self, sender, b):
        #sender.state=not sender.state
        logging.debug("Manually backup '%s'", b.name)
        b.create(None)

    def __status_callback(self, obj, index, status):
        logging.debug('Status callbackup %s' % str(status))
        with self.lock:
            self.statuses[index]=status
            logging.debug('Rebuilding menu')
            self.menu.clear()
            menu, active=self.__rebuild_menu()
            self.menu.update(menu)
            self.title=traynames[active]