ACE/netsvcs/clients/Tokens/manual/manual.cpp

   1
   2 //=============================================================================
   3 /**
   4  *  @file    manual.cpp
   5  *
   6  *  Allows manual operations on local and remote tokens.
   7  *
   8  *  @author Tim Harrison
   9  */
  10 //=============================================================================
  11
  12
  13 #include "ace/Get_Opt.h"
  14 #include "ace/Local_Tokens.h"
  15 #include "ace/Remote_Tokens.h"
  16 #include "ace/Singleton.h"
  17 #include "ace/Thread_Manager.h"
  18 #include "ace/Token_Invariants.h"
  19 #include "ace/Token_Collection.h"
  20 #include "ace/Map_Manager.h"
  21 #include "ace/Service_Config.h"
  22
  23 #if defined (ACE_HAS_THREADS) && defined (ACE_HAS_THREADS_LIBRARY)
  24
  25
  26
  27 typedef ACE_Token_Invariant_Manager ACE_TOKEN_INVARIANTS;
  28
  29 /**
  30  * @class STDIN_Token
  31  *
  32  * @brief STDIN Token
  33  *
  34  * Translates STDIN commands to ACE Token commands.
  35  */
  36 class STDIN_Token : public ACE_Event_Handler
  37 {
  38 public:
  39   /// Construction.
  40   STDIN_Token (void);
  41
  42   /// Parse command-line arguments.
  43   int parse_args (int argc, ACE_TCHAR *argv[]);
  44
  45   //FUZZ: disable check_for_lack_ACE_OS
  46   /// Register with whatever event dispatcher is needed and run.
  47   ///FUZZ: enable check_for_lack_ACE_OS
  48   int open (int argc, char *argv[]);
  49
  50   // = Event_Handler methods.
  51   int handle_input (ACE_HANDLE);
  52   int handle_exception (ACE_HANDLE);
  53
  54   typedef ACE_CString TID;
  55
  56 private:
  57
  58   /// Display options.
  59   void display_menu (void);
  60
  61   /// Get or make a proxy to <token> with a <tid> client id.
  62   ACE_Token_Proxy *get_proxy (const char *tid, const char *token, char type);
  63
  64   /// Create a proxy to <token> with a <tid> client id.
  65   ACE_Token_Proxy *create_proxy (const char *token, char type);
  66
  67   // = Mapping from tid to Token_Collection.
  68   /// COLLECTION maintains a mapping from tid to a collection.
  69   typedef ACE_Map_Manager<TID, ACE_Token_Collection *, ACE_Null_Mutex>
  70     COLLECTIONS;
  71
  72   /// Allows iterations through collections_.
  73   typedef ACE_Map_Iterator<TID, ACE_Token_Collection *, ACE_Null_Mutex>
  74     COLLECTIONS_ITERATOR;
  75
  76   /// Allows iterations through collections_.
  77   typedef ACE_Map_Entry<TID, ACE_Token_Collection *>
  78     COLLECTIONS_ENTRY;
  79
  80   /// A collection for each <tid>.
  81   COLLECTIONS collections_;
  82
  83   const char *server_host_;
  84   int server_port_;
  85   int ignore_deadlock_;
  86   int debug_;
  87   int remote_;
  88 };
  89
  90 STDIN_Token::STDIN_Token (void)
  91   : server_host_ (ACE_DEFAULT_SERVER_HOST),
  92     server_port_ (ACE_DEFAULT_SERVER_PORT),
  93     ignore_deadlock_ (0),
  94     debug_ (0),
  95     remote_ (0)
  96 {
  97 }
  98
  99 int
 100 STDIN_Token::parse_args (int argc, ACE_TCHAR *argv[])
 101 {
 102   ACE_LOG_MSG->open (argv[0], ACE_Log_Msg::STDERR);
 103
 104   ACE_Get_Opt get_opt (argc, argv, ACE_TEXT("h:p:diu"), 1);
 105
 106   for (int c; (c = get_opt ()) != -1; )
 107     {
 108       switch (c)
 109       {
 110       case 'h':  // specify the host machine on which the server is running
 111         server_host_ = get_opt.opt_arg ();
 112         remote_ = 1;
 113         break;
 114       case 'p':  // specify the port on which the server is running
 115         server_port_ = ACE_OS::atoi (get_opt.opt_arg ());
 116         remote_ = 1;
 117         break;
 118       case 'd':
 119         debug_ = 1;
 120         break;
 121       case 'i':
 122         ignore_deadlock_ = 1;
 123         break;
 124       case 'u':
 125         // usage: fallthrough
 126       default:
 127         ACE_ERROR_RETURN ((LM_ERROR,
 128         "%n:\n"
 129         "[-h <remote host>]\n"
 130         "[-p <remote port>]\n"
 131         "[-i ignore deadlock]\n"
 132         "[-d debug]\n", 1), -1);
 133       }
 134     }
 135
 136   if (remote_)
 137     ACE_Remote_Mutex::set_server_address (ACE_INET_Addr (server_port_,
 138                                                          server_host_));
 139
 140   return 0;
 141 }
 142
 143 int
 144 STDIN_Token::open (int argc, char *argv[])
 145 {
 146   if (this->parse_args (argc, argv) == -1)
 147     return -1;
 148
 149   // Register for signals.
 150   if (ACE_Reactor::instance ()->register_handler
 151       (SIGINT, this) == -1)
 152     ACE_DEBUG ((LM_DEBUG, "Can't register signal handler\n"));
 153
 154 #if defined (ACE_WIN32)
 155
 156 #else
 157   // Register for STDIN events with Reactor.
 158   if (ACE_Reactor::instance ()->register_handler
 159       (ACE_STDIN, this, ACE_Event_Handler::READ_MASK) == -1)
 160     ACE_ERROR_RETURN ((LM_DEBUG, "Can't register signal handler\n"), 0);
 161
 162
 163 #endif /* ACE_WIN32 */
 164
 165
 166   this->display_menu ();
 167
 168 #if defined (ACE_WIN32)
 169
 170 #else
 171   ACE_Reactor::run_event_loop ();
 172 #endif /* ACE_WIN32 */
 173
 174   ACE_OS::printf ("Exiting...\n");
 175   return 0;
 176 }
 177
 178 int
 179 STDIN_Token::handle_input (ACE_HANDLE fd)
 180 {
 181   ACE_UNUSED_ARG (fd);
 182
 183   char tid[BUFSIZ];
 184   char token[BUFSIZ];
 185   char type[16];
 186   char operation[16];
 187
 188   if (::scanf ("%s %s %s %s", tid, token, type, operation) <= 0)
 189     {
 190       ACE_OS::printf ("Try again.\n");
 191       return 0;
 192     }
 193
 194   ACE_Token_Proxy *proxy =
 195     this->get_proxy (tid, token, type[0]);
 196
 197   if (proxy == 0)
 198     return -1;
 199
 200   switch (operation[0])
 201     {
 202     case 'a':
 203     case 'A':
 204       if (proxy->acquire () == 0)
 205         {
 206           ACE_OS::printf ("Succeeded.\n");
 207           if (ACE_TOKEN_INVARIANTS::instance ()->acquired (proxy) == 0)
 208             ACE_OS::printf ("Violated invariant.\n");
 209         }
 210       else
 211         ACE_ERROR ((LM_ERROR, "%p.\n", "Acquire failed"));
 212       break;
 213     case 'n':
 214     case 'N':
 215       ACE_TOKEN_INVARIANTS::instance ()->releasing (proxy);
 216       if (proxy->renew () == 0)
 217         {
 218           ACE_OS::printf ("Succeeded.\n");
 219           if (ACE_TOKEN_INVARIANTS::instance ()->acquired (proxy) == 0)
 220             ACE_OS::printf ("Violated invariant.\n");
 221         }
 222       else
 223         ACE_ERROR ((LM_ERROR, "%p.\n", "Renew failed"));
 224       break;
 225
 226     case 'r':
 227     case 'R':
 228       ACE_TOKEN_INVARIANTS::instance ()->releasing (proxy);
 229       if (proxy->release () == 0)
 230         ACE_OS::printf ("Succeeded.\n");
 231       else
 232         ACE_ERROR ((LM_ERROR, "%p.\n", "Release failed"));
 233       break;
 234
 235     case 't':
 236     case 'T':
 237       if (proxy->tryacquire () == 0)
 238         {
 239           ACE_OS::printf ("Succeeded.\n");
 240           if (ACE_TOKEN_INVARIANTS::instance ()->acquired (proxy) == 0)
 241             ACE_OS::printf ("Violated invariant.\n");
 242         }
 243       else
 244         ACE_ERROR ((LM_ERROR, "%p.\n", "Tryacquire failed"));
 245       break;
 246     }
 247
 248   this->display_menu ();
 249   return 0;
 250 }
 251
 252 void
 253 STDIN_Token::display_menu (void)
 254 {
 255   ACE_OS::printf ("<tid> <token> <type> <operation>\n");
 256 }
 257
 258 int
 259 STDIN_Token::handle_exception (ACE_HANDLE fd)
 260 {
 261   ACE_UNUSED_ARG (fd);
 262
 263   ACE_Reactor::run_event_loop ();
 264   return -1;
 265 }
 266
 267 ACE_Token_Proxy *
 268 STDIN_Token::get_proxy (const char *_tid, const char *token, char type)
 269 {
 270   ACE_Token_Collection *proxy_collection;
 271
 272   TID tid (_tid);
 273
 274   if (collections_.find (tid, proxy_collection) == -1)
 275     // We did not find a proxy_collection.
 276     {
 277       // Make one.
 278       proxy_collection = new ACE_Token_Collection (debug_, "no name collection");
 279
 280       // Put it in the collections.
 281       if (collections_.bind (tid, proxy_collection) == -1)
 282         {
 283           delete proxy_collection;
 284           return 0;
 285         }
 286     }
 287
 288   // Either way, we have a proxy_collection now.
 289
 290   // See if the proxy already exists in the collection.
 291   ACE_Token_Proxy *proxy = proxy_collection->is_member (token);
 292
 293   // If not, create one.
 294   if (proxy == 0)
 295     {
 296       proxy = this->create_proxy (token, type);
 297
 298       // Put the new_proxy in this tid's collection.
 299       if (proxy_collection->insert (*proxy) == -1)
 300         ACE_ERROR_RETURN ((LM_ERROR, "insert failed\n"), 0);
 301
 302       // Delete our copy (one was created in the collection).
 303       delete proxy;
 304       proxy = proxy_collection->is_member (token);
 305
 306       if (proxy == 0)
 307         ACE_ERROR_RETURN ((LM_ERROR, "is_member failed\n"), 0);
 308
 309       // Set the client_id (it was set to 1 since we're
 310       // single-threaded.
 311       proxy->client_id (_tid);
 312     }
 313
 314   return proxy;
 315 }
 316
 317 ACE_Token_Proxy *
 318 STDIN_Token::create_proxy (const char *token, char type)
 319 {
 320   switch (type)
 321     {
 322     case 'm':
 323     case 'M':
 324       if (remote_)
 325         return new ACE_Remote_Mutex (token, ignore_deadlock_, debug_);
 326       else
 327         return new ACE_Local_Mutex (token, ignore_deadlock_, debug_);
 328
 329     case 'r':
 330     case 'R':
 331       if (remote_)
 332         return new ACE_Remote_RLock (token, ignore_deadlock_, debug_);
 333       else
 334         return new ACE_Local_RLock (token, ignore_deadlock_, debug_);
 335
 336     case 'w':
 337     case 'W':
 338       if (remote_)
 339         return new ACE_Remote_WLock (token, ignore_deadlock_, debug_);
 340       else
 341         return new ACE_Local_WLock (token, ignore_deadlock_, debug_);
 342     }
 343
 344   // should never get here, but this avoids a compiler warning . . .
 345   return 0;
 346 }
 347
 348 int
 349 ACE_TMAIN(int argc, ACE_TCHAR *argv[])
 350 {
 351   STDIN_Token st;
 352   return st.open (argc, argv);
 353 }
 354
 355 #else
 356 int
 357 ACE_TMAIN(int, ACE_TCHAR *[])
 358 {
 359   ACE_ERROR_RETURN ((LM_ERROR,
 360                      "threads or ACE_HAS_TOKENS_LIBRARY not supported on this platform\n"), -1);
 361 }
 362 #endif /* ACE_HAS_THREADS && ACE_HAS_TOKENS_LIBRARY */