Commit 56e74ad4 authored by Tharrington, Arnold's avatar Tharrington, Arnold
Browse files

Latest commit.

Implemneted namd_machine_registrations.py.
parent 424da4da
Loading
Loading
Loading
Loading
+29 −0
Original line number Diff line number Diff line
@@ -22,8 +22,11 @@ import argparse # Needed for parsing command line arguments.
# Local imports
from loggerutils.logger import create_logger_description
from loggerutils.logger import create_logger
import namd_machine_registrations

def main():
    mr =  _register_machines_buildtargets()

    args = _parse_arguments()

    logger = create_logger(log_id='Default',
@@ -53,9 +56,35 @@ def _parse_arguments():
                           default=logging.WARNING,
                           help=create_logger_description() )

    # Adding mandatory argument group.
    mandatory_args_group = my_parser.add_argument_group(title="Mandatory Arguments")

    mandatory_args_group.add_argument("--machine-name",
        help="The name of the machine on which the sotware will be installed.",
        required=True,
        type=str,
        metavar='<machine name>')

    mandatory_args_group.add_argument("--target-build",
        help="The NAMD build target.",
        required=True,
        type=str,
        metavar='<target build>')

    my_args = my_parser.parse_args()

    return my_args 

def _register_machines_buildtargets():
    # Register Crusher
    reg_mach = namd_machine_registrations.NamdBuildRegister()
    builder1 = lambda x,y : print(f"Building {y} on {x}")  
    namd_machine_registrations.register_new_machine(reg_mach,'Crusher')
    namd_machine_registrations.register_new_build(reg_mach,machine_name='Crusher',build_target='Multicore',builder=builder1)
    namd_machine_registrations.build_software(reg_mach,machine_name='Crusher',build_target="Multicore")


    return reg_mach

if __name__ == "__main__":
    main()
+2 −1
Original line number Diff line number Diff line
@@ -2,4 +2,5 @@

__all__ = ["lmod_interface",
           "loggerutils",
           "pathoption"]
           "pathoption",
           "namd_machine_registration"]
+140 −0
Original line number Diff line number Diff line
#! /usr/bin/env python3
"""Convenience module for registering new machine builds.

The fuction register_new_machine registers a new machine.

The fuction register_new_build registers a new build.
"""
# System imports

# Local imports

def register_new_machine(reg_builder,machine_name=''):
    """Registers a new machine to build NAMD.

    Registers 'machine_name' for building NAMD. Registering the same 
    machine more than once hase no effect on reg_builder. 

    Args:
        reg_builder (NamdBuildRegister) : An instance of class NamdBuildRegister.
        machine_name (str) : The name of the machine being registered.

    Returns:
       A machine that has registered machine "machine_name".  
    """

    reg_builder.register_machine(machine_name)
    return  

def register_new_build(reg_builder,machine_name='',build_target='',builder=''):
    """Registers a new build target for machine 'machine_name'.
   
    Registers 'machine_name' for building NAMD target 'build_target'
    Registering the same machine and build target more than once hase no effect
    on reg_builder. 
    
    Args:
        reg_builder (NamdBuildRegister) : An instance of class NamdBuildRegister.
        machine_name (str) : The name of the machine being registered.
        build_target (str) : The name of the NAMD build target.
        builder (function referece) : A callable object that will build NAMD.
    
    Returns:
       A machine that has registered machine "machine_name".  
    """

    print( f"Registering build target: {machine_name}, {build_target}." )
    reg_builder.add_buildtarget(machine_name=machine_name,build_target=build_target,builder=builder)
    return reg_builder

def build_software(reg_builder,machine_name='',build_target=''):
    """ """
    reg_builder.build(machine_name=machine_name,build_target=build_target)
    return

class NamdBuildRegister():
    """Stores the machines and machine registrations for building NAMD.
    
    Attributes:
        _machine_names : A array that stores the NAMD machine names.
        _builder : An dict of callable objects. The dict is a nested dict
                   such that to access the builder for machine_name and 
                   build_target, one does self._builder[machine_name][build_target]
    """
    def __init__(self):
        self._machine_names = []
        self._builder = {}

    def register_machine(self,machine_name):
        """Adds a machine for registration

        If the machine already exists then nothing is done.

        Args:
            machine_name (str) : The machine name.
        """
        if not ( machine_name in self._machine_names ) :
            print( f"Registering {machine_name}." )
            self._machine_names += [machine_name]
            self._builder[machine_name] = {}

        return

    def unregister_machine(self,machine_name):
        """Removes machine machine_name
        
        If the machine already removed then nothing is done.
        
        Args:
            machine_name (str) : The machine name.
        """
        if machine_name in self._machine_names :
            self._machine_names.pop(machine_name)
            self._builder.pop(machine_name)

    def add_buildtarget(self,machine_name,builder,build_target):
        """Adds a new build target 

        The build target must not previously exist.
        
        Args:
            machine_name (str) : The name of the machine
            builder (callable object) : When innvoked, builds namd for the
                                        desired target.
            build_target (str) : The NAMD build target.

        """

        # First verify that the machine is registered.
        if not ( machine_name in self._machine_names ) :
            msg = ( f'Error! The nachine "{machine_name}" is not registered.' )
            raise ValueError(msg)

        # Verify that the build_target is not previously registered
        if build_target in self._builder[machine_name] :
            msg = ( f'Error! The build target "{build_target}" for "{machine_name}"'
                    f' is previously registered.' )
            raise ValueError(msg)

        self._builder[machine_name][build_target] = builder

        return

    def remove_buildtarget(self,machine_name,build_target):
        """Removes a build target of machine machine_name
        
        Args:
            machine_name (str) : The name of the machine
            build_target (str) : The NAMD build target.

        """

        if  machine_name in self._machine_names  :
            if build_target in self._builder[_machine_name] :
                self._builder[machine_name].pop(build_target,'')
        return

    def build(self,machine_name,build_target):
        """ """
        self._builder[machine_name][build_target](machine_name,build_target)
        return
+1 −2
Original line number Diff line number Diff line
@@ -2,9 +2,8 @@

The function create_pathoption returns an PathOption object. 

The function  register_pathoption registers a new path option permmited value and the
The function  register_pathoption registers a new path option permitted value and the
corresponding function reference.

"""

import errors_pathoption