Java IOService.endBatch方法代码示例

import org.uberfire.io.IOService; //导入方法依赖的package包/类
@Override
public void sessionDestroyed(HttpSessionEvent se) {
    final ConfigIOServiceProducer ioServiceProducer = ConfigIOServiceProducer.getInstance();
    final IOService ioService = ioServiceProducer.configIOService();
    final FileSystem fileSystem = ioServiceProducer.configFileSystem();

    @SuppressWarnings("unchecked")
    final Set<LockInfo> locks = (Set<LockInfo>) se.getSession()
            .getAttribute(VFSLockServiceImpl.LOCK_SESSION_ATTRIBUTE_NAME);

    if (locks != null) {
        try {
            ioService.startBatch(fileSystem);
            for (LockInfo lock : locks) {
                try {
                    final Path lockPath = Paths.convert(PathFactory.newLock(lock.getFile()));
                    // Lock could have change ownership due to a forced lock release
                    if (ioService.readAllString(lockPath).equals(lock.lockedBy())) {
                        ioService.delete(lockPath);
                    }
                } catch (NoSuchFileException e) {
                    // Logging this with a lower level as it can happen when a user triggers 
                    // a forced lock release or when the locked file itself was deleted.
                    logger.debug("Problem when releasing lock on session end (lock no longer exists): " + lock,
                                 e);
                } catch (Throwable t) {
                    logger.warn("Problem when releasing lock on session end: " + lock,
                                t);
                }
            }
        } finally {
            ioService.endBatch();
        }
    }
}
 

import org.uberfire.io.IOService; //导入方法依赖的package包/类
public static void migrate(Path dir, IOService ioService, XStream xs, KieServerTemplateStorage templateStorage) {

        logger.debug("Attempting to find and migrate 6.2 type kie server templates inside directory '{}'...", dir);
        try {
            ioService.startBatch(dir.getFileSystem());
            for (final Path path : ioService.newDirectoryStream(dir, new DirectoryStream.Filter<Path>() {
                @Override
                public boolean accept(Path entry) throws IOException {
                    return entry.toString().endsWith("-info.xml");
                }
            })) {

                logger.debug("Found 6.2 type kie server template file '{}', migrating it...", path);
                try {
                    final KieServerInstance kieServerInstance = (KieServerInstance) xs.fromXML(ioService.readAllString(path));

                    logger.debug("Loaded KieServerInstance {}", kieServerInstance);
                    ServerTemplate serverTemplate = new ServerTemplate();
                    serverTemplate.setId(kieServerInstance.getIdentifier());
                    serverTemplate.setName(kieServerInstance.getName());

                    KieServerSetup serverSetup = kieServerInstance.getKieServerSetup();
                    if (serverSetup != null) {
                        Set<KieContainerResource> containerResources = kieServerInstance.getKieServerSetup().getContainers();
                        logger.debug("Server with id {} has containers {}", kieServerInstance.getIdentifier(), containerResources);
                        if (containerResources != null) {
                            for (KieContainerResource containerRef : containerResources) {

                                ContainerSpec containerSpec = new ContainerSpec(containerRef.getContainerId(),
                                        containerRef.getContainerId(),
                                        serverTemplate,
                                        containerRef.getReleaseId(),
                                        containerRef.getStatus(),
                                        new HashMap<Capability, ContainerConfig>());

                                logger.debug("Migrating container '{}' to container spec '{}'", containerRef, containerSpec);
                                serverTemplate.addContainerSpec(containerSpec);
                            }
                        }

                    }
                    Set<KieServerInstanceInfo> instanceInfos = kieServerInstance.getManagedInstances();
                    if (instanceInfos != null) {
                        logger.debug("Server with id {} has server instances {}", kieServerInstance.getIdentifier(), instanceInfos);
                        for (KieServerInstanceInfo instanceInfo : instanceInfos) {

                            logger.debug("Migrating server instance '{}'", instanceInfo);
                            serverTemplate.addServerInstance(ModelFactory.newServerInstanceKey(serverTemplate.getId(), instanceInfo.getLocation()));

                            serverTemplate.setCapabilities(instanceInfo.getCapabilities());
                        }
                    }
                    logger.debug("About to store migrated server template {}", serverTemplate);
                    // store migrated information
                    templateStorage.store(serverTemplate);
                    logger.info("Server template {} migrated successfully, removing old version...", serverTemplate);
                    // delete old to do not attempt second time migration
                    try {
                        ioService.startBatch(path.getFileSystem());
                        ioService.delete(path);
                    } finally {
                        ioService.endBatch();
                    }
                    logger.debug("Old version of server template '{}' has been removed", kieServerInstance);
                } catch (Exception ex) {
                    logger.error("Error while migrating old version (6.2.) of kie server instance from path {}", path, ex);
                }
            }

        } catch ( final NotDirectoryException ignore ) {
            logger.debug("No directory found, ignoring migration of kie server templates");
        } finally {
            ioService.endBatch();
        }
    }