transportbindingmetric.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

/*
 * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
 *  
 *  The Sun Project JXTA(TM) Software License
 *  
 *  Redistribution and use in source and binary forms, with or without 
 *  modification, are permitted provided that the following conditions are met:
 *  
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  
 *  2. Redistributions in binary form must reproduce the above copyright notice, 
 *     this list of conditions and the following disclaimer in the documentation 
 *     and/or other materials provided with the distribution.
 *  
 *  3. The end-user documentation included with the redistribution, if any, must 
 *     include the following acknowledgment: "This product includes software 
 *     developed by Sun Microsystems, Inc. for JXTA(TM) technology." 
 *     Alternately, this acknowledgment may appear in the software itself, if 
 *     and wherever such third-party acknowledgments normally appear.
 *  
 *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must 
 *     not be used to endorse or promote products derived from this software 
 *     without prior written permission. For written permission, please contact 
 *     Project JXTA at http://www.jxta.org.
 *  
 *  5. Products derived from this software may not be called "JXTA", nor may 
 *     "JXTA" appear in their name, without prior written permission of Sun.
 *  
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
 *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND 
 *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN 
 *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
 *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, 
 *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *  
 *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United 
 *  States and other countries.
 *  
 *  Please see the license information page at :
 *  <http://www.jxta.org/project/www/license.html> for instructions on use of 
 *  the license in source files.
 *  
 *  ====================================================================
 *  
 *  This software consists of voluntary contributions made by many individuals 
 *  on behalf of Project JXTA. For more information on Project JXTA, please see 
 *  http://www.jxta.org.
 *  
 *  This license is based on the BSD license adopted by the Apache Foundation. 
 */

package net.jxta.impl.endpoint.transportMeter;


import net.jxta.document.Element;
import net.jxta.document.TextElement;
import net.jxta.endpoint.EndpointAddress;
import net.jxta.endpoint.Message;
import net.jxta.impl.meter.MetricUtilities;
import net.jxta.peer.PeerID;
import net.jxta.util.documentSerializable.DocumentSerializable;
import net.jxta.util.documentSerializable.DocumentSerializableUtilities;
import net.jxta.util.documentSerializable.DocumentSerializationException;

import java.util.Enumeration;


public class TransportBindingMetric implements DocumentSerializable {
    public static final String CONNECTED = "connected";
    public static final String CLOSED = "closed";
    public static final String DROPPED = "dropped";
    public static final String FAILED = "failed";

    private PeerID peerID;
    private EndpointAddress endpointAddress;

    private String initiatorState = null;
    private String acceptorState = null;
    private long initiatorTransitionTime;
    private long acceptorTransitionTime;

    private int acceptorBytesReceived;
    private int acceptorBytesSent;
    private int acceptorConnections;
    private int acceptorConnectionsClosed;
    private int acceptorConnectionsDropped;
    private int acceptorConnectionsFailed;
    private int acceptorMessagesReceived;
    private int acceptorMessagesSent;
    private long acceptorReceiveFailureProcessingTime;
    private int acceptorReceiveFailures;
    private long acceptorReceiveProcessingTime;
    private long acceptorSendFailureProcessingTime;
    private int acceptorSendFailures;
    private long acceptorSendProcessingTime;
    private long acceptorTotalTimeConnected;
    private long acceptorTimeToConnect;
    private long acceptorTimeToFail;
    private int initiatorBytesReceived;
    private int initiatorBytesSent;
    private long initiatorTotalTimeConnected;
    private int initiatorConnections;
    private int initiatorConnectionsClosed;
    private int initiatorConnectionsDropped;
    private int initiatorConnectionsFailed;
    private int initiatorMessagesReceived;
    private int initiatorMessagesSent;
    private long initiatorReceiveFailureProcessingTime;
    private int initiatorReceiveFailures;
    private long initiatorReceiveProcessingTime;
    private long initiatorSendFailureProcessingTime;
    private int initiatorSendFailures;
    private long initiatorSendProcessingTime;
    private long initiatorTimeToConnect;
    private long initiatorTimeToFail;

    private int numPings;
    private int numFailedPings;
    private long pingTime;
    private long pingFailedTime;
    private int numPingsReceived;

    public TransportBindingMetric(TransportBindingMeter transportBindingMeter, boolean initiatorConnected, boolean acceptorConnected) {
        this.peerID = transportBindingMeter.getPeerID();
        this.endpointAddress = transportBindingMeter.getEndpointAddress();
        this.initiatorState = initiatorConnected ? CONNECTED : CLOSED;
        this.acceptorState = acceptorConnected ? CONNECTED : CLOSED;
    }

    public TransportBindingMetric() {}

    public TransportBindingMetric(TransportBindingMetric prototype) {
        this.peerID = prototype.peerID;
        this.endpointAddress = prototype.endpointAddress;
        this.initiatorState = prototype.initiatorState;
        this.acceptorState = prototype.acceptorState;
        this.initiatorTransitionTime = prototype.initiatorTransitionTime;
        this.acceptorTransitionTime = prototype.acceptorTransitionTime;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof TransportBindingMetric) {
            TransportBindingMetric other = (TransportBindingMetric) obj;

            return endpointAddress.equals(other.endpointAddress);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        return peerID.hashCode() + endpointAddress.hashCode();
    }

    public PeerID getPeerID() {
        return peerID;
    }

    public void setPeerID(PeerID peerID) {
        this.peerID = peerID;
    }

    public EndpointAddress getEndpointAddress() {
        return endpointAddress;
    }

    /**
     * State of this Initiator Binding
     *
     * @return TransportBindingMetric.CONNECTED, TransportBindingMetric.DISCONNECTED or TransportBindingMetric.FAILED
     */
    public String getInitiatorState() {
        return initiatorState;
    }

    /**
     * State of this Acceptor Binding
     *
     * @return TransportBindingMetric.CONNECTED, TransportBindingMetric.DISCONNECTED or TransportBindingMetric.FAILED
     */
    public String getAcceptorState() {
        return acceptorState;
    }

    /**
     * Get the time that it entered the current state
     *
     * @return transition time in ms since January 1, 1970, 00:00:00 GMT
     */
    public long getInitiatorTransitionTime() {
        return initiatorTransitionTime;
    }

    /**
     * Get the time that it entered the current state
     *
     * @return transition time in ms since January 1, 1970, 00:00:00 GMT
     */
    public long getAcceptorTransitionTime() {
        return acceptorTransitionTime;
    }

    public boolean isAcceptorConnected() {
        return (acceptorState != null) && acceptorState.equals(CONNECTED);
    }

    public boolean isInitiatorConnected() {
        return (initiatorState != null) && initiatorState.equals(CONNECTED);
    }

    public long getTimeAcceptorConnectionEstablished() {
        return isAcceptorConnected() ? acceptorTransitionTime : 0;
    }

    public long getTimeInitiatorConnectionEstablished() {
        return isInitiatorConnected() ? initiatorTransitionTime : 0;
    }

    public int getAcceptorBytesReceived() {
        return acceptorBytesReceived;
    }

    public int getAcceptorBytesSent() {
        return acceptorBytesSent;
    }

    public int getAcceptorConnections() {
        return acceptorConnections;
    }

    public int getAcceptorConnectionsClosed() {
        return acceptorConnectionsClosed;
    }

    public int getAcceptorConnectionsDropped() {
        return acceptorConnectionsDropped;
    }

    public int getAcceptorConnectionsFailed() {
        return acceptorConnectionsFailed;
    }

    public int getAcceptorMessagesReceived() {
        return acceptorMessagesReceived;
    }

    public int getAcceptorMessagesSent() {
        return acceptorMessagesSent;
    }

    public long getAcceptorReceiveFailureProcessingTime() {
        return acceptorReceiveFailureProcessingTime;
    }

    public int getAcceptorReceiveFailures() {
        return acceptorReceiveFailures;
    }

    public long getAcceptorReceiveProcessingTime() {
        return acceptorReceiveProcessingTime;
    }

    public long getAcceptorSendFailureProcessingTime() {
        return acceptorSendFailureProcessingTime;
    }

    public int getAcceptorSendFailures() {
        return acceptorSendFailures;
    }

    public long getAcceptorSendProcessingTime() {
        return acceptorSendProcessingTime;
    }

    public long getAcceptorTimeToConnect() {
        return acceptorTimeToConnect;
    }

    public long getAcceptorTimeToFail() {
        return acceptorTimeToFail;
    }

    public int getInitiatorBytesReceived() {
        return initiatorBytesReceived;
    }

    public int getInitiatorBytesSent() {
        return initiatorBytesSent;
    }

    public int getInitiatorConnections() {
        return initiatorConnections;
    }

    public int getInitiatorConnectionsClosed() {
        return initiatorConnectionsClosed;
    }

    public int getInitiatorConnectionsDropped() {
        return initiatorConnectionsDropped;
    }

    public int getInitiatorConnectionsFailed() {
        return initiatorConnectionsFailed;
    }

    public int getInitiatorMessagesReceived() {
        return initiatorMessagesReceived;
    }

    public int getInitiatorMessagesSent() {
        return initiatorMessagesSent;
    }

    public long getInitiatorReceiveFailureProcessingTime() {
        return initiatorReceiveFailureProcessingTime;
    }

    public int getInitiatorReceiveFailures() {
        return initiatorReceiveFailures;
    }

    public long getInitiatorReceiveProcessingTime() {
        return initiatorReceiveProcessingTime;
    }

    public long getInitiatorSendFailureProcessingTime() {
        return initiatorSendFailureProcessingTime;
    }

    public int getInitiatorSendFailures() {
        return initiatorSendFailures;
    }

    public long getInitiatorSendProcessingTime() {
        return initiatorSendProcessingTime;
    }

    public long getInitiatorTimeToConnect() {
        return initiatorTimeToConnect;
    }

    public long getInitiatorTimeToFail() {
        return initiatorTimeToFail;
    }

    public int getNumPings() {
        return numPings;
    }

    public int getNumFailedPings() {
        return numFailedPings;
    }

    public long getPingTime() {
        return pingTime;
    }

    public long getPingFailedTime() {
        return pingFailedTime;
    }

    public int getNumPingsReceived() {
        return numPingsReceived;
    }

    public int getBytesReceived() {
        return acceptorBytesReceived + initiatorBytesReceived;
    }

    public int getBytesSent() {
        return acceptorBytesSent + initiatorBytesSent;