Home | History | Annotate | Download | only in cloud 
      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 "components/policy/core/common/cloud/cloud_policy_service.h"
      6 
      7 #include "base/callback.h"
      8 #include "policy/proto/device_management_backend.pb.h"
      9 
     10 namespace em = enterprise_management;
     11 
     12 namespace policy {
     13 
     14 CloudPolicyService::CloudPolicyService(const PolicyNamespaceKey& policy_ns_key,
     15                                        CloudPolicyClient* client,
     16                                        CloudPolicyStore* store)
     17     : policy_ns_key_(policy_ns_key),
     18       client_(client),
     19       store_(store),
     20       refresh_state_(REFRESH_NONE),
     21       initialization_complete_(false) {
     22   client_->AddNamespaceToFetch(policy_ns_key_);
     23   client_->AddObserver(this);
     24   store_->AddObserver(this);
     25 
     26   // Make sure we initialize |client_| from the policy data that might be
     27   // already present in |store_|.
     28   OnStoreLoaded(store_);
     29 }
     30 
     31 CloudPolicyService::~CloudPolicyService() {
     32   client_->RemoveNamespaceToFetch(policy_ns_key_);
     33   client_->RemoveObserver(this);
     34   store_->RemoveObserver(this);
     35 }
     36 
     37 std::string CloudPolicyService::ManagedBy() const {
     38   const em::PolicyData* policy = store_->policy();
     39   if (policy) {
     40     std::string username = policy->username();
     41     std::size_t pos = username.find('@');
     42     if (pos != std::string::npos)
     43       return username.substr(pos + 1);
     44   }
     45   return std::string();
     46 }
     47 
     48 void CloudPolicyService::RefreshPolicy(const RefreshPolicyCallback& callback) {
     49   // If the client is not registered, bail out.
     50   if (!client_->is_registered()) {
     51     callback.Run(false);
     52     return;
     53   }
     54 
     55   // Else, trigger a refresh.
     56   refresh_callbacks_.push_back(callback);
     57   refresh_state_ = REFRESH_POLICY_FETCH;
     58   client_->FetchPolicy();
     59 }
     60 
     61 void CloudPolicyService::OnPolicyFetched(CloudPolicyClient* client) {
     62   if (client_->status() != DM_STATUS_SUCCESS) {
     63     RefreshCompleted(false);
     64     return;
     65   }
     66 
     67   const em::PolicyFetchResponse* policy = client_->GetPolicyFor(policy_ns_key_);
     68   if (policy) {
     69     if (refresh_state_ != REFRESH_NONE)
     70       refresh_state_ = REFRESH_POLICY_STORE;
     71     store_->Store(*policy, client->fetched_invalidation_version());
     72   } else {
     73     RefreshCompleted(false);
     74   }
     75 }
     76 
     77 void CloudPolicyService::OnRegistrationStateChanged(CloudPolicyClient* client) {
     78 }
     79 
     80 void CloudPolicyService::OnClientError(CloudPolicyClient* client) {
     81   if (refresh_state_ == REFRESH_POLICY_FETCH)
     82     RefreshCompleted(false);
     83 }
     84 
     85 void CloudPolicyService::OnStoreLoaded(CloudPolicyStore* store) {
     86   // Update the client with state from the store.
     87   const em::PolicyData* policy(store_->policy());
     88 
     89   // Timestamp.
     90   base::Time policy_timestamp;
     91   if (policy && policy->has_timestamp()) {
     92     policy_timestamp =
     93         base::Time::UnixEpoch() +
     94         base::TimeDelta::FromMilliseconds(policy->timestamp());
     95   }
     96   client_->set_last_policy_timestamp(policy_timestamp);
     97 
     98   // Public key version.
     99   if (policy && policy->has_public_key_version())
    100     client_->set_public_key_version(policy->public_key_version());
    101   else
    102     client_->clear_public_key_version();
    103 
    104   // Whether to submit the machine ID.
    105   bool submit_machine_id = false;
    106   if (policy && policy->has_valid_serial_number_missing())
    107     submit_machine_id = policy->valid_serial_number_missing();
    108   client_->set_submit_machine_id(submit_machine_id);
    109 
    110   // Finally, set up registration if necessary.
    111   if (policy && policy->has_request_token() && policy->has_device_id() &&
    112       !client_->is_registered()) {
    113     DVLOG(1) << "Setting up registration with request token: "
    114              << policy->request_token();
    115     client_->SetupRegistration(policy->request_token(),
    116                                policy->device_id());
    117   }
    118 
    119   if (refresh_state_ == REFRESH_POLICY_STORE)
    120     RefreshCompleted(true);
    121 
    122   CheckInitializationCompleted();
    123 }
    124 
    125 void CloudPolicyService::OnStoreError(CloudPolicyStore* store) {
    126   if (refresh_state_ == REFRESH_POLICY_STORE)
    127     RefreshCompleted(false);
    128   CheckInitializationCompleted();
    129 }
    130 
    131 void CloudPolicyService::CheckInitializationCompleted() {
    132   if (!IsInitializationComplete() && store_->is_initialized()) {
    133     initialization_complete_ = true;
    134     FOR_EACH_OBSERVER(Observer, observers_, OnInitializationCompleted(this));
    135   }
    136 }
    137 
    138 void CloudPolicyService::RefreshCompleted(bool success) {
    139   // Clear state and |refresh_callbacks_| before actually invoking them, s.t.
    140   // triggering new policy fetches behaves as expected.
    141   std::vector<RefreshPolicyCallback> callbacks;
    142   callbacks.swap(refresh_callbacks_);
    143   refresh_state_ = REFRESH_NONE;
    144 
    145   for (std::vector<RefreshPolicyCallback>::iterator callback(callbacks.begin());
    146        callback != callbacks.end();
    147        ++callback) {
    148     callback->Run(success);
    149   }
    150 }
    151 
    152 void CloudPolicyService::AddObserver(Observer* observer) {
    153   observers_.AddObserver(observer);
    154 }
    155 
    156 void CloudPolicyService::RemoveObserver(Observer* observer) {
    157   observers_.RemoveObserver(observer);
    158 }
    159 
    160 }  // namespace policy
    161