process.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

  ACE_HANDLE std_out = ACE_STDOUT;

  if (!::DuplicateHandle (::GetCurrentProcess (),
                          std_out,
                          ::GetCurrentProcess (),
                          &startup_info.hStdOutput,
                          NULL,
                          TRUE,
                          DUPLICATE_SAME_ACCESS))
    {
      ACE_ERROR ((LM_ERROR,
                  "%p duplicate failed.\n",
                  "test_ls"));
      return;
    }

  BOOL fork_result =
    ACE_TEXT_CreateProcess ("c:\\Utils\\bin\\ls.exe",
                                   "-a",
                            NULL, // No process attributes.
                            NULL, // No thread attributes.
                            TRUE, // Allow handle inheritance.
                            NULL, // CREATE_NEW_CONSOLE, // Create a new console window.
                            NULL,
                            0, // Current directory to start in.
                            &startup_info,
                            &process_info);

  ::CloseHandle (startup_info.hStdOutput);

  if (fork_result == 0)
    ACE_ERROR ((LM_ERROR,
                "%p CreateProcess failed.\n",
                "test_ls"));
  else
    {
      ::WaitForSingleObject (process_info.hProcess,
                             INFINITE);
      ACE_DEBUG ((LM_ERROR,
                  "ls succeeded.\n"));
    }
}

// This code spawns a new process.  The new process inherits our
// existing environment, plus one more.  This has to be done by hand
// since CreateProcess does not allow us to inherit AND add
// environment variables.

static void
win32_spawn_environment_process (void)
{
  PROCESS_INFORMATION process_info;
  ACE_TEXT_STARTUPINFO startup_info;
  ACE_OS::memset ((void *) &startup_info,
                  0,
                  sizeof startup_info);
  ACE_OS::memset ((void *) &process_info,
                  0,
                  sizeof process_info);
  startup_info.cb = sizeof (startup_info);
  startup_info.dwFlags = STARTF_USESTDHANDLES;

  ACE_HANDLE std_in = ACE_STDIN;
  ACE_HANDLE std_out = ACE_STDOUT;
  ACE_HANDLE std_err = ACE_STDERR;

  if (!::DuplicateHandle (::GetCurrentProcess(),
                          std_out,
                          ::GetCurrentProcess(),
                          &startup_info.hStdOutput,
                          NULL,
                          TRUE,
                          DUPLICATE_SAME_ACCESS))
    {
      ACE_ERROR ((LM_ERROR,
                  "%p duplicate failed.\n", "spawn_environment_process"));
      return;
    }

  if (!::DuplicateHandle (::GetCurrentProcess(),
                          std_err,
                          ::GetCurrentProcess(),
                          &startup_info.hStdError,
                          NULL,
                          TRUE,
                          DUPLICATE_SAME_ACCESS))
    {
      ACE_ERROR ((LM_ERROR,
                  "%p duplicate failed.\n",
                  "spawn_environment_process"));
      return;
    }

  if (!::DuplicateHandle (::GetCurrentProcess(),
                          std_in,
                          ::GetCurrentProcess(),
                          &startup_info.hStdInput,
                          NULL,
                          TRUE,
                          DUPLICATE_SAME_ACCESS))
    {
      ACE_ERROR ((LM_ERROR,
                  "%p duplicate failed.\n",
                  "spawn_environment_process"));
      return;
    }

  // Normally, this would be just GetEnvironmentStrings, but it
  // doesn't follow the same rules as the rest of the Win32 API
  char *existing_environment = ACE_OS::getenvstrings ();
  char environment[10240];
  ACE_OS::sprintf (environment,
                   "ACE_PROCESS_TEST=%s",
                   environment_string);

  int size = 0;
  while (existing_environment[size] != '\0')
    size += ACE_OS::strlen (existing_environment + size) + 1;

  ACE_OS::memcpy (environment + (ACE_OS::strlen (environment) + 1),
                  existing_environment,
                  size);

  ACE_TEXT_FreeEnvironmentStrings (existing_environment);

  BOOL fork_result =
    ACE_TEXT_CreateProcess ("d:\\harrison\\ACE_wrappers\\examples\\OS\\Process\\process.exe",
                            "process -g",
                            NULL, // No process attributes.
                            NULL, // No thread attributes.
                            TRUE, // Allow handle inheritance.
                            NULL, // CREATE_NEW_CONSOLE, // Create a new console window.
                            environment, // Environment.
                            //"d:\\harrison\\ACE_wrappers\\examples\\OS\\Process\\",
                            0,
                            &startup_info,
                            &process_info);

  ::CloseHandle (startup_info.hStdOutput);
  ::CloseHandle (startup_info.hStdError);

  if (fork_result == 0)
    ACE_ERROR ((LM_ERROR,
                "%p.\n",
                "spawn_environment_process"));
  else
    {
      ::WaitForSingleObject (process_info.hProcess,
                             INFINITE);
      ACE_DEBUG ((LM_ERROR, 
                  "spawn_environment_process succeeded.\n"));
    }
}
#endif

static void
test_setenv (const char *argv0)
{
  ACE_Process_Options options;
  //  options.setenv ("ACE_PROCESS_TEST", "here's a really large number: %u", 0 - 1);
  options.setenv ("ACE_PROCESS_TEST= here's a large number %u", 0 - 1);
  options.setenv ("ACE_PROCESS_TEST2", "ophilli");
  options.command_line ("%s -g", argv0);
  ACE_Process process;
  if (process.spawn (options) == -1)
    {
      ACE_ERROR ((LM_ERROR,
                  "%p.\n",
                  "test_setenv"));
      return;
    }

  ACE_exitcode status;
  process.wait (&status);
  ACE_DEBUG ((LM_DEBUG,
              "Process exit with status %d\n",
              status));
}

// Tests the ACE_Tokenizer.
static void
tokenize (char *buffer)
{
  // This tokenizer will replace all spaces with end-of-string
  // characters and will preserve text between "" and '' pairs.
  ACE_Tokenizer parser (buffer);
  parser.delimiter_replace (' ', '\0');
  parser.preserve_designators ('\"', '\"'); // "  This quote is for emacs
  parser.preserve_designators ('\'', '\'');

  for (const char *temp; ;)
    {
      temp = parser.next ();
      if (temp == 0)
        break;
      ACE_DEBUG ((LM_DEBUG,
                  temp));
      ACE_DEBUG ((LM_DEBUG,
                  "\n"));
    }
}

int
main (int argc, char *argv[])
{
  if (ACE_LOG_MSG->open (argv[0]) == -1)
    ACE_ERROR ((LM_ERROR,
                "cannot open logger!!!\n"));

  ACE_DEBUG ((LM_DEBUG,
              "starting...\n"));

  if (::parse_args (argc, argv) == -1)
    return -1;

  if (run_all)
    {
      ACE_Process_Options options;
      options.command_line ("%s -d -l -s -w",
                            argv[0]);
      ACE_Process process;
      if (process.spawn (options) == -1)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "%p.\n",
                           "main"),
                          -1);
      ACE_exitcode status;
      process.wait (&status);
      ACE_DEBUG ((LM_DEBUG,
                  "Process exit with status %d\n",
                  status));
    }

  if (run_date)
    ::test_date ();

  if (run_setenv)
    ::test_setenv (argv[0]);

  if (get_env)
    {
      ACE_DEBUG ((LM_DEBUG, "checking ACE_PROCESS_TEST\n"));
      char *value = ACE_OS::getenv ("ACE_PROCESS_TEST");
      char *value2 = ACE_OS::getenv ("ACE_PROCESS_TEST2");
      ACE_DEBUG ((LM_DEBUG,
                  "ACE_PROCESS_TEST = %s.\n"
                  "ACE_PROCESS_TEST2 = %s.\n",
                  value == 0 ? "no value" : value,
                  value2 == 0 ? "no value" : value2));
    }

  if (run_ls)
    ::test_ls ();

  if (run_wait)
    ::test_wait ();

#if defined (ACE_WIN32)
  if (environment_string != 0)
    win32_spawn_environment_process ();
#endif /* ACE_WIN32 */

  if (print_file != 0)
    test_more ();

  char buf1[30];
  char buf2[30];
  ACE_OS::strcpy(buf1, " -f hi honey -g \"I\'m home\"");
  ACE_OS::strcpy(buf2, "\"token 1\"\'token 2\'\"token 3\" ");

  if (run_tokenizer)
    {
      tokenize ( buf1 );
      tokenize ( buf2 );
    }

  return 0;
}