remoting/host/config_file_watcher.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/config_file_watcher.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/files/file_path_watcher.h"
  12 #include "base/files/file_util.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/single_thread_task_runner.h"
  16 #include "base/timer/timer.h"
  17
  18 namespace remoting {
  19
  20 // The name of the command-line switch used to specify the host configuration
  21 // file to use.
  22 const char kHostConfigSwitchName[] = "host-config";
  23
  24 const base::FilePath::CharType kDefaultHostConfigFile[] =
  25     FILE_PATH_LITERAL("host.json");
  26
  27 #if defined(OS_WIN)
  28 // Maximum number of times to try reading the configuration file before
  29 // reporting an error.
  30 const int kMaxRetries = 3;
  31 #endif  // defined(OS_WIN)
  32
  33 class ConfigFileWatcherImpl
  34     : public base::RefCountedThreadSafe<ConfigFileWatcherImpl> {
  35  public:
  36   // Creates a configuration file watcher that lives on the |io_task_runner|
  37   // thread but posts config file updates on on |main_task_runner|.
  38   ConfigFileWatcherImpl(
  39       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
  40       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
  41       const base::FilePath& config_path);
  42
  43
  44   // Notify |delegate| of config changes.
  45   void Watch(ConfigWatcher::Delegate* delegate);
  46
  47   // Stops watching the configuration file.
  48   void StopWatching();
  49
  50  private:
  51   friend class base::RefCountedThreadSafe<ConfigFileWatcherImpl>;
  52   virtual ~ConfigFileWatcherImpl();
  53
  54   void FinishStopping();
  55
  56   void WatchOnIoThread();
  57
  58   // Called every time the host configuration file is updated.
  59   void OnConfigUpdated(const base::FilePath& path, bool error);
  60
  61   // Called to notify the delegate of updates/errors in the main thread.
  62   void NotifyUpdate(const std::string& config);
  63   void NotifyError();
  64
  65   // Reads the configuration file and passes it to the delegate.
  66   void ReloadConfig();
  67
  68   std::string config_;
  69   base::FilePath config_path_;
  70
  71   scoped_ptr<base::DelayTimer<ConfigFileWatcherImpl> > config_updated_timer_;
  72
  73   // Number of times an attempt to read the configuration file failed.
  74   int retries_;
  75
  76   // Monitors the host configuration file.
  77   scoped_ptr<base::FilePathWatcher> config_watcher_;
  78
  79   ConfigWatcher::Delegate* delegate_;
  80
  81   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
  82   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
  83
  84   base::WeakPtrFactory<ConfigFileWatcherImpl> weak_factory_;
  85
  86   DISALLOW_COPY_AND_ASSIGN(ConfigFileWatcherImpl);
  87 };
  88
  89 ConfigFileWatcher::ConfigFileWatcher(
  90     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
  91     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
  92     const base::FilePath& config_path)
  93     : impl_(new ConfigFileWatcherImpl(main_task_runner,
  94                                       io_task_runner, config_path)) {
  95 }
  96
  97 ConfigFileWatcher::~ConfigFileWatcher() {
  98   impl_->StopWatching();
  99   impl_ = nullptr;
 100 }
 101
 102 void ConfigFileWatcher::Watch(ConfigWatcher::Delegate* delegate) {
 103   impl_->Watch(delegate);
 104 }
 105
 106 ConfigFileWatcherImpl::ConfigFileWatcherImpl(
 107     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
 108     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
 109     const base::FilePath& config_path)
 110     : config_path_(config_path),
 111       retries_(0),
 112       delegate_(nullptr),
 113       main_task_runner_(main_task_runner),
 114       io_task_runner_(io_task_runner),
 115       weak_factory_(this) {
 116   DCHECK(main_task_runner_->BelongsToCurrentThread());
 117 }
 118
 119 void ConfigFileWatcherImpl::Watch(ConfigWatcher::Delegate* delegate) {
 120   DCHECK(main_task_runner_->BelongsToCurrentThread());
 121   DCHECK(!delegate_);
 122
 123   delegate_ = delegate;
 124
 125   io_task_runner_->PostTask(
 126       FROM_HERE,
 127       base::Bind(&ConfigFileWatcherImpl::WatchOnIoThread, this));
 128 }
 129
 130 void ConfigFileWatcherImpl::WatchOnIoThread() {
 131   DCHECK(io_task_runner_->BelongsToCurrentThread());
 132   DCHECK(!config_updated_timer_);
 133   DCHECK(!config_watcher_);
 134
 135   // Create the timer that will be used for delayed-reading the configuration
 136   // file.
 137   config_updated_timer_.reset(new base::DelayTimer<ConfigFileWatcherImpl>(
 138       FROM_HERE, base::TimeDelta::FromSeconds(2), this,
 139       &ConfigFileWatcherImpl::ReloadConfig));
 140
 141   // Start watching the configuration file.
 142   config_watcher_.reset(new base::FilePathWatcher());
 143   if (!config_watcher_->Watch(
 144           config_path_, false,
 145           base::Bind(&ConfigFileWatcherImpl::OnConfigUpdated, this))) {
 146     PLOG(ERROR) << "Couldn't watch file '" << config_path_.value() << "'";
 147     main_task_runner_->PostTask(
 148         FROM_HERE,
 149         base::Bind(&ConfigFileWatcherImpl::NotifyError,
 150             weak_factory_.GetWeakPtr()));
 151     return;
 152   }
 153
 154   // Force reloading of the configuration file at least once.
 155   ReloadConfig();
 156 }
 157
 158 void ConfigFileWatcherImpl::StopWatching() {
 159   DCHECK(main_task_runner_->BelongsToCurrentThread());
 160
 161   weak_factory_.InvalidateWeakPtrs();
 162   io_task_runner_->PostTask(
 163       FROM_HERE, base::Bind(&ConfigFileWatcherImpl::FinishStopping, this));
 164 }
 165
 166 ConfigFileWatcherImpl::~ConfigFileWatcherImpl() {
 167   DCHECK(!config_updated_timer_);
 168   DCHECK(!config_watcher_);
 169 }
 170
 171 void ConfigFileWatcherImpl::FinishStopping() {
 172   DCHECK(io_task_runner_->BelongsToCurrentThread());
 173
 174   config_updated_timer_.reset();
 175   config_watcher_.reset();
 176 }
 177
 178 void ConfigFileWatcherImpl::OnConfigUpdated(const base::FilePath& path,
 179                                             bool error) {
 180   DCHECK(io_task_runner_->BelongsToCurrentThread());
 181
 182   // Call ReloadConfig() after a short delay, so that we will not try to read
 183   // the updated configuration file before it has been completely written.
 184   // If the writer moves the new configuration file into place atomically,
 185   // this delay may not be necessary.
 186   if (!error && config_path_ == path)
 187     config_updated_timer_->Reset();
 188 }
 189
 190 void ConfigFileWatcherImpl::NotifyError() {
 191   DCHECK(main_task_runner_->BelongsToCurrentThread());
 192
 193   delegate_->OnConfigWatcherError();
 194 }
 195
 196 void ConfigFileWatcherImpl::NotifyUpdate(const std::string& config) {
 197   DCHECK(main_task_runner_->BelongsToCurrentThread());
 198
 199   delegate_->OnConfigUpdated(config_);
 200 }
 201
 202 void ConfigFileWatcherImpl::ReloadConfig() {
 203   DCHECK(io_task_runner_->BelongsToCurrentThread());
 204
 205   std::string config;
 206   if (!base::ReadFileToString(config_path_, &config)) {
 207 #if defined(OS_WIN)
 208     // EACCESS may indicate a locking or sharing violation. Retry a few times
 209     // before reporting an error.
 210     if (errno == EACCES && retries_ < kMaxRetries) {
 211       PLOG(WARNING) << "Failed to read '" << config_path_.value() << "'";
 212
 213       retries_ += 1;
 214       config_updated_timer_->Reset();
 215       return;
 216     }
 217 #endif  // defined(OS_WIN)
 218
 219     PLOG(ERROR) << "Failed to read '" << config_path_.value() << "'";
 220
 221     main_task_runner_->PostTask(
 222         FROM_HERE,
 223         base::Bind(&ConfigFileWatcherImpl::NotifyError,
 224             weak_factory_.GetWeakPtr()));
 225     return;
 226   }
 227
 228   retries_ = 0;
 229
 230   // Post an updated configuration only if it has actually changed.
 231   if (config_ != config) {
 232     config_ = config;
 233     main_task_runner_->PostTask(
 234         FROM_HERE,
 235         base::Bind(&ConfigFileWatcherImpl::NotifyUpdate,
 236             weak_factory_.GetWeakPtr(), config_));
 237   }
 238 }
 239
 240 }  // namespace remoting