Home | History | Annotate | Download | only in cloud 
      1 // Copyright (c) 2013 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 #ifndef COMPONENTS_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_UPDATER_H_
      6 #define COMPONENTS_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_UPDATER_H_
      7 
      8 #include <map>
      9 #include <queue>
     10 #include <string>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/callback_forward.h"
     14 #include "base/memory/ref_counted.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/weak_ptr.h"
     17 #include "components/policy/policy_export.h"
     18 
     19 namespace base {
     20 class SequencedTaskRunner;
     21 }
     22 
     23 namespace policy {
     24 
     25 class ExternalPolicyDataFetcher;
     26 
     27 // This class downloads external policy data. Given a |Request|, data is fetched
     28 // from the |url|, verified to not exceed |max_size| and to match the expected
     29 // |hash| and then handed to a callback that can do further verification before
     30 // finally deciding whether the fetched data is valid.
     31 // If a fetch is not successful or retrieves invalid data, retries are scheduled
     32 // with exponential backoff.
     33 // The actual fetching is handled by an ExternalPolicyDataFetcher, allowing this
     34 // class to run on a background thread where network I/O is not possible.
     35 class POLICY_EXPORT ExternalPolicyDataUpdater {
     36  public:
     37   struct POLICY_EXPORT Request {
     38    public:
     39     Request();
     40     Request(const std::string& url, const std::string& hash, int64 max_size);
     41 
     42     bool operator==(const Request& other) const;
     43 
     44     std::string url;
     45     std::string hash;
     46     int64 max_size;
     47   };
     48 
     49   // This callback is invoked when a fetch has successfully retrieved |data|
     50   // that does not exceed |max_size| and matches the expected |hash|. The
     51   // callback can do further verification to decide whether the fetched data is
     52   // valid.
     53   // If the callback returns |true|, the data is accepted and the |Request| is
     54   // finished. If the callback returns |false|, the data is rejected and the
     55   // fetch is retried after a long backoff. Note that in this case, the callback
     56   // may be invoked multiple times as the fetch is repeated. Make sure to not
     57   // bind base::Passed() scoped_ptrs to the callback in such cases as these
     58   // become invalid after a callback has been run once. base::Owned() can be
     59   // used in all cases.
     60   typedef base::Callback<bool(const std::string&)> FetchSuccessCallback;
     61 
     62   // This class runs on the background thread represented by |task_runner|,
     63   // which must support file I/O. All network I/O is forwarded to a different
     64   // thread by the |external_policy_data_fetcher|.
     65   ExternalPolicyDataUpdater(
     66       scoped_refptr<base::SequencedTaskRunner> task_runner,
     67       scoped_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher,
     68       size_t max_parallel_fetches);
     69   ~ExternalPolicyDataUpdater();
     70 
     71   // Fetches the external data specified in the |request|. The |key| is an
     72   // opaque identifier. If another request for the same |key| is still pending,
     73   // it will be canceled and replaced with the new |request|. The callback will
     74   // be invoked after a successful fetch. See the documentation of
     75   // |FetchSuccessCallback| for more details.
     76   void FetchExternalData(const std::string key,
     77                          const Request& request,
     78                          const FetchSuccessCallback& callback);
     79 
     80   // Cancels the pending request identified by |key|. If no such request is
     81   // pending, does nothing.
     82   void CancelExternalDataFetch(const std::string& key);
     83 
     84  private:
     85   class FetchJob;
     86 
     87   // Starts jobs from the |job_queue_| until |max_parallel_jobs_| are running or
     88   // the queue is depleted.
     89   void StartNextJobs();
     90 
     91   // Appends |job| to the |job_queue_| and starts it immediately if less than
     92   // |max_parallel_jobs_| are running.
     93   void ScheduleJob(FetchJob* job);
     94 
     95   // Callback for jobs that succeeded.
     96   void OnJobSucceeded(FetchJob* job);
     97 
     98   // Callback for jobs that failed.
     99   void OnJobFailed(FetchJob* job);
    100 
    101   scoped_refptr<base::SequencedTaskRunner> task_runner_;
    102   scoped_ptr<ExternalPolicyDataFetcher> external_policy_data_fetcher_;
    103 
    104   // The maximum number of jobs to run in parallel.
    105   size_t max_parallel_jobs_;
    106 
    107   // The number of jobs currently running.
    108   size_t running_jobs_;
    109 
    110   // Queue of jobs waiting to be run. Jobs are taken off the queue and started
    111   // by StartNextJobs().
    112   std::queue<base::WeakPtr<FetchJob> > job_queue_;
    113 
    114   // Map that owns all existing jobs, regardless of whether they are currently
    115   // queued, running or waiting for a retry.
    116   std::map<std::string, FetchJob*> job_map_;
    117 
    118   // |True| once the destructor starts. Prevents jobs from being started during
    119   // shutdown.
    120   bool shutting_down_;
    121 
    122   DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataUpdater);
    123 };
    124 
    125 }  // namespace policy
    126 
    127 #endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_UPDATER_H_
    128