Merge pull request #768 from marshall/moreScriptVars

Add $build_dir and $target_dir variables for target scripts

Author: autopulated

yotta/lib/target.py

@@ -591,6 +591,17 @@ def findProgram(self, builddir, program):
         logging.error('could not find program "%s" to debug' %  program)
         return None
 
+    def buildProgEnvAndVars(self, program, build_dir):
+        prog_env = os.environ.copy()
+        prog_env['YOTTA_PROGRAM'] = _encodePathForEnv(program)
+        prog_env['YOTTA_BUILD_DIR'] = _encodePathForEnv(build_dir)
+        prog_env['YOTTA_TARGET_DIR'] = _encodePathForEnv(self.path)
+        prog_vars = dict(program=program,
+                         build_dir=build_dir,
+                         target_dir=self.path)
+
+        return (prog_env, prog_vars)
+
     @fsutils.dropRootPrivs
     def start(self, builddir, program, forward_args):
         ''' Launch the specified program. Uses the `start` script if specified
@@ -603,20 +614,18 @@ def start(self, builddir, program, forward_args):
             if prog_path is None:
                 return
 
-            env = os.environ.copy()
-            env['YOTTA_PROGRAM'] = _encodePathForEnv(prog_path)
-
+            start_env, start_vars = self.buildProgEnvAndVars(prog_path, builddir)
             if self.getScript('start'):
                 cmd = [
-                    os.path.expandvars(string.Template(x).safe_substitute(program=prog_path))
+                    os.path.expandvars(string.Template(x).safe_substitute(**start_vars))
                     for x in self.getScript('start')
                 ] + forward_args
             else:
                 cmd = shlex.split('./' + prog_path) + forward_args
 
             logger.debug('starting program: %s', cmd)
             child = subprocess.Popen(
-                cmd, cwd = builddir, env = env
+                cmd, cwd = builddir, env = start_env
             )
             child.wait()
             if child.returncode:
@@ -663,16 +672,15 @@ def _debugWithScript(self, builddir, program):
             if prog_path is None:
                 return
 
-            env = os.environ.copy()
-            env['YOTTA_PROGRAM'] = _encodePathForEnv(prog_path)
+            debug_env, debug_vars = self.buildProgEnvAndVars(prog_path, builddir)
 
             cmd = [
-                os.path.expandvars(string.Template(x).safe_substitute(program=prog_path))
+                os.path.expandvars(string.Template(x).safe_substitute(**debug_vars))
                 for x in self.getScript('debug')
             ]
             logger.debug('starting debugger: %s', cmd)
             child = subprocess.Popen(
-                cmd, cwd = builddir, env = env
+                cmd, cwd = builddir, env = debug_env
             )
             child.wait()
             if child.returncode:
@@ -749,11 +757,14 @@ def test(self, test_dir, module_dir, test_command, filter_command, forward_args)
         # to use filter scripts shipped with the module)
         test_command = './' + test_command
         test_script = self.getScript('test')
+
+        test_env, test_vars = self.buildProgEnvAndVars(os.path.abspath(os.path.join(test_dir, test_command)), test_dir)
+
         if test_script is None:
             cmd = shlex.split(test_command) + forward_args
         else:
             cmd = [
-                os.path.expandvars(string.Template(x).safe_substitute(program=os.path.abspath(os.path.join(test_dir, test_command))))
+                os.path.expandvars(string.Template(x).safe_substitute(**test_vars))
                 for x in test_script
             ] + forward_args
 
@@ -768,21 +779,18 @@ def test(self, test_dir, module_dir, test_command, filter_command, forward_args)
             python_interpreter = sys.executable
             filter_command = [python_interpreter] + filter_command
 
-        env = os.environ.copy()
-        env['YOTTA_PROGRAM'] = _encodePathForEnv(test_command)
-
         test_child = None
         test_filter = None
         try:
             logger.debug('running test: %s', cmd)
             if filter_command:
                 logger.debug('using output filter command: %s', filter_command)
                 test_child = subprocess.Popen(
-                    cmd, cwd = test_dir, stdout = subprocess.PIPE, env = env
+                    cmd, cwd = test_dir, stdout = subprocess.PIPE, env = test_env
                 )
                 try:
                     test_filter = subprocess.Popen(
-                        filter_command, cwd = module_dir, stdin = test_child.stdout, env = env
+                        filter_command, cwd = module_dir, stdin = test_child.stdout, env = test_env
                     )
                 except OSError as e:
                     logger.error('error starting test output filter "%s": %s', filter_command, e)
@@ -803,7 +811,7 @@ def test(self, test_dir, module_dir, test_command, filter_command, forward_args)
             else:
                 try:
                     test_child = subprocess.Popen(
-                        cmd, cwd = test_dir, env = env
+                        cmd, cwd = test_dir, env = test_env
                     )
                     logger.debug('waiting for test child')
                 except OSError as e:

yotta/test/cli/test_debug.py

@@ -5,13 +5,15 @@
 # See LICENSE file for details.
 
 # standard library modules, , ,
+import json
 import unittest
 import os
 
 # internal modules:
 from yotta.test.cli import util
 from yotta.test.cli import cli
 
+JSON_MARKER = '###---###'
 def _nopDebugTargetDescription(name):
     native_target = util.nativeTarget()
     if ',' in native_target:
@@ -25,24 +27,43 @@ def _nopDebugTargetDescription(name):
         "%s": "*"
       },
       "scripts": {
-        "debug": ["./scripts/nop.py", "$program"]
+        "debug": ["./scripts/nop.py", "$program", "$build_dir", "$target_dir"]
       }
     }
     ''' % (name, native_target),
     './scripts/nop.py':'''
 import os
-print('would debug %s' % os.environ['YOTTA_PROGRAM'])
-    '''
+import sys
+import json
+
+env_keys = ["YOTTA_PROGRAM", "YOTTA_BUILD_DIR", "YOTTA_TARGET_DIR"]
+print(json.dumps({"argv": sys.argv[1:], "env": {k: v for k, v in os.environ.items() if k in env_keys}}))
+print('%s')
+    ''' % JSON_MARKER
     }
 
 class TestCLIDebug(unittest.TestCase):
     @unittest.skipIf(not util.canBuildNatively(), "can't build natively on windows yet")
     def test_noop_debug(self):
         test_dir = util.writeTestFiles(util.Test_Trivial_Exe, True)
-        util.writeTestFiles(_nopDebugTargetDescription('debug-test-target'), test_dir=os.path.join(test_dir, 'yotta_targets', 'debug-test-target'))
+        target_dir = os.path.realpath(os.path.join(test_dir, 'yotta_targets', 'debug-test-target'))
+        build_dir = os.path.realpath(os.path.join(test_dir, 'build', 'debug-test-target'))
+
+        util.writeTestFiles(_nopDebugTargetDescription('debug-test-target'), test_dir=target_dir)
         output = util.runCheckCommand(['--target', 'debug-test-target', 'build'], test_dir)
         output = util.runCheckCommand(['--target', 'debug-test-target', 'debug'], test_dir)
-        self.assertIn('would debug source/test-trivial-exe', output)
+        json_output = output[:output.index(JSON_MARKER)]
+        result = json.loads(json_output)
+
+        self.assertTrue(result is not None)
+        self.assertEqual(len(result['argv']), 3)
+        self.assertEqual(result['argv'][0], 'source/test-trivial-exe')
+        self.assertEqual(result['env']['YOTTA_PROGRAM'], 'source/test-trivial-exe')
+        self.assertEqual(result['argv'][1], build_dir)
+        self.assertEqual(result['env']['YOTTA_BUILD_DIR'], build_dir)
+        self.assertEqual(result['argv'][2], target_dir)
+        self.assertEqual(result['env']['YOTTA_TARGET_DIR'], target_dir)
+
         util.rmRf(test_dir)
 
     @unittest.skipIf(not util.canBuildNatively(), "can't build natively on windows yet")