예제 #1
0
class SwitchDriver:
    """
    Main class for running the switch driver process.
    """

    def fetch_metadata(self):
        """
        @brief collect metadata from the user
        """
        self.driver_make = prompt.text("Driver Make")
        self.driver_model = prompt.text("Driver Model")
        self.driver_name = prompt.text("Driver Name")

        self.metadata = Metadata(self.driver_make, self.driver_model, self.driver_name)

    def fetch_comm_config(self):
        """
        @brief collect connection information for the logger from the user
        """
        config_path = "%s/%s" % (self.metadata.driver_dir(), CommConfig.config_filename())
        self.comm_config = CommConfig.get_config_from_console(config_path)
        self.comm_config.get_from_console()

    def run(self):
        """
        @brief Run it.
        """
        print("*** Starting Switch Driver Process***")

        self.fetch_metadata()
        self.fetch_comm_config()
        self.metadata.link_current_metadata()
예제 #2
0
class SwitchDriver():
    """
    Main class for running the switch driver process.
    """
    def fetch_metadata(self):
        """
        @brief collect metadata from the user
        """
        self.driver_make = prompt.text('Driver Make')
        self.driver_model = prompt.text('Driver Model')
        self.driver_name = prompt.text('Driver Name')

        self.metadata = Metadata(self.driver_make, self.driver_model,
                                 self.driver_name)

    def fetch_comm_config(self):
        """
        @brief collect connection information for the logger from the user
        """
        config_path = "%s/%s" % (self.metadata.driver_dir(),
                                 CommConfig.config_filename())
        self.comm_config = CommConfig.get_config_from_console(config_path)
        self.comm_config.get_from_console()

    def run(self):
        """
        @brief Run it.
        """
        print("*** Starting Switch Driver Process***")

        self.fetch_metadata()
        self.fetch_comm_config()
        self.metadata.link_current_metadata()
예제 #3
0
    def fetch_metadata(self):
        """
        @brief collect metadata from the user
        """
        self.driver_make = prompt.text('Driver Make')
        self.driver_model = prompt.text('Driver Model')
        self.driver_name = prompt.text('Driver Name')

        self.metadata = Metadata(self.driver_make, self.driver_model,
                                 self.driver_name)
예제 #4
0
    def test_constructor(self):
        """
        Test object creation
        """
        default_metadata = Metadata()
        self.assertTrue(default_metadata)

        specific_metadata = Metadata('seabird', 'sbe37smb', 'ooicore')
        self.assertTrue(specific_metadata)

        failure_metadata = None
        try:
            failure_metadata = Metadata('seabird')
        except InvalidParameters, e:
            self.assertTrue(e)
예제 #5
0
 def overwrite(self):
     """
     @brief Overwrite the current files with what is stored in the current metadata file.
     """
     self.metadata = Metadata()
     self.comm_config = CommConfig.get_config_from_file(self.metadata)
     self.generate_code(force = True)
예제 #6
0
    def test_list(self):
        """
        Test the full file manifest
        """
        filelist = DriverFileList(Metadata(), ROOTDIR, self.implfile(),
                                  self.nosefile())
        self.assertTrue(filelist)

        known_files = [
            'mi/__init__.py',
            'mi/base.py',
            'mi/base2.py',
            'mi/base3.py',
            'mi/base4.py',
            'mi/foo/__init__.py',
            'mi/foo/impl.py',
            'mi/foo/res/test_file',
            'mi/foo/test/__init__.py',
            'mi/foo/test/test_process.py',
        ]

        files = filelist.files()
        log.debug("F: %s" % files)

        self.assertEqual(sorted(files), sorted(known_files))
        pass
예제 #7
0
    def fetch_metadata(self):
        """
        @brief collect metadata from the user
        """
        self.driver_make = prompt.text("Driver Make")
        self.driver_model = prompt.text("Driver Model")
        self.driver_name = prompt.text("Driver Name")

        self.metadata = Metadata(self.driver_make, self.driver_model, self.driver_name)
예제 #8
0
class StartDriver():
    """
    Main class for running the start driver process.
    """

    def fetch_metadata(self):
        """
        @brief collect metadata from the user
        """
        self.metadata = Metadata()
        self.metadata.get_from_console()

    def fetch_comm_config(self):
        """
        @brief collect connection information for the logger from the user
        """
        config_path = "%s/%s" % (self.metadata.driver_dir(), CommConfig.config_filename())
        self.comm_config = CommConfig.get_config_from_console(config_path)
        self.comm_config.get_from_console()

    def generate_code(self, force = False):
        """
        @brief generate the directory structure, code and tests for the new driver.
        """
        driver = DriverGenerator( self.metadata, force = force )
        driver.generate()

    def overwrite(self):
        """
        @brief Overwrite the current files with what is stored in the current metadata file.
        """
        self.metadata = Metadata()
        self.comm_config = CommConfig.get_config_from_file(self.metadata)
        self.generate_code(force = True)

    def run(self):
        """
        @brief Run it.
        """
        print( "*** Starting Driver Creation Process***" )

        self.fetch_metadata()
        self.fetch_comm_config()
        self.generate_code()
예제 #9
0
    def __init__(self):
        """
        @brief ctor
        """
        self.metadata = Metadata()
        self._zipfile = None
        self._manifest = None
        self._compression = None
        self.generator = DriverGenerator(self.metadata)

        # Set compression level
        self.zipfile_compression()
예제 #10
0
    def test_extra_list(self):
        """
        Find all the files in the driver directory
        """
        rootdir = dirname(TESTDIR)
        filelist = DriverFileList(Metadata(), ROOTDIR, self.implfile(),
                                  self.nosefile())
        self.assertTrue(filelist)

        known_files = ['%s/res/test_file' % TESTDIR]

        files = filelist._extra_files()

        log.debug(sorted(files))
        log.debug(sorted(known_files))

        self.assertEqual(sorted(files), sorted(known_files))
예제 #11
0
 def fetch_metadata(self):
     """
     @brief collect metadata from the user
     """
     self.metadata = Metadata()
     self.metadata.get_from_console()
예제 #12
0
class PackageDriver():
    """
    Main class for running the package driver process.
    """

    ###
    #   Configuration
    ###
    def log_file(self):
        return "qualification.log"

    def log_path(self):
        return "%s/%s" % (self.metadata.idk_dir(), self.log_file())

    def archive_path(self):
        return "%s/%s_%02d_driver.zip" % (os.environ['HOME'], self.metadata.name.lower(), self.metadata.version)


    ###
    #   Public Methods
    ###
    def __init__(self):
        """
        @brief ctor
        """
        self.metadata = Metadata()
        self._zipfile = None
        self._manifest = None
        self._compression = None
        self.generator = DriverGenerator(self.metadata)

        # Set compression level
        self.zipfile_compression()

    def run_qualification_tests(self):
        """
        @brief Run all qualification tests for the driver and store the results for packaging
        """
        log.info("-- Running qualification tests")

        test = NoseTest(self.metadata, log_file=self.log_path())
        test.report_header()

        result = test.run_qualification()

        if(test.run_qualification()):
            log.info(" ++ Qualification tests passed")
            return True
        else:
            log.error("Qualification tests have fail!  No package created.")
            return False

    def package_driver(self):
        """
        @brief Store driver files in a zip package
        """
        log.info("-- Building driver package")
        self._store_package_files()

    def run(self):
        print "*** Starting Driver Packaging Process***"

        if( self.run_qualification_tests() ):
            self.package_driver()
            print "Package Created: " + self.archive_path()
        else:
            sys.exit()

    def zipfile(self):
        """
        @brief Return the ZipFile object.  Create the file if it isn't already open
        @retval ZipFile object
        """
        if(not self._zipfile):
            self._zipfile = zipfile.ZipFile(self.archive_path(), mode="w")

        return self._zipfile

    def zipfile_compression(self):
        """
        @brief What type of compression should we use for the package file.  If we have access to zlib, we will compress
        @retval Compression type
        """

        if(self._compression): return self._compression

        try:
            import zlib
            self._compression = zipfile.ZIP_DEFLATED
            log.info("Setting compression level to deflated")
        except:
            log.info("Setting compression level to store only")
            self._compression = zipfile.ZIP_STORED

    def manifest(self):
        """
        @brief Return the PackageManifest object.  Create it if it doesn't already exist
        @retval PackageManifest object
        """
        if(not self._manifest):
            self._manifest = PackageManifest(self.metadata)

        return self._manifest


    ###
    #   Private Methods
    ###
    def _store_package_files(self):
        """
        @brief Store all files in zip archive and add them to the manifest file
        """

        # Add python source files
        self._add_file(self.generator.driver_full_name(), 'src', 'driver source code')
        self._add_file(self.generator.driver_test_full_name(), 'src/test', 'driver test code')

        # Add the package metadata file
        self._add_file(self.metadata.metadata_path(), description = 'package metadata')

        # Add the qualification test log
        self._add_file(self.log_path(), description = 'qualification tests results')

        # Store additional resource files
        self._store_resource_files()

        # Finally save the manifest file.  This must be last of course
        self._add_file(self.manifest().manifest_path(), description = 'package manifest file')


    def _store_resource_files(self):
        """
        @brief Store additional files added by the driver developer.  These files life in the driver resource dir.
        """
        log.debug( " -- Searching for developer added resource files." )

        for file in os.listdir(self.generator.resource_dir()):
            log.debug("    ++ found: " + file)
            desc = prompt.text( 'Describe ' + file )
            self._add_file(self.generator.resource_dir() + "/" + file, 'resource', desc)


    def _add_file(self, source, destdir=None, description=None):
        """
        @brief Add a file to the zip package and store the file in the manifest.
        """
        filename = os.path.basename(source)
        dest = filename
        if(destdir):
            dest = "%s/%s" % (destdir, filename)

        log.debug( "archive %s to %s" % (filename, dest) )

        self.manifest().add_file(dest, description);
        self.zipfile().write(source, dest, self.zipfile_compression())
예제 #13
0
 def fetch_metadata(self):
     """
     @brief collect metadata from the user
     """
     self.metadata = Metadata()