def test_R_supported_version(self): """R is in path and version is supported """ minimum_version = (2, 12, 0) self.assertTrue(which('R'), "R not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "R --version | grep 'R version' | awk '{print $3}'" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = False if version[0] == minimum_version[0]: if version[1] == minimum_version[1]: if version[2] >= minimum_version[2]: pass_test = True elif version[1] > minimum_version[1]: pass_test = True elif version[0] > minimum_version[0]: pass_test = True except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported R version. %s or greater is required, but running %s." % ('.'.join(map(str, minimum_version)), version_string))
def remote_submit_job(login_info: str, remote_dir: str, app_args: str, modules, envars=None) -> None: """ Execute the given command in the remote COMPSs environment. :param cmd: Command to execute. :returns: The execution stdout. """ enqueue_debug = '-d' if utils.is_debug() else '' commands = [ f'cd {remote_dir}', *modules, f'enqueue_compss {enqueue_debug} {app_args}' ] if envars: commands = [f'export {var}' for var in envars] + commands if utils.is_debug(): print('********* DEBUG *********') print('Remote submit job commands:') for cmd in commands: print('\t', '->', cmd) print('***************************') stdout = utils.ssh_run_commands(login_info, commands) job_id = stdout.strip().split('\n')[-1].split(' ')[-1] print('Job submitted:', job_id) return job_id
def test_ParsInsert_supported_version(self): """ParsInsert is in path and version is supported """ acceptable_version = ["1.04"] self.assertTrue( which('ParsInsert'), "ParsInsert not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "ParsInsert -v | grep App | awk '{print $3}'" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() # remove log file generated remove_files(['ParsInsert.log'], error_on_missing=False) version_string = stdout.strip() try: pass_test = version_string in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported ParsInsert version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_clearcut_supported_version(self): """clearcut is in path and version is supported """ acceptable_version = (1, 0, 9) self.assertTrue( which('clearcut'), "clearcut not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "clearcut -V" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[2].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported clearcut version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_raxmlHPC_supported_version(self): """raxmlHPC is in path and version is supported """ acceptable_version = [(7, 3, 0), (7, 3, 0)] self.assertTrue( which('raxmlHPC'), "raxmlHPC not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "raxmlHPC -v | grep version" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[4].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported raxmlHPC version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_mothur_supported_version(self): """mothur is in path and version is supported """ acceptable_version = (1, 25, 0) self.assertTrue( which("mothur"), "mothur not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.", ) # mothur creates a log file in cwd, so create a tmp and cd there first log_file = join(get_qiime_temp_dir(), "mothur.log") command = "mothur \"#set.logfile(name=%s)\" | grep '^mothur v'" % log_file stdout, stderr, exit_Status = qiime_system_call(command) # remove log file remove_files([log_file], error_on_missing=False) version_string = stdout.strip().split(" ")[1].strip("v.") try: version = tuple(map(int, version_string.split("."))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported mothur version. %s is required, but running %s." % (".".join(map(str, acceptable_version)), version_string), )
def test_ParsInsert_supported_version(self): """ParsInsert is in path and version is supported """ acceptable_version = ["1.04"] self.assertTrue( which("ParsInsert"), "ParsInsert not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.", ) command = "ParsInsert -v | grep App | awk '{print $3}'" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() # remove log file generated remove_files(["ParsInsert.log"], error_on_missing=False) version_string = stdout.strip() try: pass_test = version_string in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported ParsInsert version. %s is required, but running %s." % (".".join(map(str, acceptable_version)), version_string), )
def test_rtax_supported_version(self): """rtax is in path and version is supported """ acceptable_version = [(0, 984)] self.assertTrue( which('rtax'), "rtax not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "rtax 2>&1 > %s | grep Version | awk '{print $2}'" % devnull proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported rtax version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_R_supported_version(self): """R is in path and version is supported """ minimum_version = (2, 12, 0) self.assertTrue( which('R'), "R not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "R --version | grep 'R version' | awk '{print $3}'" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = False if version[0] == minimum_version[0]: if version[1] == minimum_version[1]: if version[2] >= minimum_version[2]: pass_test = True elif version[1] > minimum_version[1]: pass_test = True elif version[0] > minimum_version[0]: pass_test = True except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported R version. %s or greater is required, but running %s." % ('.'.join(map(str, minimum_version)), version_string))
def test_python_supported_version(self): """python is in path and version is supported """ min_acceptable_version = (2, 7, 0) min_unacceptable_version = (3, 0, 0) command = 'python --version' proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_str_matches = re.findall('Python\s+(\S+)\s*', stdout.strip()) self.assertEqual(len(version_str_matches), 1, "Could not determine the Python version in '%s'." % stdout) version_string = version_str_matches[0] try: if version_string[-1] == '+': version_string = version_string[:-1] version = tuple(map(int, version_string.split('.'))) if len(version) == 2: version = (version[0], version[1], 0) pass_test = (version >= min_acceptable_version and version < min_unacceptable_version) except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported Python version. Must be >= %s and < %s, " "but running %s." % ('.'.join(map(str, min_acceptable_version)), '.'.join(map(str, min_unacceptable_version)), version_string))
def test_python_supported_version(self): """python is in path and version is supported """ min_acceptable_version = (2, 7, 0) min_unacceptable_version = (3, 0, 0) command = 'python --version' proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_str_matches = re.findall('Python\s+(\S+)\s*', stdout.strip()) self.assertEqual( len(version_str_matches), 1, "Could not determine the Python version in '%s'." % stdout) version_string = version_str_matches[0] try: if version_string[-1] == '+': version_string = version_string[:-1] version = tuple(map(int, version_string.split('.'))) if len(version) == 2: version = (version[0], version[1], 0) pass_test = (version >= min_acceptable_version and version < min_unacceptable_version) except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported Python version. Must be >= %s and < %s, " "but running %s." % ('.'.join(map(str, min_acceptable_version)), '.'.join( map(str, min_unacceptable_version)), version_string))
def test_mothur_supported_version(self): """mothur is in path and version is supported """ acceptable_version = (1, 25, 0) self.assertTrue( which('mothur'), "mothur not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") # mothur creates a log file in cwd, so create a tmp and cd there first log_file = join(get_qiime_temp_dir(), 'mothur.log') command = "mothur \"#set.logfile(name=%s)\" | grep '^mothur v'" % log_file stdout, stderr, exit_Status = qiime_system_call(command) # remove log file remove_files([log_file], error_on_missing=False) version_string = stdout.strip().split(' ')[1].strip('v.') try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported mothur version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def testClose(self): sequentialStorage = SequentialStorage(self.tempdir) sequentialStorage.add(identifier='abc', data="1") lockFile = join(self.tempdir, 'write.lock') self.assertTrue(isfile(lockFile)) sequentialStorage.close() stdout, stderr = Popen("lsof -n %s" % lockFile, stdout=PIPE, stderr=PIPE, shell=True).communicate() self.assertEquals('', stdout.strip()) self.assertRaises(AttributeError, lambda: sequentialStorage.add('def', data='2'))
def run_subprocess(command, *args, **kwargs): """Run command using subprocess.Popen Run command and wait for command to complete. If the return code was zero then return, otherwise raise CalledProcessError. By default, this will also add stdout= and stderr=subproces.PIPE to the call to Popen to suppress printing to the terminal. Parameters ---------- command : list of str Command to run as subprocess (see subprocess.Popen documentation). *args, **kwargs : arguments Arguments to pass to subprocess.Popen. Returns ------- stdout : str Stdout returned by the process. stderr : str Stderr returned by the process. """ if 'stderr' not in kwargs: kwargs['stderr'] = subprocess.PIPE if 'stdout' not in kwargs: kwargs['stdout'] = subprocess.PIPE # Check the PATH environment variable. If run_subprocess() is to be called # frequently this should be refactored so as to only check the path once. env = kwargs.get('env', os.environ) if any(p.startswith('~') for p in env['PATH'].split(os.pathsep)): msg = ("Your PATH environment variable contains at least one path " "starting with a tilde ('~') character. Such paths are not " "interpreted correctly from within Python. It is recommended " "that you use '$HOME' instead of '~'.") warnings.warn(msg) logger.info("Running subprocess: %s" % str(command)) p = subprocess.Popen(command, *args, **kwargs) stdout, stderr = p.communicate() if stdout.strip(): logger.info("stdout:\n%s" % stdout) if stderr.strip(): logger.info("stderr:\n%s" % stderr) output = (stdout, stderr) if p.returncode: print output raise subprocess.CalledProcessError(p.returncode, command, output) return output
def test_rtax_supported_version(self): """rtax is in path and version is supported """ acceptable_version = [(0, 984)] self.assertTrue(which('rtax'), "rtax not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "rtax 2>&1 > %s | grep Version | awk '{print $2}'" % devnull proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported rtax version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_clearcut_supported_version(self): """clearcut is in path and version is supported """ acceptable_version = (1, 0, 9) self.assertTrue(which('clearcut'), "clearcut not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "clearcut -V" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[2].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported clearcut version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_raxmlHPC_supported_version(self): """raxmlHPC is in path and version is supported """ acceptable_version = [(7, 3, 0), (7, 3, 0)] self.assertTrue(which('raxmlHPC'), "raxmlHPC not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "raxmlHPC -v | grep version" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[4].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported raxmlHPC version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_INFERNAL_supported_version(self): """INFERNAL is in path and version is supported """ acceptable_version = (1, 0, 2) self.assertTrue(app_path('cmbuild'), "Infernal not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = "cmbuild -h | grep INF" proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[2].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported INFERNAL version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_pplacer_supported_version(self): """pplacer is in path and version is supported """ acceptable_version = [(1, 1), (1, 1)] self.assertTrue(app_path('pplacer'), "pplacer not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "pplacer --version" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip()[1:4] try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported pplacer version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_FastTree_supported_version(self): """FastTree is in path and version is supported """ acceptable_version = (2, 1, 3) self.assertTrue(app_path('FastTree'), "FastTree not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.") command = "FastTree 2>&1 > %s | grep version" % devnull proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[4].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported FastTree version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_pplacer_supported_version(self): """pplacer is in path and version is supported """ acceptable_version = [(1, 1), (1, 1)] self.assertTrue(app_path('pplacer'), "pplacer not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = "pplacer --version" proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip()[1:4] try: version = tuple(map(int, version_string.split('.'))) pass_test = version in acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported pplacer version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_INFERNAL_supported_version(self): """INFERNAL is in path and version is supported """ acceptable_version = (1,0,2) self.assertTrue(app_path('cmbuild'), "Infernal not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = "cmbuild -h | grep INF" proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[2].strip() try: version = tuple(map(int,version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported INFERNAL version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_muscle_supported_version(self): """muscle is in path and version is supported """ acceptable_version = (3,8,31) self.assertTrue(app_path('muscle'), "muscle not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = "muscle -version" proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[1].strip('v') try: version = tuple(map(int,version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported muscle version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_FastTree_supported_version(self): """FastTree is in path and version is supported """ acceptable_version = (2, 1, 3) self.assertTrue(app_path('FastTree'), "FastTree not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = "FastTree 2>&1 > %s | grep version" % devnull proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(' ')[4].strip() try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported FastTree version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_uclust_supported_version(self): """uclust is in path and version is supported """ acceptable_version = (1, 2, 22) self.assertTrue(app_path('uclust'), "uclust not found. This may or may not be a problem depending on "+\ "which components of QIIME you plan to use.") command = 'uclust --version' proc = Popen(command,shell=True,universal_newlines=True,\ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split('v')[-1].strip('q') try: version = tuple(map(int, version_string.split('.'))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported uclust version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_python_supported_version(self): """python is in path and version is supported """ acceptable_version = (2, 7, 3) command = 'python --version' proc = Popen(command,shell=True,universal_newlines=True, \ stdout=PIPE,stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split('Python')[-1].strip() try: if version_string[-1] == '+': version_string = version_string[:-1] version = tuple(map(int, version_string.split('.'))) if len(version) == 2: version = (version[0], version[1], 0) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test,\ "Unsupported python version. %s is required, but running %s." \ % ('.'.join(map(str,acceptable_version)), version_string))
def test_python_supported_version(self): """python is in path and version is supported """ acceptable_version = (2, 7, 3) command = 'python --version' proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split('Python')[-1].strip() try: if version_string[-1] == '+': version_string = version_string[:-1] version = tuple(map(int, version_string.split('.'))) if len(version) == 2: version = (version[0], version[1], 0) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue(pass_test, "Unsupported python version. %s is required, but running %s." % ('.'.join(map(str, acceptable_version)), version_string))
def test_blast_supported_version(self): """blast is in path and version is supported """ acceptable_version = (2, 2, 22) self.assertTrue( which("blastall"), "blast not found. This may or may not be a problem depending on " + "which components of QIIME you plan to use.", ) command = "blastall | grep blastall" proc = Popen(command, shell=True, universal_newlines=True, stdout=PIPE, stderr=STDOUT) stdout = proc.stdout.read() version_string = stdout.strip().split(" ")[1].strip() try: version = tuple(map(int, version_string.split("."))) pass_test = version == acceptable_version except ValueError: pass_test = False version_string = stdout self.assertTrue( pass_test, "Unsupported blast version. %s is required, but running %s." % (".".join(map(str, acceptable_version)), version_string), )