# -c, --calc APP | Run using the specified calc application. By default
# calcif2 will be used.
# |
-D, --difx VERSION | Run using a specific DiFX version. If not specified
# the value of the DIFX_VERSION environment variable will
# be used. Failing that, "DIFX-DEVEL" will be used.
# |
-h, --help | Print help information and quit.
# |
-H, --hostname NAME | Use NAME as the host of the DiFX Server program.
# Default is to use DIFX_CONTROL_HOST environment variable.
# |
-P, --port PORT | Use PORT as the TCP port to communicated with the DiFX Server.
# Default is to use DIFX_CONTROL_PORT environment variable.
# |
--svex FILE | Use the LOCAL file as the "source" of the .vex data. This file
# will be copied to the experiment directory, which will be created.
# This option is similar to the -vex option, but it allows you to use
# a local file. The full path to the local file should be given.
# |
--sv2d FILE | Use the LOCAL file as the "source" of the .v2d data. This file
# will be copied to the experiment directory, which will be created.
# This option is similar to the -v2d option, but it allows you to use
# a local file. The full path to the local file should be given.
# |
-t, --timeout SEC | Use SEC seconds as the timeout value for each job. This is the
# amount of time DiFXrun will wait before it gives up on a
# "silent" (i.e. no messages received from) job and declares it
# non-responsive. Default value is 300.0.
# |
--vex PATH | Copy the .vex file given by PATH (the full path to it on the
# DiFX server) to the experiment directory.
# |
--v2d PATH | Copy the .v2d file given by PATH (the full path to it on the
# DiFX server) to the experiment directory.
# |
" % ( sys.argv[0] )
print ""
print "Options can include:"
print ""
print " --calc APP"
print " -c APP Run the calc process using the given calc application. If"
print " not specified the default \"calcif2\" will be used."
print ""
print " --difx VERSION"
print " -D VERSION Run using a specific DiFX version. If not specified"
print " the value of the DIFX_VERSION environment variable will"
print " be used. Failing that, \"DIFX-DEVEL\" will be used."
print ""
print " --help"
print " -h Print this help information and quit."
print ""
print " --hostname NAME"
print " -H NAME Use NAME as the host of the difxServer program."
print " Default is to use DIFX_CONTROL_HOST environment variable."
print ""
print " --port PORT"
print " -P PORT Use PORT as the TCP port to communicated with the difxServer."
print " Default is to use DIFX_CONTROL_PORT environment variable."
print ""
print " --sv2d FILE Use the LOCAL file as the \"source\" of the .v2d data. This file"
print " will be copied to the experiment directory, which will be created."
print " This option is similar to the --v2d option, but it allows you to use"
print " a local file. The full path to the local file should be given."
print ""
print " --vex PATH Copy the .vex file given by PATH (the full path to it on the"
print " DiFX server) to the directory."
print ""
print " --v2d PATH Copy the .v2d file given by PATH (the full path to it on the"
print " DiFX server) to the directory. Giving the full path to a .v2d file triggers"
print " the creation of the directory."
print ""
exit( 0 )
elif sys.argv[i] in [ "-c", "--calc" ]:
calcCommand = sys.argv[i+1]
i = i + 2
elif sys.argv[i] in [ "-H", "--hostname" ]:
host = sys.argv[i+1]
i = i + 2
elif sys.argv[i] in [ "-D", "--difx" ]:
DiFXVersion = sys.argv[i+1]
i = i + 2
elif sys.argv[i] in [ "-P", "--port" ]:
port = int( sys.argv[i+1] )
i = i + 2
elif sys.argv[i] in [ "--sv2d" ]:
v2dLocal = sys.argv[i+1]
i = i + 2
elif sys.argv[i] in [ "-t", "--timeout" ]:
timeout = int( sys.argv[i+1] )
i = i + 2
elif sys.argv[i] in [ "--vex" ]:
vexPath = sys.argv[i+1]
i = i + 2
elif sys.argv[i] in [ "--v2d" ]:
v2dPath = sys.argv[i+1]
i = i + 2
else:
passDir = sys.argv[i]
i = i + 1
except RuntimeError:
print "Usage: %s [options] <.input path>" % ( sys.argv[0] )
exit( 0 )
# If no directory was specified, but a .v2d path was, assume we are supposed
# to create jobs using the .v2d file.
if passDir == None:
if v2dPath != None:
# Extract the pass path and v2d file name out of the v2dPath.
try:
idx = v2dPath.rindex( "/" )
passDir = v2dPath[:idx]
v2dFile = v2dPath[idx + 1:]
except ValueError:
print "Improper path name in v2d path."
exit( 0 )
else:
print "No path for the experiment was provided."
exit( 0 )
else:
# See if the v2dPath specification begins with a "/" character. This means
# the directory should be created (if necessary) and the file at this path
# copied to it.
if v2dPath != None and v2dPath[0] == '/':
copyRemote = v2dPath
try:
idx = v2dPath.rindex( "/" )
v2dFile = v2dPath[idx + 1:]
except ValueError:
print "Unable to extract .v2d file name from \"" + v2dPath + "\"."
exit( 0 )
createDir = True
# There might also be a local file we want to use as the .v2d file.
elif v2dLocal != None and v2dLocal[0] == '/':
copyLocal = v2dLocal
try:
idx = v2dLocal.rindex( "/" )
v2dFile = v2dLocal[idx + 1:]
except ValueError:
print "Unable to extract .v2d file name from \"" + v2dLocal + "\"."
exit( 0 )
createDir = True
# If the .v2d file specification does not have path information, it is assumed
# to be in the directory, which is assumed to exist (we'll check all of this of
# course!).
elif v2dPath != None:
v2dFile = v2dPath
else:
# See if the passDir contains a .v2d file name already.
try:
idx = passDir.rindex( ".v2d" )
try:
inx = passDir.rindex( "/" )
if inx > idx or len( passDir ) - idx != 4:
print "Path \"" + passDir + "\" may contain a .v2d file but looks wrong."
exit( 0 )
else:
v2dFile = passDir[inx + 1:]
passDir = passDir[:inx]
except ValueError:
print "Path \"" + passDir + "\" may contain a .v2d file but looks wrong."
exit( 0 )
except ValueError:
# Didn't find the .v2d file name, so we'll need to look in the directory
# for it, if that directory exists. If it DOESN'T, we'll create it and make
# a new .v2d file containing only a .vex specification, if that was given.
buildMissingV2d = True
locateV2d = True
# Check the directory name.
if passDir[0] != "/":
print "Experiment directory \"" + passDir + "\" must be a complete path."
exit( 0 )
# Start the vex2difx class, set the version, etc.
print "Making client connection..."
difx = DiFXvex2difx.Client()
difx.connect()
if not difx.socketOK:
difx.close()
exit( 0 )
difx.monitor()
difx.waitTime( timeout )
difx.version( DiFXVersion )
# It is possible we need to build a new .v2d file. We will only do this when the
# specified directory path does not exist and a .vex specification is supplied
# with no .v2d specification.
if buildMissingV2d:
# Do we have a .vex specification?
if vexPath != None:
# Make sure the specified directory does not exist. If it doesn't, cause
# it to be created.
dirList = difx.ls( passDir )
if dirList == None:
createDir = True
locateV2d = False
# Create the specified directory if we are doing that - before we do so, make
# sure it doesn't exist already!.
if createDir:
dirList = difx.ls( passDir )
if dirList == None:
# Directory doesn't exist!
print "Creating directory \"" + passDir + "\"."
difx.mkdir( passDir )
else:
print "\"" + passDir + "\" exists."
# See that the pass directory exists.
dirList = difx.ls( passDir, "-l -d" )
if dirList == None:
# Directory doesn't exist!
if createDir:
print "\"" + passDir + "\" does not exist - creating the directory must have failed."
else:
print "this is what we are doing"
print "\"" + passDir + "\" does not exist!"
difx.close()
exit( 0 )
else:
# Something was returned by the ls command, but we need to be sure it is a directory
# and that we can write there.
lineData = dirList[0]
# First character should be a "d" - or its not a directory!
if lineData[0] != "d":
print "\"" + passDir + "\" does not appear to be a directory."
difx.close()
exit( 0 )
# Test of we can write something there
difx.sendFile( passDir + "/thisisatest", "this is a test" )
dirList = difx.ls( passDir + "/thisisatest" )
if dirList == None:
print "\"" + difx.serverUser + "\" does not appear to have write permission for \"" + passDir + "\"."
difx.close()
exit( 0 )
else:
difx.rm( passDir + "/thisisatest" )
# Locate a .v2d file in that directory if we need to do that.
if locateV2d:
dirList = difx.ls( passDir + "/*.v2d" )
if dirList == None:
print "Directory \"" + passDir + "\" does not contain any .v2d files."
difx.close()
exit( 0 )
else:
try:
idx = dirList[0].rfind( "/" )
v2dFile = dirList[0][idx + 1:]
print "Using existing .v2d file \"" + v2dFile + "\" from directory \"" + passDir + "\"."
except:
print "Problem parsing a legal .v2d file from \"" + dirList[0] + "\"."
difx.close()
exit( 0 )
# Make a copy of a remote .v2d file if so specified.
fileStr = None
if copyRemote != None:
# Make sure the remote file exists.
dirList = difx.ls( copyRemote )
if dirList == None:
print "No file \"" + copyRemote + "\" exists on the DiFX server."
difx.close()
exit( 0 )
# Make sure we can read it (this also gives us the contents, which we use below).
fileStr = difx.getFile( copyRemote )
if fileStr == None or len( fileStr ) == 0:
print "File \"" + copyRemote + "\" cannot be read on the DiFX server."
difx.close()
exit( 0 )
# Or make a copy of a local .v2d file if so specified.
elif copyLocal != None:
try:
f = open( copyLocal )
except IOError:
print ".v2d file \"" + copyLocal + "\" does not exist on the local machine."
difx.close()
exit( 0 )
fileStr = f.read()
if len( fileStr ) == 0:
print ".v2d file \"" + copyLocal + "\" has zero length."
difx.close()
exit( 0 )
elif buildMissingV2d:
fileStr = "vex = " + vexPath
v2dFile = "auto.v2d"
print "Creating new .v2d file containing only .vex specification."
# Either a remote or local .v2d file need to be altered to show the proper .vex path and
# then copied to the new experiment directory.
if copyRemote or copyLocal or buildMissingV2d:
# Were we given a .vex specification? If so, copy that file to the new directory.
# If not, get the full path of the "vex" instruction from the .v2d content and
# copy that. In either case, the .v2d content must be altered to point to this
# new .vex file.
if vexPath == None and not buildMissingV2d:
# Locate the vexPath in the .v2d file.
v2dLines = fileStr.splitlines()
foundVexSpec = False
for line in v2dLines:
if not foundVexSpec and line.strip()[0:3] == "vex" and line.strip()[3:].strip()[0] == "=":
foundVexSpec = True
vexPath = line.strip()[3:].strip()[1:].strip()
# See if this .vex path is "complete", in that it contains a full path. We can only
# guess at this - we assume it is complete if the first character is a slash. If
# not, use the path of the .v2d file as its path (the source of the .vex file
# must be a complete path).
if vexPath[0] != "/":
# Not a full path - add the path to the .v2d file. We can only do this if it is a remote
# file.
if copyRemote != None:
try:
idx = copyRemote.rfind( "/" )
vexPath = copyRemote[:idx] + "/" + vexPath
except ValueError:
print "Problem creating a complete path to .vex file \"" + vexPath + "\"."
difx.close()
exit( 0 )
print "Using \"" + vexPath + "\" as .vex file source."
else:
print ".v2d file contains incomplete path \"" + vexPath + "\" to .vex file."
difx.close()
exit( 0 )
if vexPath == None:
if copyRemote != None:
print "No .vex file specification in \"" + copyRemote + "\" - illegal .v2d file!"
else:
print "No .vex file specification in \"" + copyLocal + "\" - illegal .v2d file!"
difx.close()
exit( 0 )
# Make sure the specified .vex exists.
vexContent = difx.getFile( vexPath )
if vexContent == None or len( vexContent ) == 0:
print "File \"" + vexPath + "\" cannot be read on the DiFX server."
difx.close()
exit( 0 )
# Split the file name off of the full path - we'll use the same name in our new directory
vexFile = None
try:
idx = vexPath.rindex( "/" )
if idx < len( vexPath ) - 2:
difx.sendFile( passDir + "/" + vexPath[idx + 1:], vexContent )
vexFile = vexPath[idx + 1:]
else:
print "No valid .vex file name in \"" + vexPath + "\"."
difx.close()
exit( 0 )
except ValueError:
print "Unable to find .vex file name in \"" + vexPath + "\"."
difx.close()
exit( 0 )
# Replace the name of the .vex file in the .v2d with our new file (no path)
# so that all job creation will be local.
if vexFile == None:
# This shouldn't be possible.
print "Unknown .vex file."
difx.close()
exit( 0 )
# Split up the .v2d content and locate the .vex specification.
v2dLines = fileStr.splitlines()
foundVexSpec = False
counter = 0
for line in v2dLines:
if not foundVexSpec and line.strip()[0:3] == "vex" and line.strip()[3:].strip()[0] == "=":
foundVexSpec = True
v2dLines[counter] = "vex = " + vexFile + "\n"
counter = counter + 1
fileStr = "\n".join( v2dLines )
difx.sendFile( passDir + "/" + v2dFile, fileStr )
# Make sure the .v2d file now exists in the specified directory.
dirList = difx.ls( passDir + "/" + v2dFile );
if dirList == None:
print "\"" + passDir + "/" + v2dFile + "\" does not exist."
difx.close()
exit( 0 )
# Add callback functions for different results
difx.newFileCallback( newFileCallback )
difx.processCompleteCallback( processCompleteCallback )
# Set the calc command if the user has set it, otherwise go with the default
if calcCommand != None:
difx.calcCommand( calcCommand )
difx.v2dFile( v2dFile )
difx.passPath( passDir )
difx.runVex2Difx()
difx.close()