Java ExecutionResult.getSuccess方法代码示例

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
private synchronized void execute()
{
    // have we already done this?
    if (executed)
    {
        return;
    }
    executed = true;
    for (RuntimeExec command : shutdownCommands)
    {
        ExecutionResult result = command.execute();
        // check for failure
        if (!result.getSuccess())
        {
            logger.error("Shutdown command execution failed.  Continuing with other commands.: \n" + result);
        }
    }
    // done
    if (logger.isDebugEnabled())
    {
        logger.debug("Executed shutdown commands");
    }
}
 

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
/**
 * Executes the check command, if present.  Any errors will result in this component
 * being rendered unusable within the transformer registry, but may still be called
 * directly.
 */
public void afterPropertiesSet()
{
    if (transformCommand == null)
    {
        throw new AlfrescoRuntimeException("Mandatory property 'transformCommand' not set");
    }
    
    // execute the command
    if (checkCommand != null)
    {
        ExecutionResult result = checkCommand.execute();
        // check the return code
        if (this.available = result.getSuccess())
        {
            this.versionString = result.getStdOut().trim();
        }
        else
        {
            logger.error("Failed to start a runtime executable content transformer: \n" + result);
        }
    }
    else
    {
        // no check - just assume it is available
        available = true;
    }
}
 

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
@Override
public void afterPropertiesSet() throws Exception
{
    PropertyCheck.mandatory(this, "executer", executer);
    PropertyCheck.mandatory(this, "checkCommand", checkCommand);
    // check availability
    try
    {
        ExecutionResult result = this.checkCommand.execute();
        if(result.getSuccess())
        {
            this.versionString = result.getStdOut().trim();
            setAvailable(true);
            logger.info("Using PDF Renderer: "+this.versionString);
        }
        else
        {
            setAvailable(false);
            logger.error("Alfresco-PDF-Renderer is not available for transformations.\n"+result.toString());
        }
    }
    catch (Throwable e)
    {
        setAvailable(false);
        logger.error(getClass().getSimpleName() + " not available: " + (e.getMessage() != null ? e.getMessage() : ""));
        // debug so that we can trace the issue if required
        logger.debug(e);
    }
}
 

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
/**
 * Adds a Linux version
 * 
 * @param osName os.name attribute
 * @return String
 */
public static String updateOSNameAttributeForLinux(String osName)
{
    RuntimeExec exec = new RuntimeExec();
    Map<String, String[]> commandMap = new HashMap<String, String[]>(3, 1.0f);
    commandMap.put("Linux", new String[] { "lsb_release", "-d" });
    exec.setCommandsAndArguments(commandMap);
    ExecutionResult ret = exec.execute();
    if (ret.getSuccess())
    {
        osName += " (" + ret.getStdOut().replace("\n", "") + ")";
    }
    else
    {
        commandMap.put("Linux", new String[] { "uname", "-a" });
        exec.setCommandsAndArguments(commandMap);
        ret = exec.execute();
        if (ret.getSuccess())
        {
            osName += " (" + ret.getStdOut().replace("\n", "") + ")";
        }
        else
        {
            osName += " (Unknown)";
        }
    }
    return osName;
}
 

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
@Override
protected synchronized void onBootstrap(ApplicationEvent event)
{
    // If the command is disabled then do nothing.
    if (this.enabled == false)
    {
        if (logger.isDebugEnabled())
        {
            logger.debug("Bootstrap execution of " + startupCommands.size() + " was not enabled");
        }
        return;
    }
    // execute
    for (RuntimeExec command : startupCommands)
    {
        ExecutionResult result = command.execute();
        // check for failure
        if (!result.getSuccess())
        {
            String msg = "Bootstrap command failed: \n" + result;
            if (failOnError)
            {
                throw new AlfrescoRuntimeException(msg);
            }
            else
            {
                logger.error(msg);
            }
        }
        else
        {
            // It executed, so keep track of it
            executionResults.add(result);
        }
    }
    if (killProcessesOnShutdown)
    {
        // Force a shutdown on VM termination as we can't rely on the Spring context termination
        this.shutdownThread = new KillProcessShutdownThread();
        Runtime.getRuntime().addShutdownHook(this.shutdownThread);
    }
    // done
    if (logger.isDebugEnabled())
    {
        logger.debug("Bootstrap execution of " + startupCommands.size() + " commands was successful");
    }
}
 

import org.alfresco.util.exec.RuntimeExec.ExecutionResult; //导入方法依赖的package包/类
/**
 * Unmount a remote CIFS shared filesystem
 * 
 * @param driveLetter String
 * @param mountPoint String
 * @exception CifsMountException
 */
public void unmountFilesystem( String driveLetter, String mountPoint)
	throws CifsMountException
{
	// Create the command line launcher
	
       RuntimeExec exec = new RuntimeExec();

       // Create the command map and properties
       
       Map<String, String> commandMap = new HashMap<String, String>( 1);
       Map<String, String> defProperties = new HashMap<String, String>( 10);
	
	// Determine the platform type and build the appropriate command line string
	
	Platform.Type platform = Platform.isPlatformType();
	
	switch ( platform)
	{
	// Windows
	
	case WINDOWS:
		commandMap.put( "Windows.*", WindowsUnMountCmd);
		break;
		
	// Linux
		
	case LINUX:
		commandMap.put( "Linux", LinuxUnMountCmd);
		break;
		
	// Mac OS X
		
	case MACOSX:
		commandMap.put( "Mac OS X", MacOSXUnMountCmd);
		break;
	}
	
	// Set the command map
	
	exec.setCommandMap( commandMap);
	
	// Build the command line properties list
	
       defProperties.put( "drive", driveLetter);
       defProperties.put( "mountpoint", mountPoint);
       
       exec.setDefaultProperties(defProperties);
	
       // Get the command to be used on this platform

       if ( logger.isDebugEnabled())
       	logger.debug( "UnMount CIFS share, cmdLine=" + Arrays.toString(exec.getCommand()));
       
       // Run the command
       
       ExecutionResult execRes = exec.execute();
       
       if ( logger.isDebugEnabled())
       	logger.debug( "UnMount result=" + execRes);
       
       // Check if the command was successful
       
       if ( execRes.getSuccess() == false)
       	throw new CifsMountException( execRes.getExitValue(), execRes.getStdOut(), execRes.getStdErr());
}