Home | History | Annotate | Download | only in update_engine 
      1 //
      2 // Copyright (C) 2015 The Android Open Source Project
      3 //
      4 // Licensed under the Apache License, Version 2.0 (the "License");
      5 // you may not use this file except in compliance with the License.
      6 // You may obtain a copy of the License at
      7 //
      8 //      http://www.apache.org/licenses/LICENSE-2.0
      9 //
     10 // Unless required by applicable law or agreed to in writing, software
     11 // distributed under the License is distributed on an "AS IS" BASIS,
     12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13 // See the License for the specific language governing permissions and
     14 // limitations under the License.
     15 //
     16 
     17 #include "update_engine/weave_service.h"
     18 
     19 #include <cmath>
     20 #include <string>
     21 
     22 #include <base/bind.h>
     23 #include <brillo/errors/error.h>
     24 #include <brillo/message_loops/message_loop.h>
     25 
     26 #include "update_engine/update_status_utils.h"
     27 
     28 using std::string;
     29 
     30 namespace {
     31 
     32 const char kWeaveComponent[] = "updater";
     33 const char kWeaveTrait[] = "_updater";
     34 
     35 }  // namespace
     36 
     37 namespace chromeos_update_engine {
     38 
     39 bool WeaveService::Init(DelegateInterface* delegate) {
     40   delegate_ = delegate;
     41   weave_service_subscription_ = weaved::Service::Connect(
     42       brillo::MessageLoop::current(),
     43       base::Bind(&WeaveService::OnWeaveServiceConnected,
     44                  base::Unretained(this)));
     45   return true;
     46 }
     47 
     48 void WeaveService::OnWeaveServiceConnected(
     49     const std::weak_ptr<weaved::Service>& service) {
     50   weave_service_ = service;
     51   auto weave_service = weave_service_.lock();
     52   if (!weave_service)
     53     return;
     54 
     55   weave_service->AddComponent(kWeaveComponent, {kWeaveTrait}, nullptr);
     56   weave_service->AddCommandHandler(
     57       kWeaveComponent, kWeaveTrait, "checkForUpdates",
     58       base::Bind(&WeaveService::OnCheckForUpdates, base::Unretained(this)));
     59   weave_service->AddCommandHandler(
     60       kWeaveComponent, kWeaveTrait, "trackChannel",
     61       base::Bind(&WeaveService::OnTrackChannel, base::Unretained(this)));
     62   UpdateWeaveState();
     63 }
     64 
     65 void WeaveService::SendStatusUpdate(int64_t /* last_checked_time */,
     66                                     double /* progress */,
     67                                     update_engine::UpdateStatus /* status */,
     68                                     const string& /* new_version */,
     69                                     int64_t /* new_size */) {
     70   // We query the Weave
     71   UpdateWeaveState();
     72 }
     73 
     74 void WeaveService::SendChannelChangeUpdate(
     75     const string& /* tracking_channel */) {
     76   UpdateWeaveState();
     77 }
     78 
     79 void WeaveService::UpdateWeaveState() {
     80   auto weave_service = weave_service_.lock();
     81   if (!weave_service || !delegate_)
     82     return;
     83 
     84   int64_t last_checked_time;
     85   double progress;
     86   update_engine::UpdateStatus update_status;
     87   string current_channel;
     88   string tracking_channel;
     89 
     90   if (!delegate_->GetWeaveState(&last_checked_time,
     91                                 &progress,
     92                                 &update_status,
     93                                 &current_channel,
     94                                 &tracking_channel))
     95     return;
     96 
     97   // Round to progress to 1% (0.01) to avoid excessive and meaningless state
     98   // changes.
     99   progress = std::floor(progress * 100.) / 100.;
    100 
    101   base::DictionaryValue state;
    102   state.SetString("_updater.currentChannel", current_channel);
    103   state.SetString("_updater.trackingChannel", tracking_channel);
    104   state.SetString("_updater.status", UpdateStatusToWeaveStatus(update_status));
    105   state.SetDouble("_updater.progress", progress);
    106   state.SetDouble("_updater.lastUpdateCheckTimestamp",
    107                   static_cast<double>(last_checked_time));
    108 
    109   if (!weave_service->SetStateProperties(kWeaveComponent, state, nullptr)) {
    110     LOG(ERROR) << "Failed to update _updater state.";
    111   }
    112 }
    113 
    114 void WeaveService::OnCheckForUpdates(std::unique_ptr<weaved::Command> command) {
    115   brillo::ErrorPtr error;
    116   if (!delegate_->OnCheckForUpdates(&error)) {
    117     command->AbortWithCustomError(error.get(), nullptr);
    118     return;
    119   }
    120   command->Complete({}, nullptr);
    121 }
    122 
    123 void WeaveService::OnTrackChannel(std::unique_ptr<weaved::Command> command) {
    124   string channel = command->GetParameter<string>("channel");
    125   brillo::ErrorPtr error;
    126   if (!delegate_->OnTrackChannel(channel, &error)) {
    127     command->AbortWithCustomError(error.get(), nullptr);
    128     return;
    129   }
    130   command->Complete({}, nullptr);
    131 }
    132 
    133 }  // namespace chromeos_update_engine
    134