path: root/devtools/vcodepickle.py

#!/usr/bin/env python

import p4helpers
import sys
import os
import shutil
import pickle
import zipfile
import zlib
import datetime
import subprocess
import getopt
import glob
import struct
try:
	import wx
except:
	pass

# 
# Set program defaults.
#
g_ChangelistInfoFilename = '__CHANGELISTINFO__'

RUNMODE_BACKUP = 0
RUNMODE_RESTORE = 1
RUNMODE_EMPTY = 2
RUNMODE_NONE = 3

g_RunMode = RUNMODE_NONE
g_ZipFilename = ''
g_bAutoRevert = False
g_bBinsOnly = False
g_Changelist = []
g_bShowUI = False
g_bPickleAllChanges = False
g_bVerbose = True
g_IncludeGlobPatterns = []
g_ExcludeGlobPatterns = []
g_ChangelistComment = ''
g_DefaultFilename = None

g_bCreateDiff = False
g_DiffDir = ''

g_SettingsFilename = 'vcodepickle.cfg'
g_Settings = {}

g_UISaveDirKey = 'uisavedir'

# These are used with -changetree if the user wants to restore the changelist to
# a different tree than it originally came from.
g_FromTree = None
g_ToTree = None

g_QueuedWarnings = []


#
# Pickle data for various file versions supported by vcodepickle.
#
class CV2Data:
	changelistComment = None

class CV3Data:
	relativeToDepotFileMap = None


def ShowUsage():
	print "vcodepickle.py [options] <--backup [options] or --restore or --diff or --empty> [--file filename] [--changelist <changelist> | --bins]"
	print ""
	print "-q/--quiet               sshhhhhh."
	print "-b/--backup              pickle local changes to file"
	print "-r/--restore             apply pickled edits to client"
	print "--empty            	 	create a valid, but empty, pickle, used by buildbot"
	print "-d/--diff                produce a diff of the changes in a vcodepickled zipfile"
	print "-f/--file filename       pickle file - optional for backup, required for restore"
	print "-c/--changelist <#|all>  in backup mode, pickle specified changelist(s)"
	print "                         in restore mode, reapply changes to the specified changelist"
	print "                         defaults to 'default'"
	print "   --prompt				if using --backup, this asks where to backup (and makes suggestions)"
	print "                         if using --restore, this brings up a file open dialog"
	print ""
	print "backup options:"
	print ""
	print "  --bins                 pickle binaries from the auto-checkout changelist"
	print "  --revert               in backup mode, revert open files after pickling"
	print "  -e/--exclude <globpat> a glob pattern of files to exclude from pickling"
	print "  -i/--include <globpat> a glob pattern of files to include in the code pickle"
	print ""
	print "restore options:"
	print ""
	print "  --changetree <src> <dst> allows you to restore to a Perforce tree different from the original one"
	print ""
	print "diff options:"
	print ""
	print "  --diffdir <directory>    specify where the diff files will go"
	print ""
	print 'ex: vcodepickle.py --backup --changelist all --exclude "bin/*"'
	print '    creates a zip file of all files not matching "bin/*" in all changelists'	
	print ""
	print "ex: vcodepickle.py --restore --file vcodepickle_2009_01_20.zip -c 342421"
	print "    restore from the specified file into changelist 342421"
	print ""
	print "ex: vcodepickle.py --diff --file VCP_2009-03-26__17h-01m-25s.zip"
	print "    creates a diff of the pickled changes in the specified file"
	sys.exit( 1 )


def DefaultPickleDirName( username ):
	return '\\\\fileserver\\user\\' + username + '\\vcodepickles'


def DefaultPickleDiffName( username ):
	return '\\\\fileserver\\user\\' + username + '\\vcodepicklediff'

def CreateChangelist( comment ):
	po = subprocess.Popen( 'p4 change -i', shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE )
	po.stdin.write( 'Change: new\n\nDescription:\n\t' + comment.replace('\n','\n\t') + '\n\n' )
	po.stdin.close()
	theOutput = po.stdout.readline()
	ret = po.wait()
	if ret == 0:
		return int( theOutput.split( ' ' )[1] )
	else:
		print "Creating a changelist failed."
		print theOutput
		sys.exit( 1 )

def GetChangelistComment( nChangelist ):
	po = subprocess.Popen( 'p4 change -o ' + nChangelist, shell=True, stdout=subprocess.PIPE )
	lines = po.stdout.readlines()
	ret = po.wait()
	if ret != 0:
		print "Couldn't get changelist description for change " + nChangelist
		sys.exit( 1 )
	
	comment = ''
	bFound = False
	for line in lines:
		if bFound == True:
			if line[0] == '\t':
				comment += line[1:]
			else:
				break
		else:
			if line[:12] == 'Description:':
				bFound = True
	
	return comment	


def chomp( str ):
	while 1:
		str2 = str.lstrip( '\n' ).lstrip( '\r' ).rstrip( '\n' ).rstrip( '\r' )
		if len( str2 ) == len( str ):
			return str
		else:
			str = str2


def AddQueuedWarning( s ):
	global g_QueuedWarnings
	g_QueuedWarnings.append( s )
	
def PrintQueuedWarnings():
	global g_QueuedWarnings
	if len( g_QueuedWarnings ) > 0:
		print "\n\n===== WARNINGS =====\n"
		nWarning = 1
		for warning in g_QueuedWarnings:
			print "%d:\n%s\n" % (nWarning, warning)
			nWarning += 1


def DoesFileExistInPerforce( filename ):
	x = p4helpers.ReadPerforceOutput( 'p4 -G fstat ' + filename )
	return (x[1][0]['code'] != 'error')

#
# The settings file is just a bunch of key/value pairs on different lines separated by =
#
def LoadSettingsFile( filename ):
	ret = {}
	try:
		f = open( filename, 'rt' )
	except IOError:
		return {}
		
	for line in f.readlines():
		line = chomp( line )
		parts = line.split( '=' )
		if len( parts ) > 0:
			ret[parts[0]] = parts[1]
	f.close()
	return ret;
	
def SaveSettingsFile( filename, thedict ):
	f = open( filename, 'wt' )
	for (k,v) in thedict.items():
		f.write( '%s=%s\n' % (k, v) )
	f.close()


def SetZipFilename( filename ):
	global g_ZipFilename
	g_ZipFilename = filename
	if g_ZipFilename[-4:].lower() != '.zip':
		g_ZipFilename += '.zip'


def GetReadableChangelistComment( str ):
	alphabet = 'abcdefghijklmnopqrstuvwxyz'

	# Strip out all lists of repeating nonalphabetic characters
	tempstr = ''
	prevchar = ''
	for i in range(0,len(str)):
		testchar = str[i:i+1]
		if testchar != prevchar or alphabet.find(testchar) != -1:
			tempstr += testchar
		prevchar = testchar
	
	str = tempstr
	str = str[:100]
	
	outstr = ''
	validchars = alphabet + alphabet.upper() + '0123456789_'
	prevchar = ''
	for i in range(0,len(str)):
		testchar = str[i:i+1]
		if validchars.find( testchar ) == -1:
			if prevchar != '-':
				outstr += '-'
		else:
			outstr += testchar
		prevchar = outstr[-1:]
	
	return outstr


def ShowUIForFilename():
	global g_Settings
	global g_SettingsFilename
	global g_ZipFilename
	global g_DefaultFilename
	
	#
	# Get the directory to save to.
	#
	username = os.environ['username']
	defaultdirname = DefaultPickleDirName(username)

	if not g_Settings.has_key( g_UISaveDirKey ):
		g_Settings[g_UISaveDirKey] = defaultdirname
	
	if g_Settings[g_UISaveDirKey] == 'default':
		theinput = raw_input( '\nDirectory\n=========\n(Leave blank for "%s")\n> ' % ( defaultdirname ) )
	else:
		theinput = raw_input( '\nDirectory\n=========\n(Leave blank    for "%s")\n(Type "default" for "%s"\n--> ' % ( g_Settings[g_UISaveDirKey], defaultdirname ) )

	if theinput == '':
		theDirName = g_Settings[g_UISaveDirKey]
	else:
		g_Settings[g_UISaveDirKey] = theinput
		theDirName =  theinput
	
	if theDirName.lower() == 'default':
		theDirName = defaultdirname

	#
	# Make sure it exists.. create it if necessary.
	#
	if os.access( theDirName, os.F_OK ) != True:
		theinput = raw_input( "Directory %s doesn't exist. Create? (Y/n) " % theDirName )
		if theinput == '' or theinput.lower() == 'y':
			os.makedirs( theDirName )
		else:
			print "Exiting."
			sys.exit( 1 )
	
	#
	# Get the filename to save to.
	#
	theinput = raw_input( '\nFilename\n========\n(Leave blank for "%s")\n> ' % ( g_DefaultFilename ) )
	
	if theinput == '':
		theZipFilename = g_DefaultFilename
	else:
		theZipFilename = theinput

	#
	# Construct the actual zip filename we'll use.
	#		
	SetZipFilename( os.path.join( theDirName, theZipFilename ) )			

	
	#
	# Check if it already exists.
	#
	if os.access( g_ZipFilename, os.F_OK ) == True:
		theinput = raw_input( "%s already exists. Overwrite? (y/N)" % g_ZipFilename )
		if theinput == '' or theinput.lower() == 'n':
			print "Exiting."
			sys.exit(1)

	# 
	# Save the settings back out.
	#
	SaveSettingsFile( g_SettingsFilename, g_Settings )



class VCodePickle:
	theZipFile = None
	filesDeleted = {}
	filesAdded = {}
	filesEdited = {}
	changelistComment = ''
	relativeToDepotFileMap = {}	# Maps src\engine\cl_main.cpp to //valvegames/main/src/engine/cl_main.cpp (obviously //valvegames/main/src changes based on the root)
	
	def Load( self, zipFilename ):
		self.theZipFile = zipfile.ZipFile( zipFilename, 'r', zipfile.ZIP_DEFLATED )

		# Load the added and deleted lists.
		changelistinfo = self.theZipFile.read( g_ChangelistInfoFilename + '.TXT' )
		(self.filesDeleted, self.filesAdded, self.filesEdited) = pickle.loads( changelistinfo )
		
		self.changelistComment = 'vcodepickle: ' + os.path.basename(g_ZipFilename)
		
		# Load version2 data.
		try:
			ci2 = pickle.loads( self.theZipFile.read( g_ChangelistInfoFilename + 'v2.TXT' ) )
			self.changelistComment = ci2.changelistComment
		except KeyError:
			pass
		
		# Load version3 data
		try:
			ci3 = pickle.loads( self.theZipFile.read( g_ChangelistInfoFilename + 'v3.TXT' ) )
			self.relativeToDepotFileMap = ci3.relativeToDepotFileMap
		except KeyError:
			pass



##
# Given a 'zip' instance, copy data from the 'name' to the
# 'out' stream.

def explode( out, zip, name ):
	zinfo = zip.getinfo(name)

	stringFileHeader = "PK\003\004"   # magic number for file header
	structFileHeader = "<4s2B4HlLL2H"  # 12 items, file header record, 30 bytes
	_FH_FILENAME_LENGTH = 10
	_FH_EXTRA_FIELD_LENGTH = 11

	filepos = zip.fp.tell()
	zip.fp.seek(zinfo.header_offset, 0)

	# Skip the file header:
	fheader = zip.fp.read(30)
	if fheader[0:4] != stringFileHeader:
		raise zipfile.BadZipfile, "Bad magic number for file header"
		
	fheader = struct.unpack(structFileHeader, fheader)
	fname = zip.fp.read(fheader[_FH_FILENAME_LENGTH])
	if fheader[_FH_EXTRA_FIELD_LENGTH]:
		zip.fp.read(fheader[_FH_EXTRA_FIELD_LENGTH])

	if fname != zinfo.orig_filename:
		raise zipfile.BadZipfile, 'File name in directory "%s" and header "%s" differ.' % ( zinfo.orig_filename, fname)

	if zinfo.compress_type == zipfile.ZIP_STORED:
		decoder = None
	elif zinfo.compress_type == zipfile.ZIP_DEFLATED:
		if not zlib:
			raise RuntimeError,  "De-compression requires the (missing) zlib module"
		decoder = zlib.decompressobj(-zlib.MAX_WBITS)
	else:
		raise zipfile.BadZipfile,"Unsupported compression method %d for file %s" % (zinfo.compress_type, name)

	size = zinfo.compress_size
	
	while 1:
		data = zip.fp.read(min(size, 8192))
		if not data:
			break
		size -= len(data)
		if decoder:
			data = decoder.decompress(data)
		out.write(data)
	
	if decoder:
		out.write(decoder.decompress('Z'))
		out.write(decoder.flush())

	zip.fp.seek(filepos, 0)



def WriteFileFromZip( theZipFile, srcFilename, sDestFilename ):
#	thebytes = theZipFile.read( srcFilename )
	
	try:
		f = open( sDestFilename, 'wb')
	except:
		os.makedirs( os.path.dirname( sDestFilename ) )
		f = open( sDestFilename, 'wb' )

	explode( f, theZipFile, srcFilename );
#	f.write( thebytes )
	f.close()


def PerforceToZipFilename( sP4Filename ):
	if sP4Filename[0] != '/' or sP4Filename[1] != '/':
		print "PerforceToZipFilename: invalid filename (%s)" % (sP4Filename)
	
	return sP4Filename[2:]


def CheckFilesOpenedForEdit( thePickle, theDict ):
	ret = []
	for k in theDict.keys():
		sDepotFilename = thePickle.relativeToDepotFileMap[k]
		if p4helpers.GetClientFileAction( sDepotFilename ) != 'none':
			ret.append( sDepotFilename )
	
	return ret
	


def HandleNewTree( thePickle ):
	global g_FromTree, g_ToTree

	if g_FromTree == None:
		return
		
	print "-changetree is translating these files:\n"
	
	for k in thePickle.relativeToDepotFileMap.keys():
		sFromFilename = thePickle.relativeToDepotFileMap[k]
		
		if sFromFilename[:len(g_FromTree)].lower() == g_FromTree.lower():
			sToFilename = g_ToTree + sFromFilename[len(g_FromTree):]
			
			print sFromFilename + "\n\t-> " + sToFilename + "\n"
			
			thePickle.relativeToDepotFileMap[k] = sToFilename
		else:
			print "Used -changetree [%s] [%s], but file %s does not come from the source tree." % (g_FromTree, g_ToTree, sFilename)
			sys.exit( 1 )

	# Translate the revision number to a changelist number for edited files.
	newEdited = {}
	for k in thePickle.filesEdited.keys():
		thePickle.filesEdited[k] = "head"
		
		sDepotFilename = thePickle.relativeToDepotFileMap[k]
		if DoesFileExistInPerforce( sDepotFilename ):
			newEdited[k] = thePickle.filesEdited[k]
		else:
			AddQueuedWarning( "%s was edited in the old tree, but doesn't exist in the new tree. This was treated as an add instead." % sDepotFilename )
			thePickle.filesAdded[k] = thePickle.filesEdited[k]
	
	thePickle.filesEdited = newEdited
	
	print "\n"
	
	
def PromptForOpenZipFilename( sClientRoot, promptDir ):
	if not sys.modules.has_key( "wx" ):
		print >>sys.stderr, "Couldn't load wx, no UI available."
		sys.exit( 1 )
		
	temp_app = wx.PySimpleApp()
	dialog = wx.FileDialog ( None, style = wx.OPEN )
	dialog.SetMessage( "Select code pickle" );
	dialog.SetDirectory(promptDir)
	dialog.SetWildcard( "VCodePickle Zips (*.zip)|*.zip|All Files (*.*)|*.*" );
	
	if dialog.ShowModal() == wx.ID_OK:
		print 'Selected: %s\n' % (dialog.GetPath())
		return dialog.GetPath()
	else:
		print 'Cancelled.'
		return None
   
   
def DoRestore( sClientRoot, sZipFilename ):
	global g_bBinsOnly
	thePickle = VCodePickle()
	thePickle.Load( sZipFilename )
	
	# First make sure they don't have any files open for edit that we want to mess with.	
	print "Checking the code pickle...\n"
	
	openedForEdit = CheckFilesOpenedForEdit( thePickle, thePickle.filesAdded ) + CheckFilesOpenedForEdit( thePickle, thePickle.filesEdited )
	if len( openedForEdit ) > 0 and g_bBinsOnly==False:
		print "You have one or more files open locally that are in the vcodepickle you are trying to restore:\n"
		for f in openedForEdit:
			print "\t" + f
		print "\nPlease revert the specified file(s) and retry the vcodepickle command you were doing."
		return

	changelistNum = None
	if ( g_bBinsOnly == False ):
		changelistNum = CreateChangelist( thePickle.changelistComment )
	else:
		changelistNum = 'default'
	
	HandleNewTree( thePickle )

	if g_bVerbose: print "Adding %d files..." % len( thePickle.filesAdded )
	for k in thePickle.filesAdded.keys():
		sDepotFilename = thePickle.relativeToDepotFileMap[k]

		if DoesFileExistInPerforce( sDepotFilename ):
			sLocalClientFilename = p4helpers.GetClientFileInfo( sDepotFilename )[0]
			AddQueuedWarning( "%s was added in the code pickle, but already exists in Perforce. We'll treat it as an edit." % sLocalClientFilename );
			
			p4helpers.CheckPerforceReturn( 'p4 sync %s' % (sDepotFilename) )
			p4helpers.CheckPerforceReturn( 'p4 edit -c %s %s' % (changelistNum, sDepotFilename) )
			WriteFileFromZip( thePickle.theZipFile, k.replace('\\','/'), sLocalClientFilename )
		else:
			# Note: We do the "p4 add" first because we don't yet know the local filename for this depot filename,
			# and there's no way to get it if the file doesn't already exist.
			#
			# Perforce will let you do a "p4 add" on a file that doesn't exist in your local tree yet, then you can
			# do a "p4 fstat" (p4helpers.GetClientFileInfo) on it to find its local filename.
			sCmd = 'p4 add -c %s %s' % (changelistNum, sDepotFilename)
			p4helpers.CheckPerforceReturn( sCmd )
			
			# Get the local filename and copy from the zip file to that.
			sLocalClientFilename = p4helpers.GetClientFileInfo( sDepotFilename )
			if sLocalClientFilename == None:
				AddQueuedWarning( "Unable to add %s. It probably isn't in your client spec." % sDepotFilename )
			else:
				sLocalClientFilename = sLocalClientFilename[0]
				WriteFileFromZip( thePickle.theZipFile, k.replace('\\','/'), sLocalClientFilename )
				
			if g_bVerbose: print "\t" + k

	if g_bVerbose: print "Deleting %d files..." % len( thePickle.filesDeleted )
	for k in thePickle.filesDeleted.keys():
		sDepotFilename = thePickle.relativeToDepotFileMap[k]
		p4helpers.CheckPerforceReturn( 'p4 delete -c %s %s ' % (changelistNum, sDepotFilename) )
		if g_bVerbose: print "\t" + k

	if g_bVerbose: print "Editing %d files..." % len( thePickle.filesEdited )
	for k in thePickle.filesEdited.keys():
		revisionNumber = thePickle.filesEdited[k]
		sDepotFilename = thePickle.relativeToDepotFileMap[k]
		sLocalClientFilename = p4helpers.GetClientFileInfo( sDepotFilename )[0]

		# the zipfiles like forward slashes
		internalfilename = k.replace('\\','/')
		
		# Sync to the revision they had it at, edit, copy the file over, and sync to the latest so Perforce forces a resolve.
		p4helpers.CheckPerforceReturn( 'p4 sync %s#%s' % (sDepotFilename, revisionNumber) )
		p4helpers.CheckPerforceReturn( 'p4 edit -c %s %s' % (changelistNum, sDepotFilename) )
		WriteFileFromZip( thePickle.theZipFile, internalfilename, sLocalClientFilename )
		p4helpers.CheckPerforceReturn( 'p4 sync %s' % sDepotFilename )
		if g_bVerbose: print "\t%s#%s" % (k, revisionNumber)
		
	thePickle.theZipFile.close()

	PrintQueuedWarnings()
			
	if g_FromTree != None:
		print "\n"
		print "    WARNING!!!!! -changetree edited the HEAD revision of the files in new tree."
		print "    So if they have been edited since you checked them out for your"
		print "    code pickle, then you must MANUALLY merge those changes into the new version."


def SetupBinChangelists():
	global g_Changelist	
	clientInfo = p4helpers.GetClientInfo()
	pendingChanges = p4helpers.GetPendingChanges( clientInfo[ 'Client' ] )
	for changeList in pendingChanges:
		if ( changeList[ 'desc' ].find( 'Visual Studio Auto Checkout' ) <> -1 ):
			g_Changelist.append( changeList[ 'change' ] )

def AutoFillChangelistArray():
	global g_bBinsOnly
	global g_RunMode
	global g_bPickleAllChanges
	global g_Changelist

	if ( g_bBinsOnly and g_RunMode == RUNMODE_BACKUP ):
		SetupBinChangelists()
	
	elif g_bPickleAllChanges:
		clientInfo = p4helpers.GetClientInfo()
		pendingChanges = p4helpers.GetPendingChanges( clientInfo[ 'Client' ] )
		for changeList in pendingChanges:
			g_Changelist.append( changeList['change'] )
			
		g_Changelist.append( 'default' )
		
	elif len( g_Changelist ) == 0 and g_RunMode == RUNMODE_BACKUP:
		g_Changelist.append( 'default' )


def CheckFileExcludedByPatterns( sFilename ):
	global g_IncludeGlobPatterns
	global g_ExcludeGlobPatterns

	bInclude = ( len( g_IncludeGlobPatterns ) == 0 ) # include by default
	for includePattern in g_IncludeGlobPatterns:
		if glob.fnmatch.fnmatch( sFilename, includePattern ):
			bInclude = True
			break
	if not bInclude:
		if g_bVerbose: print "skipping %s, doesn't match any include pattern" % sFilename
		return True

	for excludePattern in g_ExcludeGlobPatterns:
		if glob.fnmatch.fnmatch( sFilename, excludePattern ):
			if g_bVerbose: print "skipping %s matches exclude pattern %s" % ( sFilename, excludePattern )
			return True
			
	return False



def DoBackup( sClientRoot, sZipFilename, bAutoRevert ):
	global g_Changelist
	global g_ChangelistInfoFilename
	global g_ChangelistComment

	filesDeleted = {}
	filesAdded = {}
	filesEdited = {}

	#
	# Filter out all the files that aren't of the changelist we want.
	#
	openedFiles = p4helpers.ReadPerforceOutput( 'p4 -G opened' )[1]
	changelistfiles = [x for x in openedFiles if ( x['change'] in g_Changelist ) ]

	# Ok, there's something to do. Open the zip file.
	theZipFile = zipfile.ZipFile( sZipFilename, 'w', zipfile.ZIP_DEFLATED )

	#
	#
	#
	relativeToDepotFileMap = {}
	
	for openedFile in changelistfiles:
		# Get the local client filename.
		depotFile = openedFile['depotFile']		# (//valvegames/main/src/etc....)
		x = p4helpers.GetClientFileInfo( depotFile )
		
		localFilename = x[0]
		sFriendlyName = localFilename[ len(sClientRoot)+1: ]	# ONLY for printing messages
		
		# Get the filename in the zipfile. We're just going to use the depot filename and make it palatable to the zipfile.
		# You could easily restore the depot filename from this filename, but for now we're just looking it up in relativeToDepotFileMap on the receiving end.
		sFilenameInZip = PerforceToZipFilename( depotFile )

		# Check include and exclude patterns and skip this file if necessary.
		if CheckFileExcludedByPatterns( sFilenameInZip ):
			continue
		
		relativeToDepotFileMap[sFilenameInZip] = depotFile

		# Don't do anything if it's a delete.
		action = x[2]
		
		bCopy = True
		if action == 'delete':
			filesDeleted[sFilenameInZip] = 1
			bCopy = False
			print "%s (DELETE)" % (sFriendlyName)
		else:
			if os.access( localFilename, os.F_OK ) == True:
				theZipFile.write( localFilename, sFilenameInZip )
			else:
				print "\n**\n** WARNING: File '%s' is in the changelist but not on disk. It will not be in the zipfile.\n**\n" % sFriendlyName
			
			if action == 'add':
				filesAdded[sFilenameInZip] = 1
				print "%s (ADD)" % (sFriendlyName)
			else:
				filesEdited[sFilenameInZip] = openedFile['rev']
				print "%s#%s" % (sFriendlyName, openedFile['rev'])
	
		# Revert the file..
		if bAutoRevert == True:
			p4helpers.CheckPerforceReturn( 'p4 revert ' + localFilename )


	# Save the metadata about add/delete/edit and file revisions.
	data = pickle.dumps( [filesDeleted, filesAdded, filesEdited] )
	theZipFile.writestr( g_ChangelistInfoFilename + '.TXT', data )
	
	# Save v2 data.
	ci2 = CV2Data()
	ci2.changelistComment = g_ChangelistComment
	data = pickle.dumps( ci2 )
	theZipFile.writestr( g_ChangelistInfoFilename + 'v2.TXT', data )
	
	# Save v3 data.
	ci3 = CV3Data()
	ci3.relativeToDepotFileMap = relativeToDepotFileMap
	data = pickle.dumps( ci3 )
	theZipFile.writestr( g_ChangelistInfoFilename + 'v3.TXT', data )
	

	# 
	# Write a human-readable changelist file.
	#
	theZipFile.writestr( 'ReadableChangelist.txt', g_ChangelistComment )
	
	theZipFile.close()


def DoEmptyPickle( sZipFilename ):
	global g_ChangelistComment

	filesDeleted = {}
	filesAdded = {}
	filesEdited = {}

	relativeToDepotFileMap = {}

	# Ok, there's something to do. Open the zip file.
	theZipFile = zipfile.ZipFile( sZipFilename, 'w', zipfile.ZIP_DEFLATED )

	# Save the metadata about add/delete/edit and file revisions.
	data = pickle.dumps( [filesDeleted, filesAdded, filesEdited] )
	theZipFile.writestr( g_ChangelistInfoFilename + '.TXT', data )
	
	# Save v2 data.
	ci2 = CV2Data()
	ci2.changelistComment = g_ChangelistComment
	data = pickle.dumps( ci2 )
	theZipFile.writestr( g_ChangelistInfoFilename + 'v2.TXT', data )
	
	# Save v3 data.
	ci3 = CV3Data()
	ci3.relativeToDepotFileMap = relativeToDepotFileMap
	data = pickle.dumps( ci3 )
	theZipFile.writestr( g_ChangelistInfoFilename + 'v3.TXT', data )
	

	# 
	# Write a human-readable changelist file.
	#
	theZipFile.writestr( 'ReadableChangelist.txt', g_ChangelistComment )
	
	theZipFile.close()



def DoDiff( sZipFilename, sDiffDir ):
	# Load the zipfile.
	thePickle = VCodePickle()
	thePickle.Load( sZipFilename )

	sTempFilesDir = os.path.join( sDiffDir, "tempfiles" )

	# Get rid of the old directory.
	if os.access( sDiffDir, os.F_OK ) == True:
		theinput = raw_input( "Warning: This will clear out %s. Proceed (y/N)? " % sDiffDir )
		if theinput == '' or theinput.lower() == 'n':
			print "Exiting."
			sys.exit( 0 )
		
		# Delete all the files.
		# This method is lame but if we use unlink() on a network path, you won't be able to delete them
		# next time around or even from that command line. You can delete them from an explorer window, but 
		# not from the command prompt anymore. Strange.
		os.system( 'rd /s /q "%s"' % sDiffDir )
				
	# Create the directories.
	os.makedirs( sTempFilesDir )
	
	# Dump out the changelist description.
	f = open( os.path.join( sDiffDir, "changelist.txt" ), 'wt' )
	f.write( thePickle.changelistComment )
	f.close()	
	
	# Dump out all the files.
	for sFilename in thePickle.filesEdited.keys():
		# The zipfile utils like forward slashes.
		sInternalFilename = sFilename.replace('\\','/')
		
		# Write the file to tempfiles\basefilename
		sEditedFilename = os.path.join( sTempFilesDir, os.path.basename( sInternalFilename ) )
		WriteFileFromZip( thePickle.theZipFile, sInternalFilename, sEditedFilename )
		
		# Have Perforce write out the prior version.
		nFileRevision = int( thePickle.filesEdited[sFilename] )
		sPriorFilename = os.path.join( sTempFilesDir, os.path.basename( sInternalFilename ) ) + '.prev'
		p4helpers.ReadPerforceOutput( 'p4 -G print -o %s %s#%d' % (sPriorFilename, thePickle.relativeToDepotFileMap[sFilename], nFileRevision) )
		
		# Write out a batch file with the diff command.
		sBatchFilename = os.path.join( sDiffDir, sInternalFilename.replace( '/', '-' ) ) + '.bat'
		fp = open( sBatchFilename, 'wt' )
		sPercent = '%'
		fp.write( """		
			@echo off
			setlocal
			""" )
		fp.write( "set sPriorFilename=%s\n" % sPriorFilename )
		fp.write( "set sEditedFilename=%s\n" % sEditedFilename )

		fp.write( """		
			rem // ------------------------------------------------------------------------------------------------------------------------ //
			rem // First, check if a P4DIFF environment variable exists.
			rem // ------------------------------------------------------------------------------------------------------------------------ //
			set diffProg=%P4DIFF%
			if "%diffprog%" == "" (
				goto CheckRegistry
			)

			:DoDiff
			"%diffProg%" %sPriorFilename% %sEditedFilename%
			goto End

			rem // ------------------------------------------------------------------------------------------------------------------------ //
			rem // No P4DIFF? Ok, check for what P4Win has setup as its diff program.
			rem // The nasty for command there basically runs the reg command, does away with stderr output, pipes the output
			rem // to FINDSTR to strip out everything but the second line which contains the result we want. Then it takes the relevant
			rem // part of the end of that line, which is what we care about.
			rem // ------------------------------------------------------------------------------------------------------------------------ //
			:CheckRegistry
			for /F "tokens=2* delims=REG_SZ" %%a in ('reg query HKEY_CURRENT_USER\Software\Perforce\P4win\Options /v DiffApp 2^>nul ^| FINDSTR DiffApp') do set initialValue=%%a
			if "%initialValue%" == "" (
				set diffProg=p4diff.exe
			) else (
				for /F "tokens=*" %%s in ("%initialValue%") do set diffProg=%%s
			)
			goto DoDiff
			
			:End

			""" )
			
		# Now the batch file references the diff program. Just add the arguments we care about.
		fp.close()
		
		print "Wrote %s" % sBatchFilename
	
	thePickle.theZipFile.close()
	
	# Open up that directory.
	os.system( 'start %s' % sDiffDir )

	


def main():
	global g_bVerbose
	global g_RunMode
	global g_ZipFilename
	global g_bAutoRevert
	global g_bBinsOnly
	global g_bPickleAllChanges
	global g_Changelist
	global g_IncludeGlobPatterns
	global g_ExcludeGlobPatterns
	global g_ChangelistInfoFilename
	global g_ChangelistComment
	global g_DiffDir
	global g_bShowUI
	global g_DefaultFilename
	global g_bCreateDiff
	
	
	#
	# Parse out the command line.
	#
	try:
		opts, args = getopt.getopt( sys.argv[1:], "bdrf:c:ri:e:?q",
									[ "prompt", "diff", "diffdir=", "backup", "restore", "file=", "bins", "changelist=", "revert", "include=", "exclude=", "quiet", "help", "empty" ] )
	except getopt.GetoptError, e:
		print ""
		print "Argument error: ", e
		print ""
		ShowUsage()
		sys.exit(1)

	bPrompt = False
	for o, a in opts:
		if o in ( "-?", "--help" ):
			ShowUsage()
			sys.exit(1)
		if o in ( "-q", "--quiet" ):
			g_bVerbose = False
		if o in ( "--prompt" ):
			bPrompt = True
		if o in ( "-b", "--backup" ):
			assert( g_RunMode == RUNMODE_NONE )
			g_RunMode = RUNMODE_BACKUP
		if o in ( "-r", "--restore" ):
			assert( g_RunMode == RUNMODE_NONE )
			g_RunMode = RUNMODE_RESTORE
		if o in ( "-e", "--empty" ):
			assert( g_RunMode == RUNMODE_NONE )
			g_RunMode = RUNMODE_EMPTY
		if o in ( "-d", "--diff" ):
			g_bCreateDiff = True
		if o.lower() == "--diffdir" :
			g_DiffDir = a
		if o in ( "-f", "--file" ):
			g_ZipFilename = a
			if g_ZipFilename[-4:].lower() != '.zip':
				g_ZipFilename += '.zip'
		if o in ( "-c", "--changelist" ):
			if a in ( 'all', '*' ):
				g_bPickleAllChanges = True
			else:
				g_Changelist.append( a )
		if o.lower() == "--bins":
			g_bBinsOnly = True
		if o in ( "--revert" ):
			g_bAutoRevert = True
		if o in ( "-i", "--include" ):
			g_IncludeGlobPatterns.append( a )
		if o in ( "-e", "--exclude" ):
			g_ExcludeGlobPatterns.append( a )

	if g_RunMode == RUNMODE_NONE and not g_bCreateDiff:
		ShowUsage()
		sys.exit( 1 )

	if ( g_RunMode == RUNMODE_RESTORE or g_RunMode == RUNMODE_EMPTY ) and len( g_ZipFilename ) == 0 and not bPrompt:
		print >>sys.stderr, "\n*** file parameter is required in restore/empty mode ***\n\n\n"
		ShowUsage()
		sys.exit( 1 )

	if len(g_Changelist) and g_bBinsOnly and g_RunMode == RUNMODE_BACKUP:
		print >>sys.stderr, "\n*** -c and --bins are mutally exclusive ***\n\n\n"
		ShowUsage()
		sys.exit( 1 )

	if ( len( g_IncludeGlobPatterns ) or len( g_ExcludeGlobPatterns ) ) and g_RunMode != RUNMODE_BACKUP:
		print >>sys.stderr, "\n*** -i/-e apply only in backup mode ***\n\n\n"
		ShowUsage()
		sys.exit(1)
			
	g_Settings = LoadSettingsFile( g_SettingsFilename )

	# Auto-fill g_Changelist if necessary.
	AutoFillChangelistArray()
		

	if g_RunMode == RUNMODE_BACKUP:
		#
		# Get the string for the changelist.
		#
		sDate = datetime.datetime.now().strftime("%Y-%m-%d__%Hh-%Mm-%Ss")
		if g_Changelist[0] == 'default':
			g_ChangelistComment = 'vcodepickle: ' + os.path.basename(g_ZipFilename)
			g_DefaultFilename = 'VCP_' + sDate + '.zip'
		else:
			g_ChangelistComment = GetChangelistComment( g_Changelist[0] )
			partOfChangelistComment = GetReadableChangelistComment( g_ChangelistComment )
			g_DefaultFilename = 'VCP_' + partOfChangelistComment + '_' + sDate + '.zip'

		#
		# Generate a default zip filename if they didn't specify one. 
		#
		# Either we'll use a mixture of the current date and their changelist text
		# and if it was launched from a Perforce tool (used the -ui) parameter,
		# we'll let them specify where to save it (and default to \\fileserver\user\username\[the date and the changelist comment])
		#
		if bPrompt == True:
			ShowUIForFilename()
		else:
			#
			# Non-ui mode. Just use what they entered on the command line or use the default if they didn't enter anything.
			#
			if len( g_ZipFilename ) == 0:
				SetZipFilename( g_DefaultFilename )

		
	g_ClientInfo = p4helpers.GetClientInfo()

	# Get the root directory without a trailing slash.
	g_ClientRoot = g_ClientInfo['Root']
	if g_ClientRoot[-1:] == '\\' or g_ClientRoot[-1:] == '/':
		g_ClientRoot = g_ClientRoot[:-1]

	if g_bVerbose:
		print "\n---- vcodepickle ----"
		print "zipfile        : " + g_ZipFilename
		print "p4 client root : " + g_ClientRoot
		if g_bAutoRevert == True:
			print "-revert specified"
		print "-----------------------"
		print ""



	if g_RunMode == RUNMODE_BACKUP:
		DoBackup( g_ClientRoot, g_ZipFilename, g_bAutoRevert )
	if g_RunMode == RUNMODE_EMPTY:
		DoEmptyPickle( g_ZipFilename )
	
	elif g_RunMode == RUNMODE_RESTORE:
		if bPrompt:
			username = os.environ['username']
			g_ZipFilename = PromptForOpenZipFilename( g_ClientRoot, DefaultPickleDirName(username) )
			if g_ZipFilename != None:
				DoRestore( g_ClientRoot, g_ZipFilename )
		else:
			DoRestore( g_ClientRoot, g_ZipFilename )
	
	if g_bCreateDiff:
		print "\n\nPreparing diff...\n"
		username = os.environ['username']
		if g_DiffDir == '':
			g_DiffDir = DefaultPickleDiffName(username)
				
		if bPrompt and ( g_RunMode != RUNMODE_BACKUP ):	# If RUNMODE_BACKUP, then g_ZipFilename is already set to a valid thing.
			g_ZipFilename = PromptForOpenZipFilename( g_ClientRoot, DefaultPickleDirName(username) )
			if g_ZipFilename != None:
				DoDiff( g_ZipFilename, g_DiffDir )
		else:
			DoDiff( g_ZipFilename, g_DiffDir )



if __name__ == '__main__':
	main()