src/sync/test/fake_server/fake_server.cc

   1 // Copyright 2014 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 "sync/test/fake_server/fake_server.h"
   6
   7 #include <algorithm>
   8 #include <limits>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/guid.h"
  14 #include "base/logging.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/stl_util.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/string_util.h"
  19 #include "base/strings/stringprintf.h"
  20 #include "base/synchronization/lock.h"
  21 #include "net/base/net_errors.h"
  22 #include "net/http/http_status_code.h"
  23 #include "sync/internal_api/public/base/model_type.h"
  24 #include "sync/protocol/sync.pb.h"
  25 #include "sync/test/fake_server/bookmark_entity.h"
  26 #include "sync/test/fake_server/permanent_entity.h"
  27 #include "sync/test/fake_server/tombstone_entity.h"
  28 #include "sync/test/fake_server/unique_client_entity.h"
  29
  30 using std::string;
  31 using std::vector;
  32
  33 using syncer::GetModelType;
  34 using syncer::ModelType;
  35 using syncer::ModelTypeSet;
  36
  37 // The default store birthday value.
  38 static const char kDefaultStoreBirthday[] = "1234567890";
  39
  40 // The default keystore key.
  41 static const char kDefaultKeystoreKey[] = "1111111111111111";
  42
  43 namespace fake_server {
  44
  45 class FakeServerEntity;
  46
  47 namespace {
  48
  49 // A filter used during GetUpdates calls to determine what information to
  50 // send back to the client. There is a 1:1 correspondence between any given
  51 // GetUpdates call and an UpdateSieve instance.
  52 class UpdateSieve {
  53  public:
  54   ~UpdateSieve() { }
  55
  56   // Factory method for creating an UpdateSieve.
  57   static scoped_ptr<UpdateSieve> Create(
  58       const sync_pb::GetUpdatesMessage& get_updates_message);
  59
  60   // Sets the progress markers in |get_updates_response| given the progress
  61   // markers from the original GetUpdatesMessage and |new_version| (the latest
  62   // version in the entries sent back).
  63   void UpdateProgressMarkers(
  64       int64 new_version,
  65       sync_pb::GetUpdatesResponse* get_updates_response) const {
  66     ModelTypeToVersionMap::const_iterator it;
  67     for (it = request_from_version_.begin(); it != request_from_version_.end();
  68          ++it) {
  69       sync_pb::DataTypeProgressMarker* new_marker =
  70           get_updates_response->add_new_progress_marker();
  71       new_marker->set_data_type_id(
  72           GetSpecificsFieldNumberFromModelType(it->first));
  73
  74       int64 version = std::max(new_version, it->second);
  75       new_marker->set_token(base::Int64ToString(version));
  76     }
  77   }
  78
  79   // Determines whether the server should send an |entity| to the client as
  80   // part of a GetUpdatesResponse.
  81   bool ClientWantsItem(FakeServerEntity* entity) const {
  82     int64 version = entity->GetVersion();
  83     if (version <= min_version_) {
  84       return false;
  85     } else if (entity->IsDeleted()) {
  86       return true;
  87     }
  88
  89     ModelTypeToVersionMap::const_iterator it =
  90         request_from_version_.find(entity->GetModelType());
  91
  92     return it == request_from_version_.end() ? false : it->second < version;
  93   }
  94
  95   // Returns the minimum version seen across all types.
  96   int64 GetMinVersion() const {
  97     return min_version_;
  98   }
  99
 100  private:
 101   typedef std::map<ModelType, int64> ModelTypeToVersionMap;
 102
 103   // Creates an UpdateSieve.
 104   UpdateSieve(const ModelTypeToVersionMap request_from_version,
 105               const int64 min_version)
 106       : request_from_version_(request_from_version),
 107         min_version_(min_version) { }
 108
 109   // Maps data type IDs to the latest version seen for that type.
 110   const ModelTypeToVersionMap request_from_version_;
 111
 112   // The minimum version seen among all data types.
 113   const int min_version_;
 114 };
 115
 116 scoped_ptr<UpdateSieve> UpdateSieve::Create(
 117     const sync_pb::GetUpdatesMessage& get_updates_message) {
 118   CHECK_GT(get_updates_message.from_progress_marker_size(), 0)
 119       << "A GetUpdates request must have at least one progress marker.";
 120
 121   UpdateSieve::ModelTypeToVersionMap request_from_version;
 122   int64 min_version = std::numeric_limits<int64>::max();
 123   for (int i = 0; i < get_updates_message.from_progress_marker_size(); i++) {
 124     sync_pb::DataTypeProgressMarker marker =
 125         get_updates_message.from_progress_marker(i);
 126
 127     int64 version = 0;
 128     // Let the version remain zero if there is no token or an empty token (the
 129     // first request for this type).
 130     if (marker.has_token() && !marker.token().empty()) {
 131       bool parsed = base::StringToInt64(marker.token(), &version);
 132       CHECK(parsed) << "Unable to parse progress marker token.";
 133     }
 134
 135     ModelType model_type = syncer::GetModelTypeFromSpecificsFieldNumber(
 136         marker.data_type_id());
 137     request_from_version[model_type] = version;
 138
 139     if (version < min_version)
 140       min_version = version;
 141   }
 142
 143   return scoped_ptr<UpdateSieve>(
 144       new UpdateSieve(request_from_version, min_version));
 145 }
 146
 147 }  // namespace
 148
 149 FakeServer::FakeServer() : version_(0),
 150                            store_birthday_(kDefaultStoreBirthday),
 151                            authenticated_(true),
 152                            error_type_(sync_pb::SyncEnums::SUCCESS) {
 153   keystore_keys_.push_back(kDefaultKeystoreKey);
 154   CHECK(CreateDefaultPermanentItems());
 155 }
 156
 157 FakeServer::~FakeServer() {
 158   STLDeleteContainerPairSecondPointers(entities_.begin(), entities_.end());
 159 }
 160
 161 bool FakeServer::CreateDefaultPermanentItems() {
 162   ModelTypeSet all_types = syncer::ProtocolTypes();
 163   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
 164     ModelType model_type = it.Get();
 165     FakeServerEntity* top_level_entity =
 166         PermanentEntity::CreateTopLevel(model_type);
 167     if (top_level_entity == NULL) {
 168       return false;
 169     }
 170     SaveEntity(top_level_entity);
 171
 172     if (model_type == syncer::BOOKMARKS) {
 173       FakeServerEntity* bookmark_bar_entity =
 174           PermanentEntity::Create(syncer::BOOKMARKS,
 175                                   "bookmark_bar",
 176                                   "Bookmark Bar",
 177                                   ModelTypeToRootTag(syncer::BOOKMARKS));
 178       if (bookmark_bar_entity == NULL) {
 179         return false;
 180       }
 181       SaveEntity(bookmark_bar_entity);
 182
 183       FakeServerEntity* other_bookmarks_entity =
 184           PermanentEntity::Create(syncer::BOOKMARKS,
 185                                   "other_bookmarks",
 186                                   "Other Bookmarks",
 187                                   ModelTypeToRootTag(syncer::BOOKMARKS));
 188       if (other_bookmarks_entity == NULL) {
 189         return false;
 190       }
 191       SaveEntity(other_bookmarks_entity);
 192     }
 193   }
 194
 195   return true;
 196 }
 197
 198 bool FakeServer::CreateMobileBookmarksPermanentItem() {
 199   // This folder is called "Synced Bookmarks" by sync and is renamed
 200   // "Mobile Bookmarks" by the mobile client UIs.
 201   FakeServerEntity* mobile_bookmarks_entity =
 202       PermanentEntity::Create(syncer::BOOKMARKS,
 203                               "synced_bookmarks",
 204                               "Synced Bookmarks",
 205                               ModelTypeToRootTag(syncer::BOOKMARKS));
 206   if (mobile_bookmarks_entity == NULL) {
 207     return false;
 208   }
 209   SaveEntity(mobile_bookmarks_entity);
 210   return true;
 211 }
 212
 213 void FakeServer::SaveEntity(FakeServerEntity* entity) {
 214   delete entities_[entity->GetId()];
 215   entity->SetVersion(++version_);
 216   entities_[entity->GetId()] = entity;
 217 }
 218
 219 void FakeServer::HandleCommand(const string& request,
 220                                const HandleCommandCallback& callback) {
 221   if (!authenticated_) {
 222     callback.Run(0, net::HTTP_UNAUTHORIZED, string());
 223     return;
 224   }
 225
 226   sync_pb::ClientToServerMessage message;
 227   bool parsed = message.ParseFromString(request);
 228   CHECK(parsed) << "Unable to parse the ClientToServerMessage.";
 229
 230   sync_pb::SyncEnums_ErrorType error_code;
 231   sync_pb::ClientToServerResponse response_proto;
 232
 233   if (message.has_store_birthday() &&
 234       message.store_birthday() != store_birthday_) {
 235     error_code = sync_pb::SyncEnums::NOT_MY_BIRTHDAY;
 236   } else if (error_type_ != sync_pb::SyncEnums::SUCCESS) {
 237     error_code = error_type_;
 238   } else {
 239     bool success = false;
 240     switch (message.message_contents()) {
 241       case sync_pb::ClientToServerMessage::GET_UPDATES:
 242         success = HandleGetUpdatesRequest(message.get_updates(),
 243                                           response_proto.mutable_get_updates());
 244         break;
 245       case sync_pb::ClientToServerMessage::COMMIT:
 246         success = HandleCommitRequest(message.commit(),
 247                                       message.invalidator_client_id(),
 248                                       response_proto.mutable_commit());
 249         break;
 250       default:
 251         callback.Run(net::ERR_NOT_IMPLEMENTED, 0, string());;
 252         return;
 253     }
 254
 255     if (!success) {
 256       // TODO(pvalenzuela): Add logging here so that tests have more info about
 257       // the failure.
 258       callback.Run(net::ERR_FAILED, 0, string());
 259       return;
 260     }
 261
 262     error_code = sync_pb::SyncEnums::SUCCESS;
 263   }
 264
 265   response_proto.set_error_code(error_code);
 266   response_proto.set_store_birthday(store_birthday_);
 267   callback.Run(0, net::HTTP_OK, response_proto.SerializeAsString());
 268 }
 269
 270 bool FakeServer::HandleGetUpdatesRequest(
 271     const sync_pb::GetUpdatesMessage& get_updates,
 272     sync_pb::GetUpdatesResponse* response) {
 273   // TODO(pvalenzuela): Implement batching instead of sending all information
 274   // at once.
 275   response->set_changes_remaining(0);
 276
 277   scoped_ptr<UpdateSieve> sieve = UpdateSieve::Create(get_updates);
 278
 279   if (get_updates.create_mobile_bookmarks_folder() &&
 280       !CreateMobileBookmarksPermanentItem()) {
 281     return false;
 282   }
 283
 284   bool send_encryption_keys_based_on_nigori = false;
 285   int64 max_response_version = 0;
 286   for (EntityMap::iterator it = entities_.begin(); it != entities_.end();
 287        ++it) {
 288     FakeServerEntity* entity = it->second;
 289     if (sieve->ClientWantsItem(entity)) {
 290       sync_pb::SyncEntity* response_entity = response->add_entries();
 291       entity->SerializeAsProto(response_entity);
 292       max_response_version = std::max(max_response_version,
 293                                       response_entity->version());
 294
 295       if (entity->GetModelType() == syncer::NIGORI) {
 296         send_encryption_keys_based_on_nigori =
 297             response_entity->specifics().nigori().passphrase_type() ==
 298                 sync_pb::NigoriSpecifics::KEYSTORE_PASSPHRASE;
 299       }
 300     }
 301   }
 302
 303   if (send_encryption_keys_based_on_nigori ||
 304       get_updates.need_encryption_key()) {
 305     for (vector<string>::iterator it = keystore_keys_.begin();
 306          it != keystore_keys_.end(); ++it) {
 307       response->add_encryption_keys(*it);
 308     }
 309   }
 310
 311   sieve->UpdateProgressMarkers(max_response_version, response);
 312   return true;
 313 }
 314
 315 string FakeServer::CommitEntity(
 316     const sync_pb::SyncEntity& client_entity,
 317     sync_pb::CommitResponse_EntryResponse* entry_response,
 318     string client_guid,
 319     string parent_id) {
 320   if (client_entity.version() == 0 && client_entity.deleted()) {
 321     return string();
 322   }
 323
 324   FakeServerEntity* entity;
 325   if (client_entity.deleted()) {
 326     entity = TombstoneEntity::Create(client_entity.id_string());
 327     // TODO(pvalenzuela): Change the behavior of DeleteChilden so that it does
 328     // not modify server data if it fails.
 329     if (!DeleteChildren(client_entity.id_string())) {
 330       return string();
 331     }
 332   } else if (GetModelType(client_entity) == syncer::NIGORI) {
 333     // NIGORI is the only permanent item type that should be updated by the
 334     // client.
 335     entity = PermanentEntity::CreateUpdatedNigoriEntity(
 336         client_entity,
 337         entities_[client_entity.id_string()]);
 338   } else if (client_entity.has_client_defined_unique_tag()) {
 339     entity = UniqueClientEntity::Create(client_entity);
 340   } else {
 341     // TODO(pvalenzuela): Validate entity's parent ID.
 342     if (entities_.find(client_entity.id_string()) != entities_.end()) {
 343       entity = BookmarkEntity::CreateUpdatedVersion(
 344         client_entity,
 345         entities_[client_entity.id_string()],
 346         parent_id);
 347     } else {
 348       entity = BookmarkEntity::CreateNew(client_entity, parent_id, client_guid);
 349     }
 350   }
 351
 352   if (entity == NULL) {
 353     // TODO(pvalenzuela): Add logging so that it is easier to determine why
 354     // creation failed.
 355     return string();
 356   }
 357
 358   SaveEntity(entity);
 359   BuildEntryResponseForSuccessfulCommit(entry_response, entity);
 360   return entity->GetId();
 361 }
 362
 363 void FakeServer::BuildEntryResponseForSuccessfulCommit(
 364   sync_pb::CommitResponse_EntryResponse* entry_response,
 365   FakeServerEntity* entity) {
 366     entry_response->set_response_type(sync_pb::CommitResponse::SUCCESS);
 367     entry_response->set_id_string(entity->GetId());
 368
 369     if (entity->IsDeleted()) {
 370       entry_response->set_version(entity->GetVersion() + 1);
 371     } else {
 372       entry_response->set_version(entity->GetVersion());
 373       entry_response->set_name(entity->GetName());
 374     }
 375 }
 376
 377 bool FakeServer::IsChild(const string& id, const string& potential_parent_id) {
 378   if (entities_.find(id) == entities_.end()) {
 379     // We've hit an ID (probably the imaginary root entity) that isn't stored
 380     // by the server, so it can't be a child.
 381     return false;
 382   } else if (entities_[id]->GetParentId() == potential_parent_id) {
 383     return true;
 384   } else {
 385     // Recursively look up the tree.
 386     return IsChild(entities_[id]->GetParentId(), potential_parent_id);
 387   }
 388 }
 389
 390 bool FakeServer::DeleteChildren(const string& id) {
 391   vector<string> child_ids;
 392   for (EntityMap::iterator it = entities_.begin(); it != entities_.end();
 393        ++it) {
 394     if (IsChild(it->first, id)) {
 395       child_ids.push_back(it->first);
 396     }
 397   }
 398
 399   for (vector<string>::iterator it = child_ids.begin(); it != child_ids.end();
 400        ++it) {
 401     FakeServerEntity* tombstone = TombstoneEntity::Create(*it);
 402     if (tombstone == NULL) {
 403       LOG(WARNING) << "Tombstone creation failed for entity with ID " << *it;
 404       return false;
 405     }
 406     SaveEntity(tombstone);
 407   }
 408
 409   return true;
 410 }
 411
 412 bool FakeServer::HandleCommitRequest(
 413     const sync_pb::CommitMessage& commit,
 414     const std::string& invalidator_client_id,
 415     sync_pb::CommitResponse* response) {
 416   std::map<string, string> client_to_server_ids;
 417   string guid = commit.cache_guid();
 418   ModelTypeSet committed_model_types;
 419
 420   // TODO(pvalenzuela): Add validation of CommitMessage.entries.
 421   ::google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>::const_iterator it;
 422   for (it = commit.entries().begin(); it != commit.entries().end(); ++it) {
 423     sync_pb::CommitResponse_EntryResponse* entry_response =
 424         response->add_entryresponse();
 425
 426     sync_pb::SyncEntity client_entity = *it;
 427     string parent_id = client_entity.parent_id_string();
 428     if (client_to_server_ids.find(parent_id) !=
 429         client_to_server_ids.end()) {
 430       parent_id = client_to_server_ids[parent_id];
 431     }
 432
 433     string entity_id = CommitEntity(client_entity,
 434                                     entry_response,
 435                                     guid,
 436                                     parent_id);
 437     if (entity_id.empty()) {
 438       return false;
 439     }
 440
 441     // Record the ID if it was renamed.
 442     if (entity_id != client_entity.id_string()) {
 443       client_to_server_ids[client_entity.id_string()] = entity_id;
 444     }
 445     FakeServerEntity* entity = entities_[entity_id];
 446     committed_model_types.Put(entity->GetModelType());
 447   }
 448
 449   FOR_EACH_OBSERVER(Observer, observers_,
 450                     OnCommit(invalidator_client_id, committed_model_types));
 451   return true;
 452 }
 453
 454 scoped_ptr<base::DictionaryValue> FakeServer::GetEntitiesAsDictionaryValue() {
 455   scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
 456
 457   // Initialize an empty ListValue for all ModelTypes.
 458   ModelTypeSet all_types = ModelTypeSet::All();
 459   for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
 460     dictionary->Set(ModelTypeToString(it.Get()), new base::ListValue());
 461   }
 462
 463   for (EntityMap::const_iterator it = entities_.begin(); it != entities_.end();
 464        ++it) {
 465     FakeServerEntity* entity = it->second;
 466     if (entity->IsDeleted() || entity->IsFolder()) {
 467       // Tombstones are ignored as they don't represent current data. Folders
 468       // are also ignored as current verification infrastructure does not
 469       // consider them.
 470       continue;
 471     }
 472     base::ListValue* list_value;
 473     if (!dictionary->GetList(ModelTypeToString(entity->GetModelType()),
 474                                                &list_value)) {
 475       return scoped_ptr<base::DictionaryValue>();
 476     }
 477     // TODO(pvalenzuela): Store more data for each entity so additional
 478     // verification can be performed. One example of additional verification
 479     // is checking the correctness of the bookmark hierarchy.
 480     list_value->Append(new base::StringValue(entity->GetName()));
 481   }
 482
 483   return dictionary.Pass();
 484 }
 485
 486 void FakeServer::InjectEntity(scoped_ptr<FakeServerEntity> entity) {
 487   SaveEntity(entity.release());
 488 }
 489
 490 bool FakeServer::SetNewStoreBirthday(const string& store_birthday) {
 491   if (store_birthday_ == store_birthday)
 492     return false;
 493
 494   store_birthday_ = store_birthday;
 495   return true;
 496 }
 497
 498 void FakeServer::SetAuthenticated() {
 499   authenticated_ = true;
 500 }
 501
 502 void FakeServer::SetUnauthenticated() {
 503   authenticated_ = false;
 504 }
 505
 506 // TODO(pvalenzuela): comments from Richard: we should look at
 507 // mock_connection_manager.cc and take it as a warning. This style of injecting
 508 // errors works when there's one or two conditions we care about, but it can
 509 // eventually lead to a hairball once we have many different conditions and
 510 // triggering logic.
 511 void FakeServer::TriggerError(const sync_pb::SyncEnums::ErrorType& error_type) {
 512   error_type_ = error_type;
 513 }
 514
 515 void FakeServer::AddObserver(Observer* observer) {
 516   observers_.AddObserver(observer);
 517 }
 518
 519 void FakeServer::RemoveObserver(Observer* observer) {
 520   observers_.RemoveObserver(observer);
 521 }
 522
 523 }  // namespace fake_server