#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# Bràsil!

FILE_LIST=[
    "c:/",
]

COPYRIGHT="""
    Brasil for windows 1.2 Jythonized
   is part of the RedScorpion ObjectsRoot.com Business Site.
  Brasil is released always under GNU License v2.0
     (C)CopyLeft 2008 Giovanni Giorgi
        http://gioorgi.com/tag/brasil4win/
Jython support:
  Try:
C:\jython2.5a3\jython.bat C:\giorgi\ordev\orAdminScripts\brasilWin.py
But be sure to have at least 1Gb of RAM, adding -Xms1024m   -Xmx1024m  to
the launch line
"""

import sys,os,time,datetime

MAIN_StartTime=datetime.datetime.now()
    
#ZIP_DEST="F:/fastBackup"+str(datetime.datetime.now())+".zip"
#ZIP_DEST="F:/fastBackup.zip"
dataOdierna=datetime.datetime.now().strftime("%Y-%m-%d_%H")
#ZIP_DEST="e:/fastBackup"+dataOdierna+".zip"
ZIP_DEST="c:/temp/fastBackup"+dataOdierna+".zip"
# SLEEP_STEP is not used at the moment
SLEEP_STEP=200
SLEEP_SECONDS=5

def log(msg):
    sys.stdout.write( msg )

def info(msg):
    log( str(datetime.datetime.now())+" [INFO] "+msg+"\n")

def isFile(f):
    return os.path.isfile(f)


try:
    import psyco
    info("PSYCO Optimizing...")
    psyco.log()
    MEM_TO_USE=512
    # Optimize up to MEM_TO_USE/2 KB of RAM    
    psyco.full(memory=(MEM_TO_USE/2))
    # Then Optimize aggressive.
    psyco.profile(0.05, memory=(MEM_TO_USE/2))
    # Take the rest, until 30% of watermark
    # See http://psyco.sourceforge.net/psycoguide/node8.html
    psyco.profile(0.3)
    info("PSYCO Optimized")
except ImportError:
    info("No Psyco Found. Optimization skipped")


try:
    #import java.lang.Object
    from java.lang import System
    from java.io import File
    info("Jython Detected. Enabling custom optimizations")
    # [GG]Not sure is faster:
    del isFile
    def isFile(f):
        return File(f).isFile()    
    from zipfile import ZipFile,ZIP_DEFLATED,ZIP_STORED
except ImportError:
    info("No Jython Support detected");
    from zipfile import ZipFile,ZIP_DEFLATED,ZIP_STORED


def expandDirectories(file_list):
    TotalFileSize=globals()["TotalFileSize"]
    expandedList=[]
    log("\nExpanding Data...")
    cxf=0
    for f in file_list:
        cxf=cxf+1
        if isFile(f):
            expandedList.append(f)            
            log("\nAdded flat file:"+f+"\n")
            TotalFileSize=TotalFileSize+os.stat(f).st_size
        else:
            for root, dirs, files in os.walk(f):
                for fx in files:
                    expandedList.append(root+"/"+fx)
                    TotalFileSize=TotalFileSize+os.stat(root+"/"+fx).st_size
            log("\n* Expanding Data... "+str(len(expandedList))) 
        log("\rExpanding Data... "+str(len(expandedList)) + " on "+str(cxf)+"/"+str(len(file_list)))
    log("\n")
    info("Files Expanded")
    globals()["TotalFileSize"]=TotalFileSize
    return expandedList
    
def processList(file_list):
    CurrentStoredBytes=globals()["CurrentStoredBytes"]
    minimumMBPerSec=float(2)
    startTime=datetime.datetime.now()
    usedTime=0
    recoveryList=[]
    counter=0
    totalFiles=len(file_list)
    info("Files to backup:"+str(totalFiles))
    log("\n\r ETA: [ Not yet Ready ] ")
    f=ZipFile(ZIP_DEST,mode='a',allowZip64=True)
    showProgress=False
    for fname in file_list:
        # Store data in the zip:        
        #log("\r.......\r")
        try:
            # Ogni Tanto puo' generare un IOError anche la open...bho                       
            #info(fname+ " Processing ("+str(counter) + ")")
            timeRequired=datetime.datetime.now()
            
            f.write(fname, compress_type=ZIP_DEFLATED)            
            timeRequired=datetime.datetime.now() - timeRequired
            fileSize=os.stat(fname).st_size 
            #log(" Zip Time: "+str(timeRequired.seconds))
            #Try to mesure the time needed. 2 is too low on windooze
            #laptops
            # Compute mean
            usedTime=datetime.datetime.now() -startTime
            mb=(fileSize/float(1024))/float(1024)
            if timeRequired.seconds>0.01:
                mbPerSec=(float(mb)/float(timeRequired.seconds))
            else:
                # Approximate it, to avoid destorying the mean
                mbPerSec=float(mb)/float(0.01)
            counter=counter+1
            CurrentStoredBytes=CurrentStoredBytes+fileSize
            if usedTime.seconds >0.01:
                mbFSMean= ((CurrentStoredBytes/float(1024))/float(1024))/usedTime.seconds
            else:
                mbFSMean= ((CurrentStoredBytes/float(1024))/float(1024))/0.01
            #if (timeRequired.seconds > 5) and (mbFSMean <4):
            if ( mbFSMean < minimumMBPerSec and (minimumMBPerSec < 1 ) ):
                log("\n")
                # Try to mesure the problem: os.stat(fname).st_size                
                info("System slowdown! \nMB/SEC: "+
                     str(mbFSMean)+ " Expected near " + str(minimumMBPerSec)+
                     "\n System under heavy Load?... ...Sleeping "+str(SLEEP_SECONDS)+"s")
                time.sleep(SLEEP_SECONDS)    
                showProgress=True
                minimumMBPerSec=mbFSMean*0.01
                #info("\nReset of minimumMBPerSec:"+str(minimumMBPerSec)+"\n")
            elif mbFSMean < (minimumMBPerSec*0.90):
                # Small tuning:                
                minimumMBPerSec=mbFSMean-1
                log("\n Retargeting minimumMBPerSec to "+str(minimumMBPerSec))
            elif mbFSMean > minimumMBPerSec*1.10:
                oldMinimum=minimumMBPerSec
                #Strict tight                
                if ( (minimumMBPerSec-1) <= mbFSMean):
                    # Crude tuning: at least half mb plus!
                    minimumMBPerSec = mbFSMean-0.5
                else:
                    # Fine tuning:
                    minimumMBPerSec=mbFSMean*0.90
                showProgress=True
                ## Write down only if it is worth to
                #if abs(oldMinimum - minimumMBPerSec) >0.05:
                #    showProgress=True
                #log("\r *** *** Updated minimumMBPerSec:"+str(minimumMBPerSec)+" *** ***")
            # Avoid crazy values
            if (minimumMBPerSec >50) or (mbFSMean >50):
                # Reset off-topic values
                minimumMBPerSec=2
        # Jython 2.5 alpha3 do not support WindowsError exception, so it has been removed
        # Jython 2.5 can launch also an OSError
        except OSError,ose:
            log("\n"+str(ose));
            info("Cannot read:"+fname+ " Scheduled for recovery")
            recoveryList.append(fname)
            f.close();f=ZipFile(ZIP_DEST,mode='a',allowZip64=True) 
        except IOError,e:
            log("\n"+str(e));
            info("Cannot read:"+fname+ " Scheduled for recovery")
            recoveryList.append(fname)
            f.close();f=ZipFile(ZIP_DEST,mode='a',allowZip64=True) 
        if showProgress==True or (counter % 40 ==0 and counter>10 and CurrentStoredBytes>20000000):
            showProgress=False            
            # Percentuale di tempo usato?
            # Stima dimensionale:
            timePerBytes=float(usedTime.seconds)/float(CurrentStoredBytes)
            eta1=timePerBytes*(TotalFileSize-CurrentStoredBytes)
            # Stima Temporale:
            timePerFile=float(usedTime.seconds)/float(counter)
            eta2=timePerFile*(totalFiles-counter+len(recoveryList))
            # Media delle due stime:
            eta=(eta1+eta2)/2            
            # Put again \r ETA
            log("\n ETA:"+str(
                (datetime.datetime.now()+datetime.timedelta(seconds=eta)).strftime("%H:%M:%S")
            )+ " Files:" +str(totalFiles-counter))
            log(" MB/SEC:"+str(mbFSMean) + " Min:" +str(minimumMBPerSec)+"   ")
            #log(str(counter) +" Recovery:"+str(len(recoveryList)))
        #if counter % SLEEP_STEP ==0:
        #    log("\n  zzz  zzz  zzzz              ")
        #    time.sleep(SLEEP_SECONDS)
    f.close()
    globals()["CurrentStoredBytes"]=CurrentStoredBytes
    return recoveryList


### MAIN
    
info(COPYRIGHT)
info("Brasil Window Backuper... Creating new archive...")
f=ZipFile(ZIP_DEST,mode='w',allowZip64=True)
f.write(sys.argv[0])
f.printdir()
f.close()




info("******************************")

TotalFileSize=0
CurrentStoredBytes=0

fullFileList=expandDirectories(FILE_LIST)
SLEEP_STEP=int(float(len(fullFileList))/5.0)
info("Bytes to store:"+str(TotalFileSize)+" SLEEP_STEP="+str(SLEEP_STEP))
recovery1=processList(fullFileList)
retries=8
if len(recovery1) >0:    
    while( len(recovery1) >0) and retries >0:
        info("\n\n\t**** Recovery loop (Re)Started "+str(retries))
        retries=retries -1
        r=processList(recovery1)
        recovery1=r
        info("\nRestating in 30 seconds...\n")
        time.sleep(20)
        info("\nRestating in 10 seconds...\n")
        time.sleep(10)
        
if len(recovery1) >0:
    info("BACKUP FAILED FOR SOME FILES:\n\t"+str(recovery1))

log("\n")
info("-------------------")
f=ZipFile(ZIP_DEST,mode='r')
info("Stored:"+str(len(f.infolist()))+" files on:"+ZIP_DEST)
info("Start Time:"+str(MAIN_StartTime))
#f.printdir()
f.close()
info("Brasil Windows Zipper Ended.")