org.cristalise.kernel.entity.transfer.TransferItem Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of cristalise-kernel Show documentation

Cristal-ise is a description-driven software platform originally developed to track the construction of the CMS ECAL detector of the LHC at CERN. This is its core library, known as the kernel, which manages business objects called Items. Items are entirely configured from data, called descriptions, held in other Items. Every change of a state in an Item is a consequence of an execution of an activity in that Item's lifecycle, meaning that Cristal-ise applications are completely traceable, even in their design. It also supports extensive versioning of Item description data, giving the system a high level of flexibility.

There is a newer version: 6.0.0

Show newest version

/**
 * This file is part of the CRISTAL-iSE kernel.
 * Copyright (c) 2001-2015 The CRISTAL Consortium. All rights reserved.
 *
 * 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; either version 3 of the License, or (at
 * your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; with out 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 library; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * http://www.fsf.org/licensing/licenses/lgpl.html
 */
package org.cristalise.kernel.entity.transfer;

import static org.cristalise.kernel.persistency.ClusterType.OUTCOME;
import static org.cristalise.kernel.persistency.ClusterType.PROPERTY;
import static org.cristalise.kernel.property.BuiltInItemProperties.NAME;
import static org.cristalise.kernel.security.BuiltInAuthc.SYSTEM_AGENT;
import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import org.cristalise.kernel.collection.Collection;
import org.cristalise.kernel.collection.CollectionArrayList;
import org.cristalise.kernel.common.ObjectNotFoundException;
import org.cristalise.kernel.entity.C2KLocalObject;
import org.cristalise.kernel.entity.TraceableEntity;
import org.cristalise.kernel.lifecycle.instance.Workflow;
import org.cristalise.kernel.lookup.AgentPath;
import org.cristalise.kernel.lookup.DomainPath;
import org.cristalise.kernel.lookup.InvalidItemPathException;
import org.cristalise.kernel.lookup.ItemPath;
import org.cristalise.kernel.lookup.Path;
import org.cristalise.kernel.persistency.ClusterType;
import org.cristalise.kernel.persistency.outcome.Outcome;
import org.cristalise.kernel.process.Gateway;
import org.cristalise.kernel.property.Property;
import org.cristalise.kernel.property.PropertyArrayList;
import org.cristalise.kernel.utils.FileStringUtility;
import org.cristalise.kernel.utils.Logger;

public class TransferItem {
    private ArrayList domainPaths;
    protected ItemPath        itemPath;
    static AgentPath          importAgentId;

    public TransferItem() throws Exception {
        try {
            importAgentId = Gateway.getLookup().getAgentPath(SYSTEM_AGENT.getName());
        }
        catch (ObjectNotFoundException e) {
            Logger.error("TransferItem - System agent not found!");
            throw e;
        }
    }

    public TransferItem(ItemPath itemPath) throws Exception {
        this.itemPath = itemPath;
        domainPaths = new ArrayList();
        Iterator paths = Gateway.getLookup().searchAliases(itemPath);
        while (paths.hasNext()) {
            DomainPath thisPath = (DomainPath) paths.next();
            domainPaths.add(thisPath.toString());
        }
    }

    public ArrayList getDomainPaths() {
        return domainPaths;
    }

    public void setDomainPaths(ArrayList domainPaths) {
        this.domainPaths = domainPaths;
    }

    public void setUUID(String uuid) throws InvalidItemPathException {
        itemPath = new ItemPath(uuid);
    }

    public String getUUID() {
        return itemPath.getUUID().toString();
    }

    public void exportItem(File dir, String path) throws Exception {
        Logger.msg("Path " + path + " in " + itemPath);
        String[] contents = Gateway.getStorage().getClusterContents(itemPath, path);
        if (contents.length > 0) {
            FileStringUtility.createNewDir(dir.getCanonicalPath());
            for (String content : contents) {
                exportItem(new File(dir, content), path + "/" + content);
            }
        }
        else { // no children, try to dump object
            try {
                C2KLocalObject obj = Gateway.getStorage().get(itemPath, path, null);
                Logger.msg("Dumping object " + path + " in " + itemPath);
                File dumpPath = new File(dir.getCanonicalPath() + ".xml");
                FileStringUtility.string2File(dumpPath, Gateway.getMarshaller().marshall(obj));
                return;
            }
            catch (ObjectNotFoundException ex) {} // not an object
        }
    }

    public void importItem(File dir) throws Exception {
        // check if already exists
        try {
            Property name = (Property) Gateway.getStorage().get(itemPath, PROPERTY + "/" + NAME, null);
            throw new Exception("Item " + itemPath + " already in use as " + name.getValue());
        }
        catch (Exception ex) {}

        // retrieve objects
        ArrayList objectFiles = FileStringUtility.listDir(dir.getCanonicalPath(), false, true);
        ArrayList objects = new ArrayList();
        for (String element : objectFiles) {
            String xmlFile = FileStringUtility.file2String(element);
            C2KLocalObject newObj;
            String choppedPath = element.substring(dir.getCanonicalPath().length() + 1, element.length() - 4);

            Logger.msg(choppedPath);

            if (choppedPath.startsWith(OUTCOME.getName())) newObj = new Outcome(choppedPath, xmlFile);
            else                                                newObj = (C2KLocalObject) Gateway.getMarshaller().unmarshall(xmlFile);

            objects.add(newObj);
        }

        // create item
        TraceableEntity newItem = Gateway.getCorbaServer().createItem(itemPath);
        Gateway.getLookupManager().add(itemPath);

        PropertyArrayList props = new PropertyArrayList();
        CollectionArrayList colls = new CollectionArrayList();
        Workflow wf = null;
        // put objects
        for (C2KLocalObject obj : objects) {
            if (obj instanceof Property)        props.list.add((Property) obj);
            else if (obj instanceof Collection) colls.list.add((Collection) obj);
            else if (obj instanceof Workflow)   wf = (Workflow) obj;
        }

        if (wf == null) throw new Exception("No workflow found in import for " + itemPath);

        // init item
        newItem.initialise(importAgentId.getSystemKey(),
                           Gateway.getMarshaller().marshall(props),
                           Gateway.getMarshaller().marshall(wf.search("workflow/domain")),
                           Gateway.getMarshaller().marshall(colls),
                           "", "");

        // store objects
        importByType(ClusterType.HISTORY, objects);
        importByType(ClusterType.OUTCOME, objects);
        importByType(ClusterType.VIEWPOINT, objects);
        Gateway.getStorage().commit(this);

        // add domPaths
        for (String element : domainPaths) {
            DomainPath newPath = new DomainPath(element, itemPath);
            Gateway.getLookupManager().add(newPath);
        }
    }

    private void importByType(ClusterType type, ArrayList objects) throws Exception {
        for (C2KLocalObject element : objects) {
            if (element.getClusterType().equals(type)) Gateway.getStorage().put(itemPath, element, this);
        }

    }
}