249 lines
9.3 KiB
Python
Executable File
249 lines
9.3 KiB
Python
Executable File
#!/usr/bin/env python
|
|
"""
|
|
Script for generating distributables based on platform skeletons.
|
|
|
|
User supplies path for pyfa code base, root skeleton directory, and where the
|
|
builds go. The builds are automatically named depending on the pyfa config
|
|
values of `version` and `tag`. If it's a Stable release, the naming
|
|
convention is:
|
|
|
|
pyfa-pyfaversion-expansion-expversion-platform
|
|
|
|
If it is not Stable (tag=git), we determine if the pyfa code base includes
|
|
the git repo to use as an ID. If not, uses randomly generated 6-character ID.
|
|
The unstable naming convention:
|
|
|
|
pyfa-YYYMMDD-id-platform
|
|
|
|
dist.py can also build the Windows installer provided that it has a path to
|
|
Inno Setup (and, for generating on non-Windows platforms, that WINE is
|
|
installed). To build the EXE file, `win` must be included in the platforms to
|
|
be built.
|
|
"""
|
|
|
|
#@todo: ensure build directory can be written to
|
|
# todo: default build and dist directories
|
|
|
|
from optparse import OptionParser
|
|
import os.path
|
|
import shutil
|
|
import sys
|
|
import tarfile
|
|
import datetime
|
|
import random
|
|
import string
|
|
import zipfile
|
|
import errno
|
|
from subprocess import call
|
|
|
|
class FileStub():
|
|
def write(self, *args):
|
|
pass
|
|
|
|
def flush(self, *args):
|
|
pass
|
|
|
|
def copyanything(src, dst):
|
|
try:
|
|
shutil.copytree(src, dst, ignore=loginfo)
|
|
except: # python >2.5
|
|
try:
|
|
shutil.copy(src, dst)
|
|
except:
|
|
raise
|
|
|
|
def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
|
|
return ''.join(random.choice(chars) for x in range(size))
|
|
|
|
def zipdir(path, zip):
|
|
for root, dirs, files in os.walk(path):
|
|
for file in files:
|
|
zip.write(os.path.join(root, file))
|
|
|
|
skels = ['win', 'mac', 'src', 'win-wx3']
|
|
iscc = "C:\Program Files (x86)\Inno Setup 5\ISCC.exe" # inno script location via wine
|
|
|
|
if __name__ == "__main__":
|
|
oldstd = sys.stdout
|
|
parser = OptionParser()
|
|
parser.add_option("-s", "--skeleton", dest="skeleton", help="Location of Pyfa-skel directory")
|
|
parser.add_option("-b", "--base", dest="base", help="Location of cleaned read-only base directory")
|
|
parser.add_option("-d", "--destination", dest="destination", help="Where to copy our distributable")
|
|
parser.add_option("-p", "--platforms", dest="platforms", help="Comma-separated list of platforms to build", default="win,src,mac")
|
|
parser.add_option("-q", "--quiet", dest="silent", action="store_true")
|
|
parser.add_option("-w", "--winexe", dest="winexe", action="store_true", help="Build the Windows installer file (needs Inno Setup). Must include 'win' in platform options")
|
|
parser.add_option("-z", "--zip", dest="zip", action="store_true", help="zip archive instead of tar")
|
|
|
|
options, args = parser.parse_args()
|
|
|
|
if options.skeleton is None or options.base is None or options.destination is None:
|
|
print "Need --skeleton argument as well as --base and --destination argument"
|
|
parser.print_help()
|
|
sys.exit()
|
|
|
|
if options.silent:
|
|
sys.stdout = FileStub()
|
|
|
|
options.platforms = options.platforms.split(",")
|
|
|
|
#sys.path.append(options.base)
|
|
#import config as pyfaconfig
|
|
|
|
for skel in skels:
|
|
if skel not in options.platforms:
|
|
continue
|
|
|
|
print "\n======== %s ========"%skel
|
|
|
|
info = {}
|
|
config = {}
|
|
skeleton = os.path.expanduser(os.path.join(options.skeleton, skel))
|
|
|
|
execfile(os.path.join(options.base, "config.py"), config)
|
|
execfile(os.path.join(skeleton, "info.py"), info)
|
|
|
|
destination = os.path.expanduser(options.destination)
|
|
if not os.path.isdir(destination) or not os.access(destination, os.W_OK | os.X_OK):
|
|
print "Destination directory does not exist or is not writable: {}".format(destination)
|
|
sys.exit()
|
|
|
|
dirName = info["arcname"]
|
|
|
|
nowdt = datetime.datetime.now()
|
|
now = "%04d%02d%02d" % (nowdt.year, nowdt.month, nowdt.day)
|
|
|
|
git = False
|
|
if config['tag'].lower() == "git":
|
|
try: # if there is a git repo associated with base, use master commit
|
|
with open(os.path.join(options.base, ".git", "refs", "heads", "master"), 'r') as f:
|
|
id = f.readline()[0:6]
|
|
git = True
|
|
except: # else, use custom ID
|
|
id = id_generator()
|
|
fileName = "pyfa-{}-{}-{}".format(now, id, info["os"])
|
|
else:
|
|
fileName = "pyfa-{}-{}-{}-{}".format(
|
|
config['version'],
|
|
config['expansionName'].lower(),
|
|
config['expansionVersion'],
|
|
info["os"]
|
|
)
|
|
|
|
archiveName = "{}.{}".format(fileName, "zip" if options.zip else "tar.bz2")
|
|
dst = os.path.join(os.getcwd(), dirName) # tmp directory where files are copied
|
|
tmpFile = os.path.join(os.getcwd(), archiveName)
|
|
|
|
i = 0
|
|
ignoreData = (".git", ".gitignore", ".gitmodules", "dist_assets", "saveddata", "build", "dist", "scripts", ".idea")
|
|
def loginfo(path, names):
|
|
# Print out a "progress" and return directories / files to ignore
|
|
global i
|
|
i += 1
|
|
if i % 10 == 0:
|
|
sys.stdout.write(".")
|
|
sys.stdout.flush()
|
|
return ignoreData
|
|
|
|
try:
|
|
print "Copying skeleton to ", dst
|
|
i = 0
|
|
shutil.copytree(skeleton, dst, ignore=loginfo)
|
|
print
|
|
if "win-wx3" not in skel:
|
|
# simply copying base into working build
|
|
base = os.path.join(dst, info["base"])
|
|
print "Copying base to ", base
|
|
|
|
i = 0
|
|
for stuff in os.listdir(os.path.expanduser(options.base)):
|
|
currSource = os.path.join(os.path.expanduser(options.base), stuff)
|
|
currDest = os.path.join(base, stuff)
|
|
if stuff in ignoreData:
|
|
continue
|
|
elif os.path.isdir(currSource):
|
|
shutil.copytree(currSource, currDest, ignore=loginfo)
|
|
else:
|
|
shutil.copy2(currSource, currDest)
|
|
|
|
print
|
|
print "Copying done, making archive: ", tmpFile
|
|
else:
|
|
# this should work, but it's barely been tested
|
|
base = os.path.join(dst, info["base"])
|
|
source = os.path.expanduser(options.base)
|
|
sys.path.append(source)
|
|
import setup
|
|
|
|
libraryFile = os.path.join(base, "library.zip")
|
|
|
|
with zipfile.ZipFile(libraryFile, 'a') as library:
|
|
# change cwd to source so that the zip append will work correctly
|
|
oldcwd = os.getcwd()
|
|
os.chdir(source)
|
|
for dir in setup.packages:
|
|
zipdir(dir, library)
|
|
library.write('pyfa.py', 'pyfa__main__.py')
|
|
library.write('config.py')
|
|
|
|
for dir in setup.include_files:
|
|
copyanything(dir, os.path.join(base, dir))
|
|
|
|
os.chdir(oldcwd)
|
|
|
|
if options.zip:
|
|
archive = zipfile.ZipFile(tmpFile, 'w', compression=zipfile.ZIP_DEFLATED)
|
|
zipdir(dirName, archive)
|
|
archive.close()
|
|
else:
|
|
archive = tarfile.open(tmpFile, "w:bz2")
|
|
archive.add(dst, arcname=info["arcname"])
|
|
archive.close()
|
|
|
|
print "Moving archive to ", destination
|
|
shutil.move(tmpFile, destination)
|
|
|
|
if "win" in skel and options.winexe:
|
|
print "Compiling EXE"
|
|
|
|
if config['tag'].lower() == "git":
|
|
if git: # if git repo info available, use git commit
|
|
expansion = "git-%s"%(id)
|
|
else: # if there is no git repo, use timestamp
|
|
expansion = now
|
|
else: # if code is Stable, use expansion name
|
|
expansion = "%s %s"%(config['expansionName'], config['expansionVersion']),
|
|
|
|
calllist = ["wine"] if 'win' not in sys.platform else []
|
|
|
|
call(calllist + [
|
|
iscc,
|
|
os.path.join(os.path.dirname(__file__), "pyfa-setup.iss"),
|
|
"/dMyAppVersion=%s"%(config['version']),
|
|
"/dMyAppExpansion=%s"%(expansion),
|
|
"/dMyAppDir=%s"%dst,
|
|
"/dMyOutputDir=%s"%destination,
|
|
"/dMyOutputFile=%s"%fileName]) #stdout=devnull, stderr=devnull
|
|
|
|
print "EXE completed"
|
|
|
|
except Exception as e:
|
|
print "Encountered an error: \n\t", e
|
|
raise
|
|
finally:
|
|
print "Deleting tmp files\n"
|
|
try:
|
|
try:
|
|
shutil.rmtree("dist") # Inno dir
|
|
except:
|
|
pass
|
|
shutil.rmtree(dst)
|
|
os.unlink(tmpFile)
|
|
except:
|
|
pass
|
|
|
|
sys.stdout = oldstd
|
|
if os.path.isdir(destination):
|
|
print os.path.join(destination, os.path.split(tmpFile)[1])
|
|
else:
|
|
print destination
|