" :-/ Changing the font size also causes problems.
# The following fudging seems to give us something that's somewhat reasonable... :-/
if re.search( r"width:\s*?\d+?px", snippet_info["content"] ):
width = int( width * 140 / 100 )
elem.set( "width", str(width) )
elem.set( "height", str(height) )
except Exception as ex: #pylint: disable=broad-except
# NOTE: Don't let an error here stop the process.
logging.error( "Can't get snippet screenshot: %s", ex )
logging.error( traceback.format_exc() )
ET.ElementTree( root ).write( fp )
return root
def _parse_label_report( fname ):
"""Read the label report generated by the VASSAL shim."""
doc = ET.parse( fname )
report = {
"was_modified": doc.getroot().attrib["wasModified"] == "true"
}
for action in doc.getroot():
nodes = []
for node in action:
nodes.append( { "id": node.attrib["id"] } )
if "x" in node.attrib and "y" in node.attrib:
nodes[-1]["pos"] = ( node.attrib["x"], node.attrib["y"] )
if "caption" in node.attrib:
nodes[-1]["caption"] = node.attrib["caption"]
if node.text:
nodes[-1]["message"] = node.text
report[ action.tag ] = nodes
return report
# ---------------------------------------------------------------------
@app.route( "/analyze-vsav", methods=["POST"] )
def analyze_vsav(): #pylint: disable=too-many-locals
"""Analyze a VASL scenario file."""
# parse the request
start_time = time.time()
vsav_data = request.json[ "vsav_data" ]
vsav_filename = request.json[ "filename" ]
# initialize
logger = logging.getLogger( "analyze_vsav" )
try:
# get the VSAV data (we do this inside the try block so that the user gets shown
# a proper error dialog if there's a problem decoding the base64 data)
vsav_data = base64.b64decode( vsav_data )
logger.info( "Analyzing VSAV (#bytes=%d): %s", len(vsav_data), vsav_filename )
with TempFile() as input_file:
# save the VSAV data in a temp file
input_file.write( vsav_data )
input_file.close( delete=False )
fname = app.config.get( "ANALYZE_VSAV_INPUT" ) # nb: for diagnosing problems
if fname:
logger.debug( "Saving a copy of the VSAV data: %s", fname )
with open( fname, "wb" ) as fp:
fp.write( vsav_data )
# run the VASSAL shim to analyze the VSAV file
with TempFile() as report_file:
report_file.close( delete=False )
vassal_shim = VassalShim()
vassal_shim.analyze_scenario( input_file.name, report_file.name )
report = _parse_analyze_report( report_file.name )
except Exception as ex: #pylint: disable=broad-except
return VassalShim.translate_vassal_shim_exception( ex, logger )
# translate any remapped GPID's back into their original values
# NOTE: We need to do this e.g. if we're analyzing a scenario that was created using VASL 6.5.0
# and it contains pieces that had their GPID's changed from 6.4.4. This kind of nonsense
# is probably unsustainable over the long-term, but we try to maintain some semblance of
# back-compatibility for as long as we can :-/
report2 = { "pieces": {} }
for gpid,vals in report.items():
orig_gpid = get_reverse_remapped_gpid( globvars.vasl_mod, gpid )
if orig_gpid == gpid:
report2["pieces"][ gpid ] = vals
else:
report2["pieces"][ orig_gpid ] = vals
# extract the VASSAL and VASL versions from the VSAV data
def get_node_text( key, node_name ):
elem = doc.find( "./{}".format( node_name ) )
if elem is not None:
report2[ key ] = elem.text
with zipfile.ZipFile( io.BytesIO( vsav_data ) ) as zfile:
module_data = zfile.read( "moduledata" )
doc = ET.parse( io.BytesIO( module_data ) )
get_node_text( "vassal_version", "VassalVersion" )
get_node_text( "vasl_version", "version" )
# return the results
logger.info( "Analyzed the VSAV file OK: elapsed=%.3fs\n%s",
time.time() - start_time,
pprint.pformat( report2, indent=2, width=120 )
)
return jsonify( report2 )
def _parse_analyze_report( fname ):
"""Read the analysis report generated by the VASSAL shim."""
doc = ET.parse( fname )
report = {}
for node in doc.getroot():
report[ node.attrib["gpid"] ] = { "name": node.attrib["name"], "count": node.attrib["count"] }
return report
# ---------------------------------------------------------------------
class VassalShim:
"""Provide access to VASSAL via the Java shim."""
_vassal_version = None
def __init__( self ): #pylint: disable=too-many-branches
# locate the VASSAL engine
vassal_dir = self._get_vassal_dir()
if not vassal_dir:
raise SimpleError( "The VASSAL installation directory has not been configured." )
self.vengine_jar = None
for root,_,fnames in os.walk( vassal_dir ):
for fname in fnames:
if fname == "Vengine.jar":
self.vengine_jar = os.path.join( root, fname )
break
if not self.vengine_jar:
raise SimpleError( "Can't find Vengine.jar: {}".format( vassal_dir ) )
# locate the VASSAL shim JAR
self.shim_jar = app.config.get( "VASSAL_SHIM" )
if not self.shim_jar:
if IS_FROZEN:
meipass = sys._MEIPASS #pylint: disable=no-member,protected-access
self.shim_jar = os.path.join( meipass, "vasl_templates/webapp/vassal-shim.jar" )
else:
self.shim_jar = os.path.join( os.path.split(__file__)[0], "../../vassal-shim/release/vassal-shim.jar" )
if not os.path.isfile( self.shim_jar ):
raise SimpleError( "Can't find the VASSAL shim JAR." )
# FUDGE! The VASSAL shim looks for a config file in the same directory as itself, but if we are frozen,
# the user runs the executable that unpacks everything to a temp directory and runs from there, and so
# they can't set up the config file. Instead, we allow them to place it in the config/ directory and
# copy it over over to the temp directory, where the VASSAL shim JAR will find it when it runs.
fname = os.path.join( os.path.join(BASE_DIR,"config"), "vassal-shim.properties" )
if os.path.isfile( fname ):
shutil.copy( fname, os.path.split(self.shim_jar)[0] )
@staticmethod
def get_version():
"""Get the VASSAL version."""
if VassalShim._vassal_version:
return VassalShim._vassal_version
vassal_dir = VassalShim._get_vassal_dir()
if not vassal_dir:
return None
# FUDGE! We can't capture the output on Windows, get the result in a temp file instead :-/
with TempFile() as temp_file:
temp_file.close( delete=False )
VassalShim()._run_vassal_shim( "version", temp_file.name ) #pylint: disable=protected-access
with open( temp_file.name, "r", encoding="utf-8" ) as fp:
VassalShim._vassal_version = fp.read()
return VassalShim._vassal_version
@staticmethod
def is_compatible_version( vassal_version, vasl_version ):
"""Check if the VASSAL+VASL versions are compatible."""
return vasl_version in SUPPORTED_VASSAL_VERSIONS.get( vassal_version, [] )
def dump_scenario( self, fname ):
"""Dump a scenario file."""
return self._run_vassal_shim( "dump", fname )
def analyze_scenario( self, vsav_fname, report_fname ):
"""Analyze a scenario file."""
return self._run_vassal_shim(
"analyze", vsav_fname, report_fname
)
def update_scenario( self, vsav_fname, snippets_fname, output_fname, report_fname ):
"""Update a scenario file."""
# locate the boards
return self._run_vassal_shim(
"update", VassalShim.get_boards_dir(), vsav_fname, snippets_fname, output_fname, report_fname
)
def analyze_logfiles( self, *fnames ):
"""Analyze a log file."""
return self._run_vassal_shim(
"analyzeLogs", *fnames
)
def prepare_asa_upload( self, vsave_fname, stripped_vsav_fname, screenshot_fname ):
"""Prepare files for upload to the ASL Scenario Archive."""
return self._run_vassal_shim(
"prepareUpload", vsave_fname, stripped_vsav_fname, screenshot_fname
)
def _run_vassal_shim( self, *args ): #pylint: disable=too-many-locals
"""Run the VASSAL shim."""
# NOTE: If VASSAL is taking a really long time to run (when it's loading the VASL module),
# check if any NIC's are enabled, but there isn't actually any internet access. I suspect
# that VASL is checking for something online, and taking a really long time to time-out.
# If there are no NIC's, then the attempt to connect fails immediately, but there are,
# the networking stack tries to find a route online.
# initialize
logger = logging.getLogger( "vassal_shim" )
# locate the Java runtime
java_path = get_java_path()
java8_path = app.config.get( "JAVA8_PATH" )
if java8_path:
# FUDGE! From 3.3, VASSAL no longer works with Java 8. We want to mantain back-compatibility
# with the older versions of VASL (6.5.1 and older) for some time, and while it's not a big issue
# from the user's perspective (they just configure the appropriate VASSAL+VASL), it's problematic
# for the test suite (since it has to be able to run the correct version of Java for the VASSAL
# being used). We do this here, and since it's just for the purpose of running tests, we can
# require that the VASSAL version be embedded in the filename.
# NOTE: I eventually gave up trying to maintain back-compat with older versions of VASL, but
# the GPID remapping test (test_gpid_remapping() in test_counters.py) is an important one,
# but is currently only relevant for 6.4.4 and 6.5.0-.1, so for the sole purpose of being able
# to run those tests, we still support Java 8. Sigh...
mo = re.search( r"\d+\.\d+\.\d+", self.vengine_jar )
if compare_version_strings( mo.group(), "3.3.0" ) < 0:
# we're using a legacy version of VASSAL - use Java 8
java_path = java8_path
# prepare the command
class_path = app.config.get( "JAVA_CLASS_PATH" )
if not class_path:
class_path = [ self.vengine_jar, self.shim_jar ]
class_path.append( os.path.split( self.shim_jar )[0] ) # nb: to find logback(-test).xml
if IS_FROZEN:
class_path.append( BASE_DIR ) # nb: also to find logback(-test).xml
sep = ";" if os.name == "nt" else ":"
class_path = sep.join( class_path )
args2 = [
java_path, "-classpath", class_path, "vassal_shim.Main",
args[0]
]
if args[0] in ("dump","analyze","analyzeLogs","update","prepareUpload"):
if not globvars.vasl_mod:
raise SimpleError( "The VASL module has not been configured." )
args2.append( globvars.vasl_mod.filename )
args2.extend( args[1:] )
# figure out how long to the let the VASSAL shim run
# NOTE: This used to be 2 minutes, but adding the ability to load images from the internet
# slows the process down, since VASSAL loads images insanely slowly :-/
timeout = int( app.config.get( "VASSAL_SHIM_TIMEOUT", 5*60 ) )
if timeout <= 0:
timeout = None
# run the VASSAL shim
logger.info( "Running VASSAL shim (timeout=%s): %s", str(timeout), " ".join(args2) )
start_time = time.time()
# NOTE: We can't use pipes to capture the output here when we're frozen on Windows ("invalid handle" errors),
# I suspect because we freeze the application using --noconsole, which causes problems when
# the child process tries to inherit handles. Capturing the output in temp files also fails (!),
# as does using subprocess.DEVNULL (!!!) Setting close_fds when calling Popen() also made no difference.
# The only thing that worked was removing "--noconsole" when freezing the application, but that causes
# a DOS box to appear when we are run :-/
# However, we can also not specify any stdout/stderr, and since we don't actually check the output,
# we can get away with this, even if it is a bit icky :-/ However, if the VASSAL shim throws an error,
# we won't be able to show the stack trace, just a generic "VASSAL shim failed" message :-(
with TempFile() as buf1, TempFile() as buf2:
kwargs = {}
if not ( os.name == "nt" and IS_FROZEN ):
kwargs = { "stdout": buf1.temp_file, "stderr": buf2.temp_file }
if os.name == "nt":
# NOTE: Using CREATE_NO_WINDOW doesn't fix the problem of VASSAL's UI sometimes appearing,
# but it does hide the DOS box if the user has configured java.exe instead of javaw.exe.
kwargs["creationflags"] = 0x8000000 # nb: win32process.CREATE_NO_WINDOW
try:
with subprocess.Popen( args2, **kwargs ) as proc:
try:
proc.wait( timeout )
except subprocess.TimeoutExpired:
proc.kill()
raise
except FileNotFoundError as ex:
raise SimpleError( "Can't run the VASSAL shim (have you configured Java?): {}".format( ex ) ) from ex
buf1.close( delete=False )
with open( buf1.name, "r", encoding="utf-8" ) as fp:
stdout = fp.read()
buf2.close( delete=False )
with open( buf2.name, "r", encoding="utf-8" ) as fp:
stderr = fp.read()
elapsed_time = time.time() - start_time
logger.info( "- Completed OK: %.3fs", elapsed_time )
# check the result
stderr = stderr.replace( "Warning: Could not get charToByteConverterClass!", "" ).strip()
# NOTE: VASSAL's internal representation of a scenario seems to be tightly coupled with its UI,
# which means that when we load a scenario, bits of the UI sometimes start appearing (although not always,
# presumably because there's a race between how fast we can make our changes and save the scenario
# vs. how fast the UI can start up :-/). When the UI does start to appear, it fails, presumably because
# we haven't performed the necessary startup incantations, and dumps a stack trace to stderr.
# The upshot is that the only thing we look for is an exit code of 0, which means that the VASSAL shim
# saved the scenario successfully and exited cleanly; any output on stderr means that some part
# of VASSAL barfed as it was trying to start up and can (hopefully) be safely ignored.
if stderr:
logger.warning( "VASSAL shim stderr output:\n%s", stderr )
if proc.returncode != 0:
raise VassalShimError( proc.returncode, stdout, stderr )
return stdout
@staticmethod
def get_boards_dir():
"""Get the configured boards directory."""
boards_dir = app.config.get( "BOARDS_DIR" )
if not boards_dir:
raise SimpleError( "The VASL boards directory has not been configured." )
if not os.path.isdir( boards_dir ):
raise SimpleError( "Can't find the VASL boards: {}".format( boards_dir ) )
return boards_dir
@staticmethod
def translate_vassal_shim_exception( ex, logger ):
"""Convert an exception thrown by the VassalShim to a JSON response to return to the caller."""
if isinstance( ex, VassalShimError ):
logger.error( "VASSAL shim error: rc=%d", ex.retcode )
if ex.retcode != 0:
return jsonify( {
"error": "Unexpected return code from the VASSAL shim: {}".format( ex.retcode ),
"stdout": ex.stdout,
"stderr": ex.stderr,
} )
return jsonify( {
"error": "Unexpected error output from the VASSAL shim.",
"stdout": ex.stdout,
"stderr": ex.stderr,
} )
if isinstance( ex, subprocess.TimeoutExpired ):
return jsonify( {
"error": "The VASSAL shim took too long to run, please try again." \
"
If this problem persists, try configuring a longer timeout."
} )
if isinstance( ex, SimpleError ):
logger.error( "VASSAL shim error: %s", ex )
return jsonify( { "error": str(ex) } )
logger.error( "Unexpected VASSAL shim error: %s", ex )
return jsonify( {
"error": str(ex),
"stdout": traceback.format_exc(),
} )
@staticmethod
def check_vassal_version( msg_store ):
"""Check the version of VASSAL."""
if not VassalShim._get_vassal_dir() or not msg_store:
return
try:
version = VassalShim.get_version()
except Exception as ex: #pylint: disable=broad-except
if msg_store:
# NOTE: We get here if Java is unable to run the VASSAL shim e.g. because it's too much older
# than the version used to compile the shim. We normally show the user detailed error output
# from VASSAL in a dialog, but getting the VASSAL version number is a bit different, since it's
# an unsolicited action done as we start up, so showing the error to the user is problematic,
# since we don't have a way to trigger the dialog. We could add a new field to MsgStore for
# detailed messages that should be shown in a dialog, but what if e.g. there's more than one?
# It gets messy real fast, so we just extract the important part of the error output and
# show it to the user in a normal error balloon.
msg = str( ex )
if isinstance( ex, VassalShimError ):
mo = re.search( r'Exception in thread "main" (.+?)$', ex.stderr or ex.stdout, re.MULTILINE )
if mo:
msg = mo.group( 1 )
msg_store.error( "Can't get the VASSAL version:
{}
",
html.escape( msg )
)
return
if version not in SUPPORTED_VASSAL_VERSIONS:
if msg_store:
msg_store.warning(
"This program has not been tested with VASSAL {}.Things might work, but they might not...",
version
)
elif globvars.vasl_mod:
if not VassalShim.is_compatible_version( version, globvars.vasl_mod.vasl_version ):
if msg_store:
msg_store.error(
"VASSAL {} and VASL {} are not compatible.".format( version, globvars.vasl_mod.vasl_version ),
version
)
@staticmethod
def _get_vassal_dir():
"""Get the VASSAL installation directory."""
return app.config.get( "VASSAL_DIR" )
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
class VassalShimError( Exception ):
"""Represents an error returned by the VASSAL shim."""
def __init__( self, retcode, stdout, stderr ):
super().__init__()
self.retcode = retcode
self.stdout = stdout
self.stderr = stderr
def __str__( self ):
return "VassalShim error: rc={}".format( self.retcode )