org.ow2.bonita.facade.impl.ManagementAPIImpl Maven / Gradle / Ivy

Go to download
/**
 * Copyright (C) 2007  Bull S. A. S.
 * Bull, Rue Jean Jaures, B.P.68, 78340, Les Clayes-sous-Bois
 * This 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
 * version 2.1 of the License.
 * This 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; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA  02110-1301, USA.
 **/
package org.ow2.bonita.facade.impl;

import java.io.IOException;
import java.net.URL;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import org.ow2.bonita.definition.GlobalClassData;
import org.ow2.bonita.definition.PackageClassData;
import org.ow2.bonita.definition.PackageDependency;
import org.ow2.bonita.deployment.Deployer;
import org.ow2.bonita.deployment.DeploymentRuntimeException;
import org.ow2.bonita.facade.def.element.BusinessArchive;
import org.ow2.bonita.facade.def.element.Resource;
import org.ow2.bonita.facade.def.element.impl.BusinessArchiveImpl;
import org.ow2.bonita.facade.def.majorElement.PackageDefinition;
import org.ow2.bonita.facade.def.majorElement.PackageFullDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessDefinition;
import org.ow2.bonita.facade.def.majorElement.ProcessFullDefinition;
import org.ow2.bonita.facade.exception.DeploymentException;
import org.ow2.bonita.facade.exception.PackageNotFoundException;
import org.ow2.bonita.facade.exception.ProcessNotFoundException;
import org.ow2.bonita.facade.exception.UndeletableInstanceException;
import org.ow2.bonita.facade.exception.UndeletablePackageException;
import org.ow2.bonita.facade.internal.InternalManagementAPI;
import org.ow2.bonita.facade.uuid.PackageDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
import org.ow2.bonita.runtime.ClassDataLoader;
import org.ow2.bonita.runtime.XpdlInstance;
import org.ow2.bonita.services.Archiver;
import org.ow2.bonita.services.Querier;
import org.ow2.bonita.services.Recorder;
import org.ow2.bonita.services.Repository;
import org.ow2.bonita.util.BonitaRuntimeException;
import org.ow2.bonita.util.ClassDataTool;
import org.ow2.bonita.util.EngineEnvTool;
import org.ow2.bonita.util.Misc;

/**
 * @author Marc Blachon, Guillaume Porcher, Charles Souillard, Miguel Valdes,
 *         Pierre Vigneras
 */
public class ManagementAPIImpl implements InternalManagementAPI {

  protected ManagementAPIImpl() {
  }

  public Map deploy(final BusinessArchive businessArchive) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(businessArchive);
    try {
      return Deployer.deploy(businessArchive, EngineEnvTool.getUserId());
    } catch (final Exception e) {
      throw new DeploymentException(e.getMessage(), e);
    }
  }

  private BusinessArchive getBusinessArchive(byte[] barContent) throws DeploymentException {
    try {
      return new BusinessArchiveImpl(Misc.getResourcesFromZip(barContent));
    } catch (Exception e) {
      throw new DeploymentException("Exception caught while builing BusinessArchive: " + e.getMessage(), e);
    }
  }
  public Map deployBar(final URL barURL) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(barURL);
    return this.deployArchive(barURL);
  }

  public Map deployBar(final byte[] barContent) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(barContent);
    return deploy(getBusinessArchive(barContent));
  }

  @Deprecated
  public Map deploy(final URL xpdlURL, final Class< ? >[] classes) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(xpdlURL);
    Map resources = new HashMap();
    try {
      resources.put(xpdlURL.toString(), Misc.getAllContentFrom(xpdlURL));
      if (classes != null) {
        for (Class< ? > clazz : classes) {
          resources.put(clazz.getName() + ".class", ClassDataTool.getClassData(clazz));
        }
      }
      BusinessArchive businessArchive = new BusinessArchiveImpl(resources);
      return deploy(businessArchive);
    } catch (IOException e) {
      throw new DeploymentException("Exception caught while builing BusinessArchive: " + e.getMessage(), e);
    }
  }

  @Deprecated
  public Map deployXpdl(final byte[] xpdlFile) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(xpdlFile);
    Map resources = new HashMap();
    try {
      resources.put("xpdlProcess.xpdl", xpdlFile);
      BusinessArchive businessArchive = new BusinessArchiveImpl(resources);
      return deploy(businessArchive);
    } catch (IOException e) {
      throw new DeploymentException("Exception caught while builing BusinessArchive: " + e.getMessage(), e);
    }
  }

  @Deprecated
  public Map deployXpdl(final URL xpdlURL) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(xpdlURL);
    return deploy(xpdlURL, null);
  }

  @Deprecated
  public Map deployZip(final byte[] zipFile) throws DeploymentException {
    Misc.checkArgsNotNull(zipFile);
    return deploy(getBusinessArchive(zipFile));
  }

  @Deprecated
  public Map deployZip(final URL zipURL) throws DeploymentException {
    Misc.checkArgsNotNull(zipURL);
    return this.deployArchive(zipURL);
  }

  public void deployClass(final byte[] clazz) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(clazz);
    String className;
    try {
      className = ClassDataTool.visitClass(clazz).getClassName();
    } catch (final ArrayIndexOutOfBoundsException e) {
      throw new DeploymentException("The byte table is not correct parameter.");
    }
    final Repository repository = EngineEnvTool.getRepository();
    final GlobalClassData globalClassData = repository.getGlobalClassData(className);
    if (globalClassData != null) {
      // this class was already deployed
      throw new DeploymentException("There is already a deployed class with this name: ", className);
    }
    repository.storeGlobalClassData(new GlobalClassData(className, clazz));
  }

  public void deployClassesInJar(final byte[] classesArchive) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(classesArchive);
    BusinessArchive businessArchive = getBusinessArchive(classesArchive);
    Collection classResources = businessArchive.getClasses();
    final Collection classes = new ArrayList();
    for (Resource clazzData : classResources) {
      classes.add(clazzData.getData());
    }
    this.deployClasses(classes);
  }

  public void deployClasses(final Collection classes) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(classes);
    for (final byte[] data : classes) {
      this.deployClass(data);
    }
  }

  public void undeploy(final PackageDefinitionUUID packageUUID) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(packageUUID);
    try {
      Deployer.undeployPackage(packageUUID, EngineEnvTool.getUserId());
    } catch (final DeploymentRuntimeException e) {
      throw new DeploymentException(e.getMessage(), e);
    }
  }

  public void removeClass(final String className) throws DeploymentException {
    FacadeUtil.checkArgsNotNull(className);

    final Repository repository = EngineEnvTool.getRepository();
    if (repository.getGlobalClassData(className) == null) {
      throw new DeploymentException("There is no class defined in global class repository  with name: ", className);

    }
    // check that no process is still using this class
    final Set packageDependencies = repository.getPackageDependencies(className);
    if (packageDependencies != null && !packageDependencies.isEmpty()) {
      for (final PackageDependency packageDependency : packageDependencies) {
        final PackageClassData data = repository.getPackageClassData(packageDependency.getPackageDefinitionUUID());
        if (data == null || !data.getClasses().containsKey(className)) {
          throw new DeploymentException("Package is still using global class. " + "Cannot undeploy class.",
              className, packageDependency.getPackageDefinitionUUID());
        }
      }
    }
    repository.removeGlobalClassData(className);
    ClassDataLoader.removeCommonClass(className);
  }

  public void removeClasses(final String[] classNames) throws DeploymentException {
    if (classNames != null) {
      for (final String className : classNames) {
        this.removeClass(className);
      }
    }
  }

  public void replaceClass(final String className, final byte[] newClazz) throws DeploymentException {
    this.removeClass(className);
    this.deployClass(newClazz);
  }

  private Map deployArchive(final URL archiveURL) throws DeploymentException {
    Misc.checkArgsNotNull(archiveURL);
    try {
      return deploy(getBusinessArchive(Misc.getAllContentFrom(archiveURL)));
    } catch (IOException e) {
      throw new DeploymentException("Exception caught while builing BusinessArchive: " + e.getMessage(), e);
    }
  }
  
  public void deletePackage(final PackageDefinitionUUID packageDefinitionUUID) throws PackageNotFoundException, 
  UndeletablePackageException, UndeletableInstanceException {
    FacadeUtil.checkArgsNotNull(packageDefinitionUUID);

    final Querier journal = EngineEnvTool.getJournalQueriers();
    final Querier history = EngineEnvTool.getHistoryQueriers();
    final Repository repository = EngineEnvTool.getRepository();

    final PackageFullDefinition journalPack = journal.getPackage(packageDefinitionUUID);
    final boolean inJournal = journalPack != null;
    final PackageFullDefinition historyPack = history.getPackage(packageDefinitionUUID);
    final boolean inHistory = historyPack != null;

    if (!inJournal && !inHistory) {
      throw new PackageNotFoundException(packageDefinitionUUID);
    }

    Set processes;
    String packageId;
    String packageVersion;
    if (inJournal) {
      processes = journalPack.getProcesses();
      packageId = journalPack.getPackageId();
      packageVersion = journalPack.getVersion();
    } else {
      processes = historyPack.getProcesses();
      packageId = historyPack.getPackageId();
      packageVersion = historyPack.getVersion();
    }

    repository.removePackageVersion(packageId, packageVersion);
    final RuntimeAPIImpl runtimeAPI = new RuntimeAPIImpl();
    try {
      for (final ProcessFullDefinition process : processes) {
        final ProcessDefinitionUUID processUUID = process.getUUID();
        runtimeAPI.deleteAllProcessInstances(processUUID);
        repository.removeProcessVersion(process.getProcessId(), process.getVersion(), packageId);
      }
    } catch (final ProcessNotFoundException e) {
      throw new BonitaRuntimeException(e);
    }

    if (inJournal) {
      // check that none of the processes have running instances
      for (final ProcessFullDefinition process : processes) {
        final ProcessDefinitionUUID processUUID = process.getUUID();
        final Set xpdlInstances = repository.getXpdlInstances(processUUID);
        if (!xpdlInstances.isEmpty()) {
          final ProcessInstanceUUID instanceUUID = xpdlInstances.iterator().next().getUUID();
          throw new UndeletablePackageException(packageDefinitionUUID, processUUID, instanceUUID);
        }

      }
      Deployer.removePackageDependencies(journalPack);
      final Recorder recorder = EngineEnvTool.getRecorder();
      recorder.remove(journalPack);
    }

    if (inHistory) {
      final Archiver archiver = EngineEnvTool.getArchiver();
      archiver.remove(historyPack);
    }

  }
  
  public void deleteAllPackages() throws UndeletableInstanceException,
      RemoteException, UndeletablePackageException {
    Querier querier = EngineEnvTool.getAllQueriers();
    for (PackageDefinition packageDefinition : querier.getPackages()) {
      try {
        deletePackage(packageDefinition.getUUID());
      } catch (PackageNotFoundException e) {
        //nothing
      }
    }
  }
}