org.gridgain.grid.spi.GridSpiAdapter Maven / Gradle / Ivy

Go to download
/* 
 Copyright (C) GridGain Systems. All Rights Reserved.
 
 Licensed 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.gridgain.grid.spi;

import org.gridgain.grid.*;
import org.gridgain.grid.events.*;
import org.gridgain.grid.kernal.*;
import org.gridgain.grid.kernal.managers.communication.*;
import org.gridgain.grid.kernal.managers.eventstorage.*;
import org.gridgain.grid.logger.*;
import org.gridgain.grid.resources.*;
import org.gridgain.grid.spi.swapspace.*;
import org.gridgain.grid.util.json.*;
import org.gridgain.grid.util.typedef.*;
import org.gridgain.grid.util.typedef.internal.*;
import org.jetbrains.annotations.*;

import javax.management.*;
import java.io.*;
import java.nio.*;
import java.text.*;
import java.util.*;

import static org.gridgain.grid.events.GridEventType.*;

/**
 * This class provides convenient adapter for SPI implementations.
 */
public abstract class GridSpiAdapter implements GridSpi, GridSpiManagementMBean, GridSpiJsonConfigurable {
    /** Instance of SPI annotation. */
    private GridSpiInfo spiAnn;

    /** */
    private ObjectName spiMBean;

    /** SPI start timestamp. */
    private long startTstamp;

    /** */
    @GridLoggerResource
    private GridLogger log;

    /** */
    @GridMBeanServerResource
    private MBeanServer jmx;

    /** */
    @GridHomeResource
    private String ggHome;

    /** */
    @GridLocalNodeIdResource
    private UUID nodeId;

    /** SPI name. */
    private String name;

    /** Authenticator. */
    private volatile Authenticator auth = new Authenticator() {
        @Override public boolean authenticateNode(UUID nodeId, Map attrs) {
            return false;
        }
    };

    /** Grid SPI context. */
    private volatile GridSpiContext spiCtx = new GridDummySpiContext(null, auth);

    /** Discovery listener. */
    private GridLocalEventListener paramsLsnr;

    /**
     * Creates new adapter and initializes it from the current (this) class.
     * SPI name will be initialized to the simple name of the class
     * (see {@link Class#getSimpleName()}).
     */
    protected GridSpiAdapter() {
        for (Class cls = getClass(); cls != null; cls = cls.getSuperclass())
            if ((spiAnn = cls.getAnnotation(GridSpiInfo.class)) != null)
                break;

        assert spiAnn != null : "Every SPI must have @GridSpiInfo annotation.";

        name = U.getSimpleName(getClass());
    }

    /**
     * Starts startup stopwatch.
     */
    protected void startStopwatch() {
        startTstamp = U.currentTimeMillis();
    }

    /** {@inheritDoc} */
    @Override public final String getAuthor() {
        return spiAnn.author();
    }

    /** {@inheritDoc} */
    @Override public final String getVendorUrl() {
        return spiAnn.url();
    }

    /** {@inheritDoc} */
    @Override public final String getVendorEmail() {
        return spiAnn.email();
    }

    /** {@inheritDoc} */
    @Override public final String getVersion() {
        return spiAnn.version();
    }

    /** {@inheritDoc} */
    @Override public final String getStartTimestampFormatted() {
        return DateFormat.getDateTimeInstance().format(new Date(startTstamp));
    }

    /** {@inheritDoc} */
    @Override public final String getUpTimeFormatted() {
        return X.timeSpan2HMSM(getUpTime());
    }

    /** {@inheritDoc} */
    @Override public final long getStartTimestamp() {
        return startTstamp;
    }

    /** {@inheritDoc} */
    @Override public final long getUpTime() {
        return startTstamp == 0 ? 0 : U.currentTimeMillis() - startTstamp;
    }

    /** {@inheritDoc} */
    @Override public UUID getLocalNodeId() {
        return nodeId;
    }

    /** {@inheritDoc} */
    @Override public final String getGridGainHome() {
        return ggHome;
    }

    /** {@inheritDoc} */
    @Override public String getName() {
        return name;
    }

    /**
     * Sets SPI name.
     *
     * @param name SPI name.
     */
    @GridSpiConfiguration(optional = true)
    public void setName(String name) {
        this.name = name;
    }

    /** {@inheritDoc} */
    @Override public final void onContextInitialized(final GridSpiContext spiCtx) throws GridSpiException {
        assert spiCtx != null;

        auth = new Authenticator() {
            @Override public boolean authenticateNode(UUID nodeId, Map attrs) throws GridException {
                return spiCtx.authenticateNode(nodeId, attrs);
            }
        };

        this.spiCtx = spiCtx;

        spiCtx.addLocalEventListener(paramsLsnr = new GridLocalEventListener() {
            @Override public void onEvent(GridEvent evt) {
                assert evt instanceof GridDiscoveryEvent : "Invalid event [expected=" + EVT_NODE_JOINED +
                    ", actual=" + evt.type() + ", evt=" + evt + ']';

                GridNode node = spiCtx.node(((GridDiscoveryEvent)evt).eventNodeId());

                if (node != null)
                    try {
                        checkConfigurationConsistency(spiCtx, node, false);
                        checkConfigurationConsistency0(spiCtx, node, false);
                    }
                    catch(GridSpiException e) {
                        U.error(log, "Spi consistency check failed [node=" + node.id() + ", spi=" + getName() + ']', e);
                    }
            }
        }, EVT_NODE_JOINED);

        for (GridNode node : spiCtx.remoteNodes()) {
            checkConfigurationConsistency(spiCtx, node, true);
            checkConfigurationConsistency0(spiCtx, node, true);
        }

        onContextInitialized0(spiCtx);
    }

    /**
     * Method to be called in the end of onContextInitialized method.
     *
     * @param spiCtx SPI context.
     * @throws GridSpiException In case of errors.
     */
    protected void onContextInitialized0(final GridSpiContext spiCtx) throws GridSpiException {
        // No-op.
    }

    /** {@inheritDoc} */
    @Override public final void onContextDestroyed() {
        onContextDestroyed0();

        if (spiCtx != null && paramsLsnr != null)
            spiCtx.removeLocalEventListener(paramsLsnr);

        GridNode locNode = spiCtx == null ? null : spiCtx.localNode();

        // Set dummy no-op context.
        spiCtx = new GridDummySpiContext(locNode, auth);
    }

    /**
     * Method to be called in the beginning of onContextDestroyed() method.
     */
    protected void onContextDestroyed0() {
        // No-op.
    }

    /**
     * This method returns SPI internal instances that need to be injected as well.
     * Usually these will be instances provided to SPI externally by user, e.g. during
     * SPI configuration.
     *
     * @return Internal SPI objects that also need to be injected.
     */
    public Collection