ServiceGroupContext.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied. See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */


package org.apache.axis2.context;

import org.apache.axiom.util.UIDGenerator;
import org.apache.axis2.AxisFault;
import org.apache.axis2.context.externalize.ActivateUtils;
import org.apache.axis2.context.externalize.ExternalizeConstants;
import org.apache.axis2.context.externalize.SafeObjectInputStream;
import org.apache.axis2.context.externalize.SafeObjectOutputStream;
import org.apache.axis2.context.externalize.SafeSerializable;
import org.apache.axis2.description.AxisService;
import org.apache.axis2.description.AxisServiceGroup;
import org.apache.axis2.engine.AxisConfiguration;
import org.apache.axis2.i18n.Messages;
import org.apache.axis2.util.MetaDataEntry;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class ServiceGroupContext extends AbstractContext 
    implements Externalizable, SafeSerializable {

    /*
     * setup for logging
     */
    private static final Log log = LogFactory.getLog(ServiceGroupContext.class);

    private static final String myClassName = "ServiceGroupContext";

    /**
     * @serial The serialization version ID tracks the version of the class.
     * If a class definition changes, then the serialization/externalization
     * of the class is affected. If a change to the class is made which is
     * not compatible with the serialization/externalization of the class,
     * then the serialization version ID should be updated.
     * Refer to the "serialVer" utility to compute a serialization
     * version ID.
     */
    private static final long serialVersionUID = 9014471144479928885L;

    /**
     * @serial Tracks the revision level of a class to identify changes to the
     * class definition that are compatible to serialization/externalization.
     * If a class definition changes, then the serialization/externalization
     * of the class is affected.
     * Refer to the writeExternal() and readExternal() methods.
     */
    // supported revision levels, add a new level to manage compatible changes
    private static final int REVISION_2 = 2;
    // current revision level of this object
    private static final int revisionID = REVISION_2;


    private transient AxisServiceGroup axisServiceGroup;
    private String id;
    private Map<String, ServiceContext> serviceContextMap;

    //----------------------------------------------------------------
    // MetaData for data to be restored in activate after readExternal
    //----------------------------------------------------------------

    /**
     * Indicates whether the message context has been reconstituted
     * and needs to have its object references reconciled
     */
    private transient boolean needsToBeReconciled = false;


    /**
     * The AxisServiceContext metadata will be used during
     * activate to match up with an existing object
     */
    private transient MetaDataEntry metaAxisServiceGroup = null;

    //----------------------------------------------------------------
    // end MetaData section
    //----------------------------------------------------------------

    // simple constructor
    public ServiceGroupContext() {
        super(null);
        serviceContextMap = new HashMap<String, ServiceContext>();
    }


    public ServiceGroupContext(ConfigurationContext parent, AxisServiceGroup axisServiceGroup) {
        super(parent);
        this.axisServiceGroup = axisServiceGroup;
        serviceContextMap = new HashMap<String, ServiceContext>();
        // initially set the id to the axisServiceGroup
        if (axisServiceGroup != null) {
            setId(axisServiceGroup.getServiceGroupName());
        }
    }

    public AxisServiceGroup getDescription() {
        checkActivateWarning("getDescription");
        return axisServiceGroup;
    }

    public String getId() {
        return id;
    }

    /**
     * Gets a service context. Creates a new one from AxisService.
     * There is no need to store service context inside serviceGroup
     * context as well.
     *
     * @param service the AxisService for which to get a context
     * @return Returns ServiceContext.
     * @throws AxisFault if something goes wrong
     */
    public ServiceContext getServiceContext(AxisService service) throws AxisFault {
        AxisService axisService = axisServiceGroup.getService(service.getName());
        if (axisService == null) {
            throw new AxisFault(Messages.getMessage("invalidserviceinagroup",
                                                    service.getName(),
                                                    axisServiceGroup.getServiceGroupName()));
        }
        if (serviceContextMap == null) {
            serviceContextMap = new HashMap<String, ServiceContext>();
        }
        ServiceContext serviceContext = (ServiceContext) serviceContextMap.get(service.getName());
        if (serviceContext == null) {
            serviceContext = new ServiceContext(service, this);
            getRootContext().contextCreated(serviceContext);
            serviceContextMap.put(service.getName(), serviceContext);
        }
        return serviceContext;
    }

    public Iterator<ServiceContext> getServiceContexts() {
        if (serviceContextMap == null) {
            serviceContextMap = new HashMap<String, ServiceContext>();
        }
        if (serviceContextMap.isEmpty()) {
            return null;
        }
        return serviceContextMap.values().iterator();
    }

    public void setId(String id) {
        this.id = id;
    }

    /**
     * Adds the specified service context object to the
     * lists of service contexts for this service group
     * context.
     *
     * @param srvctx The ServiceContext object to add
     */
    public void addServiceContext(ServiceContext srvctx) {
        if (srvctx == null) {
            return;
        }

        AxisService axisService = srvctx.getAxisService();

        if (axisService == null) {
            return;
        }

        if (serviceContextMap == null) {
            serviceContextMap = new HashMap<String, ServiceContext>();
        }

        serviceContextMap.put(axisService.getName(), srvctx);

    }


    /**
     * Finds the service context object that corresponds
     * to the specified name from the list
     * of service contexts for this service group
     * context.
     *
     * @param name The name associated with the ServiceContext
     * @return The ServiceContext associated with the name,
     *         or null, if none can be found
     */
    public ServiceContext findServiceContext(String name) {
        if (serviceContextMap == null) {
            return null;
        }

        return (ServiceContext) serviceContextMap.get(name);
    }


    /**
     * Finds the service context object that corresponds
     * to the specified AxisService from the list
     * of service contexts for this service group
     * context.
     *
     * @param axisSrv the AxisService whose context we're looking for
     * @return The ServiceContext associated with the AxisService
     *         or null, if none can be found
     */
    public ServiceContext findServiceContext(AxisService axisSrv) {
        if (axisSrv == null) {
            return null;
        }

        if (serviceContextMap == null) {
            return null;
        }

        return (ServiceContext) serviceContextMap.get(axisSrv.getName());
    }

    /**
     * This will do a copy of the properties from this context object
     * to the properties of the specified context object.
     *
     * @param context The ServiceGroupContext object to hold the merged properties
     */
    public void putContextProperties(ServiceGroupContext context) {
        if (context != null) {
            // get the current properties on this context object
            Map<String, Object> props = getProperties();

            // copy them to the specified context object
            context.mergeProperties(props);
        }
    }

    /* ===============================================================
    * Externalizable support
    * ===============================================================
    */


    /**
     * Save the contents of this object.
     * <p/>
     * NOTE: Transient fields and static fields are not saved.
     * Also, objects that represent "static" data are
     * not saved, except for enough information to be
     * able to find matching objects when the message
     * context is re-constituted.
     *
     * @param out The stream to write the object contents to
     * @throws IOException
     */
    public void writeExternal(ObjectOutput o) throws IOException {
        SafeObjectOutputStream out = SafeObjectOutputStream.install(o);
        // write out contents of this object

        //---------------------------------------------------------
        // in order to handle future changes to the message 
        // context definition, be sure to maintain the 
        // object level identifiers
        //---------------------------------------------------------
        // serialization version ID
        out.writeLong(serialVersionUID);

        // revision ID
        out.writeInt(revisionID);

        //---------------------------------------------------------
        // various simple fields
        //---------------------------------------------------------

        out.writeLong(getLastTouchedTime());

        if (id == null) {
            // generate an ID to use when this object is restored
            id = UIDGenerator.generateUID();
        }
        out.writeObject(id);

        //---------------------------------------------------------
        // properties
        //---------------------------------------------------------
        out.writeMap(getProperties());

        //---------------------------------------------------------
        // AxisServiceGroup
        //---------------------------------------------------------
        metaAxisServiceGroup = null;
        if (axisServiceGroup != null) {
            metaAxisServiceGroup = new MetaDataEntry(axisServiceGroup.getClass().getName(),
                                                     axisServiceGroup.getServiceGroupName());
        }
        out.writeObject(metaAxisServiceGroup);

        //---------------------------------------------------------
        // parent 
        //---------------------------------------------------------

        // the parent is the ConfigurationContext object, which
        // at this time, is not being saved.
        // instead, we will need to register this ServiceGroupObject
        // with the existing ConfigurationContext object when
        // this object is reconstituted

    }


    /**
     * Restore the contents of the object that was previously saved.
     * <p/>
     * NOTE: The field data must read back in the same order and type
     * as it was written.  Some data will need to be validated when
     * resurrected.
     *
     * @param in The stream to read the object contents from
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public void readExternal(ObjectInput inObject) throws IOException, ClassNotFoundException {
        SafeObjectInputStream in = SafeObjectInputStream.install(inObject);
        // set the flag to indicate that the message context is being
        // reconstituted and will need to have certain object references 
        // to be reconciled with the current engine setup
        needsToBeReconciled = true;

        // trace point
        if (log.isTraceEnabled()) {
            log.trace(myClassName + ":readExternal():  BEGIN  bytes available in stream [" +
                      in.available() + "]  ");
        }

        // serialization version ID
        long suid = in.readLong();

        // revision ID
        int revID = in.readInt();

        // make sure the object data is in a version we can handle
        if (suid != serialVersionUID) {
            throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_SUID);
        }

        // make sure the object data is in a revision level we can handle
        if (revID != REVISION_2) {
            throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_REVID);
        }

        //---------------------------------------------------------
        // various simple fields
        //---------------------------------------------------------

        long time = in.readLong();
        setLastTouchedTime(time);
        id = (String) in.readObject();

        //---------------------------------------------------------
        // properties
        //---------------------------------------------------------
        properties = in.readMap(new HashMap());

        //---------------------------------------------------------
        // AxisServiceGroup
        //---------------------------------------------------------

        // axisServiceGroup is not usable until the meta data has been reconciled
        axisServiceGroup = null;
        metaAxisServiceGroup = (MetaDataEntry) in.readObject();

        //---------------------------------------------------------
        // parent 
        //---------------------------------------------------------

        // the parent is the ConfigurationContext object, whic
        // at this time, is not being saved.
        // instead, we will need to register this ServiceGroupObject
        // with the existing ConfigurationContext object when
        // this object is reconstituted

        //---------------------------------------------------------
        // other
        //---------------------------------------------------------
        serviceContextMap = new HashMap<String, ServiceContext>();

        //---------------------------------------------------------
        // done
        //---------------------------------------------------------

    }


    /**
     * Some parts of the object restored from the
     * readExternal deserialization work cannot be completed until
     * we have a configurationContext.  This method checks to see
     * if additional work needs to be done in order to complete
     * the object reconstitution.
     *
     * @param cc the active ConfigurationContext
     */
    public void activate(ConfigurationContext cc) {
        // see if there's any work to do
        if (!needsToBeReconciled) {
            // return quick
            return;
        }

        // get the axis configuration 
        AxisConfiguration axisConfig = cc.getAxisConfiguration();

        // We previously saved metaAxisServiceGroup; restore it
        if (metaAxisServiceGroup != null) {
            axisServiceGroup = 
                ActivateUtils.findServiceGroup(axisConfig,
                                               metaAxisServiceGroup.getClassName(),
                                               metaAxisServiceGroup.getQNameAsString());
        } else {
            axisServiceGroup = null;
        }

        // set parent 
        this.setParent(cc);

        // register with the parent
        cc.addServiceGroupContextIntoSoapSessionTable(this);

        //-------------------------------------------------------
        // done, reset the flag
        //-------------------------------------------------------
        needsToBeReconciled = false;

    }

    /**
     * Compares key parts of the state from the current instance of
     * this class with the specified instance to see if they are
     * equivalent.
     * <p/>
     * This differs from the java.lang.Object.equals() method in
     * that the equals() method generally looks at both the
     * object identity (location in memory) and the object state
     * (data).
     * <p/>
     *
     * @param ctx The object to compare with
     * @return TRUE if this object is equivalent with the specified object
     *         that is, key fields match
     *         FALSE, otherwise
     */
    public boolean isEquivalent(ServiceGroupContext ctx) {
        // NOTE: the input object is expected to exist (ie, be non-null)

        if (!this.axisServiceGroup.equals(ctx.getDescription())) {
            return false;
        }

        String ctxid = ctx.getId();

        if ((this.id != null) && (ctxid != null)) {
            if (!this.id.equals(ctxid)) {
                return false;
            }

        } else if ((this.id == null) && (ctxid == null)) {
            // keep going
        } else {
            // mismatch
            return false;
        }

        // TODO: consider checking the parent objects for equivalency

        // TODO: consider checking fields from the super class for equivalency

        return true;
    }

    /**
     * Trace a warning message, if needed, indicating that this
     * object needs to be activated before accessing certain fields.
     *
     * @param methodname The method where the warning occurs
     */
    private void checkActivateWarning(String methodname) {
        if (needsToBeReconciled) {
            log.warn(myClassName + ":" + methodname + "(): ****WARNING**** " + myClassName +
                     ".activate(configurationContext) needs to be invoked.");
        }
    }

    public ConfigurationContext getRootContext() {
        //parent of the ServiceGroupContext is the ConfigurationContext
        return (ConfigurationContext) this.getParent();
    }
}