def test_check_get_singularity_version(self): '''check that the singularity version is found to be that installed''' print("Testing utils.get_singularity_version") from spython.utils import get_singularity_version version = get_singularity_version() self.assertTrue(version != "") os.environ['SPYTHON_SINGULARITY_VERSION'] = "3.0" version = get_singularity_version() self.assertTrue(version == "3.0")
def test_check_get_singularity_version(): """check that the singularity version is found to be that installed""" from spython.utils import get_singularity_version version = get_singularity_version() assert version != "" with ScopedEnvVar("SPYTHON_SINGULARITY_VERSION", "3.0"): version = get_singularity_version() assert version == "3.0"
def get(self, name, return_json=False, quiet=False): '''get is a list for a single instance. It is assumed to be running, and we need to look up the PID, etc. ''' from spython.utils import (check_install, get_singularity_version) check_install() # Ensure compatible for singularity prior to 3.0, and after 3.0 subgroup = "instance.list" if (get_singularity_version().find("version 3") != -1): subgroup = ["instance", "list"] cmd = self._init_command(subgroup) cmd.append(name) output = run_command(cmd, quiet=True) # Success, we have instances if output['return_code'] == 0: # Only print the table if we are returning json if quiet is False: print(''.join(output['message'])) # Prepare json result from table header = ['daemon_name', 'pid', 'container_image'] instances = parse_table(output['message'][0], header) # Does the user want instance objects instead? listing = [] if return_json is False: for i in instances: new_instance = Instance(pid=i['pid'], name=i['daemon_name'], image=i['container_image'], start=False) listing.append(new_instance) instances = listing # Couldn't get UID elif output['return_code'] == 255: bot.error("Couldn't get UID") # Return code of 0 else: bot.info('No instances found.') # If we are given a name, return just one if name is not None and len(instances) == 1: instances = instances[0] return instances
def stop(self, name=None, sudo=False): '''start an instance. This is done by default when an instance is created. Parameters ========== image: optionally, an image uri (if called as a command from Client) name: a name for the instance sudo: if the user wants to run the command with sudo USAGE: singularity [...] instance.start [...] <container path> <instance name> ''' from spython.utils import ( check_install, run_command, get_singularity_version ) check_install() subgroup = 'instance.stop' if get_singularity_version().find("version 3"): subgroup = ["instance", "stop"] cmd = self._init_command(subgroup) # If name is provided assume referencing an instance instance_name = self.name if name is not None: instance_name = name cmd = cmd + [instance_name] output = run_command(cmd, sudo=sudo, quiet=True) if output['return_code'] != 0: message = '%s : return code %s' %(output['message'], output['return_code']) bot.error(message) return output['return_code'] return output['return_code']
def version(self): """Shortcut to get_singularity_version, takes no arguments. """ return get_singularity_version()
def instances(self, name=None, return_json=False, quiet=False): '''list instances. For Singularity, this is provided as a command sub group. singularity instance.list Return codes provided are different from standard linux: see https://github.com/singularityware/singularity/issues/1706 Parameters ========== return_json: return a json list of instances instead of objects (False) name: if defined, return the list for just one instance (used to ged pid) Return Code -- Reason 0 -- Instances Found 1 -- No Instances, libexecdir value not found, functions file not found 255 -- Couldn't get UID ''' from spython.instance.cmd.iutils import parse_table from spython.utils import check_install check_install() subgroup = 'instance.list' if get_singularity_version().find("version 3"): subgroup = ["instance", "list"] cmd = self._init_command(subgroup) # If the user has provided a name, we want to see a particular instance if name is not None: cmd.append(name) output = run_command(cmd, quiet=True) instances = None # Success, we have instances if output['return_code'] == 0: # Only print the table if we are returning json if quiet is False: print(''.join(output['message'])) # Prepare json result from table header = ['daemon_name', 'pid', 'container_image'] instances = parse_table(output['message'][0], header) # Does the user want instance objects instead? listing = [] if return_json is False: for i in instances: new_instance = self.instance(pid=i['pid'], name=i['daemon_name'], image=i['container_image'], start=False) listing.append(new_instance) instances = listing # Couldn't get UID elif output['return_code'] == 255: bot.error("Couldn't get UID") # Return code of 0 else: bot.info('No instances found.') # If we are given a name, return just one if name is not None and instances is not None: if len(instances) == 1: instances = instances[0] return instances
def get_client(quiet=False, debug=False): """ get the client and perform imports not on init, in case there are any initialization or import errors. Parameters ========== quiet: if True, suppress most output about the client debug: turn on debugging mode """ from spython.utils import get_singularity_version from .base import Client as client client.quiet = quiet client.debug = debug # Do imports here, can be customized from .apps import apps from .build import build from .execute import execute, shell from .help import helpcmd from .inspect import inspect from .instances import list_instances, stopall # global instance commands from .run import run from .pull import pull from .export import export, _export # Actions client.apps = apps client.build = build client.execute = execute client.export = export client._export = _export client.help = helpcmd client.inspect = inspect client.instances = list_instances client.run = run client.shell = shell client.pull = pull # Command Groups, Images from spython.image.cmd import generate_image_commands # deprecated client.image = generate_image_commands() # Commands Groups, Instances from spython.instance.cmd import ( generate_instance_commands, ) # instance level commands client.instance = generate_instance_commands() client.instance_stopall = stopall client.instance.version = client.version # Commands Groups, OCI (Singularity version 3 and up) if "version 3" in get_singularity_version(): from spython.oci.cmd import generate_oci_commands client.oci = generate_oci_commands()( ) # first () runs function, second # initializes OciImage class client.oci.debug = client.debug client.oci.quiet = client.quiet client.oci.OciImage.quiet = client.quiet client.oci.OciImage.debug = client.debug # Initialize cli = client() # Pass on verbosity for subclient in [cli.image, cli.instance]: subclient.debug = cli.debug subclient.quiet = cli.quiet subclient.version = cli.version return cli
def start(self, image=None, name=None, sudo=False, options=[], capture=False): '''start an instance. This is done by default when an instance is created. Parameters ========== image: optionally, an image uri (if called as a command from Client) name: a name for the instance sudo: if the user wants to run the command with sudo capture: capture output, default is False. With True likely to hang. options: a list of tuples, each an option to give to the start command [("--bind", "/tmp"),...] USAGE: singularity [...] instance.start [...] <container path> <instance name> ''' from spython.utils import (run_command, check_install, get_singularity_version) check_install() # If no name provided, give it an excellent one! if name is None: name = self.RobotNamer.generate() self.name = name.replace('-', '_') # If an image isn't provided, we have an initialized instance if image is None: # Not having this means it was called as a command, without an image if not hasattr(self, "_image"): bot.error('Please provide an image, or create an Instance first.') sys.exit(1) image = self._image # Derive subgroup command based on singularity version subgroup = 'instance.start' if get_singularity_version().find("version 3"): subgroup = ["instance", "start"] cmd = self._init_command(subgroup) # Add options, if they are provided if not isinstance(options, list): options = options.split(' ') # Assemble the command! cmd = cmd + options + [image, self.name] # Save the options and cmd, if the user wants to see them later self.options = options self.cmd = cmd output = run_command(cmd, sudo=sudo, quiet=True, capture=capture) if output['return_code'] == 0: self._update_metadata() else: message = '%s : return code %s' % (output['message'], output['return_code']) bot.error(message) return self
def version(self): '''Shortcut to get_singularity_version, takes no arguments. ''' return get_singularity_version()