Esempio n. 1
0
    def execute(self,
                session,
                consolemode,
                interactive,
                scripted,
                globalvars={},
                runMode=''):
        self.lastsession = session
        baseDir, logDir = session.get_dirs()
        waitmode, newconsole = self.get_runflags(consolemode, interactive,
                                                 scripted)

        # save history
        session.history = self.getParameters()

        timestamp = util.formattime()
        exeBaseName = os.path.basename(self.executable)

        logName = "%s-%s.log" % (exeBaseName, timestamp)
        logFile = os.path.join(logDir, logName)
        try:
            os.remove(logFile)
        except:
            pass

        # Touch the logfile
        tmpFile = open(logFile, "w")
        tmpFile.close()

        # Create InConfig and write to the logdir
        inConfName = "%s-%s-InConfig.xml" % (exeBaseName, timestamp)
        inConfFile = os.path.join(logDir, inConfName)
        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)

        # Create the pipe that we will use for the --OutConfig parameter
        pipeName = edfexecution.generate_pipename()
        pipe = edfexecution.create_pipe(pipeName)

        cwd = os.getcwd()
        os.chdir(logDir)
        try:
            #
            # This is the sneaky bit for the output.  We call launch_plugin,
            # which does two things.  First, it passes stdin,stdout, and stderr
            # to the call to subprocess.Popen so that output is duplicated to
            # the console.  Second, it passes --OutConfig a pipe so that, when we
            # later call write_outconfig, this contains only the data we want
            #
            proc = edfexecution.launch_plugin(self.executable, inConfFile,
                                              pipeName, logFile, self.io,
                                              newconsole)
            self.procs.append(proc)
        except KeyboardInterrupt:
            self.io.print_error("Stopping plugin")
            try:
                self.procs.remove(proc)
                proc.kill()
            except:
                pass
            # Create the output param for the contract
            session.contract = [
                util.oParam("Status", "Failed", "String", "Scalar"),
                util.oParam("ReturnCode", "User Abort", "String", "Scalar")
            ]
            session.mark_fail()
            raise exception.CmdErr, "Canceled by User"

        os.chdir(cwd)

        try:
            # Wait for the spawned process to connect to our named pipe
            pipe = edfexecution.connect_pipe(pipe, pipeName)
        except edfexecution.PipeError, err:
            self.io.print_error(str(err))
            pipe = None
Esempio n. 2
0
    def execute(self,
                session,
                consolemode,
                interactive,
                scripted,
                globalvars={},
                runMode='',
                archOs='x86-Windows',
                listenPort=0):
        self.lastsession = session
        baseDir, logDir = session.get_dirs()
        waitmode, newconsole = self.get_runflags(consolemode, interactive,
                                                 scripted)
        timestamp = util.formattime()

        # Save history
        session.history = self.getParameters()

        # Prompt for run mode
        if runMode in ("DANE", "DAVE"):

            # TODO: prompt operator to verify remote callback tunnel exists for localhost comms

            if runMode == "DANE":
                # Build package
                packagePath = self.build_package(logDir,
                                                 archOs,
                                                 listenPort,
                                                 globalvars=globalvars)

                # Print package info
                self.io.print_success("DANE Package: %s" % packagePath)
            # elif runMode == "DAVE":
            # # Marshal params (and get core module name)
            # modulePath, inputPath = self.marshal_params(logDir, archOs, globalvars=globalvars)

            # # Build up DAVE commandline
            # dvcmds = 'daringveteran -module "%s" -input "%s" -run %s' % (
            # modulePath,
            # inputPath,
            # 'interactive' if (listenPort) else 'batch')
            # if listenPort:
            # dvcmds += " -homeport %d" % listenPort

            # # Print core module and marshaled data info
            # self.io.print_success('DAVE Pastable:\n\t' + dvcmds)
            else:
                raise NotImplementedError(
                    "No such option '%s'; what happened??" % (runMode))

            # Set "DaveProxyPort" hidden parameter in current config
            if listenPort:
                #self.set("DaveProxyPort", str(listenPort))
                self.io.print_msg("Proxy listening on localhost:%d" %
                                  listenPort)
            else:
                # Bail right now--gracefully...
                return newconsole, None
        elif runMode == 'FB':
            # Make sure the proxy port is zeroed
            self.set("DaveProxyPort", "0")
        else:
            raise NotImplementedError("No such option '%s'; what happened??" %
                                      (runMode))

        exeBaseName = os.path.basename(self.executable)

        logName = "%s-%s.log" % (exeBaseName, timestamp)
        logFile = os.path.join(logDir, logName)
        try:
            os.remove(logFile)
        except:
            pass

        # Touch the logfile
        tmpFile = open(logFile, "w")
        tmpFile.close()

        # Create InConfig and write to the logdir
        inConfName = "%s-%s-InConfig.xml" % (exeBaseName, timestamp)
        inConfFile = os.path.join(logDir, inConfName)
        self.write_interpreted_xml_file(inConfFile, globalvars=globalvars)

        # Create the pipe that we will use for the --OutConfig parameter
        pipeName = edfexecution.generate_pipename()
        pipe = edfexecution.create_pipe(pipeName)

        cwd = os.getcwd()
        os.chdir(logDir)
        try:
            #
            # This is the sneaky bit for the output.  We call launch_plugin,
            # which does two things.  First, it passes stdin,stdout, and stderr
            # to the call to subprocess.Popen so that output is duplicated to
            # the console.  Second, it passes --OutConfig a pipe so that, when we
            # later call write_outconfig, this contains only the data we want
            #
            proc = edfexecution.launch_plugin(self.executable, inConfFile,
                                              pipeName, logFile, self.io,
                                              newconsole)
            self.procs.append(proc)
        except KeyboardInterrupt:
            self.io.print_error("Stopping plugin")
            try:
                self.procs.remove(proc)
                proc.kill()
            except:
                pass
            # Create the output param for the contract
            session.contract = [
                util.oParam("Status", "Failed", "String", "Scalar"),
                util.oParam("ReturnCode", "User Abort", "String", "Scalar")
            ]
            session.mark_fail()
            raise exception.CmdErr, "Canceled by User"

        os.chdir(cwd)

        try:
            # Wait for the spawned process to connect to our named pipe
            pipe = edfexecution.connect_pipe(pipe, pipeName)
        except edfexecution.PipeError, err:
            self.io.print_error(str(err))
            pipe = None