def spawnRezManagedCommandWatcher(pidfile, logfile, args, watcherPackages, env):
"""
| Uses rez module to start a process with a proper rez env.
:param pidfile: full path to the comand pid file (usally /var/run/puli/cw<command_id>.pid)
:param logfile: file object to store process log content
:param args: arguments passed to the CommandWatcher script
:param watcherPackages: A list of packages that will be resolved when creating Rez context
:param env: a dict holding key/value pairs that will be merged into the current env and used in subprocess
:return: a CommandWatcherProcess object holding command watcher process handle
"""
try:
from rez.resources import clear_caches
from rez.resolved_context import ResolvedContext
from rez.resolver import ResolverStatus
except ImportError as e:
LOGGER.error("Unable to load rez package in a rez managed environment.")
raise e
try:
if watcherPackages is None:
LOGGER.warning("No package specified for this command, it might not find the runner for this command.")
watcherPackagesList = []
elif type(watcherPackages) in [str, unicode]:
watcherPackagesList = watcherPackages.split()
else:
watcherPackagesList = watcherPackages
clear_caches()
context = ResolvedContext(watcherPackagesList)
success = (context.status == ResolverStatus.solved)
if not success:
context.print_info(buf=sys.stderr)
raise
# normalize environment
# JSA do not transmit env (eg PYTHONHOME) to command watcher
# envN = os.environ.copy()
envN = {}
for key in env:
envN[str(key)] = str(env[key])
proc = context.execute_shell(
command=args,
shell='bash',
stdin=False,
stdout=logfile,
stderr=subprocess.STDOUT,
block=False,
parent_environ=envN
)
LOGGER.info("Starting subprocess, log: %r, args: %r" % (logfile.name, args))
except Exception as e:
LOGGER.error("Impossible to start process: %s" % e)
raise e
file(pidfile, "w").write(str(proc.pid))
return CommandWatcherProcess(proc, pidfile, proc.pid)
def _run(self, prefix_char, args):
import argparse
parser = argparse.ArgumentParser(prog=self.tool_name,
prefix_chars=prefix_char)
def _add_argument(*nargs, **kwargs):
nargs_ = []
for narg in nargs:
nargs_.append(narg.replace('=', prefix_char))
parser.add_argument(*nargs_, **kwargs)
_add_argument("=a",
"==about",
action="store_true",
help="print information about the tool")
_add_argument(
"=i",
"==interactive",
action="store_true",
help="launch an interactive shell within the tool's configured "
"environment")
_add_argument("=p",
"==patch",
type=str,
nargs='*',
metavar="PKG",
help="run the tool in a patched environment")
_add_argument("==versions",
action="store_true",
help="list versions of package providing this tool")
_add_argument(
"==command",
type=str,
nargs='+',
metavar=("COMMAND", "ARG"),
help="read commands from string, rather than executing the tool")
_add_argument(
"==stdin",
action="store_true",
help=
"read commands from standard input, rather than executing the tool"
)
_add_argument(
"==strict",
action="store_true",
help="strict patching. Ignored if ++patch is not present")
_add_argument("==nl",
"==no-local",
dest="no_local",
action="store_true",
help="don't load local packages when patching")
_add_argument(
"==peek",
action="store_true",
help="diff against the tool's context and a re-resolved copy - "
"this shows how 'stale' the context is")
_add_argument("==verbose",
action="count",
default=0,
help="verbose mode, repeat for more verbosity")
_add_argument(
"==quiet",
action="store_true",
help="hide welcome message when entering interactive mode")
_add_argument(
"==no-rez-args",
dest="no_rez_args",
action="store_true",
help="pass all args to the tool, even if they start with '%s'" %
prefix_char)
opts, tool_args = parser.parse_known_args(args)
if opts.no_rez_args:
args = list(args)
args.remove("==no-rez-args".replace('=', prefix_char))
tool_args = args
opts = parser.parse_args([])
# print info
if opts.about:
return self.print_about()
elif opts.versions:
return self.print_package_versions()
elif opts.peek:
return self.peek()
# patching
context = self.context
if opts.patch is not None:
new_request = opts.patch
request = context.get_patched_request(new_request,
strict=opts.strict)
config.remove_override("quiet")
pkg_paths = (config.nonlocal_packages_path
if opts.no_local else None)
context = ResolvedContext(request,
package_paths=pkg_paths,
verbosity=opts.verbose)
# reapply quiet mode (see cli.forward)
if "REZ_QUIET" not in os.environ:
config.override("quiet", True)
if opts.stdin:
# generally shells will behave as though the '-s' flag was not present
# when no stdin is available. So here we replicate this behaviour.
import select
try:
if not select.select([sys.stdin], [], [], 0.0)[0]:
opts.stdin = False
except select.error:
pass # because windows
# construct command
cmd = None
if opts.command:
cmd = opts.command
elif opts.interactive:
label = self.context_name
if opts.patch:
label += '*'
config.override("prompt", "%s>" % label)
cmd = None
else:
cmd = [self.tool_name] + tool_args
retcode, _, _ = context.execute_shell(command=cmd,
stdin=opts.stdin,
quiet=opts.quiet,
block=True)
return retcode
def run_test(self, test_name):
"""Run a test.
Runs the test in its correct environment. Note that if tests share the
same requirements, the contexts will be reused.
TODO: If the package had variants, the test will be run for each
variant.
Returns:
int: Returncode - zero if all test(s) passed, otherwise the return
code of the failed test.
"""
def print_header(txt, *nargs):
pr = Printer(sys.stdout)
pr(txt % nargs, heading)
package = self.get_package()
if test_name not in self.get_test_names():
raise PackageTestError("Test '%s' not found in package %s"
% (test_name, package.uri))
if self.use_current_env:
return self._run_test_in_current_env(test_name)
for variant in package.iter_variants():
# get test info for this variant. If None, that just means that this
# variant doesn't provide this test. That's ok - 'tests' might be
# implemented as a late function attribute that provides some tests
# for some variants and not others
#
test_info = self._get_test_info(test_name, variant)
if not test_info:
continue
command = test_info["command"]
requires = test_info["requires"]
# expand refs like {root} in commands
if isinstance(command, basestring):
command = variant.format(command)
else:
command = map(variant.format, command)
# show progress
if self.verbose:
print_header(
"\nTest: %s\nPackage: %s\n%s\n",
test_name, variant.uri, '-' * 80)
# create test env
key = tuple(requires)
context = self.contexts.get(key)
if context is None:
if self.verbose:
print_header("Resolving test environment: %s\n",
' '.join(map(quote, requires)))
context = ResolvedContext(package_requests=requires,
package_paths=self.package_paths,
buf=self.stdout,
timestamp=self.timestamp,
**self.context_kwargs)
if not context.success:
context.print_info(buf=self.stderr)
raise PackageTestError(
"Cannot run test '%s' of package %s: the environment "
"failed to resolve" % (test_name, variant.uri))
self.contexts[key] = context
# run the test in the context
if self.verbose:
context.print_info(self.stdout)
if isinstance(command, basestring):
cmd_str = command
else:
cmd_str = ' '.join(map(quote, command))
print_header("\nRunning test command: %s\n" % cmd_str)
retcode, _, _ = context.execute_shell(
command=command,
stdout=self.stdout,
stderr=self.stderr,
block=True)
if retcode:
return retcode
# TODO FIXME we don't iterate over all variants yet, because we
# can't reliably do that (see class docstring)
break
return 0 # success
def _run(self, prefix_char, args):
from rez.vendor import argparse
parser = argparse.ArgumentParser(prog=self.tool_name,
prefix_chars=prefix_char)
def _add_argument(*nargs, **kwargs):
nargs_ = []
for narg in nargs:
nargs_.append(narg.replace('=', prefix_char))
parser.add_argument(*nargs_, **kwargs)
_add_argument(
"=a", "==about", action="store_true",
help="print information about the tool")
_add_argument(
"=i", "==interactive", action="store_true",
help="launch an interactive shell within the tool's configured "
"environment")
_add_argument(
"=p", "==patch", type=str, nargs='*', metavar="PKG",
help="run the tool in a patched environment")
_add_argument(
"==versions", action="store_true",
help="list versions of package providing this tool")
_add_argument(
"==command", type=str, nargs='+', metavar=("COMMAND", "ARG"),
help="read commands from string, rather than executing the tool")
_add_argument(
"==stdin", action="store_true",
help="read commands from standard input, rather than executing the tool")
_add_argument(
"==strict", action="store_true",
help="strict patching. Ignored if ++patch is not present")
_add_argument(
"==nl", "==no-local", dest="no_local", action="store_true",
help="don't load local packages when patching")
_add_argument(
"==peek", action="store_true",
help="diff against the tool's context and a re-resolved copy - "
"this shows how 'stale' the context is")
_add_argument(
"==verbose", action="count", default=0,
help="verbose mode, repeat for more verbosity")
_add_argument(
"==quiet", action="store_true",
help="hide welcome message when entering interactive mode")
_add_argument(
"==no-rez-args", dest="no_rez_args", action="store_true",
help="pass all args to the tool, even if they start with '%s'" % prefix_char)
opts, tool_args = parser.parse_known_args(args)
if opts.no_rez_args:
args = list(args)
args.remove("==no-rez-args".replace('=', prefix_char))
tool_args = args
opts = parser.parse_args([])
# print info
if opts.about:
return self.print_about()
elif opts.versions:
return self.print_package_versions()
elif opts.peek:
return self.peek()
# patching
context = self.context
if opts.patch is not None:
new_request = opts.patch
request = context.get_patched_request(new_request, strict=opts.strict)
config.remove_override("quiet")
pkg_paths = (config.nonlocal_packages_path
if opts.no_local else None)
context = ResolvedContext(request,
package_paths=pkg_paths,
verbosity=opts.verbose)
# reapply quiet mode (see cli.forward)
if "REZ_QUIET" not in os.environ:
config.override("quiet", True)
if opts.stdin:
# generally shells will behave as though the '-s' flag was not present
# when no stdin is available. So here we replicate this behaviour.
import select
if not select.select([sys.stdin], [], [], 0.0)[0]:
opts.stdin = False
# construct command
cmd = None
if opts.command:
cmd = opts.command
elif opts.interactive:
label = self.context_name
if opts.patch:
label += '*'
config.override("prompt", "%s>" % label)
cmd = None
else:
cmd = [self.tool_name] + tool_args
retcode, _, _ = context.execute_shell(command=cmd,
stdin=opts.stdin,
quiet=opts.quiet,
block=True)
return retcode
def command(opts, parser, extra_arg_groups=None):
from rez.resolved_context import ResolvedContext
from rez.resolver import ResolverStatus
from rez.package_filter import PackageFilterList, Rule
from rez.utils.formatting import get_epoch_time_from_str
from rez.config import config
import select
import sys
import os
import os.path
command = opts.command
if extra_arg_groups:
if opts.command:
parser.error("argument --command: not allowed with arguments after '--'")
command = extra_arg_groups[0] or None
context = None
request = opts.PKG
t = get_epoch_time_from_str(opts.time) if opts.time else None
if opts.isolated:
config.inherit_parent_environment = False
if opts.inherited:
config.inherit_parent_environment = True
if opts.paths is None:
pkg_paths = (config.nonlocal_packages_path
if opts.no_local else None)
else:
pkg_paths = opts.paths.split(os.pathsep)
pkg_paths = [os.path.expanduser(x) for x in pkg_paths if x]
if opts.input:
if opts.PKG and not opts.patch:
parser.error("Cannot use --input and provide PKG(s), unless patching.")
context = ResolvedContext.load(opts.input)
if opts.patch:
if context is None:
from rez.status import status
context = status.context
if context is None:
print("cannot patch: not in a context", file=sys.stderr)
sys.exit(1)
# modify the request in terms of the given patch request
request = context.get_patched_request(request,
strict=opts.strict,
rank=opts.patch_rank)
context = None
if opts.self:
from rez.utils._version import _rez_version
request += ["bleeding_rez==%s" % _rez_version]
request += ["python"] # Required by Rez
if context is None:
# create package filters
if opts.no_filters:
package_filter = PackageFilterList()
else:
package_filter = PackageFilterList.singleton.copy()
for rule_str in (opts.exclude or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_exclusion(rule)
for rule_str in (opts.include or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_inclusion(rule)
# perform the resolve
context = ResolvedContext(package_requests=request,
timestamp=t,
package_paths=pkg_paths,
building=opts.build,
package_filter=package_filter,
add_implicit_packages=(not opts.no_implicit),
verbosity=opts.verbose,
max_fails=opts.max_fails,
time_limit=opts.time_limit,
caching=(not opts.no_cache),
suppress_passive=opts.no_passive,
print_stats=opts.stats)
success = (context.status == ResolverStatus.solved)
if not success:
context.print_info(buf=sys.stderr)
if opts.fail_graph:
if context.graph:
from rez.utils.graph_utils import view_graph
g = context.graph(as_dot=True)
view_graph(g)
else:
print("the failed resolve context did not generate a graph.", file=sys.stderr)
if opts.output:
if opts.output == '-': # print to stdout
context.write_to_buffer(sys.stdout)
else:
context.save(opts.output)
sys.exit(0 if success else 1)
if not success:
sys.exit(1)
if opts.env:
env = {}
for pair in opts.env:
key, value = pair.split("=")
env[key.upper()] = value
config.additional_environment = env
# generally shells will behave as though the '-s' flag was not present when
# no stdin is available. So here we replicate this behaviour.
try:
if opts.stdin and not select.select([sys.stdin], [], [], 0.0)[0]:
opts.stdin = False
except select.error:
pass # because windows
quiet = opts.quiet or bool(command)
returncode, _, _ = context.execute_shell(
shell=opts.shell,
rcfile=opts.rcfile,
norc=opts.norc,
command=command,
stdin=opts.stdin,
quiet=quiet,
start_new_session=opts.new_session,
detached=opts.detached,
pre_command=opts.pre_command,
block=True)
sys.exit(returncode)
def run_test(self, test_name):
"""Run a test.
Runs the test in its correct environment. Note that if tests share the
same requirements, the contexts will be reused.
TODO: If the package had variants, the test will be run for each
variant.
Returns:
int: Returncode - zero if all test(s) passed, otherwise the return
code of the failed test.
"""
def print_header(txt, *nargs):
pr = Printer(sys.stdout)
pr(txt % nargs, heading)
package = self.get_package()
if test_name not in self.get_test_names():
raise PackageTestError("Test '%s' not found in package %s" %
(test_name, package.uri))
if self.use_current_env:
return self._run_test_in_current_env(test_name)
for variant in package.iter_variants():
# get test info for this variant. If None, that just means that this
# variant doesn't provide this test. That's ok - 'tests' might be
# implemented as a late function attribute that provides some tests
# for some variants and not others
#
test_info = self._get_test_info(test_name, variant)
if not test_info:
continue
command = test_info["command"]
requires = test_info["requires"]
# expand refs like {root} in commands
if isinstance(command, basestring):
command = variant.format(command)
else:
command = map(variant.format, command)
# show progress
if self.verbose:
print_header("\nTest: %s\nPackage: %s\n%s\n", test_name,
variant.uri, '-' * 80)
# create test env
key = tuple(requires)
context = self.contexts.get(key)
if context is None:
if self.verbose:
print_header("Resolving test environment: %s\n",
' '.join(map(quote, requires)))
context = ResolvedContext(package_requests=requires,
package_paths=self.package_paths,
buf=self.stdout,
timestamp=self.timestamp,
**self.context_kwargs)
if not context.success:
context.print_info(buf=self.stderr)
raise PackageTestError(
"Cannot run test '%s' of package %s: the environment "
"failed to resolve" % (test_name, variant.uri))
self.contexts[key] = context
# run the test in the context
if self.verbose:
context.print_info(self.stdout)
if isinstance(command, basestring):
cmd_str = command
else:
cmd_str = ' '.join(map(quote, command))
print_header("\nRunning test command: %s\n" % cmd_str)
retcode, _, _ = context.execute_shell(command=command,
stdout=self.stdout,
stderr=self.stderr,
block=True)
if retcode:
return retcode
# TODO FIXME we don't iterate over all variants yet, because we
# can't reliably do that (see class docstring)
break
return 0 # success
def command(opts, parser, extra_arg_groups=None):
from rez.resolved_context import ResolvedContext
from rez.resolver import ResolverStatus
from rez.package_filter import PackageFilterList, Rule
from rez.utils.formatting import get_epoch_time_from_str
from rez.config import config
import select
import sys
import os
import os.path
command = opts.command
if extra_arg_groups:
if opts.command:
parser.error(
"argument --command: not allowed with arguments after '--'")
command = extra_arg_groups[0] or None
context = None
request = opts.PKG
t = get_epoch_time_from_str(opts.time) if opts.time else None
if opts.paths is None:
pkg_paths = (config.nonlocal_packages_path if opts.no_local else None)
else:
pkg_paths = opts.paths.split(os.pathsep)
pkg_paths = [os.path.expanduser(x) for x in pkg_paths if x]
if opts.input:
if opts.PKG:
parser.error(
"Cannot use --input and provide PKG(s) at the same time")
context = ResolvedContext.load(opts.input)
if context.status != ResolverStatus.solved:
print >> sys.stderr, "cannot rez-env into a failed context"
sys.exit(1)
if opts.patch:
# TODO: patching is lagging behind in options, and needs to be updated
# anyway.
if context is None:
from rez.status import status
context = status.context
if context is None:
print >> sys.stderr, "cannot patch: not in a context"
sys.exit(1)
request = context.get_patched_request(request,
strict=opts.strict,
rank=opts.patch_rank)
context = None
if context is None:
# create package filters
if opts.no_filters:
package_filter = PackageFilterList()
else:
package_filter = PackageFilterList.singleton.copy()
for rule_str in (opts.exclude or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_exclusion(rule)
for rule_str in (opts.include or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_inclusion(rule)
# perform the resolve
context = ResolvedContext(package_requests=request,
timestamp=t,
package_paths=pkg_paths,
building=opts.build,
package_filter=package_filter,
add_implicit_packages=(not opts.no_implicit),
verbosity=opts.verbose,
max_fails=opts.max_fails,
time_limit=opts.time_limit,
caching=(not opts.no_cache))
success = (context.status == ResolverStatus.solved)
if not success:
context.print_info(buf=sys.stderr)
if opts.output:
if opts.output == '-': # print to stdout
context.write_to_buffer(sys.stdout)
else:
context.save(opts.output)
sys.exit(0 if success else 1)
if not success:
sys.exit(1)
# generally shells will behave as though the '-s' flag was not present when
# no stdin is available. So here we replicate this behaviour.
if opts.stdin and not select.select([sys.stdin], [], [], 0.0)[0]:
opts.stdin = False
quiet = opts.quiet or bool(command)
returncode, _, _ = context.execute_shell(
shell=opts.shell,
rcfile=opts.rcfile,
norc=opts.norc,
command=command,
stdin=opts.stdin,
quiet=quiet,
start_new_session=opts.new_session,
detached=opts.detached,
pre_command=opts.pre_command,
block=True)
sys.exit(returncode)
def execute(self, app_path, app_args, version, **kwargs):
"""Start the required application using rez if required.
Notes:
- Define variables used to bootstrap tank from overwrite on
first reference
- Define others within ``tk-multi-launchapp.yml`` file in the
``extra:rez:parent_variables`` list.
Args:
app_path (str):
The path of the application executable
app_args (str):
Any arguments the application may require
version (str):
version of the application being run if set in the "versions"
settings of the Launcher instance, otherwise ``None``
Returns:
dict[str]:
Execute results mapped to 'command' (str) and
'return_code' (int).
"""
multi_launchapp = self.parent
rez_info = multi_launchapp.get_setting("extra", {}).get("rez", {})
cmd, shell_type = self.background_cmd_shell_type(app_path, app_args)
# Execute App in a Rez context
rez_py_path = self.get_rez_path()
if rez_py_path:
if rez_py_path not in sys.path:
self.logger.debug('Appending to sys.path: "%s"', rez_py_path)
sys.path.append(rez_py_path)
# Only import after rez_py_path is inside sys.path
from rez.resolved_context import ResolvedContext
from rez.config import config
rez_parent_variables = rez_info.get("parent_variables", [])
rez_packages = [
request.format(version=version)
for request in rez_info.get("packages", [])
]
self.logger.debug("rez parent variables: %s", rez_parent_variables)
self.logger.debug("rez packages: %s", rez_packages)
config.parent_variables = rez_parent_variables
context = ResolvedContext(rez_packages)
parent_env = self.create_shell_parent_env(context, config,
app_path, app_args,
version, **kwargs)
env_kwargs = {"suffix": "-prev-env.py", "delete": False}
with NamedTemporaryFile(mode="w+", **env_kwargs) as env_file:
env_file.write(pformat(parent_env))
self.logger.debug('Copied existing env for rez. See: "%s"',
env_file.name)
with TemporaryFile(mode="w+") as info_buffer:
context.print_info(buf=info_buffer)
info_buffer.seek(0)
self.logger.debug(
"Executing in rez context [%s]: %s\n%s",
shell_type,
cmd,
info_buffer.read(),
)
launcher_process = context.execute_shell(
command=cmd,
parent_environ=parent_env,
shell=shell_type,
stdin=False,
block=False,
)
exit_code = launcher_process.wait()
else:
# run the command to launch the app
exit_code = subprocess.check_call(cmd)
return {"command": cmd, "return_code": exit_code}
def command(opts, parser, extra_arg_groups=None):
from rez.resolved_context import ResolvedContext
from rez.resolver import ResolverStatus
from rez.package_filter import PackageFilterList, Rule
from rez.utils.formatting import get_epoch_time_from_str
from rez.config import config
import select
import sys
import os
import os.path
command = opts.command
if extra_arg_groups:
if opts.command:
parser.error("argument --command: not allowed with arguments after '--'")
command = extra_arg_groups[0] or None
context = None
request = opts.PKG
t = get_epoch_time_from_str(opts.time) if opts.time else None
if opts.paths is None:
pkg_paths = (config.nonlocal_packages_path
if opts.no_local else None)
else:
pkg_paths = opts.paths.split(os.pathsep)
pkg_paths = [os.path.expanduser(x) for x in pkg_paths if x]
if opts.input:
if opts.PKG and not opts.patch:
parser.error("Cannot use --input and provide PKG(s), unless patching.")
context = ResolvedContext.load(opts.input)
if opts.patch:
if context is None:
from rez.status import status
context = status.context
if context is None:
print >> sys.stderr, "cannot patch: not in a context"
sys.exit(1)
# modify the request in terms of the given patch request
request = context.get_patched_request(request,
strict=opts.strict,
rank=opts.patch_rank)
context = None
if context is None:
# create package filters
if opts.no_filters:
package_filter = PackageFilterList()
else:
package_filter = PackageFilterList.singleton.copy()
for rule_str in (opts.exclude or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_exclusion(rule)
for rule_str in (opts.include or []):
rule = Rule.parse_rule(rule_str)
package_filter.add_inclusion(rule)
# perform the resolve
context = ResolvedContext(package_requests=request,
timestamp=t,
package_paths=pkg_paths,
building=opts.build,
package_filter=package_filter,
add_implicit_packages=(not opts.no_implicit),
verbosity=opts.verbose,
max_fails=opts.max_fails,
time_limit=opts.time_limit,
caching=(not opts.no_cache),
suppress_passive=opts.no_passive,
print_stats=opts.stats)
success = (context.status == ResolverStatus.solved)
if not success:
context.print_info(buf=sys.stderr)
if opts.fail_graph:
if context.graph:
from rez.utils.graph_utils import view_graph
g = context.graph(as_dot=True)
view_graph(g)
else:
print >> sys.stderr, \
"the failed resolve context did not generate a graph."
if opts.output:
if opts.output == '-': # print to stdout
context.write_to_buffer(sys.stdout)
else:
context.save(opts.output)
sys.exit(0 if success else 1)
if not success:
sys.exit(1)
# generally shells will behave as though the '-s' flag was not present when
# no stdin is available. So here we replicate this behaviour.
try:
if opts.stdin and not select.select([sys.stdin], [], [], 0.0)[0]:
opts.stdin = False
except select.error:
pass # because windows
quiet = opts.quiet or bool(command)
returncode, _, _ = context.execute_shell(
shell=opts.shell,
rcfile=opts.rcfile,
norc=opts.norc,
command=command,
stdin=opts.stdin,
quiet=quiet,
start_new_session=opts.new_session,
detached=opts.detached,
pre_command=opts.pre_command,
block=True)
sys.exit(returncode)
def execute(self, app_path, app_args, version, **kwargs):
"""
The execute functon of the hook will be called to start the required application
:param app_path: (str) The path of the application executable
:param app_args: (str) Any arguments the application may require
:param version: (str) version of the application being run if set in the "versions" settings
of the Launcher instance, otherwise None
:returns: (dict) The two valid keys are 'command' (str) and 'return_code' (int).
"""
multi_launchapp = self.parent
extra = multi_launchapp.get_setting("extra")
use_rez = False
if self.check_rez():
from rez.resolved_context import ResolvedContext
from rez.config import config
# Define variables used to bootstrap tank from overwrite on first reference
# PYTHONPATH is used by tk-maya
# NUKE_PATH is used by tk-nuke
# HIERO_PLUGIN_PATH is used by tk-nuke (nukestudio)
# KATANA_RESOURCES is used by tk-katana
config.parent_variables = [
"PYTHONPATH", "HOUDINI_PATH", "NUKE_PATH", "HIERO_PLUGIN_PATH",
"KATANA_RESOURCES"
]
rez_packages = extra["rez_packages"]
context = ResolvedContext(rez_packages)
use_rez = True
else:
print('Can not found rez.')
system = sys.platform
shell_type = 'bash'
if system == "linux2":
# on linux, we just run the executable directly
cmd = "%s %s &" % (app_path, app_args)
#cmd = "%s &" % (app_path)
elif self.parent.get_setting("engine") in ["tk-flame", "tk-flare"]:
# flame and flare works in a different way from other DCCs
# on both linux and mac, they run unix-style command line
# and on the mac the more standardized "open" command cannot
# be utilized.
cmd = "%s %s &" % (app_path, app_args)
elif system == "darwin":
# on the mac, the executable paths are normally pointing
# to the application bundle and not to the binary file
# embedded in the bundle, meaning that we should use the
# built-in mac open command to execute it
cmd = "open -n \"%s\"" % (app_path)
if app_args:
cmd += " --args \"%s\"" % app_args.replace("\"", "\\\"")
elif system == "win32":
# on windows, we run the start command in order to avoid
# any command shells popping up as part of the application launch.
cmd = "start /B \"App\" \"%s\" %s" % (app_path, app_args)
shell_type = 'cmd'
print('use_rez:{0}'.format(use_rez))
# Execute App in a Rez context
if use_rez:
n_env = os.environ.copy()
proc = context.execute_shell(command=cmd,
parent_environ=n_env,
shell=shell_type,
stdin=False,
block=False)
exit_code = proc.wait()
print('exit_code:{0}'.format(exit_code))
context.print_info(verbosity=True)
else:
# run the command to launch the app
exit_code = os.system(cmd)
return {"command": cmd, "return_code": exit_code}
def execute(self, app_path, app_args, version, **kwargs):
"""
The execute functon of the hook will be called to start the required application
:param app_path: (str) The path of the application executable
:param app_args: (str) Any arguments the application may require
:param version: (str) version of the application being run if set in the "versions" settings
of the Launcher instance, otherwise None
:returns: (dict) The two valid keys are 'command' (str) and 'return_code' (int).
"""
multi_launchapp = self.parent
extra = multi_launchapp.get_setting("extra")
use_rez = False
if self.check_rez():
rez_packages = extra["rez_packages"]
from rez.resolved_context import ResolvedContext
from rez.config import config
config.parent_variables = ["PYTHONPATH"]
context = ResolvedContext(rez_packages)
use_rez = True
system = sys.platform
shell_type = 'bash'
if system == "linux2":
# on linux, we just run the executable directly
cmd = "%s %s &" % (app_path, app_args)
elif self.parent.get_setting("engine") in ["tk-flame", "tk-flare"]:
# flame and flare works in a different way from other DCCs
# on both linux and mac, they run unix-style command line
# and on the mac the more standardized "open" command cannot
# be utilized.
cmd = "%s %s &" % (app_path, app_args)
elif system == "darwin":
# on the mac, the executable paths are normally pointing
# to the application bundle and not to the binary file
# embedded in the bundle, meaning that we should use the
# built-in mac open command to execute it
cmd = "open -n \"%s\"" % (app_path)
if app_args:
cmd += " --args \"%s\"" % app_args.replace("\"", "\\\"")
elif system == "win32":
# on windows, we run the start command in order to avoid
# any command shells popping up as part of the application launch.
cmd = "start /B \"App\" \"%s\" %s" % (app_path, app_args)
shell_type = 'cmd'
# Execute App in a Rez context
if use_rez:
n_env = os.environ.copy()
proc = context.execute_shell(
command=cmd,
parent_environ=n_env,
shell=shell_type,
stdin=False,
block=False
)
exit_code = proc.wait()
context.print_info(verbosity=True)
else:
# run the command to launch the app
exit_code = os.system(cmd)
return {
"command": cmd,
"return_code": exit_code
}