sync/engine/directory_commit_contribution.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/engine/directory_commit_contribution.h"
   6
   7 #include "sync/engine/commit_util.h"
   8 #include "sync/engine/get_commit_ids.h"
   9 #include "sync/engine/syncer_util.h"
  10 #include "sync/internal_api/public/sessions/commit_counters.h"
  11 #include "sync/syncable/model_neutral_mutable_entry.h"
  12 #include "sync/syncable/syncable_model_neutral_write_transaction.h"
  13
  14 namespace syncer {
  15
  16 using syncable::GET_BY_HANDLE;
  17 using syncable::SYNCER;
  18
  19 DirectoryCommitContribution::~DirectoryCommitContribution() {
  20   DCHECK(!syncing_bits_set_);
  21 }
  22
  23 // static.
  24 scoped_ptr<DirectoryCommitContribution> DirectoryCommitContribution::Build(
  25     syncable::Directory* dir,
  26     ModelType type,
  27     size_t max_entries,
  28     DirectoryTypeDebugInfoEmitter* debug_info_emitter) {
  29   DCHECK(debug_info_emitter);
  30
  31   std::vector<int64> metahandles;
  32
  33   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir);
  34   GetCommitIdsForType(&trans, type, max_entries, &metahandles);
  35
  36   if (metahandles.empty())
  37     return scoped_ptr<DirectoryCommitContribution>();
  38
  39   google::protobuf::RepeatedPtrField<sync_pb::SyncEntity> entities;
  40   for (std::vector<int64>::iterator it = metahandles.begin();
  41        it != metahandles.end(); ++it) {
  42     sync_pb::SyncEntity* entity = entities.Add();
  43     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
  44     commit_util::BuildCommitItem(entry, entity);
  45     entry.PutSyncing(true);
  46   }
  47
  48   sync_pb::DataTypeContext context;
  49   dir->GetDataTypeContext(&trans, type, &context);
  50
  51   return scoped_ptr<DirectoryCommitContribution>(
  52       new DirectoryCommitContribution(
  53           metahandles,
  54           entities,
  55           context,
  56           dir,
  57           debug_info_emitter));
  58 }
  59
  60 void DirectoryCommitContribution::AddToCommitMessage(
  61     sync_pb::ClientToServerMessage* msg) {
  62   DCHECK(syncing_bits_set_);
  63   sync_pb::CommitMessage* commit_message = msg->mutable_commit();
  64   entries_start_index_ = commit_message->entries_size();
  65   std::copy(entities_.begin(),
  66             entities_.end(),
  67             RepeatedPtrFieldBackInserter(commit_message->mutable_entries()));
  68   if (!context_.context().empty())
  69     commit_message->add_client_contexts()->Swap(&context_);
  70
  71   CommitCounters* counters = debug_info_emitter_->GetMutableCommitCounters();
  72   counters->num_commits_attempted += entities_.size();
  73 }
  74
  75 SyncerError DirectoryCommitContribution::ProcessCommitResponse(
  76     const sync_pb::ClientToServerResponse& response,
  77     sessions::StatusController* status) {
  78   DCHECK(syncing_bits_set_);
  79   const sync_pb::CommitResponse& commit_response = response.commit();
  80
  81   int transient_error_commits = 0;
  82   int conflicting_commits = 0;
  83   int error_commits = 0;
  84   int successes = 0;
  85
  86   std::set<syncable::Id> deleted_folders;
  87   {
  88     syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
  89     for (size_t i = 0; i < metahandles_.size(); ++i) {
  90       sync_pb::CommitResponse::ResponseType response_type =
  91           commit_util::ProcessSingleCommitResponse(
  92               &trans,
  93               commit_response.entryresponse(entries_start_index_ + i),
  94               entities_.Get(i),
  95               metahandles_[i],
  96               &deleted_folders);
  97       switch (response_type) {
  98         case sync_pb::CommitResponse::INVALID_MESSAGE:
  99           ++error_commits;
 100           break;
 101         case sync_pb::CommitResponse::CONFLICT:
 102           ++conflicting_commits;
 103           status->increment_num_server_conflicts();
 104           break;
 105         case sync_pb::CommitResponse::SUCCESS:
 106           ++successes;
 107           {
 108             syncable::Entry e(&trans, GET_BY_HANDLE, metahandles_[i]);
 109             if (e.GetModelType() == BOOKMARKS)
 110               status->increment_num_successful_bookmark_commits();
 111           }
 112           status->increment_num_successful_commits();
 113           break;
 114         case sync_pb::CommitResponse::OVER_QUOTA:
 115           // We handle over quota like a retry, which is same as transient.
 116         case sync_pb::CommitResponse::RETRY:
 117         case sync_pb::CommitResponse::TRANSIENT_ERROR:
 118           ++transient_error_commits;
 119           break;
 120         default:
 121           LOG(FATAL) << "Bad return from ProcessSingleCommitResponse";
 122       }
 123     }
 124     MarkDeletedChildrenSynced(dir_, &trans, &deleted_folders);
 125   }
 126
 127   CommitCounters* counters = debug_info_emitter_->GetMutableCommitCounters();
 128   counters->num_commits_success += successes;
 129   counters->num_commits_conflict += transient_error_commits;
 130   counters->num_commits_error += transient_error_commits;
 131
 132   int commit_count = static_cast<int>(metahandles_.size());
 133   if (commit_count == successes) {
 134     return SYNCER_OK;
 135   } else if (error_commits > 0) {
 136     return SERVER_RETURN_UNKNOWN_ERROR;
 137   } else if (transient_error_commits > 0) {
 138     return SERVER_RETURN_TRANSIENT_ERROR;
 139   } else if (conflicting_commits > 0) {
 140     // This means that the server already has an item with this version, but
 141     // we haven't seen that update yet.
 142     //
 143     // A well-behaved client should respond to this by proceeding to the
 144     // download updates phase, fetching the conflicting items, then attempting
 145     // to resolve the conflict.  That's not what this client does.
 146     //
 147     // We don't currently have any code to support that exceptional control
 148     // flow.  Instead, we abort the current sync cycle and start a new one.  The
 149     // end result is the same.
 150     return SERVER_RETURN_CONFLICT;
 151   } else {
 152     LOG(FATAL) << "Inconsistent counts when processing commit response";
 153     return SYNCER_OK;
 154   }
 155 }
 156
 157 void DirectoryCommitContribution::CleanUp() {
 158   DCHECK(syncing_bits_set_);
 159   UnsetSyncingBits();
 160   debug_info_emitter_->EmitCommitCountersUpdate();
 161   debug_info_emitter_->EmitStatusCountersUpdate();
 162 }
 163
 164 size_t DirectoryCommitContribution::GetNumEntries() const {
 165   return metahandles_.size();
 166 }
 167
 168 DirectoryCommitContribution::DirectoryCommitContribution(
 169     const std::vector<int64>& metahandles,
 170     const google::protobuf::RepeatedPtrField<sync_pb::SyncEntity>& entities,
 171     const sync_pb::DataTypeContext& context,
 172     syncable::Directory* dir,
 173     DirectoryTypeDebugInfoEmitter* debug_info_emitter)
 174     : dir_(dir),
 175       metahandles_(metahandles),
 176       entities_(entities),
 177       context_(context),
 178       entries_start_index_(0xDEADBEEF),
 179       syncing_bits_set_(true),
 180       debug_info_emitter_(debug_info_emitter) {}
 181
 182 void DirectoryCommitContribution::UnsetSyncingBits() {
 183   syncable::ModelNeutralWriteTransaction trans(FROM_HERE, SYNCER, dir_);
 184   for (std::vector<int64>::const_iterator it = metahandles_.begin();
 185        it != metahandles_.end(); ++it) {
 186     syncable::ModelNeutralMutableEntry entry(&trans, GET_BY_HANDLE, *it);
 187     entry.PutSyncing(false);
 188   }
 189   syncing_bits_set_ = false;
 190 }
 191
 192 }  // namespace syncer