def executableTarget(self, config, targetName):
cmakeTargetToRun = None
for cmakeConfiguration in self.codeModel["configurations"]:
if cmakeConfiguration["name"] == '' or cmakeConfiguration[
"name"] == config:
self.logger.debug("Found config: %s",
cmakeConfiguration["name"])
for cmakeProject in cmakeConfiguration["projects"]:
self.logger.debug(" Found project: %s",
cmakeProject["name"])
for cmakeTarget in cmakeProject["targets"]:
self.logger.debug(" Found target: %s",
cmakeTarget["name"])
if cmakeTarget["name"] == targetName:
cmakeTargetToRun = cmakeTarget
if not cmakeTargetToRun:
raise error.ProgramArgumentError("Couldn't find module %s" %
self.args.target)
if cmakeTargetToRun["type"] != "EXECUTABLE":
raise error.ProgramArgumentError("Module %s is not an executable" %
self.args.target)
return cmakeTargetToRun
def run(self, configuration):
if not self.args.target:
raise error.ProgramArgumentError("Please specify a module name with --module MODULE")
if not self.args.platform:
raise error.ProgramArgumentError("Please specify the platform name with --platform PLATFORM")
if not self.args.config:
raise error.ProgramArgumentError("Please specify the configuration name with --config CONFIG")
if configuration.platform == "ios":
if configuration.arch == "device":
raise error.ProgramArgumentError("Can't run on ios devices yet")
if configuration.arch == "std" and configuration.buildsystem == 'Xcode':
raise error.ProgramArgumentError("Can't run on ios devices yet, specifiy architecture 'simulator' to run.")
iosRunner = IOSRunner(self.buildExecutor.cmake)
exitCode = iosRunner.run(configuration, self.args)
elif configuration.platform == "android":
if configuration.buildsystem == "AndroidStudio":
androidRunner = AndroidRunner(self.buildFolder, self.androidExecutor)
exitCode = androidRunner.run(configuration, self.args)
else:
self.logger.critical("Only AndroidStudio configurations can be run")
exit(1)
else:
appRunner = DesktopRunner(self.buildExecutor.cmake, configuration, self.args)
exitCode = appRunner.run()
if exitCode != 0:
raise error.ErrorWithExitCode( "Application failed with exit code: 0x{:02x}".format(exitCode), exitCode)
def generate(self, args):
template_folder = os.path.normpath(
os.path.join(os.path.realpath(__file__), '..', 'templates', 'app'))
boden_folder = os.path.normpath(
os.path.join(os.path.realpath(__file__), '..', '..'))
project_folder = os.path.join(os.path.abspath(args.project_folder),
args.project_name)
if os.path.exists(project_folder) and len(
os.listdir(project_folder)) > 0:
raise error.ProgramArgumentError(
"Selected folder %s is not empty!" % project_folder)
boden_relative_path = os.path.relpath(boden_folder, project_folder)
vars = {
'project_name': args.project_name,
'project_folder': project_folder,
'boden_relative_path': boden_relative_path
}
self.logger.info("Creating project in %s", project_folder)
shutil.copytree(template_folder, project_folder)
for entries in os.walk(project_folder):
for file in entries[2]:
self.process_template(os.path.join(entries[0], file), vars)
def runExecutable(self, artifactToRun, args):
self.ios_simulator_device_type = self.iosInfo.getSelectedDeviceType(
args)
self.ios_simulator_os = self.iosInfo.getSelectedOS(args)
self.logger.debug("IOS Device type: %s",
self.ios_simulator_device_type)
self.logger.debug("IOS Simulator OS: %s", self.ios_simulator_os)
self.logger.debug("Executable: %s", artifactToRun)
if not artifactToRun:
raise error.ProgramArgumentError(
"Couldn't find path to exectuable for Module %s" % args.target)
if artifactToRun.endswith('.app') and os.path.isdir(artifactToRun):
r = self.readPList(os.path.join(artifactToRun, "Info.plist"))
executable = r["CFBundleExecutable"]
artifactToRun = os.path.join(artifactToRun, executable)
if not os.path.exists(artifactToRun):
raise error.ProgramArgumentError(
"exectuable for Module %s does not exists at: %s" %
(args.target, artifactToRun))
bundlePath = self.getBundlePathFromExecutable(artifactToRun)
bundleId = self.getBundleIdentifier(bundlePath)
self.logger.debug("Bundle Identifier: %s", bundleId)
simulatorId = None
try:
simulatorId = self.createSimulatorDevice()
self.logger.debug("Simulator Id: %s", simulatorId)
self.bootSimulator(simulatorId)
self.installApp(simulatorId, bundlePath)
processId = self.startApp(simulatorId, bundleId, args)
self.waitForAppToExit(simulatorId, processId, bundleId)
finally:
if simulatorId:
self.shutdownSimulator(simulatorId)
return 0
def findDeviceType(self, name):
deviceTypes = self.getAvailableDeviceTypes()
if name in deviceTypes:
return deviceTypes[name]
self.logger.critical("Couldn't find Device type %s", name)
self.logger.info("Available device types:")
for name, deviceId in deviceTypes.items():
self.logger.info(" %s" % (name))
raise error.ProgramArgumentError("--ios-device-type invalid")
def unlockKeychain(self, keychainPath, password):
self.logger.debug('Unlock: %s *****', keychainPath)
currentKeychains = self.getCurrentKeychains()
if not keychainPath in currentKeychains:
raise error.ProgramArgumentError('Keychain %s is not registered!' %
keychainPath)
result = self.callAndGetError(
[self.sec, 'unlock-keychain', '-p', password, keychainPath])
if len(result) > 0:
self.logger.critical(result)
def generate(self, args):
template_folder = os.path.normpath(
os.path.join(os.path.realpath(__file__), '..', 'templates', 'app'))
boden_folder = os.path.normpath(
os.path.join(os.path.realpath(__file__), '..', '..'))
project_folder = os.path.join(os.path.abspath(args.project_folder),
args.project_name)
if os.path.exists(project_folder) and len(
os.listdir(project_folder)) > 0:
raise error.ProgramArgumentError(
"Selected folder %s is not empty!" % project_folder)
if args.project_name == 'test':
raise error.ProgramArgumentError(
"'test' is not a valid project name, since cmake regards it as a special target!"
)
if "-" in args.project_name:
raise error.ProgramArgumentError(
"You cannot use '-' in the project name, as Android can not handle it"
)
boden_relative_path = os.path.relpath(boden_folder, project_folder)
vars = {
'project_name': args.project_name,
'project_folder': project_folder,
'boden_relative_path': boden_relative_path
}
self.logger.info("Creating project in %s", project_folder)
shutil.copytree(template_folder, project_folder)
for entries in os.walk(project_folder):
for file in entries[2]:
self.process_template(os.path.join(entries[0], file), vars)
def findSimulatorOS(self, name):
versions = self.getAvailableSimulatorOSVersions()
if ' ' in name:
n, version = name.split(' ')[:2]
fversion = float(version)
if n in versions:
if fversion in versions[n]:
return versions[n][fversion]
self.logger.critical("Couldn't find iOS version %s", name)
self.logger.info("Available versions:")
for type, v in versions.items():
for version in v.keys():
self.logger.info(" %s %s" % (type, version))
raise error.ProgramArgumentError("--ios-simulator-version invalid")
def run(self):
cmakeTargetToRun = self.cmake.executableTarget(self.args.config,
self.args.target)
artifactToRun = self.cmake.executableArtifactPath(cmakeTargetToRun)
self.logger.debug("Executable: %s", artifactToRun)
if not artifactToRun:
raise error.ProgramArgumentError(
"Couldn't find path to exectuable for Module %s" %
self.args.target)
self.logger.debug("Path: %s", artifactToRun)
if sys.platform == "win32":
return self.runWindowsApplication(artifactToRun)
else:
return self.runUnixApplication(artifactToRun)
def process(self):
command = self.args.command;
self.logger.debug('Starting command: %s', command)
selectedConfigurations = self.buildFolder.getBuildConfigurationsForCommand();
self.logger.debug("Selected platform list:")
for config in selectedConfigurations:
self.logger.debug("* %s", config)
if len(selectedConfigurations)==0:
defaultLadderKey = (self.args.platform, self.args.build_system)
architecture = self.args.arch
configuration = self.args.config
if not architecture:
architecture = "std"
if defaultLadderKey in self.defaultLadder:
defaults = self.defaultLadder[defaultLadderKey]
self.logger.info("Defaulting to: %s - %s" % (defaults[0], defaults[1]))
selectedConfigurations = [
BuildConfiguration(platform=defaults[0], arch=architecture, buildsystem=defaults[1], config=configuration)
]
else:
raise error.IncorrectCallError("Could not determine default platform / buildsystem ( and configuration ). Please specifiy one via -p, -b (and -c)")
for configuration in selectedConfigurations:
if configuration.platform not in self.bauerGlobals.platformMap:
raise error.InvalidPlatformNameError(configuration.platform);
buildDirectory = self.buildFolder.getBuildDir(configuration)
with GeneratorState(buildDirectory) as platformState:
if not "build-configuration" in platformState.state or BuildConfiguration(*platformState.state["build-configuration"]) != configuration:
if os.path.exists(buildDirectory):
self.logger.info("Build system does not match the one used when the projects for this platform were first prepared. Cleaning existing build files.");
if "build-configuration" in platformState.state:
self.logger.debug("Old config: ", BuildConfiguration(*platformState.state["build-configuration"]))
else:
self.logger.debug("(No previous state found)")
self.logger.debug("New config: %s", configuration)
shutil.rmtree(buildDirectory);
platformState.state["build-configuration"] = configuration;
if command=="prepare":
self.prepare(configuration, platformState);
elif command=="build":
self.prepare(configuration, platformState);
self.build(configuration);
elif command=="clean":
self.clean(configuration);
elif command=="distclean":
self.distClean(buildDirectory);
elif command=="builddeps":
self.buildDeps(configuration);
elif command=="run":
self.prepare(configuration, platformState);
#self.build(configuration);
self.run(configuration);
elif command=="package":
self.prepare(configuration, platformState);
self.package(configuration);
elif command=="codesign":
self.prepare(configuration, platformState);
self.codesign(configuration)
elif command=="copy":
self.copy(buildDirectory)
elif command=="open":
self.prepare(configuration, platformState)
self.open(configuration, buildDirectory)
else:
raise error.ProgramArgumentError("Invalid command: '%s'" % command);
