Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 1 | // Copyright 2014 The Chromium OS 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 "buffet/manager.h" |
| 6 | |
Alex Vakulenko | 7c3226e | 2014-05-07 17:35:24 -0700 | [diff] [blame] | 7 | #include <map> |
| 8 | #include <string> |
| 9 | |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 10 | #include <base/bind.h> |
| 11 | #include <base/bind_helpers.h> |
Alex Vakulenko | 4f7778e | 2014-09-11 16:57:24 -0700 | [diff] [blame] | 12 | #include <base/json/json_reader.h> |
Christopher Wiley | 2ffa004 | 2014-05-05 16:09:16 -0700 | [diff] [blame] | 13 | #include <base/json/json_writer.h> |
Alex Vakulenko | 24e5f5d | 2014-08-27 11:00:57 -0700 | [diff] [blame] | 14 | #include <chromeos/dbus/async_event_sequencer.h> |
| 15 | #include <chromeos/dbus/exported_object_manager.h> |
| 16 | #include <chromeos/errors/error.h> |
Christopher Wiley | 2ffa004 | 2014-05-05 16:09:16 -0700 | [diff] [blame] | 17 | #include <dbus/bus.h> |
Christopher Wiley | 54028f9 | 2014-04-01 17:33:29 -0700 | [diff] [blame] | 18 | #include <dbus/object_path.h> |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 19 | #include <dbus/values_util.h> |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 20 | |
Alex Vakulenko | 4f7778e | 2014-09-11 16:57:24 -0700 | [diff] [blame] | 21 | #include "buffet/commands/command_instance.h" |
Alex Vakulenko | cf9c146 | 2014-07-23 10:57:58 -0700 | [diff] [blame] | 22 | #include "buffet/commands/command_manager.h" |
Alex Vakulenko | b511e56 | 2014-09-12 10:27:23 -0700 | [diff] [blame] | 23 | #include "buffet/libbuffet/dbus_constants.h" |
Alex Vakulenko | ecf961a | 2014-10-28 13:50:16 -0700 | [diff] [blame] | 24 | #include "buffet/states/state_change_queue.h" |
Alex Vakulenko | 95877b5 | 2014-09-19 15:31:09 -0700 | [diff] [blame] | 25 | #include "buffet/states/state_manager.h" |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 26 | |
Christopher Wiley | 68c07cc | 2014-07-29 14:07:10 -0700 | [diff] [blame] | 27 | using chromeos::dbus_utils::AsyncEventSequencer; |
Christopher Wiley | 1aa980e | 2014-08-11 10:51:20 -0700 | [diff] [blame] | 28 | using chromeos::dbus_utils::ExportedObjectManager; |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 29 | |
| 30 | namespace buffet { |
| 31 | |
Alex Vakulenko | ecf961a | 2014-10-28 13:50:16 -0700 | [diff] [blame] | 32 | namespace { |
| 33 | // Max of 100 state update events should be enough in the queue. |
| 34 | const size_t kMaxStateChangeQueueSize = 100; |
| 35 | } // anonymous namespace |
| 36 | |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 37 | Manager::Manager(const base::WeakPtr<ExportedObjectManager>& object_manager) |
| 38 | : dbus_object_(object_manager.get(), |
| 39 | object_manager->GetBus(), |
| 40 | dbus::ObjectPath(dbus_constants::kManagerServicePath)) {} |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 41 | |
Alex Vakulenko | ecf961a | 2014-10-28 13:50:16 -0700 | [diff] [blame] | 42 | Manager::~Manager() {} |
| 43 | |
Alex Vakulenko | 4a8d9de | 2014-08-24 15:05:06 -0700 | [diff] [blame] | 44 | void Manager::RegisterAsync(const AsyncEventSequencer::CompletionAction& cb) { |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 45 | chromeos::dbus_utils::DBusInterface* itf = |
| 46 | dbus_object_.AddOrGetInterface(dbus_constants::kManagerInterface); |
Anton Muhin | 914b138 | 2014-10-01 18:06:54 +0400 | [diff] [blame] | 47 | itf->AddMethodHandler(dbus_constants::kManagerStartDevice, |
| 48 | base::Unretained(this), |
| 49 | &Manager::HandleStartDevice); |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 50 | itf->AddMethodHandler(dbus_constants::kManagerCheckDeviceRegistered, |
| 51 | base::Unretained(this), |
| 52 | &Manager::HandleCheckDeviceRegistered); |
| 53 | itf->AddMethodHandler(dbus_constants::kManagerGetDeviceInfo, |
| 54 | base::Unretained(this), |
| 55 | &Manager::HandleGetDeviceInfo); |
Anton Muhin | 9cc03fd | 2014-10-16 18:59:57 +0400 | [diff] [blame] | 56 | itf->AddMethodHandler(dbus_constants::kManagerRegisterDevice, |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 57 | base::Unretained(this), |
Anton Muhin | 9cc03fd | 2014-10-16 18:59:57 +0400 | [diff] [blame] | 58 | &Manager::HandleRegisterDevice); |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 59 | itf->AddMethodHandler(dbus_constants::kManagerUpdateStateMethod, |
| 60 | base::Unretained(this), |
| 61 | &Manager::HandleUpdateState); |
Alex Vakulenko | 4f7778e | 2014-09-11 16:57:24 -0700 | [diff] [blame] | 62 | itf->AddMethodHandler(dbus_constants::kManagerAddCommand, |
| 63 | base::Unretained(this), |
| 64 | &Manager::HandleAddCommand); |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 65 | itf->AddMethodHandler(dbus_constants::kManagerTestMethod, |
| 66 | base::Unretained(this), |
| 67 | &Manager::HandleTestMethod); |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 68 | dbus_object_.RegisterAsync(cb); |
Alex Vakulenko | 05fa681 | 2014-09-03 16:27:21 -0700 | [diff] [blame] | 69 | command_manager_ = |
| 70 | std::make_shared<CommandManager>(dbus_object_.GetObjectManager()); |
Alex Vakulenko | cf9c146 | 2014-07-23 10:57:58 -0700 | [diff] [blame] | 71 | command_manager_->Startup(); |
Alex Vakulenko | ecf961a | 2014-10-28 13:50:16 -0700 | [diff] [blame] | 72 | state_change_queue_ = std::unique_ptr<StateChangeQueue>( |
| 73 | new StateChangeQueue(kMaxStateChangeQueueSize)); |
| 74 | state_manager_ = std::make_shared<StateManager>(state_change_queue_.get()); |
Alex Vakulenko | 95877b5 | 2014-09-19 15:31:09 -0700 | [diff] [blame] | 75 | state_manager_->Startup(); |
Alex Vakulenko | 98025c2 | 2014-07-23 11:13:15 -0700 | [diff] [blame] | 76 | device_info_ = std::unique_ptr<DeviceRegistrationInfo>( |
Alex Vakulenko | 95877b5 | 2014-09-19 15:31:09 -0700 | [diff] [blame] | 77 | new DeviceRegistrationInfo(command_manager_, state_manager_)); |
Alex Vakulenko | 98025c2 | 2014-07-23 11:13:15 -0700 | [diff] [blame] | 78 | device_info_->Load(); |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 79 | } |
| 80 | |
Anton Muhin | 914b138 | 2014-10-01 18:06:54 +0400 | [diff] [blame] | 81 | void Manager::HandleStartDevice(chromeos::ErrorPtr* error) { |
| 82 | LOG(INFO) << "Received call to Manager.StartDevice()"; |
Anton Muhin | dd6d828 | 2014-10-02 20:37:00 +0400 | [diff] [blame] | 83 | |
| 84 | device_info_->StartDevice(error); |
Anton Muhin | 914b138 | 2014-10-01 18:06:54 +0400 | [diff] [blame] | 85 | } |
| 86 | |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 87 | std::string Manager::HandleCheckDeviceRegistered(chromeos::ErrorPtr* error) { |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 88 | LOG(INFO) << "Received call to Manager.CheckDeviceRegistered()"; |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 89 | std::string device_id; |
| 90 | bool registered = device_info_->CheckRegistration(error); |
Alex Vakulenko | 7c3226e | 2014-05-07 17:35:24 -0700 | [diff] [blame] | 91 | // If it fails due to any reason other than 'device not registered', |
| 92 | // treat it as a real error and report it to the caller. |
| 93 | if (!registered && |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 94 | !(*error)->HasError(kErrorDomainGCD, "device_not_registered")) { |
| 95 | return device_id; |
Alex Vakulenko | 7c3226e | 2014-05-07 17:35:24 -0700 | [diff] [blame] | 96 | } |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 97 | |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 98 | error->reset(); |
| 99 | |
| 100 | if (registered) |
| 101 | device_id = device_info_->GetDeviceId(error); |
| 102 | |
| 103 | return device_id; |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 106 | std::string Manager::HandleGetDeviceInfo(chromeos::ErrorPtr* error) { |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 107 | LOG(INFO) << "Received call to Manager.GetDeviceInfo()"; |
| 108 | |
| 109 | std::string device_info_str; |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 110 | auto device_info = device_info_->GetDeviceInfo(error); |
Alex Vakulenko | 7c3226e | 2014-05-07 17:35:24 -0700 | [diff] [blame] | 111 | if (!device_info) |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 112 | return device_info_str; |
Alex Vakulenko | 7c3226e | 2014-05-07 17:35:24 -0700 | [diff] [blame] | 113 | |
| 114 | base::JSONWriter::Write(device_info.get(), &device_info_str); |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 115 | return device_info_str; |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 116 | } |
| 117 | |
Anton Muhin | 9cc03fd | 2014-10-16 18:59:57 +0400 | [diff] [blame] | 118 | std::string Manager::HandleRegisterDevice( |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 119 | chromeos::ErrorPtr* error, |
Alex Vakulenko | 9f826a6 | 2014-08-23 19:31:27 -0700 | [diff] [blame] | 120 | const std::map<std::string, std::string>& params) { |
Anton Muhin | 9cc03fd | 2014-10-16 18:59:57 +0400 | [diff] [blame] | 121 | LOG(INFO) << "Received call to Manager.RegisterDevice()"; |
Alex Vakulenko | f3d77e5 | 2014-04-15 11:36:32 -0700 | [diff] [blame] | 122 | |
Anton Muhin | 9cc03fd | 2014-10-16 18:59:57 +0400 | [diff] [blame] | 123 | return device_info_->RegisterDevice(params, error); |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Alex Vakulenko | b635153 | 2014-08-15 11:49:35 -0700 | [diff] [blame] | 126 | void Manager::HandleUpdateState( |
Alex Vakulenko | 95877b5 | 2014-09-19 15:31:09 -0700 | [diff] [blame] | 127 | chromeos::ErrorPtr* error, |
Alex Vakulenko | b9d7264 | 2014-09-22 16:49:45 -0700 | [diff] [blame] | 128 | const chromeos::VariantDictionary& property_set) { |
Alex Vakulenko | bfc70ad | 2014-10-29 09:53:52 -0700 | [diff] [blame^] | 129 | base::Time timestamp = base::Time::Now(); |
| 130 | for (const auto& pair : property_set) { |
| 131 | state_manager_->SetPropertyValue(pair.first, pair.second, timestamp, error); |
| 132 | } |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 133 | } |
| 134 | |
Alex Vakulenko | 4f7778e | 2014-09-11 16:57:24 -0700 | [diff] [blame] | 135 | void Manager::HandleAddCommand( |
| 136 | chromeos::ErrorPtr* error, const std::string& json_command) { |
| 137 | std::string error_message; |
| 138 | std::unique_ptr<base::Value> value(base::JSONReader::ReadAndReturnError( |
| 139 | json_command, base::JSON_PARSE_RFC, nullptr, &error_message)); |
| 140 | if (!value) { |
| 141 | chromeos::Error::AddTo(error, chromeos::errors::json::kDomain, |
| 142 | chromeos::errors::json::kParseError, error_message); |
| 143 | return; |
| 144 | } |
| 145 | auto command_instance = buffet::CommandInstance::FromJson( |
| 146 | value.get(), command_manager_->GetCommandDictionary(), error); |
| 147 | if (command_instance) |
| 148 | command_manager_->AddCommand(std::move(command_instance)); |
| 149 | } |
| 150 | |
Alex Vakulenko | 35e3bab | 2014-08-15 11:45:46 -0700 | [diff] [blame] | 151 | std::string Manager::HandleTestMethod(chromeos::ErrorPtr* error, |
| 152 | const std::string& message) { |
| 153 | LOG(INFO) << "Received call to test method: " << message; |
| 154 | return message; |
Christopher Wiley | 2ffa004 | 2014-05-05 16:09:16 -0700 | [diff] [blame] | 155 | } |
| 156 | |
Christopher Wiley | 4b5f04c | 2014-03-27 14:45:37 -0700 | [diff] [blame] | 157 | } // namespace buffet |