Remote fetch device status (attributes and logs) command

chrome/browser/chromeos/policy/system_log_uploader.cc

 // Copyright (c) 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "chrome/browser/chromeos/policy/system_log_uploader.h"
+
+#include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/syslog_logging.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/feedback/anonymizer_tool.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "net/http/http_request_headers.h"
-#include "system_log_uploader.h"
 
 namespace {
 // The maximum number of successive retries.
 const int kMaxNumRetries = 1;
 
 // String constant defining the url tail we upload system logs to.
 const char* kSystemLogUploadUrlTail = "/upload";
 
 // The file names of the system logs to upload.
 // Note: do not add anything to this list without checking for PII in the file.
@@ skipping 157 matching lines @@
   // immediate future).
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 SystemLogUploader::~SystemLogUploader() {}
 
 void SystemLogUploader::OnSuccess() {
   SYSLOG(INFO) << "Upload successful.";
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
+  log_upload_in_progress_ = false;
   retry_count_ = 0;
 
   // On successful log upload schedule the next log upload after
   // upload_frequency_ time from now.
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 void SystemLogUploader::OnFailure(UploadJob::ErrorCode error_code) {
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
+  log_upload_in_progress_ = false;
 
   //  If we have hit the maximum number of retries, terminate this upload
   //  attempt and schedule the next one using the normal delay. Otherwise, retry
   //  uploading after kErrorUploadDelayMs milliseconds.
   if (retry_count_++ < kMaxNumRetries) {
     SYSLOG(ERROR) << "Upload failed with error code " << error_code
                   << ", retrying later.";
     ScheduleNextSystemLogUpload(
         base::TimeDelta::FromMilliseconds(kErrorUploadDelayMs));
   } else {
     // No more retries.
     SYSLOG(ERROR) << "Upload failed with error code " << error_code
                   << ", no more retries.";
     retry_count_ = 0;
     ScheduleNextSystemLogUpload(upload_frequency_);
   }
 }
 
 // static
 std::string SystemLogUploader::RemoveSensitiveData(
     feedback::AnonymizerTool* const anonymizer,
     const std::string& data) {
   return anonymizer->Anonymize(data);
 }
 
+void SystemLogUploader::ScheduleNextSystemLogUploadImmediately() {
+  ScheduleNextSystemLogUpload(base::TimeDelta());
+}
+
 void SystemLogUploader::RefreshUploadSettings() {
   // Attempt to fetch the current value of the reporting settings.
   // If trusted values are not available, register this function to be called
   // back when they are available.
   chromeos::CrosSettings* settings = chromeos::CrosSettings::Get();
   if (chromeos::CrosSettingsProvider::TRUSTED !=
       settings->PrepareTrustedValues(
           base::Bind(&SystemLogUploader::RefreshUploadSettings,
                      weak_factory_.GetWeakPtr()))) {
     return;
@@ skipping 34 matching lines @@
   }
   upload_job_->Start();
 }
 
 void SystemLogUploader::StartLogUpload() {
   // Must be called on the main thread.
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (upload_enabled_) {
     SYSLOG(INFO) << "Starting system log upload.";
+    log_upload_in_progress_ = true;
     syslog_delegate_->LoadSystemLogs(base::Bind(
         &SystemLogUploader::UploadSystemLogs, weak_factory_.GetWeakPtr()));
   } else {
     // If upload is disabled, schedule the next attempt after 12h.
+    SYSLOG(INFO) << "System log upload is disabled, rescheduling.";
     retry_count_ = 0;
     last_upload_attempt_ = base::Time::NowFromSystemTime();
     ScheduleNextSystemLogUpload(upload_frequency_);
   }
 }
 
 void SystemLogUploader::ScheduleNextSystemLogUpload(base::TimeDelta frequency) {
+  // Don't schedule a new system log upload if there's a log upload in progress
+  // (it will be scheduled once the current one completes).
+  if (log_upload_in_progress_)
+    return;
+
   // Calculate when to fire off the next update.
   base::TimeDelta delay = std::max(
       (last_upload_attempt_ + frequency) - base::Time::NowFromSystemTime(),
       base::TimeDelta());
   SYSLOG(INFO) << "Scheduling next system log upload " << delay << " from now.";
   // Ensure that we never have more than one pending delayed task.
   weak_factory_.InvalidateWeakPtrs();

[Andrew T Wilson (Slow), 2017/03/21 18:03:42]

I thought there was a race condition in this code, but there isn't because this
call to InvalidateWeakPtrs() will invalidate any pending calls to
StartLogUpload(). It took me a few minutes to convince myself this is race-free,
so perhaps you should add a comment to this effect (why we can't get two log
uploads even if there's one queued up on the current thread).

[Ivan Šandrk, 2017/03/22 20:20:02]

Done.

   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&SystemLogUploader::StartLogUpload,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 }
 
 }  // namespace policy