示例#1
0
def app_launch(executable, teardown=None, params='', _assert=False, **kw):
    """
    App Launch | <executable> [ | params | <cmdline parameters string> ] [ | flags and params ]

    Launches an app. The first parameter is a path to the app's executable. Optional 'suite_teardown' or 'test_teardown'
    flags force to kill the app at the end of the suite or of the test, respectively (if still running).
    A 'params' named parameter is also optional, should be followed by a parameters string (all args in one).

    :return: An application object or None in case of failure if "assert" flag is not present.

    """
    
    pi = ProcessStartInfo(executable, params)

    workdir = kw.get('workdir', '')

    if workdir!='':
        pi.WorkingDirectory=workdir
        logging.info(workdir)
    try:
        app = Application.Launch(pi)
    except:
        if _assert:
            logging.error('Failed to launch an executable')
            raise
        logging.warning('Failed to launch an executable')
        return None
    if teardown == 'test':
        CONTROLLED_APPS[-1].append(app)
    elif teardown == 'suite':
        SUITE_CONTROLLED_APPS[-2].append(app)

    return app
def ExecProcess(file, arg=""):
    from System.Diagnostics import ProcessStartInfo, Process

    processStartInfo = ProcessStartInfo(file, arg)
    processStartInfo.UseShellExecute = True
    processStartInfo.CreateNoWindow = True
    process = Process.Start(processStartInfo)
示例#3
0
def popen(executable, arguments):
    global process # XXX: keep it alive
    processStartInfo = ProcessStartInfo(executable, arguments)
    processStartInfo.UseShellExecute = False
    processStartInfo.CreateNoWindow = True
    processStartInfo.RedirectStandardOutput = True
    process = Process.Start(processStartInfo)
    return file(process.StandardOutput.BaseStream, "r")
示例#4
0
def run_cmd(command):
    # os.system(command)
    pinfo = ProcessStartInfo()
    pinfo.FileName = "cmd.exe"
    pinfo.WindowStyle = ProcessWindowStyle.Hidden
    pinfo.Arguments = "/C" + command
    cmd = Process.Start(pinfo)
    cmd.WaitForExit()
示例#5
0
def popen(executable, arguments):
    global process  # XXX: keep it alive
    processStartInfo = ProcessStartInfo(executable, arguments)
    processStartInfo.UseShellExecute = False
    processStartInfo.CreateNoWindow = True
    processStartInfo.RedirectStandardOutput = True
    process = Process.Start(processStartInfo)
    return file(process.StandardOutput.BaseStream, "r")
示例#6
0
        def onEdit(sender, args):
            global program

            path = sender.Tag

            def onStart(state):
                Process.Start(state)

            psi = ProcessStartInfo()

            if String.IsNullOrEmpty(program):
                psi.FileName = path
            else:
                psi.FileName = program
                psi.Arguments = path

            Task.Factory.StartNew(onStart, psi)
示例#7
0
		def onEdit(sender, args):
			global program
				
			path = sender.Tag

			def onStart(state):
				Process.Start(state)
					
			psi = ProcessStartInfo()

			if String.IsNullOrEmpty(program):
				psi.FileName = path
			else:
				psi.FileName = program
				psi.Arguments = path
				
			Task.Factory.StartNew(onStart, psi)
    def launch_application(self, sut_path, args=None):
        """Launches an application.

        ``sut_path`` is the absolute path to the application to launch.

        ``args`` is a string of arguments to use when starting the application (optional).

        Examples:
        | Launch Application | C:/path/to/MyApp.exe | | # Launch without arguments |
        | Launch Application | C:/path/to/MyApp.exe | /o log.txt | # Launch with arguments |
        """
        if args is not None:
            process_start_info = ProcessStartInfo(sut_path)
            process_start_info.Arguments = args
            self.state.app = Application.Launch(process_start_info)
        else:
            self.state.app = Application.Launch(sut_path)
示例#9
0
def start_imaging(path):
    psInfo = ProcessStartInfo()
    psInfo.FileName = path + "Imaging.exe"
    psInfo.Arguments = "Rowthon 1"
    psInfo.CreateNoWindow = False
    psInfo.UseShellExecute = False
    psInfo.RedirectStandardOutput = True

    p = Process.Start(psInfo)
示例#10
0
def StartCmdProcess(commandLine):
    # NOTE: do not call Process.WaitForExit() until redirected streams have been entirely read from / closed.
    #       doing so can lead to a deadlock when the child process is waiting on being able to write to output / error
    #       stream and the parent process is waiting for the child to exit! See Microsoft's documentation for more info.
    # NOTE: if redirecting both output and error streams, one should be read asynchronously to avoid a deadlock where
    #       the child process is waiting to write to one of the streams and the parent is waiting for data from the other
    #       stream. See Microsoft's documentation for more info.
    psi = ProcessStartInfo('cmd.exe', '/U /S /C " ' + commandLine + ' "')
    psi.UseShellExecute = False
    psi.CreateNoWindow = True
    psi.RedirectStandardInput = False
    psi.RedirectStandardError = False  # See notes above if enabling this alongside redirect output stream.
    psi.RedirectStandardOutput = True
    psi.StandardOutputEncoding = Encoding.Unicode
    p = Process.Start(psi)
    return p
示例#11
0
def StartRevitProcess(revitVersion, initEnvironmentVariables):
    revitExecutableFilePath = RevitVersion.GetRevitExecutableFilePath(revitVersion)
    psi = ProcessStartInfo(revitExecutableFilePath)
    psi.UseShellExecute = False
    psi.RedirectStandardError = True
    psi.RedirectStandardOutput = True
    psi.WorkingDirectory = RevitVersion.GetRevitExecutableFolderPath(revitVersion)
    initEnvironmentVariables(psi.EnvironmentVariables)
    revitProcess = Process.Start(psi)
    return revitProcess
示例#12
0
def RunICM(Adapter):
    """
    <Script>
    <Author>ANK</Author>
    <Description>run an ICM model</Description>
    <Parameters>
    <Parameter name="Adapter" type="IRuntimeAdapter">handle to the adapter</Parameter>
    </Parameters>
    </Script>
    """
    tsMgr = app.Modules.Get("Time series Manager")

    # get the adapter root folder
    rootfolder = Adapter.RootFolderPath
    
    # convert dfs0-input files to Dummy_Inflow.csv
    
    # open dummy inflow and read all lines
    inflowPath = Path.Combine(rootfolder, "MODEL_SETUP\\import\\Dummy Inflow.csv")
    inflowLines = File.ReadAllLines(inflowPath)
    
    # read dfs0-files one by one
    l=8
    tslist = []
    while inflowLines[l].split(",")[0]!="P_DATETIME" :
        tsname = inflowLines[l].split(",")[0]
        tsFile = Path.Combine(rootfolder, "INPUT_DATA", tsname+".dfs0")
        tslist.extend(TsUtilities.ReadFromDFS0(tsMgr, tsFile))
        l = l + 1;

    # make new lines
    newLines = []
    i=0
    while True:
        if i==6:
            # replace startdate
            line = tslist[0].Start.ToString("dd/MM/yyyy HH:mm:ss") + inflowLines[i][19:]
        else:
            line = inflowLines[i]

        newLines.append(line)
        
        if inflowLines[i].split(",")[0]=="P_DATETIME" :
            break;
        i = i + 1;
    
    # continue with timesteps
    for t in range(tslist[0].Count):
        line = tslist[0].Get(t).XValue.ToString("dd/MM/yyyy HH:mm:ss")
        for ds in tslist:
            line += "," + ds.Get(t).YValue.ToString(CultureInfo.InvariantCulture)
        
        newLines.append(line)

    # rewrite the input file
    File.WriteAllLines(inflowPath, newLines)
        
    # run the adapter bat-file
    startInfo = ProcessStartInfo()
    startInfo.CreateNoWindow = False;
    startInfo.UseShellExecute = False;
    startInfo.FileName = Path.Combine(rootfolder, "MODEL_SETUP", "run.bat");
    startInfo.WorkingDirectory = Path.Combine(rootfolder, "MODEL_SETUP")
    with Process.Start(startInfo) as exeProcess :
        exeProcess.WaitForExit();

    # convert exported csv-files to dfs0
    # convert node depths
    dslist = []
    for fil in Directory.GetFiles(Path.Combine(rootfolder,"MODEL_SETUP\\export"),"Node_*_depnod.csv"):
        lines = File.ReadAllLines(fil)
        
        headers = lines[0].split(",")
        for h in headers[2:]:
            ds = tsMgr.TimeSeriesList.CreateNew()
            ds.Name = h.strip()
            ds.YAxisVariable = "Water Level"
            
            dslist.append(ds)
            
    
        for line in lines[1:] :
            if not "[" in line:
                values = line.split(",")
                t = DateTime.ParseExact(values[0].strip(),"dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture)
                for v in range(2,values.Count):
                    ds = dslist[v-2]
                    vp = ds.CreateNew()
                    vp.XValue = t
                    vp.YValue = Double.Parse(values[v].strip(), CultureInfo.InvariantCulture)
                    ds.Add(vp)    
        
        # save to dfs0
        for ds in dslist:
            fil = Path.Combine(rootfolder,"OUTPUT_DATA",ds.Name+".dfs0")
            TsUtilities.ExportToDfs0(ds,fil)
示例#13
0
import clr

clr.AddReference('System')

from System.Diagnostics import Process, ProcessStartInfo

processes = Process.GetProcessesByName('Dropbox')

if len(processes) == 0:
	processStartInfo = ProcessStartInfo()
	processStartInfo.WorkingDirectory = r"C:\Users\Andrius\AppData\Roaming\Dropbox\bin"
	processStartInfo.FileName = 'Dropbox.exe'

	dropbox = Process.Start(processStartInfo)
示例#14
0
# <command>
#   <description>Startet ein externes Programm</description>
#   <param name="program" type="file">Pfad zum Programm</param>
#   <param name="arguments" type="string">(optional) Parameter für das Programm</param>
#   <param name="directorz" type="dir">(optional) Verzeichnis in dem das Programm ausgeführt wird</param>
# </command>
from System.Diagnostics import Process, ProcessStartInfo
setup = ProcessStartInfo(program, arguments)
if directory is not None:
    setup.WorkingDirectory = directory
Process.Start(setup)
示例#15
0
    print 'Conflicts', status.NumConflicts
    for conflict in ws.QueryConflicts(('$/TCWCS/Python/Main/Open_Source/', ), True):
        assert isinstance(conflict, Conflict)
        print 'Can Merge', conflict.CanMergeContent
        conflict.Resolution = Resolution.AcceptMerge
        conflict.ResolutionOptions.UseInternalEngine = True
        ws.ResolveConflict(conflict)
        if not conflict.IsResolved:
            if conflict.CanMergeContent:
                conflict.Resolution = Resolution.AcceptYours
                ws.ResolveConflict(conflict)
                if not conflict.IsResolved:
                    print 'Failed to resolve conflict', dir(conflict)
                    sys.exit(1)
            else:
                print 'Failed to resolve conflict', dir(conflict)
                sys.exit(1)

    ws.CheckIn(ws.GetPendingChanges(), x.Comment)    
    comment = x.Comment.Replace("'", "''").Replace(unichr(8217), "''")
    psi = ProcessStartInfo(path, 
                           r'"' + workspace_root + "\Tools\CodePlex\Sync.ps1\" push '" + 
                           hg_root + "' '" + workspace_root +"' '" + comment + 
                           "' -suppress_push True -commit_date '" + x.CreationDate.ToString() + "'")
    print psi.Arguments
    psi.UseShellExecute = False
    p = Process.Start(psi)
    p.WaitForExit()
    
    cur_version = x.ChangesetId
    
示例#16
0
def ExecProcess(file, arg=''):
    from System.Diagnostics import ProcessStartInfo, Process
    processStartInfo = ProcessStartInfo(file, arg)
    processStartInfo.UseShellExecute = True
    processStartInfo.CreateNoWindow = True
    process = Process.Start(processStartInfo)
示例#17
0
                                      True):
        assert isinstance(conflict, Conflict)
        print 'Can Merge', conflict.CanMergeContent
        conflict.Resolution = Resolution.AcceptMerge
        conflict.ResolutionOptions.UseInternalEngine = True
        ws.ResolveConflict(conflict)
        if not conflict.IsResolved:
            if conflict.CanMergeContent:
                conflict.Resolution = Resolution.AcceptYours
                ws.ResolveConflict(conflict)
                if not conflict.IsResolved:
                    print 'Failed to resolve conflict', dir(conflict)
                    sys.exit(1)
            else:
                print 'Failed to resolve conflict', dir(conflict)
                sys.exit(1)

    ws.CheckIn(ws.GetPendingChanges(), x.Comment)
    comment = x.Comment.Replace("'", "''").Replace(unichr(8217), "''")
    psi = ProcessStartInfo(
        path, r'"' + workspace_root + "\Tools\CodePlex\Sync.ps1\" push '" +
        hg_root + "' '" + workspace_root + "' '" + comment +
        "' -suppress_push True -commit_date '" + x.CreationDate.ToString() +
        "'")
    print psi.Arguments
    psi.UseShellExecute = False
    p = Process.Start(psi)
    p.WaitForExit()

    cur_version = x.ChangesetId