Exemple #1
0
void
DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request,
                           TAO_AMH_DSI_Response_Handler * rph)
{
  CORBA::NVList_ptr opList;
  this->orb_->create_list (0, opList);

  request->arguments (opList);

  CORBA::Request_var target_request;

  this->target_->_create_request (0, // ctx
                                  request->operation (),
                                  opList,
                                  0, // result
                                  0, // exception_list,
                                  0, // context_list,
                                  target_request.inout (),
                                  0);

  target_request->_tao_lazy_evaluation (1);

  // Outgoing request must have the same byte order as the incoming one.
  target_request->_tao_byte_order (request->_tao_incoming_byte_order ());

  try
    {
      // Updates the byte order state, if necessary.
      TAO_DII_Reply_Handler_ptr rh_ptr;
      ACE_NEW (rh_ptr, My_DII_Reply_Handler (rph, this->orb_));
      TAO_DII_Reply_Handler_var rh(rh_ptr);
      target_request->sendc (rh.in());
    }
  catch (const CORBA::UNKNOWN&)
    {
      // Outgoing reply must have the same byte order as the incoming one.
      request->_tao_reply_byte_order (target_request->_tao_byte_order ());

      request->gateway_exception_reply (
          target_request->raw_user_exception ());
      return;
    }

  // Outgoing reply must have the same byte order as the incoming one.
  request->_tao_reply_byte_order (target_request->_tao_byte_order ());

  if (ACE_OS::strcmp ("shutdown", request->operation ()) == 0)
    {
      this->orb_->shutdown (0);
    }
}
Exemple #2
0
void
DSI_Simple_Server::invoke (CORBA::ServerRequest_ptr request)
{
  CORBA::NVList_ptr list;
  this->orb_->create_list (0, list);

  request->arguments (list);

  CORBA::Request_var target_request;

  this->target_->_create_request (0, // ctx
                                  request->operation (),
                                  list,
                                  0, // result
                                  0, // exception_list,
                                  0, // context_list,
                                  target_request.inout (),
                                  0);

  target_request->_tao_lazy_evaluation (1);

  // Outgoing request must have the same byte order as the incoming one.
  target_request->_tao_byte_order (request->_tao_incoming_byte_order ());

  try
    {
      // Updates the byte order state, if necessary.
      target_request->invoke ();
    }
  catch (const CORBA::UNKNOWN&)
    {
      // Outgoing reply must have the same byte order as the incoming one.
      request->_tao_reply_byte_order (target_request->_tao_byte_order ());

      request->gateway_exception_reply (target_request->raw_user_exception ());

      return;
    }

  // Outgoing reply must have the same byte order as the incoming one.
  request->_tao_reply_byte_order (target_request->_tao_byte_order ());

  if (ACE_OS::strcmp ("shutdown", request->operation ()) == 0)
    {
      this->orb_->shutdown (0);
    }
}
// The DSI invoke request
void
TAO_CEC_DynamicImplementationServer::invoke (CORBA::ServerRequest_ptr request)
{
  // Trap the _is_a request
  if (ACE_OS::strcmp ("_is_a", request->operation () ) == 0)
    {
      this->is_a (request);
    }
  else
    {
      CORBA::NVList_ptr list;

      // Get the operation paramter information from the IFR cache.
      TAO_CEC_Operation_Params *oper_params =
        this->typed_event_channel_->find_from_ifr_cache (request->operation () );

      if (oper_params == 0)
        {
          if (TAO_debug_level >= 10)
            {
              ORBSVCS_DEBUG ((LM_DEBUG,
                          ACE_TEXT ("***** Operation not found in IFR cache *****\n")));
            }

          this->typed_event_channel_->create_list (0, list);
        }
      else
        {
          // Populate the NVList from the parameter information.
          this->typed_event_channel_->create_operation_list (oper_params, list);

          // Get the operation arguments. This ahould demarshal correctly.
          request->arguments (list);

          // Populate the TypedEvent with the list and operation name.
          TAO_CEC_TypedEvent typed_event (list, request->operation () );

          // Pass the TypedEvent to the TypedProxyPushConsumer
          this->typed_pp_consumer_->invoke (typed_event);
        }
    }
}
Exemple #4
0
// The code that actually processes the request message
void
Lorica::ProxyServant::invoke_i(CORBA::ServerRequest_ptr request,
			       TAO_AMH_DSI_Response_Handler_ptr response_handler)
{
	Lorica::ServerAgent_var agent;
	CORBA::Object_var target_obj = mapper_.current_native(agent.out());
	EvaluatorBase *evb = this->mapper_.evaluator_for (target_obj.in());

	if (!evb)
		throw CORBA::NO_IMPLEMENT();

	bool is_oneway = !request->_tao_server_request().response_expected()
		|| request->_tao_server_request().sync_with_server();

	CORBA::NVList_var args;
	CORBA::NVList_var out_args;
	this->orb_->create_list(0, args);
	this->orb_->create_list(0, out_args);

	PortableServer::POA_var poa = this->current_->get_POA();
	PortableServer::ObjectId_var oid = this->current_->get_object_id();

	CORBA::NamedValue_var result;
	try {
		if (!evb->evaluate_request(request->operation(),
					   poa.in(),
					   request,
					   args.inout(),
					   out_args.inout(),
					   result.out())) {
			if (!CORBA::is_nil(agent)) {
				agent->error_occured(errno,
						     "ProxyServant::invoke_i, evaluate_request "
						     "failed, Caught CORBA::BAD_OPERATION()\n");
			}

			if (Lorica_debug_level > 0) {
				ACE_ERROR((LM_ERROR,
					   "(%T) %N:%l - evaluate_request failed. Caught CORBA::BAD_OPERATION()\n"));
			}

			throw CORBA::BAD_OPERATION();
		}
	}
	catch (CORBA::UserException & ex) {
		if (Lorica_debug_level > 0)
			ACE_DEBUG((LM_ERROR, ACE_TEXT("(%T) %N:%l - %s\n"), ex._info().c_str()));

		if (!CORBA::is_nil(agent)) {
			agent->error_occured(errno,
					     "ProxyServant::invoke_i, evaluate_request "
					     "failed, A CORBA::BAD_OPERATION() is thrown");
		}

		if (Lorica_debug_level > 0) {
			ACE_ERROR((LM_ERROR, "(%T) %N:%l - evaluate_request raised %s\n",
				   ex._name()));
		}

		throw CORBA::BAD_OPERATION();
	}

	// do the rest, ie set up reply handler

	CORBA::Request_var target_request;
	target_obj->_create_request(0, // context
				    request->operation(),
				    args._retn(), // hand off ownership
				    0, // result,
				    0, // exception list
				    0, // context_list
				    target_request.inout(),
				    0);

	if (is_oneway) {
		target_request->send_oneway();
		return;
	}

	Messaging::ReplyHandler_var rh = new Lorica::ProxyReplyHandler(this->mapper_,
								       request->operation(),
								       poa.in(),
								       evb,
								       out_args._retn(),
								       result._retn(),
								       response_handler);

	target_request->sendc(rh.in());
}