org.ow2.petals.microkernel.system.systemstate.SystemStateServiceImpl Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of petals-microkernel Show documentation
There is a newer version: 4.3.0
/**
 * Copyright (c) 2006-2012 EBM WebSourcing, 2012-2016 Linagora
 * 
 * This program/library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 2.1 of the License, or (at your
 * option) any later version.
 * 
 * This program/library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program/library; If not, see http://www.gnu.org/licenses/
 * for the GNU Lesser General Public License version 2.1.
 */
package org.ow2.petals.microkernel.system.systemstate;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Logger;

import javax.jbi.management.LifeCycleMBean;

import org.objectweb.fractal.fraclet.annotations.Interface;
import org.objectweb.fractal.fraclet.annotations.Lifecycle;
import org.objectweb.fractal.fraclet.annotations.Requires;
import org.objectweb.fractal.fraclet.types.Step;
import org.ow2.petals.microkernel.api.configuration.ConfigurationService;
import org.ow2.petals.microkernel.api.container.Installer;
import org.ow2.petals.microkernel.api.system.SystemStateService;
import org.ow2.petals.microkernel.system.systemstate.exception.ComponentAlreadyExistsException;
import org.ow2.petals.microkernel.system.systemstate.exception.ServiceAssemblyAlreadyExistsException;
import org.ow2.petals.microkernel.system.systemstate.exception.SharedLibraryAlreadyExistsException;
import org.ow2.petals.systemstate.SystemStateBuilder;
import org.ow2.petals.systemstate.SystemStateException;
import org.ow2.petals.systemstate.generated.Component;
import org.ow2.petals.systemstate.generated.ObjectFactory;
import org.ow2.petals.systemstate.generated.ServiceAssembly;
import org.ow2.petals.systemstate.generated.SharedLibrary;
import org.ow2.petals.systemstate.generated.SystemState;

import com.ebmwebsourcing.easycommons.log.LoggingUtil;

/**
 * Creates and reads state files for components, shared libs and service assemblies. 
 * 
 * State files are text files that keep the state of JBI entities to
 * allow state retreval after Petals system shutdown or crash.
 * 
 * 
 * @author Adrien Louis - EBM WebSourcing
 * @author Roland Naudin - EBM WebSourcing
 */
@org.objectweb.fractal.fraclet.annotations.Component(provides = @Interface(name = "service", signature = SystemStateService.class))
public class SystemStateServiceImpl implements SystemStateService {

    private static final String SYSTEMSTATE_FILE = "system-state.xml";

    /**
     * logger wrapper
     */
    private final LoggingUtil log = new LoggingUtil(Logger.getLogger(SystemStateService.COMPONENT_LOGGER_NAME));

    private ObjectFactory objectFactory;

    @Requires(name = "configuration")
    private ConfigurationService configurationService;

    private SystemState systemState;

    private File systemStateFile;

    public SystemStateServiceImpl() {
        super();
    }

    @Override
    public synchronized Component createComponentStateHolder(String componentName, String archiveName)
            throws ComponentAlreadyExistsException, SystemStateException {

        // We check that the component does not already exist
        if (getComponentStateHolder(componentName) != null) {
            throw new ComponentAlreadyExistsException(componentName);
        }

        final Component componentToAdd = this.objectFactory.createComponent();
        componentToAdd.setName(componentName);
        componentToAdd.setInstallState(Installer.UNINSTALLED);
        componentToAdd.setArchiveName(archiveName);
        componentToAdd.setLifecycleState(LifeCycleMBean.UNKNOWN);

        this.systemState.getComponents().getComponent().add(componentToAdd);
        persistSystemState();

        return componentToAdd;
    }

    private void persistSystemState() throws SystemStateException {
        SystemStateBuilder.buildXmlFileSystemState(this.systemState, this.systemStateFile);
    }

    @Override
    public synchronized ServiceAssembly createServiceAssemblyStateHolder(String saName, String archiveName)
            throws ServiceAssemblyAlreadyExistsException, SystemStateException {

        // We check that the service assembly does not already exist
        if (getServiceAssemblyStateHolder(saName) != null) {
            throw new ServiceAssemblyAlreadyExistsException(saName);
        }

        final ServiceAssembly serviceAssemblyToAdd = this.objectFactory.createServiceAssembly();
        serviceAssemblyToAdd.setName(saName);
        serviceAssemblyToAdd.setArchiveName(archiveName);
        serviceAssemblyToAdd.setLifecycleState(LifeCycleMBean.UNKNOWN);

        this.systemState.getServiceAssemblies().getServiceAssembly().add(serviceAssemblyToAdd);
        persistSystemState();

        return serviceAssemblyToAdd;
    }

    @Override
    public synchronized SharedLibrary createSharedLibraryStateHolder(String slName, String version, String archiveName)
            throws SystemStateException {

        // We check that the service assembly does not already exist
        if (getSharedLibraryStateHolder(slName, version) != null) {
            throw new SharedLibraryAlreadyExistsException(slName, version);
        }

        final SharedLibrary sharedLibraryToAdd = this.objectFactory.createSharedLibrary();
        sharedLibraryToAdd.setName(slName);
        sharedLibraryToAdd.setVersion(version);
        sharedLibraryToAdd.setArchiveName(archiveName);

        this.systemState.getSharedLibraries().getSharedLibrary().add(sharedLibraryToAdd);
        persistSystemState();

        return sharedLibraryToAdd;
    }

    @Override
    public synchronized Component deleteComponentStateHolder(String componentName) throws SystemStateException {

        final Component componentStateHolder = getComponentStateHolder(componentName);

        if (componentStateHolder != null) {
            this.systemState.getComponents().getComponent().remove(componentStateHolder);
            persistSystemState();
        }

        return componentStateHolder;

    }

    @Override
    public synchronized ServiceAssembly deleteServiceAssemblyStateHolder(String saName) throws SystemStateException {

        final ServiceAssembly serviceAssemblyStateHolder = getServiceAssemblyStateHolder(saName);

        if (serviceAssemblyStateHolder != null) {
            this.systemState.getServiceAssemblies().getServiceAssembly().remove(serviceAssemblyStateHolder);
            persistSystemState();
        }

        return serviceAssemblyStateHolder;
    }

    @Override
    public synchronized SharedLibrary deleteSharedLibraryStateHolder(String slName, String version)
            throws SystemStateException {

        final SharedLibrary sharedLibraryStateHolder = getSharedLibraryStateHolder(slName, version);

        if (sharedLibraryStateHolder != null) {
            this.systemState.getSharedLibraries().getSharedLibrary().remove(sharedLibraryStateHolder);
            persistSystemState();
        }

        return sharedLibraryStateHolder;
    }

    @Override
    public synchronized Component getComponentStateHolder(String componentName) {
        for (final Component componentStateHolder : this.systemState.getComponents().getComponent()) {
            if (componentName.equals(componentStateHolder.getName())) {
                return componentStateHolder;
            }
        }

        return null;
    }

    @Override
    public synchronized List getComponentStateHolders() {
        return new ArrayList(this.systemState.getComponents().getComponent());
    }

    @Override
    public synchronized ServiceAssembly getServiceAssemblyStateHolder(String saName) {
        for (final ServiceAssembly serviceAssemblyStateHolder : this.systemState.getServiceAssemblies()
                .getServiceAssembly()) {
            if (saName.equals(serviceAssemblyStateHolder.getName())) {
                return serviceAssemblyStateHolder;
            }
        }

        return null;
    }

    @Override
    public synchronized List getServiceAssemblyStateHolders() {
        return new ArrayList(this.systemState.getServiceAssemblies().getServiceAssembly());
    }

    @Override
    public synchronized SharedLibrary getSharedLibraryStateHolder(String slName, String version) {
        for (final SharedLibrary sharedLibraryStateHolder : this.systemState.getSharedLibraries().getSharedLibrary()) {
            if (slName.equals(sharedLibraryStateHolder.getName())
                    && version.equals(sharedLibraryStateHolder.getVersion())) {
                return sharedLibraryStateHolder;
            }
        }

        return null;
    }

    @Override
    public synchronized List getSharedLibraryStateHolders() {
        return new ArrayList(this.systemState.getSharedLibraries().getSharedLibrary());
    }

    @Override
    public synchronized List getSharedLibraryStateHolders(String slName) {
        final List sharedLibrarySharedHolders = new ArrayList();
        for (final SharedLibrary sharedLibraryStateHolder : this.systemState.getSharedLibraries().getSharedLibrary()) {
            if (slName.equals(sharedLibraryStateHolder.getName())) {
                sharedLibrarySharedHolders.add(sharedLibraryStateHolder);
            }
        }

        return sharedLibrarySharedHolders;
    }

    @Override
    public boolean isComponentInstalled(String componentName) {
        return Installer.INSTALLED.equals(this.getComponentStateHolder(componentName).getInstallState());
    }

    @Override
    public synchronized void updateComponentInstallationState(String componentName, String installState)
            throws SystemStateException {
        final Component componentStateHolder = getComponentStateHolder(componentName);

        if (componentStateHolder != null) {
            componentStateHolder.setInstallState(installState);
        }

        persistSystemState();
    }

    @Override
    public synchronized void updateComponentLifeCycleState(String componentName, String lifecycleState)
            throws SystemStateException {

        final Component componentStateHolder = getComponentStateHolder(componentName);

        if (componentStateHolder != null) {
            componentStateHolder.setLifecycleState(lifecycleState);
        }

        persistSystemState();
    }

    @Override
    public synchronized void updateServiceAssemblyState(String saName, String lifecycleState)
            throws SystemStateException {

        final ServiceAssembly serviceAssemblyStateHolder = getServiceAssemblyStateHolder(saName);

        if (serviceAssemblyStateHolder != null) {
            serviceAssemblyStateHolder.setLifecycleState(lifecycleState);
        }

        persistSystemState();
    }

    /**
     * Initialize the SystemState Service.
     * 
     * @throws IOException
     * @throws SystemStateException
     */
    @Lifecycle(step = Step.START)
    public void start() throws IOException, SystemStateException {
        this.log.start();

        this.objectFactory = new ObjectFactory();
        final File repoPath = new File(
                this.configurationService.getContainerConfiguration().getRepositoryDirectoryPath());

        if (!repoPath.exists() && !repoPath.mkdir()) {
            throw new IOException("Directory '" + repoPath.getAbsolutePath() + "' can not be create");
        }

        try {
            this.systemStateFile = new File(repoPath.getAbsolutePath(), SYSTEMSTATE_FILE);
            if (!this.systemStateFile.exists()) {
                this.systemStateFile.createNewFile();
                this.systemState = this.objectFactory.createSystemState();
                this.systemState.setComponents(this.objectFactory.createComponents());
                this.systemState.setServiceAssemblies(this.objectFactory.createServiceAssemblies());
                this.systemState.setSharedLibraries(this.objectFactory.createSharedLibraries());
                persistSystemState();
            } else {
                this.systemState = SystemStateBuilder.createSystemState(this.systemStateFile);
            }
        } catch (SystemStateException e) {
            this.log.error("Failed to start System State Service", e);
            throw e;
        } catch (IOException e) {
            this.log.error("Failed to start System State Service", e);
            throw e;
        }

        this.log.end();
    }

    @Lifecycle(step = Step.STOP)
    public void stop() {
        this.log.call();
    }
}