remoting/host/win/worker_process_launcher.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/host/win/worker_process_launcher.h"
   6
   7 #include "base/location.h"
   8 #include "base/logging.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/time.h"
  11 #include "base/win/windows_version.h"
  12 #include "ipc/ipc_message.h"
  13 #include "remoting/host/chromoting_messages.h"
  14 #include "remoting/host/host_exit_codes.h"
  15 #include "remoting/host/worker_process_ipc_delegate.h"
  16
  17 using base::TimeDelta;
  18 using base::win::ScopedHandle;
  19
  20 const net::BackoffEntry::Policy kDefaultBackoffPolicy = {
  21   // Number of initial errors (in sequence) to ignore before applying
  22   // exponential back-off rules.
  23   0,
  24
  25   // Initial delay for exponential back-off in ms.
  26   100,
  27
  28   // Factor by which the waiting time will be multiplied.
  29   2,
  30
  31   // Fuzzing percentage. ex: 10% will spread requests randomly
  32   // between 90%-100% of the calculated time.
  33   0,
  34
  35   // Maximum amount of time we are willing to delay our request in ms.
  36   60000,
  37
  38   // Time to keep an entry from being discarded even when it
  39   // has no significant state, -1 to never discard.
  40   -1,
  41
  42   // Don't use initial delay unless the last request was an error.
  43   false,
  44 };
  45
  46 const int kKillProcessTimeoutSeconds = 5;
  47 const int kLaunchResultTimeoutSeconds = 5;
  48
  49 namespace remoting {
  50
  51 WorkerProcessLauncher::Delegate::~Delegate() {
  52 }
  53
  54 WorkerProcessLauncher::WorkerProcessLauncher(
  55     scoped_ptr<WorkerProcessLauncher::Delegate> launcher_delegate,
  56     WorkerProcessIpcDelegate* ipc_handler)
  57     : ipc_handler_(ipc_handler),
  58       launcher_delegate_(launcher_delegate.Pass()),
  59       exit_code_(CONTROL_C_EXIT),
  60       ipc_enabled_(false),
  61       kill_process_timeout_(
  62           base::TimeDelta::FromSeconds(kKillProcessTimeoutSeconds)),
  63       launch_backoff_(&kDefaultBackoffPolicy) {
  64   DCHECK(ipc_handler_ != NULL);
  65
  66   LaunchWorker();
  67 }
  68
  69 WorkerProcessLauncher::~WorkerProcessLauncher() {
  70   DCHECK(CalledOnValidThread());
  71
  72   ipc_handler_ = NULL;
  73   StopWorker();
  74 }
  75
  76 void WorkerProcessLauncher::Crash(
  77     const tracked_objects::Location& location) {
  78   DCHECK(CalledOnValidThread());
  79
  80   // Ask the worker process to crash voluntarily if it is still connected.
  81   if (ipc_enabled_) {
  82     Send(new ChromotingDaemonMsg_Crash(location.function_name(),
  83                                        location.file_name(),
  84                                        location.line_number()));
  85   }
  86
  87   // Close the channel and ignore any not yet processed messages.
  88   launcher_delegate_->CloseChannel();
  89   ipc_enabled_ = false;
  90
  91   // Give the worker process some time to crash.
  92   if (!kill_process_timer_.IsRunning()) {
  93     kill_process_timer_.Start(FROM_HERE, kill_process_timeout_, this,
  94                               &WorkerProcessLauncher::StopWorker);
  95   }
  96 }
  97
  98 void WorkerProcessLauncher::Send(IPC::Message* message) {
  99   DCHECK(CalledOnValidThread());
 100
 101   if (ipc_enabled_) {
 102     launcher_delegate_->Send(message);
 103   } else {
 104     delete message;
 105   }
 106 }
 107
 108 void WorkerProcessLauncher::OnProcessLaunched(
 109     base::win::ScopedHandle worker_process) {
 110   DCHECK(CalledOnValidThread());
 111   DCHECK(!ipc_enabled_);
 112   DCHECK(!launch_timer_.IsRunning());
 113   DCHECK(!process_watcher_.GetWatchedObject());
 114   DCHECK(!worker_process_.IsValid());
 115
 116   if (!process_watcher_.StartWatching(worker_process, this)) {
 117     StopWorker();
 118     return;
 119   }
 120
 121   ipc_enabled_ = true;
 122   worker_process_ = worker_process.Pass();
 123 }
 124
 125 void WorkerProcessLauncher::OnFatalError() {
 126   DCHECK(CalledOnValidThread());
 127
 128   StopWorker();
 129 }
 130
 131 bool WorkerProcessLauncher::OnMessageReceived(
 132   const IPC::Message& message) {
 133   DCHECK(CalledOnValidThread());
 134
 135   if (!ipc_enabled_)
 136     return false;
 137
 138   return ipc_handler_->OnMessageReceived(message);
 139 }
 140
 141 void WorkerProcessLauncher::OnChannelConnected(int32 peer_pid) {
 142   DCHECK(CalledOnValidThread());
 143
 144   if (!ipc_enabled_)
 145     return;
 146
 147   // This can result in |this| being deleted, so this call must be the last in
 148   // this method.
 149   ipc_handler_->OnChannelConnected(peer_pid);
 150 }
 151
 152 void WorkerProcessLauncher::OnChannelError() {
 153   DCHECK(CalledOnValidThread());
 154
 155   // Schedule a delayed termination of the worker process. Usually, the pipe is
 156   // disconnected when the worker process is about to exit. Waiting a little bit
 157   // here allows the worker to exit completely and so, notify
 158   // |process_watcher_|. As the result KillProcess() will not be called and
 159   // the original exit code reported by the worker process will be retrieved.
 160   if (!kill_process_timer_.IsRunning()) {
 161     kill_process_timer_.Start(FROM_HERE, kill_process_timeout_, this,
 162                               &WorkerProcessLauncher::StopWorker);
 163   }
 164 }
 165
 166 void WorkerProcessLauncher::OnObjectSignaled(HANDLE object) {
 167   DCHECK(CalledOnValidThread());
 168   DCHECK(!process_watcher_.GetWatchedObject());
 169   DCHECK_EQ(exit_code_, CONTROL_C_EXIT);
 170   DCHECK_EQ(worker_process_, object);
 171
 172   // Get exit code of the worker process if it is available.
 173   if (!::GetExitCodeProcess(worker_process_, &exit_code_)) {
 174     LOG_GETLASTERROR(INFO)
 175         << "Failed to query the exit code of the worker process";
 176     exit_code_ = CONTROL_C_EXIT;
 177   }
 178
 179   worker_process_.Close();
 180   StopWorker();
 181 }
 182
 183 void WorkerProcessLauncher::LaunchWorker() {
 184   DCHECK(CalledOnValidThread());
 185   DCHECK(!ipc_enabled_);
 186   DCHECK(!kill_process_timer_.IsRunning());
 187   DCHECK(!launch_timer_.IsRunning());
 188   DCHECK(!process_watcher_.GetWatchedObject());
 189   DCHECK(!launch_result_timer_.IsRunning());
 190
 191   exit_code_ = CONTROL_C_EXIT;
 192
 193   // Make sure launching a process will not take forever.
 194   launch_result_timer_.Start(
 195       FROM_HERE, base::TimeDelta::FromSeconds(kLaunchResultTimeoutSeconds),
 196       this, &WorkerProcessLauncher::RecordLaunchResult);
 197
 198   launcher_delegate_->LaunchProcess(this);
 199 }
 200
 201 void WorkerProcessLauncher::RecordLaunchResult() {
 202   DCHECK(CalledOnValidThread());
 203
 204   if (!worker_process_.IsValid()) {
 205     LOG(WARNING) << "A worker process failed to start within "
 206                  << kLaunchResultTimeoutSeconds << " seconds.";
 207
 208     launch_backoff_.InformOfRequest(false);
 209     StopWorker();
 210     return;
 211   }
 212
 213   // Assume success if the worker process has been running for a few seconds.
 214   launch_backoff_.InformOfRequest(true);
 215 }
 216
 217 void WorkerProcessLauncher::RecordSuccessfulLaunchForTest() {
 218   DCHECK(CalledOnValidThread());
 219
 220   if (launch_result_timer_.IsRunning()) {
 221     launch_result_timer_.Stop();
 222     RecordLaunchResult();
 223   }
 224 }
 225
 226 void WorkerProcessLauncher::SetKillProcessTimeoutForTest(
 227     const base::TimeDelta& timeout) {
 228   DCHECK(CalledOnValidThread());
 229
 230   kill_process_timeout_ = timeout;
 231 }
 232
 233 void WorkerProcessLauncher::StopWorker() {
 234   DCHECK(CalledOnValidThread());
 235
 236   // Record a launch failure if the process exited too soon.
 237   if (launch_result_timer_.IsRunning()) {
 238     launch_backoff_.InformOfRequest(false);
 239     launch_result_timer_.Stop();
 240   }
 241
 242   // Ignore any remaining IPC messages.
 243   ipc_enabled_ = false;
 244
 245   // Stop monitoring the worker process.
 246   process_watcher_.StopWatching();
 247   worker_process_.Close();
 248
 249   kill_process_timer_.Stop();
 250   launcher_delegate_->KillProcess();
 251
 252   // Do not relaunch the worker process if the caller has asked us to stop.
 253   if (stopping())
 254     return;
 255
 256   // Stop trying to restart the worker process if it exited due to
 257   // misconfiguration.
 258   if (kMinPermanentErrorExitCode <= exit_code_ &&
 259       exit_code_ <= kMaxPermanentErrorExitCode) {
 260     ipc_handler_->OnPermanentError();
 261     return;
 262   }
 263
 264   // Schedule the next attempt to launch the worker process.
 265   launch_timer_.Start(FROM_HERE, launch_backoff_.GetTimeUntilRelease(), this,
 266                       &WorkerProcessLauncher::LaunchWorker);
 267 }
 268
 269 } // namespace remoting