ACE/tests/XtAthenaReactor_Test.cpp

   1 /* -*- C++ -*- */
   2
   3 //=============================================================================
   4 /**
   5  *  @file    XtAthenaReactor_Test.cpp
   6  *
   7  *    This is a simple test that illustrates the possibility to integrate
   8  *    ACE to the X Main Loop. This program uses ACE_XtReactor class to
   9  *    schedule three additional event sources:
  10  *    1. Events from button "Stop Test" (registed with XtAddCallback)
  11  *    2. Events from button "Press Me" (registed with XtAddCallback)
  12  *    3. Events from X timer (registed with XtAppAddTimeOut)
  13  *    4. Events from ACE timer (registed with ACE_XtReactor::schedule_timer)
  14  *    5. Events from the TCP/IP channel using ACE_Acceptor
  15  *    No command line arguments are needed to run the test.
  16  *    Programs needs Athena Widgets to be compiled and run.
  17  *
  18  *  @author Kirill Rybaltchenko <Kirill.Rybaltchenko@cern.ch>
  19  */
  20 //=============================================================================
  21
  22
  23 #include "test_config.h"
  24 #include "ace/XtReactor/XtReactor.h"
  25 #include "ace/Event_Handler.h"
  26 #include "ace/Acceptor.h"
  27 #include "ace/SOCK_Acceptor.h"
  28 #include "ace/SOCK_Connector.h"
  29 #include "ace/Service_Config.h"
  30 #include "ace/Thread_Manager.h"
  31
  32 #include "ace/OS_NS_unistd.h"
  33
  34 #include /**/ <X11/Intrinsic.h>
  35 #include /**/ <X11/Xatom.h>
  36 #include /**/ <X11/Shell.h>
  37 #include /**/ <X11/StringDefs.h>
  38
  39 #if defined (ACE_HAS_ATHENA3D)
  40 #  include /**/ <X11/Xaw3d/Command.h>
  41 #  include /**/ <X11/Xaw3d/Label.h>
  42 #  include /**/ <X11/Xaw3d/Box.h>
  43 #else
  44 #  include /**/ <X11/Xaw/Command.h>
  45 #  include /**/ <X11/Xaw/Label.h>
  46 #  include /**/ <X11/Xaw/Box.h>
  47 #endif
  48
  49 static void set_label(Widget w, const char *p)
  50 {
  51     XtVaSetValues (w, XtNlabel, p, static_cast<void *>(0));
  52 }
  53 #define LABEL_WIDGET labelWidgetClass
  54 #define BUTTON_WIDGET commandWidgetClass
  55 #define PRESS_ME_CALLBACK XtNcallback
  56 static Widget create_box(Widget parent, const char * name)
  57 {
  58     return XtCreateWidget( (char*) name, boxWidgetClass, parent, 0, 0);
  59 }
  60
  61 // Port we listen on.
  62 static const u_short SERV_TCP_PORT = 6670;
  63
  64 // counter for events from "Press Me" button.
  65 static int count1 = 0;
  66
  67 // counter for events from X Timer.
  68 static int count2 = 0;
  69
  70 // counter for events from ACE Timer.
  71 static int count3 = 0;
  72
  73 // Callback for "Stop Test" buton - quit the program.
  74 void
  75 Quit (Widget, XtPointer, XtPointer)
  76 {
  77   ACE_OS::exit (0);
  78 }
  79
  80 static void *
  81 client (void *)
  82 {
  83   char buf[100];
  84   size_t mes_len;
  85   ACE_OS::sleep (1);
  86
  87   ACE_DEBUG ((LM_DEBUG,
  88               " (%P) Client: Starting...\n"));
  89
  90   ACE_SOCK_Stream stream;
  91   ACE_SOCK_Connector connector;
  92   ACE_OS::snprintf (buf, 100, "Client: the life was good!");
  93
  94   mes_len = (int) htonl (ACE_OS::strlen (buf) + 1);
  95
  96   if (connector.connect (stream,
  97                          ACE_INET_Addr (SERV_TCP_PORT,
  98                                         ACE_DEFAULT_SERVER_HOST)) == -1)
  99     ACE_ERROR ((LM_ERROR,
 100                 "(%P) %p\n",
 101                 "Socket open"));
 102
 103   if (stream.send (4,
 104                    (void *) &mes_len,
 105                    sizeof (size_t),
 106                    (void *)buf,
 107                    ACE_OS::strlen (buf) + 1) == -1)
 108
 109     ACE_ERROR ((LM_ERROR,
 110                 "(%P) %p\n",
 111                 "Socket send"));
 112
 113   if (stream.close () == -1)
 114     ACE_ERROR ((LM_ERROR,
 115                 "(%P) %p\n",
 116                 "Socket close"));
 117
 118   ACE_DEBUG ((LM_DEBUG,
 119               "(%P) Client: Message has been sent, about to exit...\n"));
 120   return 0;
 121 }
 122
 123 // Callback for "Press Me" button.
 124
 125 static void
 126 inc_count (Widget, XtPointer client_data, XtPointer)
 127 {
 128   char new_string[80];
 129
 130   ACE_OS::snprintf (new_string, 80, "Events: [%d] [%d] [%d]",
 131                     count1++, count2, count3);
 132
 133   set_label((Widget) client_data, new_string);
 134 }
 135
 136 // Callback for X Timer.
 137
 138 static void
 139 inc_tmo (void *w,XtIntervalId *)
 140 {
 141   char new_string[80];
 142
 143   if (count2 > 10)
 144     ACE_OS::exit (0);
 145   ACE_OS::snprintf (new_string, 80, "Events: [%d] [%d] [%d]",
 146                     count1, count2++, count3);
 147
 148   set_label((Widget) w, new_string);
 149
 150   (void) XtAppAddTimeOut (XtWidgetToApplicationContext ((Widget) w),
 151                           1000,
 152                           inc_tmo,
 153                           (Widget) w);
 154 }
 155
 156 class EV_handler : public ACE_Event_Handler
 157 {
 158 public:
 159   virtual int handle_timeout (const ACE_Time_Value &,
 160                               const void *arg)
 161   {
 162     char new_string[80];
 163     ACE_OS::snprintf (new_string, 80, "Events: [%d] [%d] [%d]",
 164                       count1, count2, count3++);
 165     set_label((Widget) arg, new_string);
 166     return 0;
 167   }
 168 };
 169
 170 class Connection_Handler : public ACE_Svc_Handler<ACE_SOCK_STREAM, ACE_NULL_SYNCH>
 171 {
 172 public:
 173   //FUZZ: disable check_for_lack_ACE_OS
 174   virtual int open (void *)
 175   {
 176   //FUZZ: enable check_for_lack_ACE_OS
 177     char buf[100];
 178     int head;
 179     ssize_t ret = this->peer ().recv_n ((char *) &head,
 180                                         sizeof (int));
 181     if (ret != sizeof (int))
 182       ACE_ERROR_RETURN ((LM_ERROR,
 183                          "(%P) %p\n",
 184                          "read header"),
 185                         -1);
 186
 187     ret = this->peer ().recv_n (buf,
 188                                 (int) ntohl (head));
 189
 190     if (ret != (int) ntohl (head))
 191       ACE_ERROR_RETURN ((LM_ERROR,
 192                          "(%P) %p\n",
 193                          "read message"),
 194                         -1);
 195     ACE_DEBUG ((LM_DEBUG,
 196                 " (%P)Server (ACE_SOCKET channel message): [%s]\n",
 197                 buf));
 198     return 0;
 199   }
 200 };
 201
 202 #if defined (HummingBird_X)
 203 extern "C" void HCLXmInit ();
 204 #endif /* HummingBird_X */
 205
 206 int
 207 run_main (int argc, ACE_TCHAR *argv[])
 208 {
 209   ACE_START_TEST (ACE_TEXT ("XtAthenaReactor_Test"));
 210
 211   XtAppContext app_context;
 212   Widget topLevel, goodbye, PressMe, lbl, digits_rc;
 213   Widget children[5];
 214
 215 #if defined (HummingBird_X)
 216   HCLXmInit ();
 217 #endif /* HummingBird_X */
 218   topLevel = XtVaAppInitialize (&app_context,
 219                                 "XTReactor_Test",
 220                                 0,
 221                                 0,
 222                                 &argc,
 223                                 argv,
 224                                 0,
 225                                 static_cast<void *>(0));
 226
 227   digits_rc = create_box(topLevel, "digits_rc");
 228
 229   //"Stop Test" button.
 230   goodbye = XtCreateWidget ( (char *) "goodbye",
 231                              BUTTON_WIDGET,
 232                              digits_rc,
 233                              0,
 234                              0);
 235   set_label(goodbye, "Stop Test");
 236
 237   //"Press Me" button
 238   PressMe = XtCreateWidget ((char *) "PressMe",
 239                             BUTTON_WIDGET,
 240                             digits_rc,
 241                             0,
 242                             0);
 243
 244   //Display for event counter
 245   lbl = XtCreateWidget ((char *) "label_for_event_one",
 246                         LABEL_WIDGET,
 247                         digits_rc,
 248                         0,
 249                         0);
 250   set_label(lbl, "label_for_all_events");
 251   int ac = 0;
 252   children[ac++] = goodbye;
 253   children[ac++] = PressMe;
 254   children[ac++] = lbl;
 255   XtManageChildren (children, ac);
 256   XtManageChild (digits_rc);
 257
 258   //Register callback for "Stop Test" button
 259   XtAddCallback (goodbye, PRESS_ME_CALLBACK, Quit, 0);
 260
 261   //Register callback for "Press Me" button
 262   XtAddCallback (PressMe,
 263                  PRESS_ME_CALLBACK,
 264                  inc_count,
 265                  (XtPointer) lbl);
 266
 267   // Register callback for X Timer
 268   (void) XtAppAddTimeOut (app_context,
 269                           1000,
 270                           inc_tmo,
 271                           (XtPointer) lbl);
 272
 273   XtRealizeWidget (topLevel);
 274
 275   // It will perform X Main Loop
 276   ACE_XtReactor reactor (app_context);
 277
 278   ACE_Reactor r (&reactor);
 279
 280   //Event Handler for ACE Timer.
 281   EV_handler evh;
 282
 283   ACE_Acceptor <Connection_Handler, ACE_SOCK_ACCEPTOR> acceptor;
 284
 285   if (acceptor.open (ACE_INET_Addr ((u_short) SERV_TCP_PORT),
 286                      &r) == -1)
 287     ACE_ERROR_RETURN ((LM_ERROR,
 288                        "%p\n",
 289                        "open"),
 290                       -1);
 291
 292   if (reactor.schedule_timer (&evh,
 293                               (const void *) lbl,
 294                               ACE_Time_Value (2),
 295                               ACE_Time_Value (2))==-1)
 296     ACE_ERROR_RETURN ((LM_ERROR,
 297                        " (%P|%t) can't register with reactor\n"),
 298                       -1);
 299
 300   ACE_Thread_Manager::instance ()->spawn ((ACE_THR_FUNC) client,
 301                                           0,
 302                                           THR_NEW_LWP | THR_DETACHED);
 303
 304   XtAppMainLoop (XtWidgetToApplicationContext (topLevel));
 305
 306   ACE_END_TEST;
 307   return 0;
 308 }
 309