void TAO_FTEC_ProxyPushSupplier::resume_connection (void)
{
if (Request_Context_Repository().is_executed_request())
return;
Request_Context_Repository().set_object_id(id());
FtRtecEventChannelAdmin::Operation update;
update.object_id = id();
update.param._d(FtRtecEventChannelAdmin::RESUME_CONNECTION);
Inherited::resume_connection();
try{
FTRTEC::Replication_Service* svc = FTRTEC::Replication_Service::instance();
ACE_READ_GUARD (FTRTEC::Replication_Service, locker, *svc);
svc->replicate_request(update,
&FtRtecEventChannelAdmin::EventChannelFacade::suspend_push_supplier);
}
catch (...){
this->suspend_connection();
throw;
}
}
// = The RtecEventChannelAdmin::ProxyPushSupplier methods...
void TAO_FTEC_ProxyPushSupplier::connect_push_consumer (
RtecEventComm::PushConsumer_ptr push_consumer,
const RtecEventChannelAdmin::ConsumerQOS &qos)
{
if (Request_Context_Repository().is_executed_request())
return;
FtRtecEventChannelAdmin::Operation update;
FtRtecEventChannelAdmin::Connect_push_consumer_param param;
update.object_id = this->id();
param.push_consumer = RtecEventComm::PushConsumer::_duplicate(push_consumer);
param.qos = qos;
update.param.connect_consumer_param(param);
Inherited::connect_push_consumer(push_consumer, qos);
try{
FTRTEC::Replication_Service* svc = FTRTEC::Replication_Service::instance();
ACE_READ_GUARD (FTRTEC::Replication_Service, locker, *svc);
svc->replicate_request(update,
&FtRtecEventChannelAdmin::EventChannelFacade::disconnect_push_supplier);
}
catch (...){
}
}
void
Basic_Replication_Strategy::replicate_request(
const FTRT::State& state,
RollbackOperation rollback,
const FtRtecEventChannelAdmin::ObjectId& oid)
{
ACE_UNUSED_ARG(rollback);
ACE_UNUSED_ARG(oid);
FTRT::TransactionDepth transaction_depth =
Request_Context_Repository().get_transaction_depth();
GroupInfoPublisherBase * info_publisher = GroupInfoPublisher::instance();
FtRtecEventChannelAdmin::EventChannel_var successor = info_publisher->successor();
if (!CORBA::is_nil(successor.in())) {
if (info_publisher->is_primary())
this->sequence_num_++;
TAO_FTRTEC::Log(1, ACE_TEXT("replicate_request : sequence no = %d\n"), sequence_num_);
Request_Context_Repository().set_sequence_number(sequence_num_);
Request_Context_Repository().set_transaction_depth(transaction_depth-1);
if (transaction_depth > 1) {
twoway_set_update(successor, state);
}
else {
try{
successor->oneway_set_update(state);
}
catch (const CORBA::Exception&){
}
}
}
else if (transaction_depth > 1) {
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::TransactionDepthTooHigh\n"));
throw FTRT::TransactionDepthTooHigh();
}
}
void TAO_FTEC_ProxyPushSupplier::disconnect_push_supplier (void)
{
if (Request_Context_Repository().is_executed_request())
return;
FtRtecEventChannelAdmin::Operation update;
update.object_id = id();
update.param._d(FtRtecEventChannelAdmin::DISCONNECT_PUSH_SUPPLIER);
Inherited::disconnect_push_supplier();
FTRTEC::Replication_Service *svc = FTRTEC::Replication_Service::instance();
ACE_READ_GUARD (FTRTEC::Replication_Service, locker, *svc);
svc->replicate_request(update, 0);
}
/// Activate in the POA
void
TAO_FTEC_ProxyPushSupplier::activate (
RtecEventChannelAdmin::ProxyPushSupplier_ptr &result)
{
result =
RtecEventChannelAdmin::ProxyPushSupplier::_nil();
try{
object_id_ = Request_Context_Repository().get_object_id();
PortableServer::POA_var poa = _default_POA();
activate_object_with_id(result, poa.in(), this, id());
}
catch (const CORBA::Exception&)
{
// ignore exceptions
}
}
void
Basic_Replication_Strategy::check_validity(void)
{
FTRT::SequenceNumber seq_no = Request_Context_Repository().get_sequence_number();
TAO_FTRTEC::Log(1 , ACE_TEXT("check_validity : sequence no = %d\n"), sequence_num_);
if (this->sequence_num_ == 0) {
// this is the first set_update received from the primary
// sync the sequence number with the primary
this->sequence_num_ = seq_no;
}
else if (seq_no != this->sequence_num_+1) {
// out of sync, we missed some set_update() request already
// throw exception
// client_interceptor_->sequence_num_--;
FTRT::OutOfSequence exception;
exception.current = this->sequence_num_;
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::OutOfSequence (old sequence_num_ = %d)\n"), this->sequence_num_);
throw FTRT::OutOfSequence(exception);
}
else
this->sequence_num_++;
}
FtRtecEventChannelAdmin::EventChannel_ptr
TAO_FTEC_Event_Channel::activate(TAO_FTEC_Event_Channel::MEMBERSHIP membership)
{
FTRTEC::Fault_Detector_Loader* detector_loader =
ACE_Dynamic_Service<FTRTEC::Fault_Detector_Loader>::instance("FTRTEC_Fault_Detector");
detector_loader->init(0, 0);
if (FTRTEC::Identification_Service::instance() == 0)
ORBSVCS_ERROR_RETURN((LM_ERROR, "No Identification\n"), 0);
// initialize naming_contex
CosNaming::NamingContext_var naming_context
= resolve_init<CosNaming::NamingContext>(orb_.in(), "NameService");
// initialize group info publisher
GroupInfoPublisher::instance()->set_naming_context(naming_context);
if (FTRTEC::Replication_Service::instance()->init(0,0) == -1)
return 0;
GroupInfoPublisher::instance()->subscribe(FTRTEC::Replication_Service::instance());
Request_Context_Repository().init(orb_.in());
// get POAManager
PortableServer::POAManager_var mgr = poa_->the_POAManager();
TAO::Utils::PolicyList_Destroyer policy_list(2);
persistent_poa_ =
create_persistent_poa(poa_, mgr, "FTEC_Persistant_POA", policy_list);
// Activate the Event channel implementation
TAO_EC_Event_Channel_Attributes attr (persistent_poa_.in (),
persistent_poa_.in ());
TAO_FTEC_Event_Channel_Impl* ec = 0;
ACE_NEW_THROW_EX (ec,
TAO_FTEC_Event_Channel_Impl (attr),
CORBA::NO_MEMORY());
this->ec_impl_ = ec;
const FtRtecEventComm::ObjectId& object_id
= FTRTEC::Identification_Service::instance()->object_id();
FtRtecEventComm::ObjectId consumer_admin_object_id(object_id);
consumer_admin_object_id[9]++;
FtRtecEventComm::ObjectId supplier_admin_object_id(consumer_admin_object_id);
supplier_admin_object_id[9]++;
ec->activate_object(orb_,
supplier_admin_object_id,
consumer_admin_object_id);
FtRtecEventChannelAdmin::EventChannel_var result;
activate_object_with_id(result.out(), persistent_poa_.in(), this, object_id);
setup_object_group(this,
naming_context.in(),
membership,
result.in());
return result._retn();
}
void
AMI_Primary_Replication_Strategy::replicate_request(
const FTRT::State& state,
RollbackOperation rollback,
const FtRtecEventChannelAdmin::ObjectId& oid)
{
ACE_Auto_Event event;
Update_Manager* manager = 0;
bool success = false;
FTRT::TransactionDepth transaction_depth =
Request_Context_Repository().get_transaction_depth();
const FtRtecEventChannelAdmin::EventChannelList& backups =
GroupInfoPublisher::instance()->backups();
size_t num_backups = backups.length();
if ((size_t)transaction_depth > num_backups) {
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::TransactionDepthTooHigh\n"));
throw FTRT::TransactionDepthTooHigh();
}
ACE_NEW_THROW_EX(manager,
Update_Manager(event, backups.length(), transaction_depth-1, success),
CORBA::NO_MEMORY());
Request_Context_Repository().set_transaction_depth(0);
for (size_t i = 0; i < num_backups; ++i) {
PortableServer::ObjectId oid;
try{
FTRT::AMI_UpdateableHandler_ptr handler = handler_.activate(manager, i, oid);
FtRtecEventChannelAdmin::EventChannel_ptr obj = backups[i];
// send set_update request to all the backup replicas
obj->sendc_set_update(handler, state);
}
catch (const CORBA::Exception& ex){
ex._tao_print_exception (
"AMI_Primary_Replication_Strategy::replicate_request : ");
manager->handle_exception(i);
if (oid.length())
poa_->deactivate_object(oid);
}
}
// wait until the first transaction_depth replicas replied.
event.wait();
if (!success) { // replication failed, transaction depth too high
for (size_t i =0; i < num_backups; ++i) {
try{
FtRtecEventChannelAdmin::EventChannel_ptr ec = backups[i];
(ec->*rollback)(oid);
}
catch (...){
}
}
TAO_FTRTEC::Log(3, ACE_TEXT("Throwing FTRT::TransactionDepthTooHigh\n"));
throw FTRT::TransactionDepthTooHigh();
}
}
