Beispiel #1
0
 def __init__(self):
     """
     Initialization Method...
     """
     self.logger = CyLogger()
     
     self.getLibc()
class test_libHelperFunctions(unittest.TestCase):
    """ 
    """
    @classmethod
    def setUpClass(self):
        """ 
        """
        self.logger = CyLogger(debug_mode=True)
        self.logger.initializeLogs()
        self.logger.log(lp.DEBUG, "Test " + self.__name__ + " initialized...")

    @classmethod
    def tearDownClass(self):
        """ 
        """
        pass

    def test_FoundException(self):
        """ 
        """
        pass

    def test_get_os_vers(self):
        """ 
        """
        pass

    def test_get_os_minor_vers(self):
        """ 
        """
        pass
Beispiel #3
0
 def __init__(self, logger):
     """
     """
     if logger:
         self.logger = logger
     else:
         self.logger = CyLogger()
     self.module_version = '20160224.032043.009191'
     self.prefix = []
 def setUpClass(self):
     """
     """
     #####
     # Set up logging
     self.logger = CyLogger(debug_mode=True)
     self.logger.initializeLogs()
     self.rw = RunWith(self.logger)
     #####
     # Start timer in miliseconds
     self.test_start_time = datetime.now()
    def setUpClass(self):
        """
        Initializer
        """
        unittest.SkipTest("Tests need to be written...")
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

        self.logger = CyLogger()
        self.logger.initializeLogs()

        self.libcPath = None  # initial initialization
Beispiel #6
0
    def setUpClass(self):
        """
        """
        #####
        # Set up logging
        self.logger = CyLogger(debug_mode=True)
        self.logger.initializeLogs()
        self.rw = RunWith(self.logger)

        self.enviro = Environment()
        self.ca = CheckApplicable(self.enviro, LOGGER)

        #####
        # Start timer in miliseconds
        self.testStartTime = datetime.now()
    def tearDownClass(self):
        """
        disconnect ramdisk
        """
        self.logger = CyLogger()
        #####
        # capture end time
        test_end_time = datetime.now()

        #####
        # Calculate and log how long it took...
        test_time = (test_end_time - self.test_start_time)

        self.logger.log(
            lp.INFO, self.__module__ + " took " + str(test_time) +
            " time to complete...")
Beispiel #8
0
def detach(device=" ", logger=False):
    """
    Eject the ramdisk
    Detach (on the mac) is a better solution than unmount and eject
    separately.. Besides unmounting the disk, it also stops any processes
    related to the mntPoint

    @author: Roy Nielsen
    """
    success = False
    if not logger:
        logger = CyLogger()
    else:
        logger = logger
    myRunWith = RunWith(logger)
    if not re.match("^\s*$", device):
        cmd = ["/usr/bin/hdiutil", "detach", device]
        myRunWith.setCommand(cmd)
        myRunWith.communicate()
        retval, reterr, retcode = myRunWith.getNlogReturns()
        if not reterr:
            success = True

        myRunWith.getNlogReturns()
    else:
        raise Exception("Cannot eject a device with an empty name..")
    return success
    def setUpClass(self):
        """
        Initializer
        """
        unittest.SkipTest("Tests need to be written...")
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

        self.logger = CyLogger()

        self.libcPath = None  # initial initialization

        #####
        # If we don't have a supported platform, skip this test.
        if not sys.platform.startswith("darwin") and \
           not sys.platform.startswith("linux"):
            raise unittest.SkipTest("This is not valid on this OS")
        raise unittest.SkipTest("Not a supported tests....")
    def setUpClass(self):
        """
        """
        self.libc = getLibc()
        self.subdirs = ["two", "three" "one/four"]
        self.logger = CyLogger()
        self.logger.log(lp.CRITICAL, "Logger initialized............................")

        """
        Set up a ramdisk and use that random location as a root to test the
        filesystem functionality of what is being tested.
        """
        #Calculate size of ramdisk to make for this unit test.
        size_in_mb = 1800
        ramdisk_size = size = size_in_mb
        self.mnt_pnt_requested = "testmntpnt"

        self.success = False
        self.mountPoint = ""
        self.ramdiskDev = False
        self.mnt_pnt_requested = False

        # get a ramdisk of appropriate size, with a secure random mountpoint
        self.my_ramdisk = RamDisk(str(ramdisk_size), self.mnt_pnt_requested, logger=self.logger)
        (self.success, self.mountPoint, self.ramdiskDev) = self.my_ramdisk.getData()
        self.logger.log(lp.WARNING, str(self.success) + " : " + str(self.mountPoint) + " : " + str(self.ramdiskDev))
        self.mount = self.mountPoint

        self.logger.log(lp.INFO, "::::::::Ramdisk Mount Point: " + str(self.mountPoint))
        self.logger.log(lp.INFO, "::::::::Ramdisk Device     : " + str(self.ramdiskDev))

        if not self.success:
            raise IOError("Cannot get a ramdisk for some reason. . .")

        #####
        # Create a temp location on disk to run benchmark tests against
        self.fs_dir = tempfile.mkdtemp()

        # Start timer in miliseconds
        self.test_start_time = datetime.now()

        self.setUpInstanceSpecifics()
Beispiel #11
0
    def __init__(self, size=0, mountpoint=False, logger=False):
        """
        """
        #####
        # Version/timestamp is
        # <YYYY><MM><DD>.<HH><MM><SS>.<microseconds>
        # in UTC time
        self.module_version = '20160224.032043.009191'
        if not isinstance(logger, CyLogger):
            self.logger = CyLogger()
        else:
            self.logger = logger
        self.logger.log(lp.INFO, "Logger: " + str(self.logger))
        self.diskSize = size
        self.success = False
        self.myRamdiskDev = None
        if not mountpoint:
            self.getRandomizedMountpoint()
        else:
            self.mntPoint = mountpoint

        self.logger.log(lp.DEBUG, "disk size: " + str(self.diskSize))
        self.logger.log(lp.DEBUG, "volume name: " + str(self.mntPoint))
class test_libMacOSHelperFunctions(unittest.TestCase):
    """

    """

    @classmethod
    def setUpClass(self):
        """
        """
        #####
        # Set up logging
        self.logger = CyLogger(debug_mode=True)
        self.logger.initializeLogs()
        self.rw = RunWith(self.logger)
        #####
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

    @classmethod
    def tearDownClass(self):
        """
        """
        pass
Beispiel #13
0
class GenericTestUtilities(object):
    """
    Generic class based Yutilities for ramdisk testing...
    
    @author: Roy Nielsen
    """
    def __init__(self):
        """
        Initialization Method...
        """
        self.logger = CyLogger()
        
        self.getLibc()
    ################################################
    ##### Helper Methods
    @classmethod
    def getLibc(self):
        """
        """
        #####
        # For Mac
        try:
            libc = ctypes.CDLL("/usr/lib/libc.dylib")
            # libc = ctypes.CDLL("libc.dylib")
        except OSError:
            #####
            # For Linux
            possible_paths = ["/lib/x86_64-linux-gnu/libc.so.6",
                              "/lib/i386-linux-gnu/libc.so.6",
                              "/usr/lib64/libc.so.6"]
            for path in possible_paths:
    
                if os.path.exists(path):
                    libc = ctypes.CDLL(path)
                    break
    
        try:
            if libc:
                libc.sync()
        except AttributeError:
            raise LibcNotAvailableError("............................Cannot Sync.")
    
        return libc

    ################################################

    def findLinuxLibC(self):
        """
        Find Linux Libc library...

        @author: Roy Nielsen
        """
        possible_paths = ["/lib/x86_64-linux-gnu/libc.so.6",
                          "/lib/i386-linux-gnu/libc.so.6"]
        for path in possible_paths:

            if os.path.exists(path):
                self.libcPath = path
                self.libc = ctypes.CDLL(self.libcPath)
                break

    ################################################
    @classmethod
    def _pass(self):
        """
        Filler if a library didn't load properly
        """
        pass

    ################################################

    def touch(self, fname="", message_level="normal"):
        """
        Python implementation of the touch command..

        @author: Roy Nielsen
        """
        if re.match("^\s*$", str(fname)):
            self.logger.log(lp.WARNING, "Cannot touch a file without a filename....")
        else:
            try:
                os.utime(fname, None)
            except:
                try:
                    open(fname, 'a').close()
                except Exception as err:
                    self.logger.log(lp.WARNING, "Cannot open to touch: " + str(fname))

    ################################################

    def mkdirs(self, path=""):
        """
        A function to do an equivalent of "mkdir -p"
        """
        if not path:
            self.logger.log(lp.WARNING, "Bad path...")
        else:
            if not os.path.exists(str(path)):
                try:
                    os.makedirs(str(path))
                except OSError as err1:
                    self.logger.log(lp.WARNING, "OSError exception attempting to create directory: " + str(path))
                    self.logger.log(lp.WARNING, "Exception: " + str(err1))
                except Exception as err2:
                    self.logger.log(lp.WARNING, "Unexpected Exception trying to makedirs: " + str(err2))

    ################################################

    def mkfile(self, file_path="", file_size=0, pattern="rand", block_size=512, mode=0o777):
        """
        Create a file with "file_path" and "file_size".  To be used in
        file creation benchmarking - filesystem vs ramdisk.

        @parameter: file_path - Full path to the file to create
        @parameter: file_size - Size of the file to create, in Mba
        @parameter: pattern - "rand": write a random pattern
                              "0xXX": where XX is a hex value for a byte
        @parameter: block_size - size of blocks to write in bytes
        @parameter: mode - file mode, default 0o777

        @returns: time in miliseconds the write took

        @author: Roy Nielsen
        """
        total_time = 0
        if file_path and file_size:
            self.libc.sync()
            file_size = file_size * 1024 * 1024
            if os.path.isdir(file_path):
                tmpfile_path = os.path.join(file_path, "testfile")
            else:
                tmpfile_path = file_path
            self.logger.log(lp.DEBUG, "Writing to: " + tmpfile_path)
            try:
                # Get the number of blocks to create
                blocks = file_size/block_size

                # Start timer in miliseconds
                start_time = datetime.now()

                # do low level file access...
                tmpfile = os.open(tmpfile_path, os.O_WRONLY | os.O_CREAT, mode)

                # do file writes...
                for i in range(blocks):
                    tmp_buffer = os.urandom(block_size)
                    os.write(tmpfile, str(tmp_buffer))
                    os.fsync(tmpfile)
                self.libc.sync()
                os.close(tmpfile)
                self.libc.sync()
                os.unlink(tmpfile_path)
                self.libc.sync()

                # capture end time
                end_time = datetime.now()
            except Exception as err:
                self.logger.log(lp.WARNING, "Exception trying to write temp file for "  + \
                                "benchmarking...")
                self.logger.log(lp.WARNING, "Exception thrown: " + str(err))
                total_time = 0
            else:
                total_time = end_time - start_time
        return total_time
Beispiel #14
0
                      help="Signature to sign with..")
    parser.add_option("-v", "--verbose", dest="verbose",
                      default="",
                      help="Determine verbosity if performing a codesign.")
    
    (opts, args) = parser.parse_args()
    
    log_level = ""
    if opts.debug:
        loglevel = 20
    elif opts.verbose:
        loglevel = 30
    else:
        loglevel = 40

    logger = CyLogger(level=lp.DEBUG)
    
    logger.initializeLogs()

    logger.log(lp.DEBUG, "Logger initialized")

    os.environ['DEVELOPER_DIR'] = '/Applications/Xcode.app/Contents/Developer'

    keychainPass = False

    if opts.password:
        #####
        # On the other end, each character was translated by 'ord' to a number,
        # and each number was separated by a colon.  Change the password from
        # letters that have been converted to a number via the 'ord' function
        # back to the origional character
Beispiel #15
0
    def __init__(self,
                 options=optparse.Values({"compileGui": False, "version": "0",
                                          "clean": False, "test": False, "debug":False, "sig":False}),
                 ramdisk_size=1024):
        '''
        Build .pkg and .dmg for stonix4mac
        @param ramdisk_size: int that defines ramdisk size in MB
        @param debug: to print debug messages
        '''
        if isinstance(options.debug, bool) and options.debug:
            debug = 20
        else:
            debug = 40
        self.logger = CyLogger(level=debug)
        self.logger.initializeLogs()
        self.ramdisk_size = ramdisk_size

        self.libc = getLibc()

        if options.sig:
            self.codesignSignature = options.sig

        self.mbl = None
        # This script needs to be run from [stonixroot]/src/MacBuild; make sure
        # that is our current operating location
        cwd = os.getcwd()
        if not re.search("src/MacBuild$", cwd):
            print "This script needs to be run from src/MacBuild. Exiting..."
            exit(1)

        try:
            rmtree("/tmp/the_luggage")
        except OSError as e:
            if not e.errno == 2:
                raise
        if options.clean:
            self.clean()

        # If version was not included at command line, use hardcoded version
        # number
        if options.version == "0":
            self.APPVERSION = "0.9.5.0"
        else:
            self.APPVERSION = options.version

        self.compileGui = options.compileGui

        if not self.confParser():
            raise ConfusingConfigurationError("Cannot determine the correct configuration...")

        self.RSYNC = "/usr/bin/rsync"

        print " "
        print " "
        print "   ************************************************************"
        print "   ************************************************************"
        print "   ***** App Version: " + self.APPVERSION
        print "   ************************************************************"
        print "   ************************************************************"
        print " "
        print " "

        self.keyuser = raw_input("Keychain User: "******"Keychain Password: ") 

        if not options.test:
            self.driver()
Beispiel #16
0
class MacBuilder():

    def __init__(self,
                 options=optparse.Values({"compileGui": False, "version": "0",
                                          "clean": False, "test": False, "debug":False, "sig":False}),
                 ramdisk_size=1024):
        '''
        Build .pkg and .dmg for stonix4mac
        @param ramdisk_size: int that defines ramdisk size in MB
        @param debug: to print debug messages
        '''
        if isinstance(options.debug, bool) and options.debug:
            debug = 20
        else:
            debug = 40
        self.logger = CyLogger(level=debug)
        self.logger.initializeLogs()
        self.ramdisk_size = ramdisk_size

        self.libc = getLibc()

        if options.sig:
            self.codesignSignature = options.sig

        self.mbl = None
        # This script needs to be run from [stonixroot]/src/MacBuild; make sure
        # that is our current operating location
        cwd = os.getcwd()
        if not re.search("src/MacBuild$", cwd):
            print "This script needs to be run from src/MacBuild. Exiting..."
            exit(1)

        try:
            rmtree("/tmp/the_luggage")
        except OSError as e:
            if not e.errno == 2:
                raise
        if options.clean:
            self.clean()

        # If version was not included at command line, use hardcoded version
        # number
        if options.version == "0":
            self.APPVERSION = "0.9.5.0"
        else:
            self.APPVERSION = options.version

        self.compileGui = options.compileGui

        if not self.confParser():
            raise ConfusingConfigurationError("Cannot determine the correct configuration...")

        self.RSYNC = "/usr/bin/rsync"

        print " "
        print " "
        print "   ************************************************************"
        print "   ************************************************************"
        print "   ***** App Version: " + self.APPVERSION
        print "   ************************************************************"
        print "   ************************************************************"
        print " "
        print " "

        self.keyuser = raw_input("Keychain User: "******"Keychain Password: "******"HOME"]
        tmphome = mkdtemp(prefix=current_user + ".")
        os.environ["HOME"] = tmphome
        os.chmod(tmphome, 0755)

        # Create a ramdisk and mount it to the tmphome
        ramdisk = self.setupRamdisk(self.ramdisk_size, tmphome)
        os.mkdir("/tmp/the_luggage")
        luggage = self.setupRamdisk(self.ramdisk_size,
                                    "/tmp/the_luggage")
        print "Device for tmp ramdisk is: " + ramdisk

        # After creation of the ramdisk, all further calls need to be wrapped
        # in a try/except block so that the ramdisk will be detached before
        # exit
        try:
            # Copy src dir to /tmp/<username> so shutil doesn't freak about
            # long filenames.
            # ONLY seems to be a problem on Mavericks
            call([self.RSYNC, "-aqp", "--exclude=\".svn\"",
                  "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                  self.STONIX_ROOT + "/src", tmphome])

            # Compile .ui files to .py files
            if self.compileGui:
                self.compileStonix4MacAppUiFiles(tmphome +
                                                 "/src/MacBuild/stonix4mac")

            # Change the versions in the program_arguments.py in both stonix
            # and stonix4mac
            self.setProgramArgumentsVersion(tmphome +
                                            "/src/stonix_resources/" +
                                            "localize.py")

            # Copy stonix source to scratch build directory
            self.prepStonixBuild(tmphome + "/src/MacBuild")

            # Compile the two apps...
            self.compileApp(self.STONIX, self.STONIXVERSION, self.STONIXICON,
                            tmphome + "/src/MacBuild/" + self.STONIX)
            self.compileApp(self.STONIX4MAC, self.STONIX4MACVERSION,
                            self.STONIX4MACICON, tmphome + "/src/MacBuild/" +
                            self.STONIX4MAC)

            # Restore the HOME environment variable
            os.environ["HOME"] = directory

            # Copy and create all necessary resources to app resources dir.
            # This only gets called for stonix4mac
            self.buildStonix4MacAppResources(self.STONIX4MAC, tmphome +
                                             "/src/MacBuild", tmphome + "/src")

            # Create dmg and pkg with luggage
            self.buildStonix4MacAppPkg(self.STONIX4MAC, self.STONIX4MACVERSION,
                                       tmphome + "/src/MacBuild")

            # Copy back to pseudo-build directory
            call([self.RSYNC, "-aqp", tmphome + "/src", self.STONIX_ROOT])

            os.chdir(self.STONIX_ROOT)
            self.mbl.chownR(current_user, "src")

            # chmod so it's readable by everyone, writable by the group
            self.mbl.chmodR(stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH |
                            stat.S_IWGRP, "src", "append")

            # Return to the start dir
            os.chdir(self.STONIX_ROOT + "/src/MacBuild")
        except (KeyboardInterrupt, SystemExit):
            self.exit(ramdisk, luggage, 130)
        except Exception:
            self.exit(ramdisk, luggage, 1)

        # Eject the ramdisk
        self.detachRamdisk(ramdisk)
        self.detachRamdisk(luggage)

        print " "
        print " "
        print "    Done building stonix4mac.app..."
        print " "
        print " "

    def setupRamdisk(self, size, mntpnt=""):
        ramdisk = RamDisk(str(size), mntpnt)

        if not ramdisk.success:
            print("Ramdisk setup failed...")
            raise Exception("Ramdisk setup failed...")

        return ramdisk.getDevice()

    def detachRamdisk(self, device):
        if detach(device):
            print("Successfully detached disk: " + str(device).strip())
            return True
        else:
            print("Couldn't detach disk: " + str(device).strip())
            raise Exception("Cannot eject disk: " + str(device).strip())

    def exit(self, ramdisk, luggage, exitcode=0):
        os.chdir(self.STONIX_ROOT)
        self.detachRamdisk(ramdisk)
        self.detachRamdisk(luggage)
        print traceback.format_exc()
        exit(exitcode)

    def clean(self):
        '''
        Clean all artifacts from previous builds.
        @author: Eric Ball
        '''
        folders = (["dmgs", "stonix", "stonix4mac/dist", "stonix4mac/private"]
                   + glob("stonix.*") + glob("dmgs.*"))
        files = (glob("*.pyc") + glob("stonix4mac/*.pyc") +
                 glob("stonix4mac/*_ui.py") + glob("stonix4mac/*.spec"))
        for folder in folders:
            try:
                rmtree(folder)
            except OSError as e:
                if not e.errno == 2:
                    raise
        for rmfile in files:
            os.remove(rmfile)
        exit(0)

    def compileStonix4MacAppUiFiles(self, stonix4macDir):
        '''
        Compile the .ui files to .py files for stonix4mac.app. Works within the
        MacBuild/stonix4mac directory

        @author: Roy Nielsen, Eric Ball
        @param stonix4macDir: Path to the [stonixroot]/src/MacBuild/stonix4mac
            directory where this method should work
        '''
        try:
            returnDir = os.getcwd()
            os.chdir(stonix4macDir)

            print "Starting compileStonix4MacAppUiFiles in " + os.getcwd()

            # to compile the .ui files to .py files:
            print "Compiling Qt ui files to python files for stonix4mac.app..."
            call([self.PYUIC, "admin_credentials.ui"],
                 stdout=open("admin_credentials_ui.py", "w"))
            call([self.PYUIC, "stonix_wrapper.ui"],
                 stdout=open("stonix_wrapper_ui.py", "w"))
            call([self.PYUIC, "general_warning.ui"],
                 stdout=open("general_warning_ui.py", "w"))

            os.chdir(returnDir)
        except Exception:
            raise

        print "compileStonix4MacAppUiFiles Finished..."

    def setProgramArgumentsVersion(self, localizePath):
        '''
        Change the STONIX version to the version specified within the build
        script
        @author: Roy Nielsen, Eric Ball
        @param localizePath: Path to the [stonixroot]/src/stonix_resources/
            localize.py file that this method should modify
        '''
        print "Changing versions in localize.py..."
        try:
            self.mbl.regexReplace(localizePath,
                                  r"^STONIXVERSION =.*$",
                                  r"STONIXVERSION = '" + self.APPVERSION + "'",
                                  backupname="../stonix_resources/localize.py.bak")
        except Exception:
            raise

        print "Finished changing versions in localize.py..."

    def prepStonixBuild(self, MacBuildDir):
        '''
        Copy stonix source to app build directory
        @author: Roy Nielsen, Eric Ball
        @param MacBuildDir: Path to the [stonixroot]/src/MacBuild directory
            where this method should work
        '''
        print "Starting prepStonixBuild..."
        try:
            returnDir = os.getcwd()
            os.chdir(MacBuildDir)

            # Make sure the "stonix" directory exists, so we can put
            # together and create the stonix.app
            if os.path.islink("stonix"):
                os.unlink("stonix")
            if not os.path.isdir("stonix"):
                os.mkdir("stonix")
            else:
                # Cannot use mkdtmp here because it will make the directory on
                # the root filesystem instead of the ramdisk, then it will try
                # to link across filesystems which won't work
                tmpdir = "stonix." + str(time())
                os.rename("stonix", tmpdir)
                os.mkdir("stonix")

            copy2("../stonix.py", "stonix")
            call([self.RSYNC, "-ap", "--exclude=\".svn\"",
                  "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                  "--exclude=\".git*\"", "../stonix_resources", "./stonix"])

            os.chdir(returnDir)
        except Exception:
            raise
        print "prepStonixBuild Finished..."

    def compileApp(self, appName, appVersion, appIcon, appPath):
        '''
        Compiles stonix4mac.app
        @author: Roy Nielsen, Eric Ball
        @param appName: Name of application as it should appear on OS X systems
        @param appVersion: Version of app being built
        @param appIcon: File name of icon for OS X app
        @param appPath: Path to [stonixroot]/src/MacBuild/[appName]
        '''
        print "Started compileApp with " + appName + ", " + appVersion + \
            ", " + appIcon
        try:
            returnDir = os.getcwd()
            os.chdir(appPath)

            self.logger.log(lp.DEBUG, "...")
            self.logger.log(lp.DEBUG, "...")
            self.logger.log(lp.DEBUG, "...")
            self.logger.log(lp.DEBUG, "\n\n\tPWD: " + appPath + " \n\n")
            myfiles = os.listdir('.')
            self.logger.log(lp.DEBUG, "\n\tDIRS: " + str(myfiles))
            self.logger.log(lp.DEBUG, "...")
            self.logger.log(lp.DEBUG, "...")
            self.logger.log(lp.DEBUG, "...")

            if os.path.isdir("build"):
                rmtree("build")
            if os.path.isdir("dist"):
                rmtree("dist")

            self.logger.log(lp.DEBUG, "Hidden imports: " + str(self.hiddenimports))

            hdnimports = self.hiddenimports + ['ctypes', '_ctypes', 'ctypes._endian', 'decimal', 'numbers']

            # to compile a pyinstaller spec file for app creation:
            print "Creating a pyinstaller spec file for the project..."
            print self.mbl.pyinstMakespec([appName + ".py"], True, True, False,
                                          "../" + appIcon + ".icns",
                                         pathex=["stonix_resources/rules",
                                                  "stonix_resources", "/usr/lib"] + self.PYPATHS,
                                          specpath=os.getcwd(), hiddenimports=hdnimports)
            '''
            if appName == "stonix":
                fo = open(appName + ".spec", "r")
                spectext = fo.read()
                fo.close()
                spectext = spectext.replace("hiddenimports=[]",
                                            "hiddenimports=['ctypes', " +
                                            "'_ctypes', 'ctypes._endian', " +
                                            "'decimal', 'numbers']")
                fo = open(appName + ".spec", "w")
                fo.write(spectext)
                fo.close()
            '''
            # to build:
            print "Building the app..."
            self.mbl.pyinstBuild(appName + ".spec", "private/tmp",
                                 appPath + "/dist", True, True)

            plist = appPath + "/dist/" + appName + ".app/Contents/Info.plist"

            # Change version string of the app
            print "Changing .app version string..."
            self.mbl.modplist(plist, "CFBundleShortVersionString", appVersion)

            # Change icon name in the app
            print "Changing .app icon..."
            self.mbl.modplist(plist, "CFBundleIconFile", appIcon + ".icns")

            # Copy icons to the resources directory
            copy2("../" + appIcon + ".icns",
                  "./dist/" + appName + ".app/Contents/Resources")

            # Change mode of Info.plist to 0755
            os.chmod(plist, 0755)
            os.chdir('dist')

        except Exception:
            raise

        print "compileApp with " + appName + ", " + appVersion + " Finished..."

    def buildStonix4MacAppResources(self, appName, appPath, appPathParent):
        '''
        Copy and/or create all necessary files to the Resources directory
        of stonix4mac.app
        @author: Roy Nielsen, Eric Ball
        @param appName: Name of application as it should appear on OS X systems
        @param appPath: Path to [stonixroot]/src/MacBuild/[appName]
        '''
        print "Started buildStonix4MacAppResources with \"" + appName + \
            "\" in " + appPath + "..."
        try:
            returnDir = os.getcwd()
            os.chdir(appPath)
            # Copy source to app dir
            call([self.RSYNC, "-aqp", "--exclude=\".svn\"",
                  "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                  "--exclude=\".git*\"", appPathParent + "/stonix_resources",
                  appPath + "/stonix/dist/stonix.app/Contents/MacOS"])

            # Copy stonix.app to the stonix4mac Resources directory
            call([self.RSYNC, "-aqp", "--exclude=\".svn\"",
                  "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                  "--exclude=\".git*\"", appPath + "/stonix/dist/stonix.app",
                  "./" + appName + "/dist/" + appName +
                  ".app/Contents/Resources"])

            # Copy the stonix.conf file
            copy2(appPath + "/../etc/stonix.conf", appPath + "/" + appName +
                  "/dist/" + appName + ".app/Contents/Resources/stonix.conf")

            copy2(appPath + "/stonix/dist/stonix.app/Contents/MacOS/" +
                  "stonix_resources/localize.py", appPath + "/" + appName +
                  "/dist/" + appName + ".app/Contents/MacOS")

            #####
            # Copy helper files to the resources directory
            call([self.RSYNC, "-aqp", appPath + '/' + appName + '/Resources/',
                              appPath + "/" + appName + "/dist/" + appName + \
                              ".app/Contents/Resources"])

            #####
            # Need a disk checkpoint here to make sure all files are flushed
            # to disk, ie perform a filesystem sync.
            self.libc.sync()
            self.libc.sync()
            
            self.mbl.codeSign(self.keyuser, self.keypass, 
                              self.codesignSignature,
                              self.codesignVerbose,
                              self.codesignDeep,
                              "./" + appName + "/dist/" + appName + ".app")

            self.mbl.codeSign(self.keyuser, self.keypass, 
                              self.codesignSignature,
                              self.codesignVerbose,
                              self.codesignDeep,
                              "./" + appName + "/dist/" + appName +
                              ".app/Contents/Resources/stonix.app")

            os.chdir(returnDir)
        except Exception:
            raise
        print "buildStonix4MacAppResources Finished..."

    def buildStonix4MacAppPkg(self, appName, appVersion, appPath):
        '''
        Build installer package and wrap into a dmg
        @author: Roy Nielsen, Eric Ball
        @param appName: Name of application as it should appear on OS X systems
        @param appVersion: Version of app being built
        @param appPath: Path to [stonixroot]/src/MacBuild
        '''

        print "Started buildStonix4MacAppPkg..."
        try:
            returnDir = os.getcwd()
            os.chdir(appPath + "/" + appName)

            print "Putting new version into Makefile..."
            self.mbl.regexReplace("Makefile", r"PACKAGE_VERSION=",
                                  "PACKAGE_VERSION=" + appVersion)

            if not os.path.isdir(appPath + "/dmgs"):
                os.mkdir(appPath + "/dmgs")
            else:
                # Cannot use mkdtmp here because it will make the directory on
                # the root filesystem instead of the ramdisk, then it will try
                # to link across filesystems which won't work
                tmpdir = appPath + "/dmgs." + str(time())
                os.rename(appPath + "/dmgs", tmpdir)
                os.mkdir(appPath + "/dmgs")

            print "Creating a .dmg file with a .pkg file inside for " + \
                "installation purposes..."
            #call(["make", "dmg", "PACKAGE_VERSION=" + appVersion,
            #      "USE_PKGBUILD=1"])
            call(["make", "pkg", "PACKAGE_VERSION=" + appVersion,
                  "USE_PKGBUILD=1"])

            print "Moving dmg and pkg to the dmgs directory."
            #dmgname = appName + "-" + appVersion + ".dmg"
            pkgname = appName + "-" + appVersion + ".pkg"
            #os.rename(dmgname, appPath + "/dmgs/" + dmgname)
            os.rename(pkgname, appPath + "/dmgs/" + pkgname)

            os.chdir(returnDir)
        except Exception:
            raise
        print "buildStonix4MacAppPkg... Finished"

    def configSectionMap(self, section):
        '''
        Acquire values from the config file and store in a dictionary.

        @author: rsn
        '''
        dict1 = {}
        options = self.parser.options(section)
        for option in options:
            try:
                dict1[option] = self.parser.get(section, option)
                if dict1[option] == -1:
                    self.logger.log(lp.DEBUG, "skip: %s" % option)
            except:
                print("exception on %s!" % option)
                dict1[option] = None
        print dict1
        return dict1

    def confParser(self):
        """
        Parse a config file to find potential conf file settings.

        @author: rsn
        """
        success = False
        # This script should be run from [stonixroot]/src/MacBuild. We must
        os.chdir("../..")
        self.STONIX_ROOT = os.getcwd()
        os.chdir("src/MacBuild")
        macbuild_root = os.getcwd()
        myconf = os.path.join(macbuild_root, 'macbuild.conf')
        print myconf
        if os.path.isfile(myconf):
            self.parser = SafeConfigParser()
            candidates =  [myconf, 'not_a_real_conf.conf']
            found = self.parser.read(candidates)
            missing = set(candidates) - set(found)

            try:
                dict1 = {}
                for section in self.parser.sections():
                    dict1[section] = self.configSectionMap(section)
                print dict1
            except:
                #####
                # happens if there was a problem attempting to read the config
                # file, Initializing class variables.
                self.STONIX = "stonix"
                self.STONIXICON = "stonix_icon"
                self.STONIXVERSION = self.APPVERSION
                self.STONIX4MAC = "stonix4mac"
                self.STONIX4MACICON = "stonix_icon"
                self.STONIX4MACVERSION = self.APPVERSION                
                #-- Internal libraries
                from macbuildlib import macbuildlib
                self.mbl = macbuildlib(self.logger)
                self.PYUIC = self.mbl.getpyuicpath()
                self.codesignVerbose = 'vvvv'
                self.codesignDeep = True
            else:
                #####
                # Config file read, initializing class variables.
                self.STONIX = dict1['stonix']['app']
                self.STONIXICON = dict1['stonix']['app_icon']
                self.STONIXVERSION = dict1['stonix']['app_version']
                self.STONIX4MAC = dict1['stonix']['wrapper']
                self.STONIX4MACICON = dict1['stonix']['wrapper_icon']
                self.STONIX4MACVERSION = dict1['stonix']['wrapper_version']
                self.PYUIC = dict1['libpaths']['pyuic']
                self.PYPATHS = dict1['libpaths']['pythonpath'].split(':')
                self.logger.log(lp.INFO, 'attempting to get codesigning information...')
                self.codesignVerbose = dict1['codesign']['verbose']
                if re.match('^True$', dict1['codesign']['deep']):
                    self.codesignDeep = True
                else:
                    self.codesignDeep = False
                self.logger.log(lp.INFO, "Grabbed codesign info...")
                for path in self.PYPATHS:
                    sys.path.append(path)
                #-- Internal libraries
                try:
                    from macbuildlib import macbuildlib
                    self.mbl = macbuildlib(self.logger, self.PYPATHS)
                except Exception, err:
                    raise
                self.logger.log(lp.INFO, "... macbuildlib loaded ...")
            finally:
                  "--debug",
                  action="store_true",
                  dest="debug",
                  default=0,
                  help="Print debug messages")
parser.add_option("-v",
                  "--verbose",
                  action="store_true",
                  dest="verbose",
                  default=0,
                  help="Print status messages")

(opts, args) = parser.parse_args()

if opts.verbose != 0:
    level = CyLogger(level=lp.INFO)
elif opts.debug != 0:
    level = CyLogger(level=lp.DEBUG)
else:
    level = lp.WARNING

if (not isinstance(opts.device, str) and \
   re.match("^[A-Za-z0-9/]+$", opts.device)) or not opts.device:
    print("Cannot detach a device with no name..")
    parser.print_help()
else:
    device = opts.device

    logger = CyLogger(level=level)
    logger.initializeLogs()
class test_ramdiskFactory(unittest.TestCase, GenericTestUtilities):
    """
    """
    @classmethod
    def setUpClass(self):
        """
        Initializer
        """
        unittest.SkipTest("Tests need to be written...")
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

        self.logger = CyLogger()

        self.libcPath = None  # initial initialization

        #####
        # If we don't have a supported platform, skip this test.
        if not sys.platform.startswith("darwin") and \
           not sys.platform.startswith("linux"):
            raise unittest.SkipTest("This is not valid on this OS")
        raise unittest.SkipTest("Not a supported tests....")

    def setUp(self):
        """
        This method runs before each test run.

        @author: Roy Nielsen
        """
        pass

###############################################################################
##### Method Tests

##################################

    def test_ramdiskFactoryFirstTest(self):
        """
        """
        pass

    ##################################

    def test_ramdiskFactorySecondTest(self):
        """
        """
        pass

###############################################################################
##### Functional Tests

###############################################################################
##### unittest Tear down

    @classmethod
    def tearDownClass(self):
        """
        disconnect ramdisk
        """
        self.logger = CyLogger()
        #####
        # capture end time
        test_end_time = datetime.now()

        #####
        # Calculate and log how long it took...
        test_time = (test_end_time - self.test_start_time)

        self.logger.log(
            lp.INFO, self.__module__ + " took " + str(test_time) +
            " time to complete...")
Beispiel #19
0
#!/usr/bin/python
import sys
sys.path.append('..')
import getpass
import ramdisk
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp
from ramdisk.lib.manage_keychain.manage_keychain import ManageKeychain

passwd = getpass.getpass("Password: "******"Keychain: ")

logger = CyLogger(debug_mode=True)
print str(logger)
logger.initializeLogs()
mk = ManageKeychain(logger)
success = False
if (mk.lockKeychain(allKeychains=True)):
    success, _ = mk.unlockKeychain(passwd, keychain)

print "Success: " + str(success)



Beispiel #20
0
class RamDiskTemplate(object):
    """
    """
    def __init__(self, size=0, mountpoint=False, logger=False):
        """
        """
        #####
        # Version/timestamp is
        # <YYYY><MM><DD>.<HH><MM><SS>.<microseconds>
        # in UTC time
        self.module_version = '20160224.032043.009191'
        if not isinstance(logger, CyLogger):
            self.logger = CyLogger()
        else:
            self.logger = logger
        self.logger.log(lp.INFO, "Logger: " + str(self.logger))
        self.diskSize = size
        self.success = False
        self.myRamdiskDev = None
        if not mountpoint:
            self.getRandomizedMountpoint()
        else:
            self.mntPoint = mountpoint

        self.logger.log(lp.DEBUG, "disk size: " + str(self.diskSize))
        self.logger.log(lp.DEBUG, "volume name: " + str(self.mntPoint))

    ###########################################################################

    def getData(self):
        """
        Getter for mount data, and if the mounting of a ramdisk was successful

        Does not print or log the data.

        @author: Roy Nielsen
        """
        return (self.success, str(self.mntPoint), str(self.myRamdiskDev))

    ###########################################################################

    def getNlogData(self):
        """
        Getter for mount data, and if the mounting of a ramdisk was successful

        Also logs the data.

        @author: Roy Nielsen
        """
        self.logger.log(lp.INFO, "Success: " + str(self.success))
        self.logger.log(lp.INFO, "Mount point: " + str(self.mntPoint))
        self.logger.log(lp.INFO, "Device: " + str(self.myRamdiskDev))
        return (self.success, str(self.mntPoint), str(self.myRamdiskDev))

    ###########################################################################

    def getNprintData(self):
        """
        Getter for mount data, and if the mounting of a ramdisk was successful
        """
        print("Success: " + str(self.success))
        print("Mount point: " + str(self.mntPoint))
        print("Device: " + str(self.myRamdiskDev))
        return (self.success, str(self.mntPoint), str(self.myRamdiskDev))

    ###########################################################################

    def getRandomizedMountpoint(self):
        """
        Create a randomized (secure) mount point - per python's implementation
        of mkdtemp - a way to make an unguessable directory on the system

        @author: Roy Nielsen
        """
        success = False
        self.mntPoint = ""
        try:
            self.mntPoint = mkdtemp()
        except Exception as err:
            self.logger.log(lp.WARNING,
                            "Exception trying to create temporary directory")
            raise err
        else:
            success = True
            self.logger.log(
                lp.WARNING, "Success: " + str(success) +
                " in get_randomizedMountpoint: " + str(self.mntPoint))
        self.logger.log(
            lp.WARNING,
            "Randomized mount point: \"" + str(self.mntPoint) + "\"")
        return success

    ###########################################################################

    def umount(self):
        """
        Unmount the disk - same functionality as __eject on the mac

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        success = False
        return success

    ###########################################################################

    def unmount(self):
        """
        Unmount the disk - same functionality as __eject on the mac

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        success = False
        return success

    ###########################################################################

    def __isMemoryAvailable(self):
        """
        Check to make sure there is plenty of memory of the size passed in
        before creating the ramdisk

        @author: Roy Nielsen
        """
        success = False
        return success

    ###########################################################################

    def _format(self):
        """
        Format the ramdisk

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        success = False
        return success

    ###########################################################################

    def getDevice(self):
        """
        Getter for the device name the ramdisk is using

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        return self.myRamdiskDev

    ###########################################################################

    def getMountPoint(self):
        """
        Getter for the mount point name the ramdisk is using

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        return self.mntPoint

    ###########################################################################

    def setDevice(self, device=None):
        """
        Setter for the device so it can be ejected.

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        self.myRamdiskDev = device

    ###########################################################################

    def getVersion(self):
        """
        Getter for the version of the ramdisk

        Must be over-ridden to provide OS/Method specific functionality

        @author: Roy Nielsen
        """
        return self.module_version
Beispiel #21
0
#!/usr/bin/env -S python -u

import traceback
import getpass
import sys

sys.path.append("../")

from ramdisk.lib.manage_user.manage_user import ManageUser
from ramdisk.lib.manage_keychain.manage_keychain import ManageKeychain
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp

logger = CyLogger(debug_mode=True)
logger.initializeLogs()
mu = ManageUser(logger)
mk = ManageKeychain(logger)

username = input("Username: "******"Password: "******"New Password: "******"Repeat New Password: "******"huh?"
klock_success = "huh?"
kpass_success = "huh?"
 def setUpClass(self):
     """ 
     """
     self.logger = CyLogger(debug_mode=True)
     self.logger.initializeLogs()
     self.logger.log(lp.DEBUG, "Test " + self.__name__ + " initialized...")
class test_libHelperExceptions(unittest.TestCase):
    """
    """
    @classmethod
    def setUpClass(self):
        """
        Initializer
        """
        unittest.SkipTest("Tests need to be written...")
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

        self.logger = CyLogger()
        self.logger.initializeLogs()

        self.libcPath = None  # initial initialization

    def setUp(self):
        """
        This method runs before each test run.

        @author: Roy Nielsen
        """
        self.libcPath = None  # initial initialization
        #####
        # setting up to call ctypes to do a filesystem sync
        if sys.platform.startswith("darwin"):
            #####
            # For Mac
            self.libc = C.CDLL("/usr/lib/libc.dylib")
        elif sys.platform.startswith("linux"):
            #####
            # For Linux
            self.findLinuxLibC()
            self.libc = C.CDLL(self.libcPath)
        else:
            self.libc = self._pass()

###############################################################################
##### Helper Classes

    def setMessageLevel(self, msg_lvl="normal"):
        """
        Set the logging level to what is passed in.
        """
        self.message_level = msg_lvl

    def findLinuxLibC(self):
        """
        Find Linux Libc library...

        @author: Roy Nielsen
        """
        possible_paths = [
            "/lib/x86_64-linux-gnu/libc.so.6", "/lib/i386-linux-gnu/libc.so.6"
        ]
        for path in possible_paths:

            if os.path.exists(path):
                self.libcPath = path
                break

    def _pass(self):
        """
        Filler if a library didn't load properly
        """
        pass

###############################################################################
##### Method Tests

##################################

    def test_init(self):
        """
        """
        pass

    ##################################

###############################################################################
##### Functional Tests

##################################

###############################################################################
##### unittest Tear down

    @classmethod
    def tearDownClass(self):
        """
        disconnect ramdisk
        """
        # self.logger = CyLogger()
        #####
        # capture end time
        test_end_time = datetime.now()

        #####
        # Calculate and log how long it took...
        test_time = (test_end_time - self.test_start_time)

        self.logger.log(lp.INFO, self.__module__ + " took " + str(test_time) + \
                        " time to complete...")
Beispiel #24
0
import sys
import copy
import time
import platform
import unittest
import ctypes as C
from datetime import datetime

sys.path.append("..")

# --- Non-native python libraries in this source tree
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp
from ramdisk.lib.getLibc import getLibc

LOGGER = CyLogger()
#LOGGER.setInitialLoggingLevel(30)


class test_getLibcTwo(unittest.TestCase):
    """
    """
    libc = getLibc()

    ##################################

    def test_get_euid(self):
        """
        """
        # libc = getLibc()
        c_euid = self.libc.geteuid()
import sys
import time
import unittest
import tempfile
from datetime import datetime

sys.path.append("..")

#--- non-native python libraries in this source tree
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp
from ramdisk.commonRamdiskTemplate import RamDiskTemplate, \
                                          BadRamdiskArguments, \
                                          NotValidForThisOS

LOGGER = CyLogger()


class test_commonRamdiskTemplate(unittest.TestCase):
    """
    """
    metaVars = {'setupDone': None, 'testStartTime': 0, 'setupCount': 0}

    def setUp(self):
        """
        Runs once before any tests start
        """
        self.metaVars['setupCount'] = self.metaVars['setupCount'] + 1

        if self.metaVars['setupDone']:
            return
Beispiel #26
0
    def __init__(self,
                 options=optparse.Values({"compileGui": False, "version": "0",
                                          "clean": False, "test": False,
                                          "debug":False, "sig":False,
                                          "hiddenImports":False,
                                          "keychain":''}),
                 ramdisk_size=1600):
        '''
        Initialization routine.
        @param: compileGui - bool to determine if the gui should be compiled
                             or not
        @param: version - if passed in, the version to use for app and package
                          creation.
        @param: clean - bool to determine whether or not to clean artifacts
                        from previous builds
        @param: test - Don't run the driver - specifically for unit testing
        @param: debug - bool to determine whether or not to log in debug mode
        @param: sig - signature to use for application and package signing
                      in the build process
        '''
        if isinstance(options.debug, bool) and options.debug:
            debug = 20
        else:
            debug = 40

        # format log file name according to tracker artf55027
        datestamp = datetime.datetime.now()
        stamp = datestamp.strftime("%Y-%m-%d_%H-%M-%S")
        log_name = "build-output_" + str(stamp) + ".log"
        # set macbuild logging path according to tracker artf55027
        try:
            log_path = os.path.dirname(os.path.realpath(__file__))
        except (IOError, OSError, AttributeError):
            log_path = os.getcwd()

        #####
        # helper class initialization
        self.logger = CyLogger(level=debug)
        # initialize the logger object to log macbuild.py logs according to tracker artf55027
        self.logger.initializeLogs(logdir=log_path, filename=log_name)
        self.rw = RunWith(self.logger)
        self.mu = ManageUser(self.logger)
        self.mk = ManageKeychain(self.logger)
        self.ramdisk_size = ramdisk_size
        self.libc = getLibc()

        #####
        # Handle command line options
        self.mbl = None
        self.signature = options.sig
        self.includeHiddenImports = options.hiddenImports
        self.keychain = options.keychain
        self.noExit = options.noExit

        # This script needs to be run from [stonixroot]/src/MacBuild; make sure
        # that is our current operating location
        cwd = os.getcwd()
        if not re.search("src/MacBuild$", cwd):
            print("This script needs to be run from src/MacBuild. Exiting...")
            exit(1)

        try:
            rmtree("/tmp/the_luggage")
        except OSError as e:
            if not e.errno == 2:
                raise
        #if options.clean:
        #    self.clean()

        if FISMACAT is not None and FISMACAT != '':
            self.FISMACAT = FISMACAT
        else:
            self.FISMACAT = "low"

        # If version was not included at command line, use hardcoded version
        # number
        if options.version == "0":
            self.APPVERSION = "0.9.5.1"
        else:
            self.APPVERSION = options.version

        self.compileGui = options.compileGui

        if not self._configParser():
            raise ConfusingConfigurationError("Cannot determine the correct configuration...")

        self.RSYNC = "/usr/bin/rsync"

        print(" ")
        print(" ")
        print("   ************************************************************")
        print("   ************************************************************")
        print(("   ***** App Version: " + self.APPVERSION))
        print("   ************************************************************")
        print("   ************************************************************")
        print(" ")
        print(" ")

        if self.signature:
            count = 0
            while count < 3:
                success = False
                self.keyuser = os.environ['SUDO_USER']
                self.keypass = getpass.getpass("Keychain Password: "******"Sorry, Keychain password is not valid... Please try again.")
                count += 1
            if not success:
                sys.exit(1)
            #####
            # Get a translated password
            self.ordPass = self.getOrdPass(self.keypass)

        else:
            self.keyuser = getpass.getuser()
            self.keypass = False
            self.ordPass = False

        if not options.test:
            self.driver()
Beispiel #27
0
class SoftwareBuilder():
    '''Class to manage the build process.  Initially used with the Stonix project
    on the Mac platform, will be used for others as well.


    '''
    def __init__(self,
                 options=optparse.Values({"compileGui": False, "version": "0",
                                          "clean": False, "test": False,
                                          "debug":False, "sig":False,
                                          "hiddenImports":False,
                                          "keychain":''}),
                 ramdisk_size=1600):
        '''
        Initialization routine.
        @param: compileGui - bool to determine if the gui should be compiled
                             or not
        @param: version - if passed in, the version to use for app and package
                          creation.
        @param: clean - bool to determine whether or not to clean artifacts
                        from previous builds
        @param: test - Don't run the driver - specifically for unit testing
        @param: debug - bool to determine whether or not to log in debug mode
        @param: sig - signature to use for application and package signing
                      in the build process
        '''
        if isinstance(options.debug, bool) and options.debug:
            debug = 20
        else:
            debug = 40

        # format log file name according to tracker artf55027
        datestamp = datetime.datetime.now()
        stamp = datestamp.strftime("%Y-%m-%d_%H-%M-%S")
        log_name = "build-output_" + str(stamp) + ".log"
        # set macbuild logging path according to tracker artf55027
        try:
            log_path = os.path.dirname(os.path.realpath(__file__))
        except (IOError, OSError, AttributeError):
            log_path = os.getcwd()

        #####
        # helper class initialization
        self.logger = CyLogger(level=debug)
        # initialize the logger object to log macbuild.py logs according to tracker artf55027
        self.logger.initializeLogs(logdir=log_path, filename=log_name)
        self.rw = RunWith(self.logger)
        self.mu = ManageUser(self.logger)
        self.mk = ManageKeychain(self.logger)
        self.ramdisk_size = ramdisk_size
        self.libc = getLibc()

        #####
        # Handle command line options
        self.mbl = None
        self.signature = options.sig
        self.includeHiddenImports = options.hiddenImports
        self.keychain = options.keychain
        self.noExit = options.noExit

        # This script needs to be run from [stonixroot]/src/MacBuild; make sure
        # that is our current operating location
        cwd = os.getcwd()
        if not re.search("src/MacBuild$", cwd):
            print("This script needs to be run from src/MacBuild. Exiting...")
            exit(1)

        try:
            rmtree("/tmp/the_luggage")
        except OSError as e:
            if not e.errno == 2:
                raise
        #if options.clean:
        #    self.clean()

        if FISMACAT is not None and FISMACAT != '':
            self.FISMACAT = FISMACAT
        else:
            self.FISMACAT = "low"

        # If version was not included at command line, use hardcoded version
        # number
        if options.version == "0":
            self.APPVERSION = "0.9.5.1"
        else:
            self.APPVERSION = options.version

        self.compileGui = options.compileGui

        if not self._configParser():
            raise ConfusingConfigurationError("Cannot determine the correct configuration...")

        self.RSYNC = "/usr/bin/rsync"

        print(" ")
        print(" ")
        print("   ************************************************************")
        print("   ************************************************************")
        print(("   ***** App Version: " + self.APPVERSION))
        print("   ************************************************************")
        print("   ************************************************************")
        print(" ")
        print(" ")

        if self.signature:
            count = 0
            while count < 3:
                success = False
                self.keyuser = os.environ['SUDO_USER']
                self.keypass = getpass.getpass("Keychain Password: "******"Sorry, Keychain password is not valid... Please try again.")
                count += 1
            if not success:
                sys.exit(1)
            #####
            # Get a translated password
            self.ordPass = self.getOrdPass(self.keypass)

        else:
            self.keyuser = getpass.getuser()
            self.keypass = False
            self.ordPass = False

        if not options.test:
            self.driver()

    #--------------------------------------------------------------------------
    # Private support methods

    def _setupRamdisk(self, size, mntpnt=""):
        ramdisk = RamDisk(str(size), mntpnt)

        if not ramdisk.success:
            print("Ramdisk setup failed...")
            raise Exception("Ramdisk setup failed...")

        return ramdisk.getDevice()

    def _detachRamdisk(self, device):
        if detach(device):
            print("Successfully detached disk: " + str(device).strip())
            return True
        else:
            print("Couldn't detach disk: " + str(device).strip())
            raise Exception("Cannot eject disk: " + str(device).strip())

    def _exit(self, ramdisk, luggage, exitcode=0):
        os.chdir(self.STONIX_ROOT)
        self._detachRamdisk(ramdisk)
        self._detachRamdisk(luggage)
        print((traceback.format_exc()))
        exit(exitcode)

    def _configSectionMap(self, section):
        '''Acquire values from the config file and store in a dictionary.
        
        @author: rsn

        :param section: 

        '''
        dict1 = {}
        options = self.parser.options(section)
        for option in options:
            try:
                dict1[option] = self.parser.get(section, option)
                if dict1[option] == -1:
                    self.logger.log(lp.DEBUG, "skip: %s" % option)
            except:
                print("exception on %s!" % option)
                dict1[option] = None
        print(dict1)
        return dict1

    def _configParser(self):
        '''Parse config file and instanciate/initialize class variables from
        config file data.


        '''
        success = False

        # This script should be run from [stonixroot]/src/MacBuild. We must
        os.chdir("../..")
        self.STONIX_ROOT = os.getcwd()
        os.chdir("src/MacBuild")
        macbuild_root = os.getcwd()
        myconf = os.path.join(macbuild_root, 'build.conf')
        print(myconf)
        self.logger.log(lp.INFO, "... macbuildlib loaded ...")
        self.PYPATHS = []

        try:
            if not os.path.isfile(myconf):
                raise ConfusingConfigurationError("Configuration File Does Not Exist...")
            self.parser = ConfigParser()
            candidates =  [myconf, 'not_a_real_conf.conf']
            found = self.parser.read(candidates)
            missing = set(candidates) - set(found)

            dict1 = {}
            for section in self.parser.sections():
                dict1[section] = self._configSectionMap(section)
            print(dict1)
        except:
            self.STONIX = "stonix"
            self.STONIXICON = "stonix_icon"
            self.STONIXVERSION = self.APPVERSION
            self.STONIX4MAC = "stonix4mac"
            self.STONIX4MACICON = "stonix_icon"
            self.STONIX4MACVERSION = self.APPVERSION
            self.mbl = MacBuildLib(self.logger)
            self.PYUIC = self.mbl.getpyuicpath()
            self.codesignVerbose = 'vvvv'
            self.codesignDeep = True
            if self.signature:
                self.doCodesign = True
            else:
                self.doCodesign = False
        else:
            self.STONIX = dict1['stonix']['app']
            self.STONIXICON = "stonix_icon"
            self.STONIXVERSION = dict1['stonix']['app_version']
            self.STONIX4MAC = dict1['stonix']['wrapper']
            self.STONIX4MACICON = "stonix_icon"
            self.STONIX4MACVERSION = dict1['stonix']['wrapper_version']
            self.APPVERSION = self.STONIXVERSION
            self.PYUIC = dict1['libpaths']['pyuic']
            self.PYPATHS = dict1['libpaths']['pythonpath'].split(':')
            if self.PYPATHS:
                self.mbl = MacBuildLib(self.logger, self.PYPATHS)
            else:
                self.mbl = MacBuildLib(self.logger)
            self.logger.log(lp.INFO, 'attempting to get codesigning information...')
            self.codesignVerbose = dict1['codesign']['verbose']
            if re.match('^True$', dict1['codesign']['ask']) or self.signature:
                self.doCodesign = True
            else:
                self.doCodesign = False
            if re.match('^True$', dict1['codesign']['deep']):
                self.codesignDeep = True
            else:
                self.codesignDeep = False
            self.logger.log(lp.INFO, "Grabbed codesign info...")
            for path in self.PYPATHS:
                sys.path.append(path)
            #-- Internal libraries
        finally:
            success = True

        return success

    def getOrdPass(self, passwd=''):
        '''Get the password translated to a direct ascii pattern of:
        
            "[\d+:]\d+"
        
        for use when in the need of passing it via self.rw.liftDown()
        
        #####
        # Prepare for transport of the password to the xcodebuild.py
        # builder.  This is not encryption, this is just encoding, using
        # similar to UTF encoding of various languages.
        # The standard python 'ord' function, to allow for special
        # characters to be passed, that may be consumed by a shell in
        # the process of passing the password to the other python script.

        :param passwd:  (Default value = '')
        :returns: s: translated password

        '''
        i = 0
        ordPass = ""
        for char in self.keypass:
            i += 1
            if i == 1:
                ordPass += str(ord(char))
            else:
                ordPass += ':' + str(ord(char))

        self.logger.log(lp.INFO, str(ordPass))
        return str(ordPass)

    #--------------------------------------------------------------------------
    # Main controller/driver for the class

    def driver(self):
        '''The driver orchestrates the build process.'''
        # Check that user building stonix has uid 0
        current_user, _ = self.mbl.checkBuildUser()

        #####
        # The driver needs to be run inside a try/except block to make sure to
        # call the tearDown method in case of an exception before exit.
        try:
            self.setUp()
            #####
            # Process Stonix
            self.preCompile(self.STONIX, self.tmphome + "/src/MacBuild/")
            # Compile the two apps...
            self.compile(self.STONIX, self.STONIXVERSION, self.STONIXICON,
                            self.tmphome + "/src/MacBuild/" + self.STONIX)

            self.postCompile(self.STONIX, self.tmphome + "/src/MacBuild/")

            #####
            # Process stonix4mac
            self.preCompile(self.STONIX4MAC, self.tmphome + "/src/MacBuild/")

            self.compile(self.STONIX4MAC, self.STONIX4MACVERSION,
                            self.STONIX4MACICON, self.tmphome + "/src/MacBuild/" + \
                            self.STONIX4MAC)

            self.postCompile(self.STONIX4MAC, self.tmphome + "/src/MacBuild/")

            #####
            # Create the installer
            self.makeInstaller(self.STONIX4MAC, self.STONIXVERSION, self.tmphome + \
                               "/src/MacBuild/")

        except (KeyboardInterrupt, SystemExit):
            print((traceback.format_exc()))
        except Exception:
            print((traceback.format_exc()))
        finally:
            self.tearDown()

    #--------------------------------------------------------------------------
    # Interface support methods

    def setUp(self):
        '''Performing build setup for the whole process.'''
        success = False
        try:
            # Check that user building stonix has uid 0
            current_user, _ = self.mbl.checkBuildUser()

            # Create temp home directory for building with pyinstaller
            self.buildHome = os.getcwd()
            self.directory = os.environ["HOME"]
            self.tmphome = mkdtemp(prefix=current_user + ".", dir="/tmp")
            os.environ["HOME"] = self.tmphome
            os.chmod(self.tmphome, 0o755)

            # Create a ramdisk and mount it to the tmphome
            self.ramdisk = self._setupRamdisk(self.ramdisk_size, self.tmphome)
            os.mkdir("/tmp/the_luggage")
            self.luggage = self._setupRamdisk(self.ramdisk_size,
                                        "/tmp/the_luggage")
            print(("Device for tmp ramdisk is: " + self.ramdisk))

            print(".")
            print(".")
            print(".")

            rsync = [self.RSYNC, "-apv", "--exclude=\".svn\"",
                  "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                  "../../src", self.tmphome]
            print((str(rsync)))

            print(".")
            print(".")
            print(".")

            output = Popen(rsync, stdout=PIPE, stderr=STDOUT).communicate()[0]
            print(("\t\trsync output: " + str(output)))

            print(".")
            print(".")
            print(".")

        except Exception as err:
            print((traceback.format_exc()))
            self.logger.log(lp.WARNING, "Problem setting up ramdisks, not likely to succeed...")
            raise err
        else:
            success = True
        return success

    def preCompile(self, appName, prepPath):
        '''

        :param appName: 
        :param prepPath: 

        '''
        success = False
        self.libc.sync()
        sleep(1)
        self.libc.sync()
        sleep(1)
        returnDir = os.getcwd()
        os.chdir(prepPath)
        self.libc.sync()
        sleep(1)
        self.libc.sync()
        sleep(1)
        try:
            if appName == 'stonix':
                #####
                # Build an __init__.py for the rules directory with all of the
                # rules imported, so they get included in the python frozen
                # package
                # currentDirPathList = os.path.dirname(os.path.abspath(__file__)).split("/")
                rulesDir = self.tmphome + "/src/stonix_resources/rules"
                self.logger.log(lp.DEBUG, "---------------------+++===")
                self.logger.log(lp.DEBUG, "---------------------+++===")
                self.logger.log(lp.DEBUG, "---------------------+++===")
                self.logger.log(lp.DEBUG, "rulesDir: " + rulesDir)
                self.logger.log(lp.DEBUG, "---------------------+++===")
                self.logger.log(lp.DEBUG, "---------------------+++===")
                self.logger.log(lp.DEBUG, "---------------------+++===")
                if not self.mbl.writeInit(rulesDir):
                    raise ValueError("No success Jim!")

                #####
                # Acquire hidden imports to include in the pyinstaller
                # compiled binaries
                if self.includeHiddenImports:
                    self.hiddenImports = self.mbl.getHiddenImports(self.tmphome + "/src/", "stonix_resources")
                else:
                    self.hiddenImports = []
                self.logger.log(lp.DEBUG, "Hidden imports: " + str(self.hiddenImports))

                # Copy src dir to /tmp/<username> so shutil doesn't freak about
                # long filenames.
                # ONLY seems to be a problem on Mavericks
                #####
                # Set the stonix version number correctly
                self.mbl.regexReplace(self.tmphome + "/src/stonix_resources/localize.py",
                                      r"^STONIXVERSION =.*$",
                                      r"STONIXVERSION = '" + self.APPVERSION + "'",
                                      backupname="../stonix_resources/localize.py.bak")
                #####
                # Make sure the "stonix" directory exists, so we can put
                # together and create the stonix.app
                if os.path.islink(self.tmphome + "/src/MacBuild/stonix"):
                    os.unlink(self.tmphome + "/src/MacBuild/stonix")
                elif os.path.isfile(self.tmphome + "/src/MacBuild/stonix"):
                    #####
                    # Cannot use mkdtmp here because it will make the directory on
                    # the root filesystem instead of the ramdisk, then it will try
                    # to link across filesystems which won't work
                    tmpdir = self.tmphome + "/src/MacBuild/stonix." + str(time())
                    os.rename(self.tmphome + "/src/MacBuild/stonix", tmpdir)
                    os.mkdir(self.tmphome + "/src/MacBuild/stonix")
                elif not os.path.isdir(self.tmphome + "/src/MacBuild/stonix"):
                    os.mkdir(self.tmphome + "/src/MacBuild/stonix")

                #####
                # Set up stonix for a build
                copy2(self.tmphome + "/src/stonix.py", self.tmphome + "/src/MacBuild/stonix")

                #####
                # Sync the stonix_resources directory, ready for the build.
                # TODO: Use run_commands utility in ramdisk/lib/
                rsync = [self.RSYNC, "-ap", "--exclude=\".svn\"",
                         "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                         "--exclude=\".git*\"",
                         self.tmphome + "/src/stonix_resources",
                         self.tmphome + "/src/MacBuild/stonix"]
                output = Popen(rsync, stdout=PIPE, stderr=STDOUT).communicate()[0]

                self.libc.sync()
                sleep(1)
                self.libc.sync()
                sleep(1)
                self.libc.sync()
                sleep(1)

                print((str(output)))
            elif appName == 'stonix4mac':
                #####
                # Change the Info.plist with the new version string
                plist = self.tmphome + "/src/MacBuild/" + appName + "/" + appName + "/Info.plist"

                # Change version string of the app
                print("Changing .app version string...")
                self.mbl.modplist(plist, "CFBundleShortVersionString", self.APPVERSION)
                self.mbl.changeViewControllerTitle("stonix4mac " + str(self.APPVERSION))

                #####
                # Change the Application icon used in the xcode build
                pbxproj = self.tmphome + "/src/MacBuild/stonix4mac/stonix4mac.xcodeproj/project.pbxproj"
                self.mbl.regexReplace(pbxproj,
                                      r"ASSETCATALOG_COMPILER_APPICON_NAME =.*$",
                                      r"ASSETCATALOG_COMPILER_APPICON_NAME = stonix4macfisma" + self.FISMACAT + ";\n",
                                      backupname=pbxproj + ".bak")

                # Change the stonix image used the privilege escalation window
                sbpath = self.tmphome + "/src/MacBuild/stonix4mac/stonix4mac/Base.lproj/Main.storyboard"
                self.mbl.regexReplace(sbpath,
                                      r"stoniximage",
                                      r"stoniximage" + self.FISMACAT,
                                      backupname=sbpath + ".bak")

            os.chdir(returnDir)
        except:
            print((traceback.format_exc()))
            raise
        else:
            success = True
        return success

    def compile(self, appName, appVersion, appIcon, appPath):
        '''Perform compile - to create an 'app' for the applications directory

        :param appName: Name of application as it should appear on OS X systems
        :param appVersion: Version of app being built
        :param appIcon: File name of icon for OS X app
        :param appPath: Path to [stonixroot]/src/MacBuild/[appName]
        
        @author: Eric Ball, Roy Nielsen

        '''
        print(("Started compileApp with " + appName + ", " + appVersion + \
            ", " + appIcon))
        try:
            returnDir = os.getcwd()
            os.chdir(appPath)

            #####
            # Determine compile type - ie: xcodebuild vs pyinstaller
            if appName == "stonix4mac":

                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, "TMPHOME: " + str(self.tmphome))
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")
                self.logger.log(lp.DEBUG, ".")

                if self.ordPass:
                    #####
                    # Run the xcodebuild script to build stonix4mac with codesigning enabled
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '--tmpenc', self.ordPass,
                           '-u', self.keyuser,
                           '-i', appName,
                           '-d',
                           '--psd', self.tmphome + "/src/Macbuild/stonix4mac",
                           '--keychain', self.keychain]

                    self.rw.setCommand(cmd)
                    output, error, retcode = self.rw.liftDown(self.keyuser, os.getcwd())
                    # output, error, retcode = self.rw.waitNpassThruStdout()
                    print("Output: " + output)
                    print("Error: " + error)
                    print("Return Code: " + str(retcode))
                else:
                    #####
                    # Run the xcodebuild script to build stonix4mac without codesigning enabled
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '-i', appName,
                           '-d',
                           '--psd', self.tmphome + "/src/Macbuild/stonix4mac"]
                    self.rw.setCommand(cmd)
                    output, error, retcode = self.rw.liftDown(self.keyuser, os.getcwd(), silent=False)
                    # output, error, retcode = self.rw.waitNpassThruStdout()
                    print("Output: " + output)
                    print("Error: " + error)
                    print("Return Code: " + str(retcode))

            elif appName == "stonix":
                #####
                # Perform pyinstaller build
                if os.path.isdir(self.tmphome + "/src/MacBuild/stonix/build"):
                    rmtree(self.tmphome + "/src/MacBuild/stonix/build")
                if os.path.isdir(self.tmphome + "/src/MacBuild/stonix/dist"):
                    rmtree(self.tmphome + "/src/MacBuild/stonix/dist")

                self.logger.log(lp.DEBUG, "Hidden imports: " + str(self.hiddenImports))

                # TODO: Reevaluate hidden imports
                hdnimports = self.hiddenImports + ['ctypes', '_ctypes', 'ctypes._endian', 'decimal', 'numbers']

                # to compile a pyinstaller spec file for app creation:
                print("Creating a pyinstaller spec file for the project...")

                stonix_hooks_path = "./additional_hooks/runtime_hooks"

                # TODO: may need to create/maintain a stonix_resources pyinstaller hooks script
                stonix_runtime_hooks = stonix_hooks_path + '/stonix_resrouces.py'

                # Make a specifications file
                output =  self.mbl.pyinstMakespec([appName + ".py"], True, False, False,
                                              "../" + appIcon + ".icns",
                                              pathex=["/usr/lib", "./stonix_resources/rules", "stonix_resources"] + self.PYPATHS,
                                              specpath=os.getcwd(),
                                              hiddenImports=hdnimports)

                print(output)

                # Build app using specifications file created by pyinstMakespec call
                print("Building the app...")
                self.mbl.pyinstBuild(appName + ".spec",
                                     "private/tmp",
                                     appPath + "/dist",
                                     True,
                                     True)

        except Exception:
            raise
        finally:
            os.chdir(returnDir)

        print(("compileApp with " + appName + ", " + appVersion + " Finished..."))

    def postCompile(self, appName, prepPath):
        '''Perform post-compile processing.
        
        @author: Eric Ball, Roy Nielsen

        :param appName: 
        :param prepPath: 

        '''
        print("Started postCompile...")
        returnDir = os.getcwd()
        os.chdir(prepPath)
        try:
            if appName == 'stonix':
                self.logger.log(lp.DEBUG, "Starting stonix postCompile.")
                returnDir = os.getcwd()
                os.chdir(prepPath)
                plist = self.tmphome + "/src/MacBuild/stonix/dist/" + appName + ".app/Contents/Info.plist"

                # Change version string of the app
                print("Changing .app version string...")
                self.mbl.modplist(plist, "CFBundleShortVersionString", self.APPVERSION)

                # Change icon name in the app
                print("Changing .app icon...")
                self.mbl.modplist(plist, "CFBundleIconFile", self.STONIXICON + ".icns")


                # Change mode of Info.plist to 0o664
                os.chmod(plist, 0o664)

                #####
                # Copy the stonix_resources directory into the
                # stonix.app/Contents/MacOS directory
                rsync = [self.RSYNC, "-avp", "--exclude=\".svn\"",
                         "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                         "--exclude=\".git*\"", self.tmphome + \
                         "/src/stonix_resources",
                         self.tmphome + "/src/MacBuild/stonix/dist/" + \
                         appName + ".app/Contents/MacOS"]

                output = Popen(rsync, stdout=PIPE, stderr=STDOUT).communicate()[0]
                print(output)
                self.libc.sync()
                self.libc.sync()

                # Copy icon to the resources directory
                copy2(self.tmphome + "/src/MacBuild/stonix4macfisma" + self.FISMACAT + ".icns",
                      self.tmphome + "/src/MacBuild/stonix/dist/" \
                      + appName + ".app/Contents/Resources/" + \
                      self.STONIXICON + ".icns")

                # Copy splashscreen to the resources directory
                copy2(self.tmphome + "/src/stonix_resources/gfx/stonix4macfisma" + \
                      self.FISMACAT + "splashscreen.png",
                      self.tmphome + "/src/MacBuild/stonix/dist/" + \
                      appName + ".app/Contents/MacOS/stonix_resources/gfx/StonixSplash.png")

                self.libc.sync()
                self.libc.sync()

                #####
                # Copy stonix.app to the stonix4mac directory
                rsync = [self.RSYNC, "-avp", "--exclude=\".svn\"",
                         "--exclude=\"*.tar.gz\"", "--exclude=\"*.dmg\"",
                         "--exclude=\".git*\"", self.tmphome + \
                         "/src/MacBuild/stonix/dist/stonix.app", "./stonix4mac"]
                output = Popen(rsync, stdout=PIPE, stderr=STDOUT).communicate()[0]
                print(output)
                self.libc.sync()

                #####
                # Optional codesign
                self.libc.sync()
                self.libc.sync()
                if self.doCodesign and self.signature:
                    # Sign stonix app
                    self.signObject(self.tmphome + '/src/Macbuild/stonix4mac',
                                    self.tmphome + '/src/Macbuild/stonix4mac',
                                    'stonix.app')

            elif appName == 'stonix4mac':
                self.logger.log(lp.DEBUG, "Starting stonix4mac postCompile.")
                os.chdir(self.tmphome + "/src/MacBuild/stonix4mac/build/Release")

                #####
                # Optional codesign
                self.libc.sync()
                self.libc.sync()
                if self.doCodesign and self.signature:
                    # Sign stonix4mac app
                    self.signObject(self.tmphome + '/src/Macbuild/stonix4mac',
                                    self.tmphome + '/src/Macbuild/stonix4mac/build/Release',
                                    appName + '.app')


            os.chdir(returnDir)
        except Exception:
            raise
        print("buildStonix4MacAppResources Finished...")

    def signObject(self, workingDir, objectParentDir, objectName):
        '''Uses xcodebuild to sign a file or bundle.

        :param workingDir: The working directory that the process will take place
        :param objectParentDir: The directory that contains the object to be signed
        :param objectName: The name of the object to be signed
        
        @author: Brandon R. Gonzales

        '''
        self.logger.log(lp.DEBUG, "\n##################################################")
        self.logger.log(lp.DEBUG, "##################################################")
        self.logger.log(lp.DEBUG, "Signing \'" + os.path.join(objectParentDir, objectName) + "\'!")
        self.logger.log(lp.DEBUG, "##################################################")
        self.logger.log(lp.DEBUG, "##################################################")
        os.chdir(workingDir)
        print(workingDir)

        #####
        # Perform a codesigning on the stonix4mac application
        cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
               '--psd', objectParentDir,
               '-c',
               '--tmpenc', self.ordPass, '-u', self.keyuser,
               '-i', objectName,
               '-d',
               '-v', self.codesignVerbose,
               '-s', '"' + self.signature + '"',
               '--keychain', self.keychain]

        self.logger.log(lp.DEBUG, '.')
        self.logger.log(lp.DEBUG, '.')
        self.logger.log(lp.DEBUG, "Working dir: " + workingDir)
        self.logger.log(lp.DEBUG, '.')
        self.logger.log(lp.DEBUG, '.')

        #####
        # Run the xcodebuild script to codesign the mac installer package
        self.rw.setCommand(cmd)
        output, error, retcode = self.rw.liftDown(self.keyuser, workingDir)
        # output, error, retcode = self.rw.communicate()
        self.logger.log(lp.DEBUG, "Codesign returns: " + str(retcode))
        for line in output.split('\n'):
            self.logger.log(lp.DEBUG, line)
        for line in error.split('\n'):
            self.logger.log(lp.DEBUG, line)

        self.libc.sync()
        sleep(1)
        self.libc.sync()
        sleep(3)

    def makeInstaller(self, appName, appVersion, appPath):
        '''Create an installer.  As of Nov 2016, use luggage to create a
               <appName>.pkg

        :param appName: Name of application as it should appear on OS X systems
        :param appVersion: Version of app being built
        :param appPath: Path to [stonixroot]/src/MacBuild
        
        @authors: Eric Ball, Roy Nielsen

        '''
        #####
        # run make to create a pkg installer
        self.logger.log(lp.DEBUG, "Started buildStonix4MacAppPkg...")
        try:
            returnDir = os.getcwd()
            os.chdir(appPath + "/" + appName)

            #####
            # Processing makefile to create a package
            self.logger.log(lp.DEBUG, "Putting new version into Makefile...")

            self.mbl.regexReplace("Makefile", r"PACKAGE_VERSION=",
                                  "PACKAGE_VERSION=" + self.APPVERSION)

            dmgsPath = self.tmphome + "/src/MacBuild/dmgs"

            if not os.path.isdir(dmgsPath) and os.path.exists(dmgsPath):
                # Cannot use mkdtmp here because it will make the directory on
                # the root filesystem instead of the ramdisk, then it will try
                # to link across filesystems which won't work
                tmpdir = self.tmphome + "/src/MacBuild/dmgs." + str(time())
                os.rename(dmgsPath, tmpdir)
                os.mkdir(dmgsPath)
            if not os.path.exists(dmgsPath):
                os.mkdir(dmgsPath)

            print(("Creating a .dmg file with a .pkg file inside for " + \
                "installation purposes..."))
            #call(["make", "dmg", "PACKAGE_VERSION=" + appVersion,
            #      "USE_PKGBUILD=1"])
            makepkg = ["/usr/bin/make", "pkg", "PACKAGE_VERSION=" + self.APPVERSION,
                  "USE_PKGBUILD=1"]
            output = Popen(makepkg, stdout=PIPE, stderr=STDOUT).communicate()[0]
            for line in output.decode('utf-8').split('\n'):
                self.logger.log(lp.DEBUG, line)
            sleep(2)
            self.libc.sync()
            sleep(2)
            self.libc.sync()
            sleep(3)
            self.libc.sync()
            sleep(3)

            #####
            # Perform a codesigning on the stonix4mac application
            if self.ordPass:
                if self.FISMACAT == "high":
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '--psd', self.tmphome + '/src/MacBuild/stonix4mac',
                           '--productsign',
                           '--tmpenc', self.ordPass, '-u', self.keyuser,
                           '-i', appName + '-red-' + str(self.STONIXVERSION) + '.pkg',
                           '-n', appName + '-red.' + str(self.STONIXVERSION) + '.pkg',
                           '-d',
                           '-s', '"Developer ID Installer"',
                           '--keychain', self.keychain]
                else:
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '--psd', self.tmphome + '/src/MacBuild/stonix4mac',
                           '--productsign',
                           '--tmpenc', self.ordPass, '-u', self.keyuser,
                           '-i', appName + '-' + str(self.STONIXVERSION) + '.pkg',
                           '-n', appName + '.' + str(self.STONIXVERSION) + '.pkg',
                           '-d',
                           '-s', '"Developer ID Installer"',
                           '--keychain', self.keychain]
            else:
                if self.FISMACAT == "high":
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '--psd', self.tmphome + '/src/MacBuild/stonix4mac',
                           '-u', self.keyuser,
                           '-i', appName + '-red-' + str(self.STONIXVERSION) + '.pkg',
                           '-n', appName + '-red.' + str(self.STONIXVERSION) + '.pkg',
                           '-d']
                else:
                    cmd = [self.tmphome + '/src/MacBuild/xcodebuild.py',
                           '--psd', self.tmphome + '/src/MacBuild/stonix4mac',
                           '-u', self.keyuser,
                           '-i', appName + '-' + str(self.STONIXVERSION) + '.pkg',
                           '-n', appName + '.' + str(self.STONIXVERSION) + '.pkg',
                           '-d']

            self.logger.log(lp.DEBUG, '.')
            self.logger.log(lp.DEBUG, '.')
            self.logger.log(lp.DEBUG, "Working dir: " + os.getcwd())
            self.logger.log(lp.DEBUG, '.')
            self.logger.log(lp.DEBUG, '.')

            #####
            # Run the xcodebuild script to codesign the mac installer package
            self.rw.setCommand(cmd)
            # output, error, retcode = self.rw.communicate()
            buildDir = os.getcwd()
            print(buildDir)
            output, error, retcode = self.rw.liftDown(self.keyuser, buildDir)
            for line in output.split('\n'):
                self.logger.log(lp.DEBUG, line)
            for line in error.split('\n'):
                self.logger.log(lp.DEBUG, line)
            sleep(2)
            self.libc.sync()
            sleep(3)
            self.libc.sync()
            sleep(2)
            self.libc.sync()

            print("Moving dmg and pkg to the dmgs directory.")
            if self.FISMACAT == "high":
                pkgname = self.STONIX4MAC + "-red." + self.APPVERSION + ".pkg"
            else:
                pkgname = self.STONIX4MAC + "." + self.APPVERSION + ".pkg"
            self.product = self.tmphome + "/src/Macbuild/" + self.STONIX4MAC + "/" + pkgname
            self.logger.log(lp.DEBUG, "Copying: " + str(pkgname) + " to: " + dmgsPath + "/" + pkgname)
            copy2(self.product, dmgsPath)

            sleep(2)
            self.libc.sync()
            sleep(3)
            self.libc.sync()
            sleep(2)
            self.libc.sync()

            os.chdir(returnDir)
        except Exception:
            print((traceback.format_exc()))
            raise
        print("buildStonix4MacAppPkg... Finished")

    def backup(self):
        ''' '''
        pass

    def tearDown(self):
        '''Disconnect ramdisk, unloading data to pre-build location.'''
        self.logger.log(lp.DEBUG, "===== Entering tearDown =====")
        self.mbl.chownR(self.keyuser, self.tmphome + "/src")

        # chmod so it's readable by everyone, writable by the group
        self.mbl.chmodR(stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH |
                        stat.S_IWGRP, self.tmphome + "/src", "append")
        self.libc.sync()
        self.libc.sync()
        # Copy bopy back to pseudo-build directory
        productDest= self.buildHome + "/dmgs"
        if not os.path.isdir(productDest):
             os.makedirs(productDest)
        cmd = [self.RSYNC, "-avp", self.product, productDest]
        self.logger.log(lp.DEBUG, str(cmd))
        output, error = Popen(cmd, stdout=PIPE, stderr=STDOUT).communicate()
        for line in output.decode('utf-8').split("\n"):
            self.logger.log(lp.DEBUG, str(line))
        if error:
            for line in error.decode('utf-8').split("\n"):
                self.logger.log(lp.DEBUG, str(line))
        self.libc.sync()
        self.libc.sync()
        cmd = [self.RSYNC, "-avp", self.tmphome + "/src/", self.buildHome + "/builtSrc"]
        self.logger.log(lp.DEBUG, str(cmd))
        output, error = Popen(cmd, stdout=PIPE, stderr=STDOUT).communicate()
        for line in output.decode('utf-8').split("\n"):
            self.logger.log(lp.DEBUG, str(line))
        if error:
            for line in error.decode('utf-8').split("\n"):
                self.logger.log(lp.DEBUG, str(line))
        self.libc.sync()
        sleep(1)
        self.libc.sync()
        sleep(1)
        self.libc.sync()
        sleep(3)

        os.chdir(self.buildHome)
        if not self.noExit:
            self._exit(self.ramdisk, self.luggage, 0)
import unittest
import ctypes as C
from datetime import datetime

#####
# Include the parent project directory in the PYTHONPATH
appendDir = "/".join(
    os.path.abspath(os.path.dirname(__file__)).split('/')[:-1])
sys.path.append(appendDir)

# --- Non-native python libraries in this source tree
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp
from ramdisk.lib.getLibc import getLibc

LOGGER = CyLogger()
#LOGGER.setInitialLoggingLevel(30)


class test_getLibc(unittest.TestCase):
    """
    """
    metaVars = {'setupDone': None, 'testStartTime': 0, 'setupCount': 0}
    libc = getLibc()

    ##################################

    def setUp(self):
        """
        This method runs before each test run.
Beispiel #29
0
                      "--verbose",
                      dest="verbose",
                      default="",
                      help="Determine verbosity if performing a codesign.")

    (opts, args) = parser.parse_args()

    log_level = ""
    if opts.debug:
        loglevel = 20
    elif opts.verbose:
        loglevel = 30
    else:
        loglevel = 40

    logger = CyLogger(level=lp.DEBUG)

    logger.initializeLogs()

    logger.log(lp.DEBUG, "Logger initialized")

    os.environ['DEVELOPER_DIR'] = '/Applications/Xcode.app/Contents/Developer'

    keychainPass = False

    if opts.password:
        #####
        # On the other end, each character was translated by 'ord' to a number,
        # and each number was separated by a colon.  Change the password from
        # letters that have been converted to a number via the 'ord' function
        # back to the origional character
class test_run_commands(unittest.TestCase):
    """
    """

    @classmethod
    def setUpClass(self):
        """
        """
        #####
        # Set up logging
        self.logger = CyLogger(debug_mode=True)
        self.logger.initializeLogs()
        self.rw = RunWith(self.logger)
        #####
        # Start timer in miliseconds
        self.test_start_time = datetime.now()

    @classmethod
    def tearDownClass(self):
        """
        """
        pass

    def test_RunCommunicateWithBlankCommand(self):
        self.rw.__init__(self.logger)
        self.assertRaises(SetCommandTypeError, self.rw.setCommand, "")
        self.assertRaises(SetCommandTypeError, self.rw.setCommand, [])
        self.assertRaises(SetCommandTypeError, self.rw.setCommand, None)
        self.assertRaises(SetCommandTypeError, self.rw.setCommand, True)
        self.assertRaises(SetCommandTypeError, self.rw.setCommand, {})

    def test_setCommand(self):
        self.rw.__init__(self.logger)
        command = ['/bin/ls', 1, '.']
        self.assertRaises(SetCommandTypeError,
                          self.rw.setCommand, [command])

    def test_communicate(self):
        """
        """
        self.rw.__init__(self.logger)
        self.logger.log(lp.DEBUG, "=============== Starting test_communicate...")

        self.rw.setCommand('/bin/ls /var/spool', myshell=True)
        _, _, retval = self.rw.communicate(silent=False)
        self.assertEqual(retval, 0,
                          "Valid [] command execution failed: " +
                          '/bin/ls /var/spool --- retval: ' + str(retval))
        self.rw.setCommand(['/bin/ls', '-l', '/usr/local'])
        _, _, retval = self.rw.communicate(silent=False)
        self.assertEqual(retval, 0,
                          "Valid [] command execution failed: " +
                          '/bin/ls /var/spool --- retval: ' + str(retval))

        self.logger.log(lp.DEBUG, "=============== Ending test_communicate...")

    def test_wait(self):
        """
        """
        self.rw.__init__(self.logger)
        self.logger.log(lp.DEBUG, "=============== Starting test_wait...")

        self.rw.setCommand('/bin/ls /var/spool')
        try:
            _, _, retval = self.rw.communicate(silent=False)
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            # raise err

        self.assertEqual(retval, 0,
                          "Valid [] command execution failed: " +
                          '/bin/ls /var/spool --- retval: ' + str(retval))

        self.rw.setCommand(['/bin/ls', '-l', '/usr/local'])
        try:
            _, _, retval = self.rw.communicate(silent=False)
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            # raise err

        self.assertEqual(retval, 0,
                          "Valid [] command execution failed: " +
                          '/bin/ls -l /usr/local --- retval: ' + str(retval))
        '''
        temporarily commented out may not work the same on python 3.10.x
        self.rw.setCommand(['/bin/ls', '/1', '/'])
        tracemalloc.start(25)
        try:
            _, _, retcode = self.rw.wait()
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            retcode = 99999
            # raise err

        self.logger.log(lp.WARNING, "retcode: " + str(retcode))
        if sys.platform == 'darwin':
            self.assertEqual(retcode, 1, "Returncode Test failed...")
        else:
            self.assertEqual(retcode, 2, "Returncode Test failed...")
        '''
        self.logger.log(lp.DEBUG, "=============== Completed test_wait...")

    @unittest.skip("temporary skip to determine if split stdout/stderr could be the problem...")
    def test_waitNpassThruStdout(self):
        """
        """
        self.rw.__init__(self.logger)
        self.logger.log(lp.DEBUG, "=============== Starting test_wait...")

        tracemalloc.start(25)

        self.rw.setCommand(['/bin/ls', '-l', '/usr/local'])
        try:
            _, _, retval = self.rw.waitNpassThruStdout()
            self.assertEqual(retval, 0,
                                       "Valid [] command execution failed: " +
                                       '/bin/ls /var/spool --- retval: ' + str(retval))
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            # raise err

        self.logger.log(lp.INFO, "...first subtest done...")

        self.rw.setCommand(['/bin/ls', '/1', '/'])
        try:
            _, _, retval = self.rw.waitNpassThruStdout()
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            # raise err

        if sys.platform == 'darwin':
            self.assertEqual(retval, 1, "Returncode Test failed...")
        else:
            self.assertEqual(retval, 2, "Returncode Test failed...")

        self.logger.log(lp.DEBUG, "=============== Completed test_wait...")

    def test_timeout(self):
        """
        """
        self.rw.__init__(self.logger)

        tracemalloc.start(25)

        if os.path.exists("/sbin/ping"):
            ping = "/sbin/ping"
        elif os.path.exists('/bin/ping'):
            ping = "/bin/ping"

        self.rw.setCommand([ping, '-c', '12', '8.8.8.8'])
        try:
            startTime = time.time()
            self.rw.timeout(3)
            elapsed = (time.time() - startTime)
        except Exception as err:
            self.logger.log(lp.ERROR, traceback.format_exc())
            # raise err
        finally:
            self.logger.log(lp.INFO, "elapsed time: " + str(elapsed))

        self.assertTrue(elapsed < 4,
                        "Elapsed time is greater than it should be...")

    def test_runAs(self):
        """
        """
        pass

    def test_liftDown(self):
        """
        """
        pass

    def test_runAsWithSudo(self):
        """
        """
        pass

    def test_runWithSudo(self):
        """
        """
        pass

    def test_getecho(self):
        """
        """
        pass

    def test_waitnoecho(self):
        """
        """
        pass

    def test_RunThread(self):
        """
        """
        pass

    def test_runMyThreadCommand(self):
        """
        """
        pass
Beispiel #31
0
import unittest
from datetime import datetime

#####
# Include the parent project directory in the PYTHONPATH
appendDir = "/".join(os.path.abspath(os.path.dirname(__file__)).split('/')[:-1])
sys.path.append(appendDir)

#--- non-native python libraries in this source tree
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp
from ramdisk.lib.run_commands import RunWith
from ramdisk.lib.environment import Environment
from ramdisk.lib.CheckApplicable import CheckApplicable

LOGGER = CyLogger()
#LOGGER.setInitialLoggingLevel(30)

class test_CheckApplicable(unittest.TestCase):
    """
    """

    ##################################

    @classmethod
    def setUpClass(self):
        """
        """
        #####
        # Set up logging
        self.logger = CyLogger(debug_mode=True)
Beispiel #32
0
#!/usr/bin/python
'''
TODO: Fix this example
'''

#--- Native python libraries
import sys

sys.path.append("../")

#--- non-native python libraries in this source tree
from ramdisk.lib.manage_user.macos_user import MacOSUser
from ramdisk.lib.loggers import CyLogger
from ramdisk.lib.loggers import LogPriority as lp

logger = CyLogger(debug_mode=True)
logger.initializeLogs()

mu = MacOSUser(logDispatcher=logger)

user = input("User to collect properties for: ")

success, userProperties = mu.getUserProperties(str(user))

print(str(userProperties))

for key, value in userProperties.iteritems():
    if not re.search("JPEG", key):
        print key + " : " + value
Beispiel #33
0
                  "--debug",
                  action="store_true",
                  dest="debug",
                  default=0,
                  help="Print debug messages")
parser.add_option("-v",
                  "--verbose",
                  action="store_true",
                  dest="verbose",
                  default=False,
                  help="Print status messages")

(opts, args) = parser.parse_args()

if opts.verbose:
    level = CyLogger(level=lp.INFO)
elif opts.debug:
    level = CyLogger(level=lp.DEBUG)
else:
    level = lp.WARNING

if opts.size:
    size = int(opts.size)  # in Megabytes
else:
    size = str(512)

if opts.mntpnt:
    mntpnt = opts.mntpnt
else:
    mntpnt = "uniontest"
Beispiel #34
0
class test_CheckApplicable(unittest.TestCase):
    """
    """

    ##################################

    @classmethod
    def setUpClass(self):
        """
        """
        #####
        # Set up logging
        self.logger = CyLogger(debug_mode=True)
        self.logger.initializeLogs()
        self.rw = RunWith(self.logger)

        self.enviro = Environment()
        self.ca = CheckApplicable(self.enviro, LOGGER)

        #####
        # Start timer in miliseconds
        self.testStartTime = datetime.now()

    ##################################

    @classmethod
    def tearDownClass(self):
        """
        """
        #####
        # capture end time
        testEndTime = datetime.now()

        #####
        # Calculate and log how long it took...
        test_time = (testEndTime - self.testStartTime)
        # print str(test_time)
        # global LOGGER
        self.logger.log(lp.INFO, self.__module__ + " took " + str(test_time) + " time so far...")

   ##################################

    def testCheckRedHatApplicable(self):
        """
        """
        self.ca.setOsFamily

    ##################################

    def testCheckLinuxApplicable(self):
        """
        """

    ##################################

    def testCheckDebianApplicable(self):
        """
        """

    ##################################

    def testCheckUbuntuApplicable(self):
        """
        """

    ##################################

    def testCheckCentOS6Applicable(self):
        """
        """

    ##################################

    def testCheckCentOS7Applicable(self):
        """
        """

    ##################################

    def testCheckMacOS1011Applicable(self):
        """
        """

    ##################################
    def testCheckMacOS1011to12Applicable(self):
        """
        """

    ##################################
    def testCheckMacOS1011to13Applicable(self):
        """