summaryrefslogtreecommitdiff
path: root/ace/Remote_Tokens.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'ace/Remote_Tokens.cpp')
-rw-r--r--ace/Remote_Tokens.cpp435
1 files changed, 0 insertions, 435 deletions
diff --git a/ace/Remote_Tokens.cpp b/ace/Remote_Tokens.cpp
deleted file mode 100644
index e5e53cd62a5..00000000000
--- a/ace/Remote_Tokens.cpp
+++ /dev/null
@@ -1,435 +0,0 @@
-// Remote_Tokens.cpp
-// $Id$
-
-#include "ace/Remote_Tokens.h"
-#include "ace/Singleton.h"
-
-#if !defined (__ACE_INLINE__)
-#include "ace/Remote_Tokens.i"
-#endif /* __ACE_INLINE__ */
-
-ACE_RCSID(ace, Remote_Tokens, "$Id$")
-
-#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0)
-#define ACE_TSS_CONNECTION_MUTEX ACE_Thread_Mutex
-#else
-#define ACE_TSS_CONNECTION_MUTEX ACE_Null_Mutex
-#endif /* ACE_MT_SAFE */
-
-// Make a typedef to simplify access to the Singleton below.
-typedef ACE_Singleton<ACE_TSS_Connection, ACE_TSS_CONNECTION_MUTEX>
- ACE_Token_Connections;
-
-// Initialize the statics from ACE_TSS_Connection;
-ACE_INET_Addr ACE_TSS_Connection::server_address_;
-
-// ************************************************************
-
-void
-ACE_TSS_Connection::set_server_address (const ACE_INET_Addr &server_address)
-{
- ACE_TRACE ("ACE_TSS_Connection::set_server_address");
- server_address_ = server_address;
-}
-
-// Necessary to make some compilers work...
-ACE_TSS_Connection::ACE_TSS_Connection (void)
-{
- ACE_TRACE ("ACE_TSS_Connection::ACE_TSS_Connection");
-}
-
-ACE_TSS_Connection::~ACE_TSS_Connection (void)
-{
- ACE_TRACE ("ACE_TSS_Connection::~ACE_TSS_Connection");
-}
-
-ACE_SOCK_Stream *
-ACE_TSS_Connection::get_connection (void)
-{
- return ACE_TSS<ACE_SOCK_Stream>::operator-> ();
-}
-
-ACE_SOCK_Stream *
-ACE_TSS_Connection::make_TSS_TYPE (void) const
-{
- ACE_TRACE ("ACE_TSS_Connection::make_TSS_TYPE");
-
- ACE_SOCK_Connector connector;
- ACE_SOCK_Stream *stream = 0;
-
- ACE_NEW_RETURN (stream,
- ACE_SOCK_Stream,
- 0);
-
- if (connector.connect (*stream, server_address_) == -1)
- {
- delete stream;
- errno = ECONNREFUSED;
- return 0;
- }
-
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_TSS_Connection new connection\n")));
- return stream;
-}
-
-ACE_TSS_Connection::operator ACE_SOCK_Stream *(void)
-{
- return this->get_connection ();
-}
-
-void
-ACE_TSS_Connection::dump (void) const
-{
- ACE_TRACE ("ACE_TSS_Connection::dump");
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_TSS_Connection::dump:\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("server_address_\n")));
- server_address_.dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("base:\n")));
- ACE_TSS<ACE_SOCK_Stream>::dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-ACE_Remote_Token_Proxy::ACE_Remote_Token_Proxy (void)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::ACE_Remote_Token_Proxy");
-}
-
-ACE_Remote_Token_Proxy::~ACE_Remote_Token_Proxy (void)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::~ACE_Remote_Token_Proxy");
-}
-
-int
-ACE_Remote_Token_Proxy::open (const ACE_TCHAR *name,
- int ignore_deadlock,
- int debug)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::open");
- ignore_shadow_deadlock_ = ignore_deadlock;
- return ACE_Token_Proxy::open (name, 0, debug);
-}
-
-void
-ACE_Remote_Token_Proxy::set_server_address (const ACE_INET_Addr &server_address)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::set_server_address");
- ACE_Token_Connections::instance ()->set_server_address (server_address);
-}
-
-int
-ACE_Remote_Token_Proxy::initiate_connection (void)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::initiate_connection");
- if (token_ == 0)
- {
- errno = ENOENT;
- ACE_ERROR_RETURN ((LM_ERROR,
- ACE_TEXT ("ACE_Remote_Token_Proxy not open.\n")), -1);
- }
-
- ACE_SOCK_Stream *peer = ACE_Token_Connections::instance ()->get_connection ();
- return peer == 0 ? 0 : 1;
-}
-
-// Do the work of sending a request and getting a reply.
-
-int
-ACE_Remote_Token_Proxy::request_reply (ACE_Token_Request &request,
- ACE_Synch_Options &)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::request_reply");
- void *buffer;
- ssize_t length;
-
- if ((length = request.encode (buffer)) == -1)
- ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("encode failed")), -1);
-
- ACE_SOCK_Stream *peer = ACE_Token_Connections::instance ()->get_connection ();
-
- if (peer == 0)
- return -1;
-
- // Transmit request via a blocking send.
-
- if (peer->send_n (buffer, length) != length)
- ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("send_n failed")), -1);
- else
- {
- ACE_Token_Reply reply;
-
- // Receive reply via blocking read.
-
- if (peer->recv (&reply, sizeof reply) != sizeof reply)
- ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("recv failed")), -1);
-
- if (reply.decode () == -1)
- ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("decode failed")), -1);
-
- errno = int (reply.errnum ());
- if (errno != 0)
- ACE_RETURN (-1);
- else
- return 0;
- }
-}
-
-int
-ACE_Remote_Token_Proxy::acquire (int notify,
- void (*sleep_hook)(void *),
- ACE_Synch_Options &options)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::acquire");
-
- // First grab the local shadow mutex.
- if (ACE_Token_Proxy::acquire (notify,
- sleep_hook,
- ACE_Synch_Options::asynch) == -1)
- {
- // Acquire failed, deal with it...
- switch (errno)
- {
- case EWOULDBLOCK :
- // Whoah, we detected wouldblock via the shadow mutex!
- if (debug_)
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) shadow: acquire will block, owner is %s\n"),
- this->token_->owner_id ()));
- // No error, but would block,
- break;
-
- case EDEADLK :
- if (debug_)
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) shadow: deadlock detected\n")));
-
- if (ignore_shadow_deadlock_)
- break;
- else
- {
- errno = EDEADLK;
- ACE_RETURN (-1);
- }
-
- default :
- ACE_ERROR_RETURN ((LM_ERROR,
- ACE_TEXT ("(%t) %p shadow acquire failed\n"),
- ACE_TEXT ("ACE_Remote_Token_Proxy")),
- -1);
- }
- }
-
- ACE_Token_Request request (token_->type (),
- this->type (),
- ACE_Token_Request::ACQUIRE,
- this->name (),
- this->client_id (),
- options);
-
- request.notify (notify);
-
- int result = this->request_reply (request, options);
-
- if (result == -1)
- {
- // Update the local shadow copy.
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("error on remote acquire, releasing shadow mutex.\n")));
- ACE_Token_Proxy::release ();
- }
- else
- {
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) acquired %s remotely.\n"), this->name ()));
- // Our shadow call may have failed. However, it's still a race
- // to the remote server. If we beat the client which holds the
- // local token, we need to fix things locally to reflect the
- // actual ownership. All that should happen is that our waiter
- // is moved to the front of the waiter list.
- token_->make_owner (waiter_);
- }
-
- return result;
-}
-
-int
-ACE_Remote_Token_Proxy::tryacquire (void (*sleep_hook)(void *))
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::tryacquire");
-
- // If we can detect locally that the tryacquire will fail, there is
- // no need to go remote.
- if (ACE_Token_Proxy::tryacquire (sleep_hook) == -1)
- {
- if (debug_)
- {
- // Save/restore errno.
- ACE_Errno_Guard error (errno);
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT ("shadow try acquire failed\n")));
- }
-
- return -1;
- }
-
- ACE_Token_Request request (token_->type (),
- this->type (),
- ACE_Token_Request::TRY_ACQUIRE,
- this->name (),
- this->client_id (),
- ACE_Synch_Options::synch);
-
- return this->request_reply (request,
- ACE_Synch_Options::synch);
-}
-
-int
-ACE_Remote_Token_Proxy::renew (int requeue_position,
- ACE_Synch_Options &options)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::renew");
-
- if (ACE_Token_Proxy::renew (requeue_position,
- ACE_Synch_Options::asynch) == -1)
- {
- // Check for error.
- if (errno != EWOULDBLOCK)
- return -1;
- else if (debug_)
- ACE_DEBUG ((LM_DEBUG,
- ACE_TEXT ("(%t) shadow: renew would block. owner %s.\n"),
- this->token_->owner_id ()));
- }
-
- ACE_Token_Request request (token_->type (),
- this->type (),
- ACE_Token_Request::RENEW,
- this->name (),
- this->client_id (),
- options);
-
- request.requeue_position (requeue_position);
-
- int result = this->request_reply (request, options);
-
- if (result == -1)
- {
- {
- // Save/restore errno.
- ACE_Errno_Guard error (errno);
- ACE_Token_Proxy::release ();
- }
- ACE_ERROR_RETURN ((LM_ERROR,
- ACE_TEXT ("%p error on remote renew, releasing shadow mutex.\n"),
- ACE_TEXT ("ACE_Remote_Token_Proxy")), -1);
- }
- else
- {
- if (debug_)
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) renewed %s remotely.\n"), this->name ()));
- // Make sure that the local shadow reflects our new ownership.
- token_->make_owner (waiter_);
- return result;
- }
-}
-
-int
-ACE_Remote_Token_Proxy::release (ACE_Synch_Options &options)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::release");
-
- ACE_Token_Request request (token_->type (),
- this->type (),
- ACE_Token_Request::RELEASE,
- this->name (),
- this->client_id (),
- options);
-
- int result = this->request_reply (request, options);
- if (result == 0)
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) released %s remotely.\n"), this->name ()));
-
- // whether success or failure, we're going to release the shadow.
- // If race conditions exist such that we are no longer the owner,
- // this release will perform a remove.
- if (ACE_Token_Proxy::release () == -1)
- ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) shadow: release failed\n")));
-
- return result;
-}
-
-int
-ACE_Remote_Token_Proxy::remove (ACE_Synch_Options &)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::remove");
- return 0;
-}
-
-void
-ACE_Remote_Token_Proxy::token_acquired (ACE_TPQ_Entry *)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::token_acquired");
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("(%t) shadow token %s acquired\n"),
- this->client_id (),
- this->name ()));
- // ACE_Token_Proxy::token_acquired (vp);
-}
-
-const ACE_TCHAR*
-ACE_Remote_Token_Proxy::owner_id (void)
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::owner_id");
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("owner_id called\n")));
- // @@ special operation
- return 0;
-}
-
-void
-ACE_Remote_Token_Proxy::dump (void) const
-{
- ACE_TRACE ("ACE_Remote_Token_Proxy::owner_id");
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Tokens::dump:\n")
- ACE_TEXT (" ignore_shadow_deadlock_ = %d\n"),
- ignore_shadow_deadlock_));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("base:\n")));
- ACE_Token_Proxy::dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-void
-ACE_Remote_Mutex::dump (void) const
-{
- ACE_TRACE ("ACE_Remote_Mutex::dump");
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Remote_Mutex::dump:\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("base:\n")));
- ACE_Remote_Token_Proxy::dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-void
-ACE_Remote_RLock::dump (void) const
-{
- ACE_TRACE ("ACE_Remote_RLock::dump");
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Remote_RLock::dump:\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("base:\n")));
- ACE_Remote_Token_Proxy::dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-void
-ACE_Remote_WLock::dump (void) const
-{
- ACE_TRACE ("ACE_Remote_WLock::dump");
- ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Remote_WLock::dump:\n")));
- ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("base:\n")));
- ACE_Remote_Token_Proxy::dump ();
- ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
-}
-
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)
-template class ACE_TSS <ACE_SOCK_Stream>;
-template class ACE_Singleton <ACE_TSS_Connection, ACE_TSS_CONNECTION_MUTEX>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#pragma instantiate ACE_TSS <ACE_SOCK_Stream>
-#pragma instantiate ACE_Singleton <ACE_TSS_Connection, ACE_TSS_CONNECTION_MUTEX>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */