| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2016 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 "services/catalog/reader.h" | |
| 6 | |
| 7 #include "base/base_paths.h" | |
| 8 #include "base/bind.h" | |
| 9 #include "base/files/file_enumerator.h" | |
| 10 #include "base/files/file_util.h" | |
| 11 #include "base/json/json_file_value_serializer.h" | |
| 12 #include "base/json/json_reader.h" | |
| 13 #include "base/memory/ptr_util.h" | |
| 14 #include "base/path_service.h" | |
| 15 #include "base/strings/string_util.h" | |
| 16 #include "base/strings/utf_string_conversions.h" | |
| 17 #include "base/task_runner_util.h" | |
| 18 #include "base/threading/thread_task_runner_handle.h" | |
| 19 #include "base/values.h" | |
| 20 #include "services/catalog/constants.h" | |
| 21 #include "services/catalog/entry.h" | |
| 22 #include "services/catalog/entry_cache.h" | |
| 23 #include "services/catalog/manifest_provider.h" | |
| 24 #include "services/catalog/public/interfaces/constants.mojom.h" | |
| 25 #include "services/service_manager/public/interfaces/constants.mojom.h" | |
| 26 | |
| 27 namespace catalog { | |
| 28 namespace { | |
| 29 | |
| 30 #if defined(OS_WIN) | |
| 31 const char kServiceExecutableExtension[] = ".service.exe"; | |
| 32 #else | |
| 33 const char kServiceExecutableExtension[] = ".service"; | |
| 34 #endif | |
| 35 | |
| 36 const char kCatalogServicesKey[] = "services"; | |
| 37 const char kCatalogServiceEmbeddedKey[] = "embedded"; | |
| 38 const char kCatalogServiceExecutableKey[] = "executable"; | |
| 39 const char kCatalogServiceManifestKey[] = "manifest"; | |
| 40 | |
| 41 base::FilePath GetManifestPath(const base::FilePath& package_dir, | |
| 42 const std::string& name, | |
| 43 const std::string& package_name_override) { | |
| 44 // TODO(beng): think more about how this should be done for exe targets. | |
| 45 std::string package_name = | |
| 46 package_name_override.empty() ? name : package_name_override; | |
| 47 return package_dir.AppendASCII(kPackagesDirName).AppendASCII( | |
| 48 package_name + "/manifest.json"); | |
| 49 } | |
| 50 | |
| 51 base::FilePath GetExecutablePath(const base::FilePath& package_dir, | |
| 52 const std::string& name) { | |
| 53 return package_dir.AppendASCII( | |
| 54 name + "/" + name + kServiceExecutableExtension); | |
| 55 } | |
| 56 | |
| 57 std::unique_ptr<Entry> ProcessManifest(const base::Value* manifest_root, | |
| 58 const base::FilePath& package_dir, | |
| 59 const base::FilePath& executable_path) { | |
| 60 | |
| 61 // Manifest was malformed or did not exist. | |
| 62 if (!manifest_root) | |
| 63 return nullptr; | |
| 64 | |
| 65 const base::DictionaryValue* dictionary = nullptr; | |
| 66 if (!manifest_root->GetAsDictionary(&dictionary)) | |
| 67 return nullptr; | |
| 68 | |
| 69 std::unique_ptr<Entry> entry = Entry::Deserialize(*dictionary); | |
| 70 if (!entry) | |
| 71 return nullptr; | |
| 72 if (!executable_path.empty()) | |
| 73 entry->set_path(executable_path); | |
| 74 else | |
| 75 entry->set_path(GetExecutablePath(package_dir, entry->name())); | |
| 76 return entry; | |
| 77 } | |
| 78 | |
| 79 std::unique_ptr<Entry> ProcessUniqueManifest( | |
| 80 std::unique_ptr<base::Value> manifest_root, | |
| 81 const base::FilePath& package_dir) { | |
| 82 return ProcessManifest(manifest_root.get(), package_dir, base::FilePath()); | |
| 83 } | |
| 84 | |
| 85 std::unique_ptr<Entry> CreateEntryForManifestAt( | |
| 86 const base::FilePath& manifest_path, | |
| 87 const base::FilePath& package_dir) { | |
| 88 JSONFileValueDeserializer deserializer(manifest_path); | |
| 89 int error = 0; | |
| 90 std::string message; | |
| 91 | |
| 92 // TODO(beng): probably want to do more detailed error checking. This should | |
| 93 // be done when figuring out if to unblock connection completion. | |
| 94 return ProcessUniqueManifest(deserializer.Deserialize(&error, &message), | |
| 95 package_dir); | |
| 96 } | |
| 97 | |
| 98 void ScanDir( | |
| 99 const base::FilePath& package_dir, | |
| 100 const Reader::ReadManifestCallback& read_manifest_callback, | |
| 101 scoped_refptr<base::SingleThreadTaskRunner> original_thread_task_runner, | |
| 102 const base::Closure& read_complete_closure) { | |
| 103 base::FileEnumerator enumerator(package_dir, false, | |
| 104 base::FileEnumerator::DIRECTORIES); | |
| 105 while (1) { | |
| 106 base::FilePath path = enumerator.Next(); | |
| 107 if (path.empty()) | |
| 108 break; | |
| 109 base::FilePath manifest_path = path.AppendASCII("manifest.json"); | |
| 110 std::unique_ptr<Entry> entry = | |
| 111 CreateEntryForManifestAt(manifest_path, package_dir); | |
| 112 if (!entry) | |
| 113 continue; | |
| 114 | |
| 115 // Skip over subdirs that contain only manifests, they're artifacts of the | |
| 116 // build (e.g. for applications that are packaged into others) and are not | |
| 117 // valid standalone packages. | |
| 118 base::FilePath package_path = GetExecutablePath(package_dir, entry->name()); | |
| 119 if (entry->name() != service_manager::mojom::kServiceName && | |
| 120 entry->name() != catalog::mojom::kServiceName && | |
| 121 !base::PathExists(package_path)) { | |
| 122 continue; | |
| 123 } | |
| 124 | |
| 125 original_thread_task_runner->PostTask( | |
| 126 FROM_HERE, | |
| 127 base::Bind(read_manifest_callback, base::Passed(&entry))); | |
| 128 } | |
| 129 | |
| 130 original_thread_task_runner->PostTask(FROM_HERE, read_complete_closure); | |
| 131 } | |
| 132 | |
| 133 std::unique_ptr<Entry> ReadManifest( | |
| 134 const base::FilePath& package_dir, | |
| 135 const std::string& mojo_name, | |
| 136 const std::string& package_name_override, | |
| 137 const base::FilePath& manifest_path_override) { | |
| 138 base::FilePath manifest_path; | |
| 139 if (manifest_path_override.empty()) { | |
| 140 manifest_path = | |
| 141 GetManifestPath(package_dir, mojo_name, package_name_override); | |
| 142 } else { | |
| 143 manifest_path = manifest_path_override; | |
| 144 } | |
| 145 | |
| 146 std::unique_ptr<Entry> entry = CreateEntryForManifestAt(manifest_path, | |
| 147 package_dir); | |
| 148 if (!entry) { | |
| 149 entry.reset(new Entry(mojo_name)); | |
| 150 entry->set_path(GetExecutablePath( | |
| 151 package_dir.AppendASCII(kPackagesDirName), mojo_name)); | |
| 152 } | |
| 153 return entry; | |
| 154 } | |
| 155 | |
| 156 void IgnoreResolveResult(service_manager::mojom::ResolveResultPtr, | |
| 157 service_manager::mojom::ResolveResultPtr) {} | |
| 158 | |
| 159 void LoadCatalogManifestIntoCache(const base::Value* root, | |
| 160 const base::FilePath& package_dir, | |
| 161 EntryCache* cache) { | |
| 162 DCHECK(root); | |
| 163 const base::DictionaryValue* catalog = nullptr; | |
| 164 if (!root->GetAsDictionary(&catalog)) { | |
| 165 LOG(ERROR) << "Catalog manifest is not a dictionary value."; | |
| 166 return; | |
| 167 } | |
| 168 DCHECK(catalog); | |
| 169 | |
| 170 const base::DictionaryValue* services = nullptr; | |
| 171 if (!catalog->GetDictionary(kCatalogServicesKey, &services)) { | |
| 172 LOG(ERROR) << "Catalog manifest \"services\" is not a dictionary value."; | |
| 173 return; | |
| 174 } | |
| 175 | |
| 176 for (base::DictionaryValue::Iterator it(*services); !it.IsAtEnd(); | |
| 177 it.Advance()) { | |
| 178 const base::DictionaryValue* service_entry = nullptr; | |
| 179 if (!it.value().GetAsDictionary(&service_entry)) { | |
| 180 LOG(ERROR) << "Catalog service entry for \"" << it.key() | |
| 181 << "\" is not a dictionary value."; | |
| 182 continue; | |
| 183 } | |
| 184 | |
| 185 bool is_embedded = false; | |
| 186 service_entry->GetBoolean(kCatalogServiceEmbeddedKey, &is_embedded); | |
| 187 | |
| 188 base::FilePath executable_path; | |
| 189 std::string executable_path_string; | |
| 190 if (service_entry->GetString(kCatalogServiceExecutableKey, | |
| 191 &executable_path_string)) { | |
| 192 base::FilePath exe_dir; | |
| 193 CHECK(base::PathService::Get(base::DIR_EXE, &exe_dir)); | |
| 194 #if defined(OS_WIN) | |
| 195 executable_path_string += ".exe"; | |
| 196 base::ReplaceFirstSubstringAfterOffset( | |
| 197 &executable_path_string, 0, "@EXE_DIR", | |
| 198 base::UTF16ToUTF8(exe_dir.value())); | |
| 199 executable_path = | |
| 200 base::FilePath(base::UTF8ToUTF16(executable_path_string)); | |
| 201 #else | |
| 202 base::ReplaceFirstSubstringAfterOffset( | |
| 203 &executable_path_string, 0, "@EXE_DIR", exe_dir.value()); | |
| 204 executable_path = base::FilePath(executable_path_string); | |
| 205 #endif | |
| 206 } | |
| 207 | |
| 208 const base::DictionaryValue* manifest = nullptr; | |
| 209 if (!service_entry->GetDictionary(kCatalogServiceManifestKey, &manifest)) { | |
| 210 LOG(ERROR) << "Catalog entry for \"" << it.key() << "\" has an invalid " | |
| 211 << "\"manifest\" value."; | |
| 212 continue; | |
| 213 } | |
| 214 | |
| 215 DCHECK(!(is_embedded && !executable_path.empty())); | |
| 216 | |
| 217 auto entry = ProcessManifest( | |
| 218 manifest, is_embedded ? base::FilePath() : package_dir, | |
| 219 executable_path); | |
| 220 if (entry) { | |
| 221 bool added = cache->AddRootEntry(std::move(entry)); | |
| 222 DCHECK(added); | |
| 223 } else { | |
| 224 LOG(ERROR) << "Failed to read manifest entry for \"" << it.key() << "\"."; | |
| 225 } | |
| 226 } | |
| 227 } | |
| 228 | |
| 229 } // namespace | |
| 230 | |
| 231 Reader::Reader(std::unique_ptr<base::Value> static_manifest, | |
| 232 EntryCache* cache) | |
| 233 : using_static_catalog_(true), | |
| 234 manifest_provider_(nullptr), | |
| 235 weak_factory_(this) { | |
| 236 PathService::Get(base::DIR_MODULE, &system_package_dir_); | |
| 237 LoadCatalogManifestIntoCache( | |
| 238 static_manifest.get(), system_package_dir_.AppendASCII(kPackagesDirName), | |
| 239 cache); | |
| 240 } | |
| 241 | |
| 242 // A sequenced task runner is used to guarantee requests are serviced in the | |
| 243 // order requested. To do otherwise means we may run callbacks in an | |
| 244 // unpredictable order, leading to flake. | |
| 245 Reader::Reader(base::SequencedWorkerPool* worker_pool, | |
| 246 ManifestProvider* manifest_provider) | |
| 247 : Reader(manifest_provider) { | |
| 248 file_task_runner_ = worker_pool->GetSequencedTaskRunnerWithShutdownBehavior( | |
| 249 base::SequencedWorkerPool::GetSequenceToken(), | |
| 250 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN); | |
| 251 } | |
| 252 | |
| 253 Reader::Reader(base::SingleThreadTaskRunner* task_runner, | |
| 254 ManifestProvider* manifest_provider) | |
| 255 : Reader(manifest_provider) { | |
| 256 file_task_runner_ = task_runner; | |
| 257 } | |
| 258 | |
| 259 Reader::~Reader() {} | |
| 260 | |
| 261 void Reader::Read(const base::FilePath& package_dir, | |
| 262 EntryCache* cache, | |
| 263 const base::Closure& read_complete_closure) { | |
| 264 file_task_runner_->PostTask( | |
| 265 FROM_HERE, | |
| 266 base::Bind(&ScanDir, package_dir, | |
| 267 base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), | |
| 268 cache, base::Bind(&IgnoreResolveResult)), | |
| 269 base::ThreadTaskRunnerHandle::Get(), | |
| 270 read_complete_closure)); | |
| 271 } | |
| 272 | |
| 273 void Reader::CreateEntryForName( | |
| 274 const std::string& name, | |
| 275 EntryCache* cache, | |
| 276 const CreateEntryForNameCallback& entry_created_callback) { | |
| 277 if (manifest_provider_) { | |
| 278 std::unique_ptr<base::Value> manifest_root = | |
| 279 manifest_provider_->GetManifest(name); | |
| 280 if (manifest_root) { | |
| 281 base::PostTaskAndReplyWithResult( | |
| 282 file_task_runner_.get(), FROM_HERE, | |
| 283 base::Bind(&ProcessUniqueManifest, base::Passed(&manifest_root), | |
| 284 system_package_dir_), | |
| 285 base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache, | |
| 286 entry_created_callback)); | |
| 287 return; | |
| 288 } | |
| 289 } else if (using_static_catalog_) { | |
| 290 // A Reader using a static catalog manifest does not support dynamic | |
| 291 // discovery or introduction of new catalog entries. | |
| 292 entry_created_callback.Run(service_manager::mojom::ResolveResultPtr(), | |
| 293 service_manager::mojom::ResolveResultPtr()); | |
| 294 return; | |
| 295 } | |
| 296 | |
| 297 base::FilePath manifest_path_override; | |
| 298 { | |
| 299 auto override_iter = manifest_path_overrides_.find(name); | |
| 300 if (override_iter != manifest_path_overrides_.end()) | |
| 301 manifest_path_override = override_iter->second; | |
| 302 } | |
| 303 | |
| 304 std::string package_name_override; | |
| 305 { | |
| 306 auto override_iter = package_name_overrides_.find(name); | |
| 307 if (override_iter != package_name_overrides_.end()) | |
| 308 package_name_override = override_iter->second; | |
| 309 } | |
| 310 base::PostTaskAndReplyWithResult( | |
| 311 file_task_runner_.get(), FROM_HERE, | |
| 312 base::Bind(&ReadManifest, system_package_dir_, name, | |
| 313 package_name_override, manifest_path_override), | |
| 314 base::Bind(&Reader::OnReadManifest, weak_factory_.GetWeakPtr(), cache, | |
| 315 entry_created_callback)); | |
| 316 } | |
| 317 | |
| 318 void Reader::OverridePackageName(const std::string& service_name, | |
| 319 const std::string& package_name) { | |
| 320 package_name_overrides_.insert(std::make_pair(service_name, package_name)); | |
| 321 } | |
| 322 | |
| 323 void Reader::OverrideManifestPath(const std::string& service_name, | |
| 324 const base::FilePath& path) { | |
| 325 manifest_path_overrides_.insert(std::make_pair(service_name, path)); | |
| 326 } | |
| 327 | |
| 328 Reader::Reader(ManifestProvider* manifest_provider) | |
| 329 : using_static_catalog_(false), | |
| 330 manifest_provider_(manifest_provider), | |
| 331 weak_factory_(this) { | |
| 332 PathService::Get(base::DIR_MODULE, &system_package_dir_); | |
| 333 } | |
| 334 | |
| 335 void Reader::OnReadManifest( | |
| 336 EntryCache* cache, | |
| 337 const CreateEntryForNameCallback& entry_created_callback, | |
| 338 std::unique_ptr<Entry> entry) { | |
| 339 if (!entry) | |
| 340 return; | |
| 341 | |
| 342 std::string name = entry->name(); | |
| 343 cache->AddRootEntry(std::move(entry)); | |
| 344 | |
| 345 // NOTE: It's currently possible to end up with a duplicate entry, in which | |
| 346 // case the above call to AddRootEntry() may actually discard |entry|. We | |
| 347 // therefore look up the Entry by name here to get resolution metadata. | |
| 348 | |
| 349 const Entry* resolved_entry = cache->GetEntry(name); | |
| 350 DCHECK(resolved_entry); | |
| 351 entry_created_callback.Run( | |
| 352 service_manager::mojom::ResolveResult::From(resolved_entry), | |
| 353 service_manager::mojom::ResolveResult::From(resolved_entry->parent())); | |
| 354 } | |
| 355 | |
| 356 } // namespace catalog | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2645973006:
[Service Manager] Get rid of dynamic service discovery (Closed)
