1//
2// Copyright (C) 2012 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/real_system_state.h"
18
19#include <string>
20
21#include <base/bind.h>
22#include <base/files/file_util.h>
23#include <base/location.h>
24#include <base/time/time.h>
25#include <brillo/make_unique_ptr.h>
26#include <brillo/message_loops/message_loop.h>
27
28#include "update_engine/common/boot_control.h"
29#include "update_engine/common/boot_control_stub.h"
30#include "update_engine/common/constants.h"
31#include "update_engine/common/hardware.h"
32#include "update_engine/common/utils.h"
33#include "update_engine/update_manager/state_factory.h"
34#include "update_engine/weave_service_factory.h"
35
36using brillo::MessageLoop;
37
38namespace chromeos_update_engine {
39
40RealSystemState::RealSystemState(const scoped_refptr<dbus::Bus>& bus)
41    : debugd_proxy_(bus),
42      power_manager_proxy_(bus),
43      session_manager_proxy_(bus),
44      shill_proxy_(bus),
45      libcros_proxy_(bus) {
46}
47
48RealSystemState::~RealSystemState() {
49  // Prevent any DBus communication from UpdateAttempter when shutting down the
50  // daemon.
51  if (update_attempter_)
52    update_attempter_->ClearObservers();
53}
54
55bool RealSystemState::Initialize() {
56  metrics_lib_.Init();
57
58  boot_control_ = boot_control::CreateBootControl();
59  if (!boot_control_) {
60    LOG(WARNING) << "Unable to create BootControl instance, using stub "
61                 << "instead. All update attempts will fail.";
62    boot_control_ = brillo::make_unique_ptr(new BootControlStub());
63  }
64
65  hardware_ = hardware::CreateHardware();
66  if (!hardware_) {
67    LOG(ERROR) << "Error intializing the HardwareInterface.";
68    return false;
69  }
70
71  LOG_IF(INFO, !hardware_->IsNormalBootMode()) << "Booted in dev mode.";
72  LOG_IF(INFO, !hardware_->IsOfficialBuild()) << "Booted non-official build.";
73
74  if (!shill_proxy_.Init()) {
75    LOG(ERROR) << "Failed to initialize shill proxy.";
76    return false;
77  }
78
79  // Initialize standard and powerwash-safe prefs.
80  base::FilePath non_volatile_path;
81  // TODO(deymo): Fall back to in-memory prefs if there's no physical directory
82  // available.
83  if (!hardware_->GetNonVolatileDirectory(&non_volatile_path)) {
84    LOG(ERROR) << "Failed to get a non-volatile directory.";
85    return false;
86  }
87  Prefs* prefs;
88  prefs_.reset(prefs = new Prefs());
89  if (!prefs->Init(non_volatile_path.Append(kPrefsSubDirectory))) {
90    LOG(ERROR) << "Failed to initialize preferences.";
91    return false;
92  }
93
94  base::FilePath powerwash_safe_path;
95  if (!hardware_->GetPowerwashSafeDirectory(&powerwash_safe_path)) {
96    // TODO(deymo): Fall-back to in-memory prefs if there's no powerwash-safe
97    // directory, or disable powerwash feature.
98    powerwash_safe_path = non_volatile_path.Append("powerwash-safe");
99    LOG(WARNING) << "No powerwash-safe directory, using non-volatile one.";
100  }
101  powerwash_safe_prefs_.reset(prefs = new Prefs());
102  if (!prefs->Init(
103          powerwash_safe_path.Append(kPowerwashSafePrefsSubDirectory))) {
104    LOG(ERROR) << "Failed to initialize powerwash preferences.";
105    return false;
106  }
107
108  // Check the system rebooted marker file.
109  std::string boot_id;
110  if (utils::GetBootId(&boot_id)) {
111    std::string prev_boot_id;
112    system_rebooted_ = (!prefs_->GetString(kPrefsBootId, &prev_boot_id) ||
113                        prev_boot_id != boot_id);
114    prefs_->SetString(kPrefsBootId, boot_id);
115  } else {
116    LOG(WARNING) << "Couldn't detect the bootid, assuming system was rebooted.";
117    system_rebooted_ = true;
118  }
119
120  // Initialize the OmahaRequestParams with the default settings. These settings
121  // will be re-initialized before every request using the actual request
122  // options. This initialization here pre-loads current channel and version, so
123  // the DBus service can access it.
124  if (!request_params_.Init("", "", false)) {
125    LOG(WARNING) << "Ignoring OmahaRequestParams initialization error. Some "
126                    "features might not work properly.";
127  }
128
129  certificate_checker_.reset(
130      new CertificateChecker(prefs_.get(), &openssl_wrapper_));
131  certificate_checker_->Init();
132
133  // Initialize the UpdateAttempter before the UpdateManager.
134  update_attempter_.reset(
135      new UpdateAttempter(this, certificate_checker_.get(), &libcros_proxy_,
136                          &debugd_proxy_));
137  update_attempter_->Init();
138
139  weave_service_ = ConstructWeaveService(update_attempter_.get());
140  if (weave_service_)
141    update_attempter_->AddObserver(weave_service_.get());
142
143  // Initialize the Update Manager using the default state factory.
144  chromeos_update_manager::State* um_state =
145      chromeos_update_manager::DefaultStateFactory(
146          &policy_provider_, &shill_proxy_, &session_manager_proxy_, this);
147  if (!um_state) {
148    LOG(ERROR) << "Failed to initialize the Update Manager.";
149    return false;
150  }
151  update_manager_.reset(
152      new chromeos_update_manager::UpdateManager(
153          &clock_, base::TimeDelta::FromSeconds(5),
154          base::TimeDelta::FromHours(12), um_state));
155
156  // The P2P Manager depends on the Update Manager for its initialization.
157  p2p_manager_.reset(P2PManager::Construct(
158          nullptr, &clock_, update_manager_.get(), "cros_au",
159          kMaxP2PFilesToKeep, base::TimeDelta::FromDays(kMaxP2PFileAgeDays)));
160
161  if (!payload_state_.Initialize(this)) {
162    LOG(ERROR) << "Failed to initialize the payload state object.";
163    return false;
164  }
165
166  // All is well. Initialization successful.
167  return true;
168}
169
170bool RealSystemState::StartUpdater() {
171  // Initiate update checks.
172  update_attempter_->ScheduleUpdates();
173
174  // Update boot flags after 45 seconds.
175  MessageLoop::current()->PostDelayedTask(
176      FROM_HERE,
177      base::Bind(&UpdateAttempter::UpdateBootFlags,
178                 base::Unretained(update_attempter_.get())),
179      base::TimeDelta::FromSeconds(45));
180
181  // Broadcast the update engine status on startup to ensure consistent system
182  // state on crashes.
183  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
184      &UpdateAttempter::BroadcastStatus,
185      base::Unretained(update_attempter_.get())));
186
187  // Run the UpdateEngineStarted() method on |update_attempter|.
188  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
189      &UpdateAttempter::UpdateEngineStarted,
190      base::Unretained(update_attempter_.get())));
191  return true;
192}
193
194void RealSystemState::AddObserver(ServiceObserverInterface* observer) {
195  CHECK(update_attempter_.get());
196  update_attempter_->AddObserver(observer);
197}
198
199void RealSystemState::RemoveObserver(ServiceObserverInterface* observer) {
200  CHECK(update_attempter_.get());
201  update_attempter_->RemoveObserver(observer);
202}
203
204}  // namespace chromeos_update_engine
205