#!/usr/bin/env python

#
# This script is run by a cron job on both gluonraid1 and gluonraid2 using
# the hdsys account every 5 minutes. It's job is to scan the "active" directory
# on the RAID disk for files that should be copied to the tape library. Any files
# found in the /raid/rawdata/active/$RUN_PERIOD directory that have not been 
# modified for at least MIN_TIME_SINCE_MODIFICATION minutes (set via variable
# below) will be moved to the "volatile" directory (preserving the directory
# structure relative to "active"). At the same time, a hard link will be made 
# in the corresponding "staging" directory pointing back to the file in the
# "volatile" directory.
#
# The exception for this are files within a subdirectory
# whose path contains "/RunLog". Files in these directories are small configuration
# files and copying them individually to tape is inefficient and we have been
# asked not to do that. Instead, the "/RunLog*" directories are scanned for
# thier newest files. If the newest file in the whole directory tree is at
# least MIN_TIME_SINCE_MODIFICATION_RUNLOG minutes old, then a tarball of the
# RunLog directory is made in "volatile" and a hard link to that made in
# "staging" so that the tarball is copied to tape.
#
# A cronjob run from the root account on gluonraid1(2) will check for files in
# "staging" directory and will copy them to the tape library if they have
# not been modified for at least 5 minutes. Once a file is copied to the
# tape library, it is unlinked in "staging". This leaves the copy that is
# in "volatile" so it can be used for offline analysis on the counting house
# computers. A separate cron job will periodically remove files from the 
# "volatile" directory in order to make space on the RAID disk.
#
# Important Values:
#
# RUN_PERIOD   is taken from the environment variable which is set in the
#              /gluex/etc/hdonline.cshrc file
#
# HDLOG        is taken from the environment variable which is set in the
#              /gluex/etc/hdonline.cshrc file. This points to the directory
#              where the log file for this script is kept. The log file is
#              probably named stage_to_tape.log and is probably:
#              /gluex/log/stage_to_tape.log
#
#
# This script can be run from any directory
#

import os
import sys
import getpass
import socket
import subprocess
import time

from os.path import join, getsize, getatime, getmtime, getctime
from os import stat
from pwd import getpwuid
from time import gmtime, localtime, strftime

VERBOSE=0
TEST_MODE=False
MIN_TIME_SINCE_MODIFICATION        = 5.0 # time in minutes
MIN_TIME_SINCE_MODIFICATION_RUNLOG = 120.0 # time in minutes
NOW = time.time()
HDLOG = os.getenv('HDLOG', '.')
LOGFILE= '%s/stage_totape.log' % HDLOG

if '-v' in sys.argv: VERBOSE=1  # allow command line to turn on verbose messageing (for debugging) 

#----------------------------
#  printlog
def printlog(mess):
	if TEST_MODE:
		print mess
	else:
		tmess = '%s : %s :: %s' % (socket.gethostname(), time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), mess)
		with open(LOGFILE, "a") as logfile: logfile.write(tmess+'\n')
#----------------------------

# Print start time to log file
printlog('----- START %s -----' % time.ctime(NOW))

RUN_PERIOD = os.getenv('RUN_PERIOD')
if(RUN_PERIOD == None):
	printlog('The "RUN_PERIOD" environment variable is not defined!"')
	printlog('Please set it to something like the following and re-run:')
	printlog(' ')
	printlog('    RunPeriod-2014-10')
	sys.exit(-1)

RAID_DIR = '/raid/rawdata'  # always use local RAID disk
ACTIVE   = RAID_DIR + '/active/' + RUN_PERIOD
STAGING  = RAID_DIR + '/staging/' + RUN_PERIOD
VOLATILE = RAID_DIR + '/volatile/' + RUN_PERIOD

if VERBOSE>0:
	print ' '
	print 'RUN_PERIOD : ' + RUN_PERIOD
	print '    ACTIVE : ' + ACTIVE
	print '   STAGING : ' + STAGING
	print '  VOLATILE : ' + VOLATILE
	print ' '

#----------------------------
#  mkdirpath
def mkdirpath(path):
	try:
		dirs = path.split('/')
		p = ''
		for dir in dirs:
			if dir == '': continue
			p += '/' + dir
			if not os.path.exists(p): os.mkdir(p)
	except Exception,e: printlog(str(e))

#----------------------------

# Walk directory tree, looking for files
printlog("Searching directory: " + ACTIVE)
dirs_to_make  = []
files_to_move = []
for root, dirs, files in os.walk(ACTIVE):

	# Loop over files
	for file in files:
		try:

			fp = join(root, file)
			fullpath = '%s' % fp
			relpath = fullpath[len(ACTIVE)+1:]
			entry = getpwuid(stat(fp).st_uid)
			owner = entry.pw_name
			mtime = getmtime(fp)			
			mdiff = (NOW - mtime)/60.0  # time since modification in minutes
			
			# Files must not have been modified recently
			if mdiff<MIN_TIME_SINCE_MODIFICATION: continue

			# Add directories and files to separate lists. This is so we only
			# try making the directory once if it happens to hold more than one
			# file. We store relative paths here so they can be easily appended
			# to the ACTIVE, STAGING, or VOLATILE variables later
			reldir = os.path.dirname(relpath)
			if reldir not in dirs_to_make : dirs_to_make.append(reldir)
			if relpath not in files_to_move : files_to_move.append(relpath)
			
		except Exception,e:
			printlog(str(e))
			printlog("Unexpected error:" + sys.exc_info()[0])
			printlog("skipping" + join(root, file))

# Make directories if they don't already exist in VOLATILE
for dir in dirs_to_make:
	volatile_path = VOLATILE + '/' + dir
	staging_path  = STAGING  + '/' + dir
	try:
		printlog('making directory: %s' % volatile_path)
		if not TEST_MODE: mkdirpath(volatile_path)
	except Exception,e:
		printlog(str(e))
		printlog('FAILED to make directory: ' + volatile_path)

	try:
		printlog('making directory: %s' % staging_path)
		if not TEST_MODE: mkdirpath(staging_path)
	except Exception,e:
		printlog(str(e))
		printlog('FAILED to make directory: ' + staging_path)


# Move files to VOLATILE
for file in files_to_move:
	frompath = ACTIVE   + '/' + file
	topath   = VOLATILE + '/' + file
	linkpath = STAGING  + '/' + file
	try:
		printlog('moving %s to %s' % (frompath, topath))
		if not TEST_MODE: os.rename(frompath, topath)
		try:
			if '/RunLog' not in topath:
				printlog('linking %s to %s' % (topath, linkpath))
				if not TEST_MODE: os.link(topath, linkpath)
		except Exception,e:
			printlog(str(e))
			printlog('FAILED to link: ' + topath)
	except Exception,e:
		printlog(str(e))
		printlog('FAILED to rename: ' + frompath)


# Walk the VOLATILE tree looking for files in the RunLog directories
# and record the age of the youngest files in each.
printlog("Searching directory for RunLog files: " + VOLATILE)
log_dir_age = {}
for root, dirs, files in os.walk(VOLATILE):

	# Loop over files
	for file in files:
		try:

			fp = join(root, file)
			fullpath = '%s' % fp
			relpath = fullpath[len(VOLATILE)+1:]
			mtime = getmtime(fp)			
			mdiff = (NOW - mtime)/60.0  # time since modification in minutes
			
			# Record the youngest age file of the RunLog dir
			if '/RunLog' in relpath :
				idx = relpath.find('/RunLog')
				runlogpath = relpath[:idx+13]
				if runlogpath in log_dir_age.keys() :
					if mdiff<log_dir_age[runlogpath] :
						log_dir_age[runlogpath] = mdiff
				else:
					log_dir_age[runlogpath] = mdiff
						
		except Exception,e:
			printlog(str(e))
			printlog("Unexpected error:" + str(sys.exc_info()[0]))
			printlog("skipping" + join(root, file))


# Look for RunLog directories whose youngest file is old enough
# to trigger creating a tarball of the directory and linking
# it to STAGING. If a tarball already exists, check if it is
# older than most recent file and remake tarball if needed.
for runlogdir in sorted(log_dir_age.keys()):

	try:

		mdiff = log_dir_age[runlogdir]

		# Files must not have been modified recently
		if mdiff<MIN_TIME_SINCE_MODIFICATION_RUNLOG: continue

		# Note: Do NOT gzip the tarball since it will push
		make_tarball = True
		fullpath_tarball = VOLATILE + '/' + runlogdir + '.tar'
		linkpath         = STAGING  + '/' + runlogdir + '.tar'
		fname_tarball = os.path.basename(fullpath_tarball)
		if os.path.exists(fullpath_tarball):
			mdiff_tarball = (NOW - getmtime(fullpath_tarball))/60.0
			if mdiff_tarball <= mdiff : make_tarball = False

		if make_tarball :
			savedir = os.getcwd()
			parentdir = os.path.dirname(fullpath_tarball)
			printlog('cd ' + parentdir)
			os.chdir(parentdir)
			try:
				cmd = ['tar', '-cf', fname_tarball, fname_tarball[:-4]]
				printlog('tar -cf %s %s ' % (fname_tarball, fname_tarball[:-4]))
				if not TEST_MODE:
					try:
						subprocess.call(cmd)
						printlog('%d bytes : %s' % (os.path.getsize(fullpath_tarball), fullpath_tarball))
					except:
						printlog('ERROR MAKING %s' % fullpath_tarball)
				linkdir = os.path.dirname(linkpath)
				if not os.path.exists(fullpath_tarball):
					printlog('making dir %s ' % (linkpath))
				printlog('linking %s to %s ' % (fullpath_tarball, linkpath))
				if not TEST_MODE: os.link(fullpath_tarball, linkpath)
			except:
				pass
			os.chdir(savedir)
		else :
			if VERBOSE>0: print 'tarball already exists. skipping: ' + fullpath_tarball

	except Exception,e:
		printlog(str(e))
		printlog("Unexpected error:" + str(sys.exc_info()[0]))
		printlog("skipping" + join(root, file))


# Print end time to log file
printlog('-----  END  %s -----' % time.ctime(NOW))