/*
|
* 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 2008-2009 Sun Microsystems, Inc.
|
* Portions Copyright 2013 ForgeRock AS.
|
*/
|
|
package org.opends.server.replication.server;
|
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import org.opends.server.replication.common.AssuredMode;
|
import org.opends.server.replication.common.ChangeNumber;
|
import org.opends.server.replication.protocol.AckMsg;
|
|
/**
|
* This class is the mother class for sub-classes holding any information needed
|
* about the acks that the replication server will wait for, when he receives an
|
* update message with the assured flag on (assured replication acknowledgments
|
* expected).
|
* It also includes info/routines for constructing the final ack to be sent to
|
* the sender of the update message.
|
*
|
* It is expected to have one sub-class per assured replication sub mode.
|
*/
|
public abstract class ExpectedAcksInfo
|
{
|
// The server handler of the server that sent the assured update message and
|
// to who we want to return the final ack
|
private ServerHandler requesterServerHandler = null;
|
|
// The requested assured mode of matching update message
|
private AssuredMode assuredMode = null;
|
|
/**
|
* The change number of the assured update message we want acks for.
|
*/
|
protected ChangeNumber changeNumber = null;
|
|
/**
|
* Is the treatment of the acks for the update message completed or not ?
|
* This is used for concurrent access to this object by either the assured
|
* timeout task or the code for processing an ack for the matching update
|
* message. This should be set to true when the treatment of the expected
|
* acks is completed or an ack timeout has occurred and we are going to
|
* remove this object from the map where it is stored.
|
*/
|
private boolean completed = false;
|
|
/**
|
* This gives the list of servers we are willing to wait acks from and the
|
* information about the ack from the servers.
|
* key: the id of the server.
|
* value: a boolean true if we received the ack from the server,
|
* false otherwise.
|
*/
|
protected Map<Integer,Boolean> expectedServersAckStatus =
|
new HashMap<Integer,Boolean>();
|
|
/**
|
* Facility for monitoring:
|
* If the timeout occurs for the original update, we call createAck(true)
|
* in the timeout code for sending back an error ack to the original server.
|
* We use this call to also save the list of server ids for server we did not
|
* have time to receive an ack from. For updating its counters, the timeout
|
* code can then call getTimeoutServers() method to now which servers did not
|
* respond in time.
|
*/
|
protected List<Integer> serversInTimeout = null;
|
|
/**
|
* Creates a new ExpectedAcksInfo.
|
* @param changeNumber The change number of the assured update message
|
* @param requesterServerHandler The server handler of the server that sent
|
* the assured update message
|
* @param assuredMode The assured mode requested by the assured update message
|
* @param expectedServers The list of servers we want an ack from
|
*/
|
protected ExpectedAcksInfo(ChangeNumber changeNumber,
|
ServerHandler requesterServerHandler, AssuredMode assuredMode,
|
List<Integer> expectedServers)
|
{
|
this.requesterServerHandler = requesterServerHandler;
|
this.assuredMode = assuredMode;
|
this.changeNumber = changeNumber;
|
|
// Initialize list of servers we expect acks from
|
for (Integer serverId : expectedServers)
|
{
|
expectedServersAckStatus.put(serverId, false);
|
}
|
}
|
|
/**
|
* Gets the server handler of the server which requested the acknowledgments.
|
* @return The server handler of the server which requested the
|
* acknowledgments.
|
*/
|
public ServerHandler getRequesterServer()
|
{
|
return requesterServerHandler;
|
}
|
|
/**
|
* Gets the list of expected servers that did not respond in time.
|
* @return The list of expected servers that did not respond in time.
|
*/
|
public List<Integer> getTimeoutServers()
|
{
|
return serversInTimeout;
|
}
|
|
/**
|
* Gets the requested assured mode for the matching update message.
|
* @return The requested assured mode for the matching update message.
|
*/
|
public AssuredMode getAssuredMode()
|
{
|
return assuredMode;
|
}
|
|
/**
|
* Process the received ack from a server we are waiting an ack from.
|
* @param ackingServer The server handler of the server that sent the ack
|
* @param ackMsg The ack message to process
|
* @return True if the expected number of acks has just been reached
|
*/
|
public abstract boolean processReceivedAck(ServerHandler ackingServer,
|
AckMsg ackMsg);
|
|
/**
|
* Creates the ack message to be returned to the requester server, taking into
|
* account the information in the received acks from every servers.
|
* @param timeout True if we call this method when the timeout occurred, that
|
* is we did not received every expected acks in time, and thus, the timeout
|
* flag should also be enabled in the returned ack message.
|
* @return The ack message ready to be sent to the requester server
|
*/
|
public abstract AckMsg createAck(boolean timeout);
|
|
/**
|
* Has the treatment of this object been completed or not?
|
* If true is returned, one must not modify this object (useless) nor remove
|
* it from the map where it is stored (will be or has already been done by the
|
* other code (ack timeout code, or ack processing code)).
|
* @return True if treatment of this object has been completed.
|
*/
|
public boolean isCompleted()
|
{
|
return completed;
|
}
|
|
/**
|
* Signal that treatment of this object has been completed and that it is
|
* going to be removed from the map where it is stored.
|
*/
|
public void completed()
|
{
|
completed = true;
|
}
|
}
|
