#!/usr/bin/python
# encoding: utf-8

import smtplib
import datetime
import time
import string
import re
import sys
import ftplib

from datetime import datetime
from datetime import date
from datetime import timedelta
from string import Template
from subprocess import Popen, PIPE
from email.mime.text import MIMEText
from email.header    import Header


# ==================================================
# ==================================================
# all configstrings are here

senderSL     = 'Mailadresse des Versenders'
receiverSL = 'Mailadresse des Empfängers'

baseSubj     = 'Backupstatus MainBackup: '


# Login-Info für die Mailverschickung
smtpHost = 'hier kommt der Mailserver rein'
smtpPort = 587
username = 'hier der Benutzername des Mailkontos'
passwd   = 'und hier das Passwort, das ist leider gar nicht sicher!!!'

# so heißt mein Backupvolume im Finder
kBackupVolumeName = "Backup"


# ==================================================
# ==================================================
class DeltaTemplate( Template):
    delimiter = "%"

def strfdelta( tdelta, fmt):
    d = {"D": tdelta.days}
    d["H"], rem = divmod( tdelta.seconds, 3600)
    d["M"], d["S"] = divmod( rem, 60)
    t = DeltaTemplate( fmt)
    return t.substitute( **d)



# liefert die vergangene Zeit in Stunden zurück
def deltaHours( dT):
    #print dT
    pastHours = dT.days * 24 + dT.seconds//3600
    return pastHours



# do executes a shell command, returning stdout and stderr
def do( cmd):
    p = Popen( cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=PIPE)
    (fi, fo, fe) = (p.stdin, p.stdout, p.stderr)
    fi.close()
    msg = fo.read()
    fo.close()
    fe.close()
    return msg



# sleep waits a bit
def sleep():
    time.sleep(30)



def sendStatusByMail( aSender, recList, aSubj, bodyTxt):
    # create a list from the recList in case we have a comma separated string of multiple receivers
    rList = [recList]
    rList = recList.split(',');
    
    try:
        msg = MIMEText( bodyTxt, 'plain', 'utf-8')
        msg['Subject'] = Header( aSubj, 'utf-8')
        msg['From'] = aSender
        msg['To'] = ", ".join( rList)
        
        s = smtplib.SMTP( smtpHost, smtpPort, timeout=10)
        #s.set_debuglevel(1)
        try:
            s.starttls()
            s.login( username, passwd)
            s.sendmail( msg['From'], rList, msg.as_string())
        finally:
            s.quit()
            #print 'pythonEmail.py: Finished with no errors.'
            result = True
    
    
    except Exception, exc:
        result = False
        sys.exit( "mail failed; %s" % str(exc) ) # give a error message    return( result)




# mounted checks if vol is mounted, returns isMounted, diskSlice
def mounted( vol):
    #print "---------- mounted"
    isMounted = False
    diskSlice =  ""

    cmdStr = "diskutil info '%s'" % (vol)
    resultStr = do( cmdStr)

    res = re.search('\r*Volume Name.*\n', resultStr)
    if res:
        volName = res.group(0)[26:-1]

        res = re.search('\r*Device Identifier.*\n', resultStr)
        if res:
            diskSlice = res.group(0)[26:-1]

        res = re.search('\r*Partition Type.*\n', resultStr)
        if res:
            isApple_HFS = res.group(0)[26:-1]

        res = re.search('\r*Mounted.*\n', resultStr)
        if res:
            isMounted = res.group(0)[26:-1]

        if ((volName == vol) and (isMounted == 'Yes') and (isApple_HFS == 'Apple_HFS')):
            #print "HFS formatiertes Volumen mit Namen '%s' gefunden" % (vol)
            result = diskSlice
            isMounted = True
        else:
            isMounted = False

    #print "---------- mounted"
    return( isMounted, diskSlice)



# mount_volume returns pair (now mounted?, was mounted?),
# after attempting to mount volume for "name" as needed
def mount_volume( vol):
    #print "---------- mount_volume"
    (nowMounted, wasMounted, aDiskSlice) = (False, False, "")

    (alreadyMounted, aDiskSlice) = mounted( vol)
    #print wasMounted, aDiskSlice

    if alreadyMounted:
        nowMounted = alreadyMounted
        #print "Volume '%s' already mounted, don't eject it at end" % (vol)

    else:
        #print "Volume '%s' not mounted, so we try to mount it now" % (vol)
        if aDiskSlice == "":
            someErrText = "Michael, prüfe dein Backup!\n\nVolume '%s' kann nicht gemounted werden da es nicht gefunden wurde!" % (vol)
            nowMounted = False
        else:
            #print "mount diskslice:", aDiskSlice
            resultStr = do( "diskutil mount %s" % (aDiskSlice))
            sleep()

            # vol should be mounted now, but check to shure
            res = re.search('\r*mounted.*\n', resultStr)
            #print res.group(0)
            if res:
                nowMounted = True
            else:
                someErrText = "Bitte das Backup pruefen!\n\nBackupvolume '%s' konnte nicht gemounted werden!" % (vol)

    if not nowMounted:
        print "Fehlertext: >%s<" % (someErrText)
        # "Mounterror senden"
        subj = "%s %s" % (baseSubj, "Fehler beim Mounten vom Backuplaufwerk")
        sendStatusByMail( senderSL, receiverSL, subj, someErrText)

    #print "---------- mount_volume"
    return( nowMounted, alreadyMounted, aDiskSlice)



# unmount_volume unmounts volume
def unmount_volume( aDiskSlice):
    #print "---------- unmount_volume"
    #print "unmount_volume: ", aDiskSlice
    do( "diskutil eject '%s'" % (aDiskSlice))
    #print "---------- unmount_volume"



def backupd_running():
    #print "---------- backupd_running"
    tmIsRunning = (do( 'tmutil status | grep -c "Running = 1"'))[0:1]
    
    if tmIsRunning == '1':
        # auf Fehler testen
        if tmIsRunning == '1':
            print 'Läuft noch, weitere Runde warten.'
            tmIsRunning = True
        else:
            print 'Fertig oder Fehler'
            lastTM_Error = (do( "syslog -T utc | grep 'Backup failed with error' | grep -E '(/System/Library/CoreServices/backupd|com.apple.backupd)' | tail -n 1"))[0:19]
            if 'error' in lastTM_Error:
                tmIsRunning = 2
            else:
                tmIsRunning = False
    return tmIsRunning




def backupWithTM( vol):
    (isMounted, wasMounted, diskSlice) = mount_volume( vol)
    #print isMounted, wasMounted, diskSlice
    
    print "---------- backupWithTM"

    lastTM_Success = (do( "tmutil latestbackup | tail -c 18"))[0:17]
    #print "---"
    #print lastTM_Success
    print "----"
    if (lastTM_Success != ''):
        print "lastDatum gefunden"
        lastTM_Success_Date = datetime.strptime( lastTM_Success, '%Y-%m-%d-%H%M%S')
        print 'Last succesfull was backup at:', lastTM_Success_Date
        
        # Delta zu jetzt berechnen und wenn zu groß dann Fehlermail senden
        # Zeitdifferenz zwischen jetzt und dem letzten erfolgreichen Backup
        ago = datetime.now() - lastTM_Success_Date
        print "ago.days", ago.days
        if (ago.days > 0):
            # im Klartext heißt das, das das letzte Backup älter als 24 Stunden ist
            print "Fehler: Zeitspanne zum letzten Backup zu groß"
        
            # noch ein wenig Be- und Umrechnungen
            h2 = datetime.strftime( lastTM_Success_Date, "%d.%m.%Y um %H:%M:%S")
            
            subj2 = "%s %s" % (baseSubj, "Backup Fehler (Status: ueberfaellig)")
            msgTxt = "Bitte das Backup pruefen!\n\nDas letzte erfolgreiche Backup war am %s. Also vor %s" % (h2, strfdelta( ago, "%D Tagen, %H Stunden und %M Minuten!"))
            #sendStatusByMail( senderSL, receiverSL, subj, msgTxt)
    else:
        print "kein lastDatum gefunden"
                # hier landen wir auch wenn das Backuplaufwerk nicht gemountet ist. Dann wird ebenfalls kein Datum gefunden...
        if isMounted:
            # Wahrscheinlicher: es ist das erste Backup auf diesem Laufwerk
            print 'Keinen Eintrag mit erfolgreichem Backup im Log gefunden. Ist das etwa das erste Backup auf diesem Laufwerk? Dann ist das ja kein echtes Problem.'
            subj2 = "%s %s" % (baseSubj, "Backup Fehler (Status:  Zeitpunkt des letzten erfolgreichen Backups konn nicht bestimmt werden)")
            msgTxt = "Bitte das Backup pruefen!\n\nKein Backupvolume gemountet"
        else:
            # Kein Datum weil es nicht gemountet ist...
            print 'Keinen Eintrag mit erfolgreichem Backup im Log gefunden weil das Backupvolume nicht gemountet ist.'
            # keine Mail verschicken, ist oben schon passiert!
            subj2 = ""
            #subj2 = "%s %s" % (baseSubj, "Backup Fehler (fatal Error:  Backupvolume ist nicht gemountet.)")
            #msgTxt = "Bitte das Backup pruefen!\n\nKein Backupvolume gemountet"
            
    
    if isMounted:
        print 'Backup gemountet, also Backup starten!'
        # TM starten
        backupStartTime = datetime.now()
        print "Backup Start um: %s" % datetime.strftime( backupStartTime, "%d.%m.%Y um %H:%M:%S")
        do( 'tmutil startbackup --auto --rotation')
        
        sleep()
        sleep()
        sleep()
        
        tmIsRunning = True
        while (tmIsRunning == True):
            sleep()
            tmIsRunning = backupd_running()
        
        sleep()
        sleep()
        sleep()
        print 'Backup ist fertig, Mail schicken'
        if tmIsRunning == 2:
            print "Fehler: Dialog blockiert oder sonstiger Fehler"
            
            # kann sein, das kein lastSuccessDate definiert ist wenn oben kein Eintrag gefunden wurde oder es das 1. Backup ist und dieses fehlgeschlagen ist...
            # wenn also lastSuccessDate nicht definiert ist dann gibts jetzt einen FEHLER, das sollte noch behoben werden!!!
            # Zeitdifferenz zwischen jetzt und dem letzten erfolgreichen Backup
            ago = datetime.now() - lastSuccessDate
            #print 'Vergangene Zeit:', ago
            #print "ago.days", ago.days
        
            # noch ein wenig Be- und Umrechnungen
            h2 = datetime.strftime( lastSuccessDate, "%d.%m.%Y um %H:%M:%S")
        
            subj2 = "Fehler beim Backup"
            msgTxt = 'Bitte das Backup  pruefen2!\n\nDas letzte erfolgreiche Backup war am %s. Also vor %s' % (h2, strfdelta( ago, "%D Tagen, %H Stunden und %M Minuten!"))
            #print msgTxt
        
        else:
            # Erfolgsmail erstellen
            print "create Successmail"
            
            #lastTM_Success = (do( "tmutil latestbackup | tail -c 18"))[0:17]
            h2 = datetime.strftime( backupStartTime, "%d.%m.%Y um %H:%M:%S")
            
            backupEndTime = datetime.now()
            dauer = backupEndTime - backupStartTime
        
            subj2 = 'Backup OK'
            msgTxt = 'Das Backup am %s war erfolgreich\nDauer: %d:%d Stunden' % (h2, dauer.seconds/3600, dauer.seconds%3600/60)
            print msgTxt
    
    
    if not wasMounted:
        print "Ready, unmount it because it was unmounted earlier"
        unmount_volume( diskSlice)
    
    # send Mail NOW
    #print "Send Statusmail"
    if (subj2 != ''):
        subj = "%s %s" % (baseSubj, subj2)
        sendStatusByMail( senderSL, receiverSL, subj, msgTxt)
        
        
    return diskSlice
    #print "---------- backupWithTM"




# ============================================================ ===================
# Main Start
if time.strftime( "%H") < "12":
    doNachmittag = False
else:
    doNachmittag = True

    

# "=========================================================== ===================="
print "======== TM Start Script =========="
diskSlice = backupWithTM( kBackupVolumeName)
print "======== TM Fertig  =========="


# dieser Test wird nur Mittags durchgeführt
if doNachmittag:
    runTest = do( "ps auxc | grep 'Microsoft Outlook'")
    #print 'runtest: ', runTest
    if not runTest:
        print 'Kein Outlook offen, also wieder Schlafen gehen'
        unmount_volume( diskSlice)
        sleep()
        sleep()
        do( "pmset sleepnow")

print "======== TM Ende Script =========="