mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

mrossign
08.02.2009 305d344b81f1fd8eb96c6c938ae0be0c268f45af
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE
 * or https://OpenDS.dev.java.net/OpenDS.LICENSE.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at
 * trunk/opends/resource/legal-notices/OpenDS.LICENSE.  If applicable,
 * add the following below this CDDL HEADER, with the fields enclosed
 * by brackets "[]" replaced with your own identifying information:
 *      Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 *
 *
 *      Copyright 2006-2009 Sun Microsystems, Inc.
 */
package org.opends.server.replication.protocol;
 
import java.io.IOException;
import java.net.SocketException;
import java.util.zip.DataFormatException;
 
/**
 * The ProtocolSession interface should be implemented by a class that
 * implement the send/reception part of the Multi-master replication
 * protocol.
 *
 * This interface is designed to make easy the move from one format
 * of the ReplicationMsg on the wire to another format.
 */
public interface ProtocolSession
{
 
  /**
   * This method is called when the session with the remote must be closed.
   * This object won't be used anymore after this method is called.
   *
   * @throws IOException If an error happen during the close process.
   */
  public abstract void close() throws IOException;
 
  /**
   * This method is called when a ReplicationMsg must be sent to
   * the remote entity. The PDU is send using serialization of the current
   * protocol version.
   *
   * It can be called by several threads and must implement appropriate
   * replication (typically, this method or a part of it should be
   * synchronized).
   *
   * @param msg The ReplicationMsg that must be sent.
   * @throws IOException If an IO error happen during the publish process.
   */
  public abstract void publish(ReplicationMsg msg)
                  throws IOException;
 
  /**
   * Same as publish(ReplicationMsg msg), but forcing the usage of a particular
   * protocol version for the PDU serialization.
   *
   * @param msg The ReplicationMsg that must be sent.
   * @param reqProtocolVersion The protocol version to use for serialization.
   * The version should normally be older than the current one.
   * @throws IOException If an IO error happen during the publish process.
   */
  public abstract void publish(ReplicationMsg msg, short reqProtocolVersion)
                  throws IOException;
 
  /**
   * Attempt to receive a ReplicationMsg.
   * This method should block the calling thread until a
   * ReplicationMsg is available or until an error condition.
   *
   * This method can only be called by a single thread and therefore does not
   * need to implement any replication.
   *
   * @return The ReplicationMsg that was received.
   * @throws IOException When error happened during IO process.
   * @throws ClassNotFoundException When the data received does extend the
   *         ReplicationMsg class.
   * @throws DataFormatException When the data received is not formatted as a
   *         ReplicationMsg.
   * @throws NotSupportedOldVersionPDUException If the received PDU is part of
   * an old protocol version and we do not support it.
   */
  public abstract ReplicationMsg receive()
                  throws IOException, ClassNotFoundException,
                         DataFormatException,
                         NotSupportedOldVersionPDUException;
 
  /**
   * Stop using the security layer, if there is any.
   */
  public abstract void stopEncryption();
 
  /**
   * Determine whether the session is using a security layer.
   * @return true if the connection is encrypted, false otherwise.
   */
  public abstract boolean isEncrypted();
 
  /**
   * Retrieve the IP address of the remote server.
   *
   * @return The IP address of the remote server.
   */
  public abstract String getRemoteAddress();
 
  /**
   * Retrieve the human readable address of the remote server.
   *
   * @return The human readable address of the remote server.
   */
  public abstract String getReadableRemoteAddress();
 
 
  /**
  * Set a timeout value.
  * With this option set to a non-zero value, calls to the receive() method
  * block for only this amount of time after which a
  * java.net.SocketTimeoutException is raised.
  * The Broker is valid and usable even after such an Exception is raised.
  *
  * @param timeout the specified timeout, in milliseconds.
  * @throws SocketException if there is an error in the underlying protocol,
  *         such as a TCP error.
  */
  public abstract void setSoTimeout(int timeout) throws SocketException;
 
 
 
  /**
   * Gets the time the last replication message was published on this
   * session.
   * @return The timestamp in milliseconds of the last message published.
   */
  public abstract long getLastPublishTime();
 
 
 
  /**
   * Gets the time the last replication message was received on this
   * session.
   * @return The timestamp in milliseconds of the last message received.
   */
  public abstract long getLastReceiveTime();
 
  /**
   * This methods allows to determine if the session close was initiated
   * on this ProtocolSession.
   *
   * @return A boolean allowing to determine if the session close was initiated
   * on this ProtocolSession.
   */
  public abstract boolean closeInitiated();
 
  /**
   * This method is called at the establishment of the session and can
   * be used to record the version of the protocol that is currently used.
   *
   * @param version The version of the protocol that is currently used.
   */
  public abstract void setProtocolVersion(short version);
}