kudu-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t...@apache.org
Subject [3/3] kudu git commit: Rename Remote Bootstrap to Tablet Copy (part 1)
Date Fri, 05 Aug 2016 21:58:54 GMT
Rename Remote Bootstrap to Tablet Copy (part 1)

This does a bunch of automated substitutions of the terminology,
renaming "remote bootstrap" to "tablet copy". This commit does
not rename the files yet, so that it's easier to review without
combining a file name change with the file content change.

This is an incompatible change since some flag and metric names are
changed. Another follow-up will have to add release notes.

Change-Id: Ic017e9121ed365cb3d9c9c81430915bf5b295bf6
Reviewed-on: http://gerrit.cloudera.org:8080/3848
Reviewed-by: Alexey Serbin <aserbin@cloudera.com>
Tested-by: Kudu Jenkins
Reviewed-by: Mike Percy <mpercy@apache.org>


Project: http://git-wip-us.apache.org/repos/asf/kudu/repo
Commit: http://git-wip-us.apache.org/repos/asf/kudu/commit/a6cb942e
Tree: http://git-wip-us.apache.org/repos/asf/kudu/tree/a6cb942e
Diff: http://git-wip-us.apache.org/repos/asf/kudu/diff/a6cb942e

Branch: refs/heads/master
Commit: a6cb942e855a7a5a022a9f55f1b888df5dbc0d36
Parents: c8e2995
Author: Todd Lipcon <todd@apache.org>
Authored: Fri Aug 5 13:59:51 2016 -0700
Committer: Todd Lipcon <todd@apache.org>
Committed: Fri Aug 5 21:56:48 2016 +0000

----------------------------------------------------------------------
 docs/contributing.adoc                          |   2 +-
 docs/design-docs/README.md                      |   2 +-
 docs/design-docs/raft-config-change.md          |  18 +--
 docs/design-docs/raft-remote-bootstrap.md       |  54 +++----
 docs/whitepaper/kudu.tex                        |   8 +-
 src/kudu/consensus/consensus.proto              |   6 +-
 src/kudu/consensus/consensus_peers.cc           |  40 +++---
 src/kudu/consensus/consensus_peers.h            |  28 ++--
 src/kudu/consensus/consensus_queue-test.cc      |  88 ++++++------
 src/kudu/consensus/consensus_queue.cc           |  26 ++--
 src/kudu/consensus/consensus_queue.h            |  16 +--
 src/kudu/consensus/log_util.cc                  |   2 +-
 src/kudu/consensus/raft_consensus-test.cc       |   2 +-
 .../integration-tests/client_failover-itest.cc  |   6 +-
 .../integration-tests/cluster_itest_util.cc     |   8 +-
 src/kudu/integration-tests/cluster_itest_util.h |   4 +-
 src/kudu/integration-tests/delete_table-test.cc |  34 ++---
 .../integration-tests/raft_consensus-itest.cc   |   4 +-
 .../integration-tests/remote_bootstrap-itest.cc |  90 ++++++------
 .../tablet_replacement-itest.cc                 |   2 +-
 src/kudu/master/catalog_manager.cc              |   8 +-
 src/kudu/master/catalog_manager.h               |   4 +-
 src/kudu/tablet/metadata.proto                  |   4 +-
 src/kudu/tablet/tablet_bootstrap-test.cc        |   4 +-
 src/kudu/tablet/tablet_bootstrap.cc             |   4 +-
 src/kudu/tablet/tablet_metadata.h               |   4 +-
 src/kudu/tablet/tablet_peer.cc                  |   2 +-
 src/kudu/tserver/CMakeLists.txt                 |  10 +-
 src/kudu/tserver/remote_bootstrap-test-base.h   |  12 +-
 src/kudu/tserver/remote_bootstrap.proto         |  52 +++----
 .../tserver/remote_bootstrap_client-test.cc     |  24 ++--
 src/kudu/tserver/remote_bootstrap_client.cc     | 138 +++++++++---------
 src/kudu/tserver/remote_bootstrap_client.h      |  50 +++----
 .../tserver/remote_bootstrap_service-test.cc    | 144 +++++++++----------
 src/kudu/tserver/remote_bootstrap_service.cc    | 140 +++++++++---------
 src/kudu/tserver/remote_bootstrap_service.h     |  40 +++---
 .../tserver/remote_bootstrap_session-test.cc    |  24 ++--
 src/kudu/tserver/remote_bootstrap_session.cc    |  70 ++++-----
 src/kudu/tserver/remote_bootstrap_session.h     |  26 ++--
 src/kudu/tserver/tablet_peer_lookup.h           |   4 +-
 src/kudu/tserver/tablet_server.cc               |   4 +-
 src/kudu/tserver/tablet_service.cc              |  12 +-
 src/kudu/tserver/tablet_service.h               |   4 +-
 src/kudu/tserver/ts_tablet_manager.cc           |  44 +++---
 src/kudu/tserver/ts_tablet_manager.h            |  10 +-
 src/kudu/tserver/tserver.proto                  |   2 +-
 46 files changed, 640 insertions(+), 640 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/docs/contributing.adoc
----------------------------------------------------------------------
diff --git a/docs/contributing.adoc b/docs/contributing.adoc
index 2b6b217..e74995f 100644
--- a/docs/contributing.adoc
+++ b/docs/contributing.adoc
@@ -304,7 +304,7 @@ Reference].
   used to group similar gflags together. If the gflag affects the entire
   process, it should not be prefixed.
 - If the gflag is for a quantity, the name should be suffixed with the units.
-  For example, `remote_bootstrap_idle_timeout_ms`.
+  For example, `tablet_copy_idle_timeout_ms`.
 - Where possible, use short names. This will save time for those entering
   command line options by hand.
 - The name is part of Kudu's compatibility contract, and should not change

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/docs/design-docs/README.md
----------------------------------------------------------------------
diff --git a/docs/design-docs/README.md b/docs/design-docs/README.md
index 433c2b4..429ea4f 100644
--- a/docs/design-docs/README.md
+++ b/docs/design-docs/README.md
@@ -26,7 +26,7 @@ made.
 | [Codegen API and impl. details](codegen.md) | Server | N/A |
 | [Consensus design](consensus.md) | Consensus | N/A |
 | [Raft config change design](raft-config-change.md) | Consensus | N/A |
-| [Raft remote bootstrap design](raft-remote-bootstrap.md) | Consensus | N/A |
+| [Raft tablet copy design](raft-remote-bootstrap.md) | Consensus | N/A |
 | [Master design](master.md) | Master | N/A |
 | [RPC design and impl. details](rpc.md) | RPC | N/A |
 | [Tablet design, impl. details and comparison to other systems](tablet.md) | Tablet | N/A |

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/docs/design-docs/raft-config-change.md
----------------------------------------------------------------------
diff --git a/docs/design-docs/raft-config-change.md b/docs/design-docs/raft-config-change.md
index d67c6cc..899c72d 100644
--- a/docs/design-docs/raft-config-change.md
+++ b/docs/design-docs/raft-config-change.md
@@ -68,14 +68,14 @@ in [2].
 This process is executed by a driver, which may be a client program or the
 Master. We’ll say the node to be added to the cluster is named `new_node`.
 
-1. Driver initiates execution of remote bootstrap procedure of `new_node` from
+1. Driver initiates execution of tablet copy procedure of `new_node` from
    the current leader `bootstrap_source` using an RPC call to the `new_node`.
-   Remote bootstrap runs to completion, which means all data and logs at the
-   time remote bootstrap was initiated were replicated to `new_node`. Driver
-   polls `new_node` for indication that the remote bootstrap process is
+   Tablet Copy runs to completion, which means all data and logs at the
+   time tablet copy was initiated were replicated to `new_node`. Driver
+   polls `new_node` for indication that the tablet copy process is
    complete.
    <br>
-   If the `bootstrap_source` node crashes before remote bootstrap is complete,
+   If the `bootstrap_source` node crashes before tablet copy is complete,
    the bootstrap fails and the driver must start the entire process over from
    the beginning. If the driver or `new_node` crashes and the tablet never
    joins the configuration, the Master should eventually delete the abandoned
@@ -95,7 +95,7 @@ Master. We’ll say the node to be added to the cluster is named `new_node`.
 3. As soon as a replica receives the ConfigChangeRequest it applies the
    configuration change in-memory. It does not wait for commitment to apply the
    change. See rationale in [2] section 4.1.
-4. The remote bootstrap session between `new_node` and `bootstrap_source` is
+4. The tablet copy session between `new_node` and `bootstrap_source` is
    closed once the config change to transition the node to `PRE_FOLLOWER` has
    been committed. This implies releasing an anchor on the log. Since
    `new_node` is already a member of the configuration receiving log updates,
@@ -167,12 +167,12 @@ another doc.
 ### Steps:
 
 1. Run a tool to determine the most up-to-date remaining replica.
-2. Remote bootstrap additional nodes from the most up-to-date remaining node.
-   Wait for remote bootstrap to complete on all the nodes.
+2. Tablet Copy additional nodes from the most up-to-date remaining node.
+   Wait for tablet copy to complete on all the nodes.
 3. Bring all tablet servers hosting the affected tablet offline (TODO: This is
    possible to implement per-tablet but not currently supported)
 4. Run tool to rewrite the ConsensusMetadata file per-tablet server to
-   forcefully update the configuration membership to add remotely bootstrapped
+   forcefully update the configuration membership to add copied
    nodes as followers. TODO: Violates Raft not to append to the log, do we also
    need to do that?
 5. Bring the affected tablets / tablet servers back online.

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/docs/design-docs/raft-remote-bootstrap.md
----------------------------------------------------------------------
diff --git a/docs/design-docs/raft-remote-bootstrap.md b/docs/design-docs/raft-remote-bootstrap.md
index e5a2a81..66c11df 100644
--- a/docs/design-docs/raft-remote-bootstrap.md
+++ b/docs/design-docs/raft-remote-bootstrap.md
@@ -12,19 +12,19 @@ See the License for the specific language governing permissions and
 limitations under the License.
 -->
 
-# Kudu remote bootstrap design
+# Kudu tablet copy design
 
-Master & remote bootstrap integration with configuration change
+Master & tablet copy integration with configuration change
 
 ## Summary
 
-This document contains information on implementing remote bootstrap in the
+This document contains information on implementing tablet copy in the
 context of Kudu's Raft implementation. Details on Raft config change in Kudu
 can be found in the [Raft config change design doc](raft-config-change.md).
 
 ## Goals
 
-1. Integrate remote bootstrap to allow for copying over "snapshotted" data and
+1. Integrate tablet copy to allow for copying over "snapshotted" data and
    logs to a tablet replica when logs from the "beginning of time" are no
    longer available for replay.
 2. The Master needs to tolerate and facilitate dynamic consensus config change.
@@ -38,29 +38,29 @@ The Master will expose the following operations to admin users:
 1. `AddReplica(tablet_id, TS to_add, Role role)`
 2. `RemoveReplica(tablet_id, TS to_remove)`
 
-### New tablet server remote bootstrap RPC
+### New tablet server tablet copy RPC
 
-Remote bootstrap allows a tablet snapshot to be moved to a new server. A
-`StartRemoteBootstrap()` RPC call will be available on each tablet server. When a
+Tablet Copy allows a tablet snapshot to be moved to a new server. A
+`StartTabletCopy()` RPC call will be available on each tablet server. When a
 leader determines that a follower needs log entries prior to what is available
 on the leader side, or when it detects that a follower does not host a given
 tablet, it sends the follower an RPC to instruct the follower to initiate
-remote bootstrap. Optionally, this callback is made idempotent by passing the
+tablet copy. Optionally, this callback is made idempotent by passing the
 latest OpId in the follower's log as an argument.
 
-### Management of remote bootstrap jobs
+### Management of tablet copy jobs
 
-Since remotely bootstrapping a tablet may involve copying many GB of data, we
-likely need to support operational visibility into ongoing remote bootstrap
+Since copying a tablet may involve copying many GB of data, we
+likely need to support operational visibility into ongoing tablet copy
 jobs, run them on their own thread pool, support cancellation, etc. TBD to
 enumerate all of this in detail.
 
-## Design & implementation of tablet remote bootstrap
+## Design & implementation of tablet tablet copy
 
 ### Tablet auto-vivification
 
 A leader could cause a tablet to auto-create / auto-vivify itself if it doesn't
-already exist by sending a StartRemoteBootstrap RPC to the tablet server. Not
+already exist by sending a StartTabletCopy RPC to the tablet server. Not
 requiring the Master to explicitly invoke a CreateTablet() RPC before adding a
 replica to a consensus config makes adding a new peer much simpler to implement
 on the Master side.
@@ -77,7 +77,7 @@ given node:
 1. Master -> Leader: `AddServer(peer=Follower_new, role=PRE_VOTER)`
 
 The leader will then take care of detecting whether the tablet is out of date
-or does not exist, in which cases it must be remotely bootstrapped, or whether
+or does not exist, in which cases it must be copied, or whether
 it can be caught-up normally.
 
 ### Note on deleted tablets
@@ -89,17 +89,17 @@ losing data that was guaranteed to be persisted according to the consensus
 protocol. That situation is described in detail in this [raft-dev mailing list
 thread](https://groups.google.com/d/msg/raft-dev/CL1qWP7a_1w/OfHqmbcbIlAJ).
 
-To safely support deletion and remote bootstrap, a tablet will have 4 states
+To safely support deletion and tablet copy, a tablet will have 4 states
 its data can be in: `DOES_NOT_EXIST` (implicit; just the non-existence of state),
 `DELETED`, `COPYING`, and `READY`. `DOES_NOT_EXIST` just means a tablet with that name
 has never been hosted on the server, `DELETED` means it's tombstoned, `COPYING`
-means it's in the process of remote bootstrapping, and `READY` means it's in a
+means it's in the process of tablet copyping, and `READY` means it's in a
 normal, consistent state. More details about Tablet Deletion is in a later
 section.
 
-### Auto-vivifying remote bootstrap protocol
+### Auto-vivifying tablet copy protocol
 
-The remote bootstrap protocol between the leader and follower is as follows.
+The tablet copy protocol between the leader and follower is as follows.
 The leader always starts attempting to heartbeat to the follower:
 
 Leader -> Follower: `AppendEntries(from, to, term, prev_idx, ops[])`
@@ -118,14 +118,14 @@ AppendEntries(from, to, term, prev_idx, ops[]):
 
 If the leader gets back a `DOES_NOT_EXIST` or `DELETED` tablet status, it will
 repeatedly attempt to "auto-vivify" the tablet on the follower by sending a
-StartRemoteBootstrap RPC to the follower.
+StartTabletCopy RPC to the follower.
 
-On the follower, the `StartRemoteBootstrap` RPC is idempotent w.r.t. repeated RPC
+On the follower, the `StartTabletCopy` RPC is idempotent w.r.t. repeated RPC
 requests from the leader and has logic to create a tablet if it doesn't yet
 exist. Roughly:
 
 ```
-StartRemoteBootstrap(from, to, tablet, current_state, last_opid_in_log = NULL):
+StartTabletCopy(from, to, tablet, current_state, last_opid_in_log = NULL):
   if (to != self.uuid): ERR_INVALID_NAME
   if (this.tablet.state == COPYING): ERR_ALREADY_BOOTSTRAPPING
   if (this.tablet.state != current_state): ERR_ILLEGAL_STATE
@@ -135,11 +135,11 @@ StartRemoteBootstrap(from, to, tablet, current_state, last_opid_in_log = NULL):
     CreateTablet(COPYING) # Create tablet in "COPYING" mode.
   if (caller.term < self.term): ERR_BAD_TERM
   if (last_opid_in_log != NULL && != this.log.last_op.id): ERR_ILLEGAL_STATE
-  RunRemoteBootstrap() # Download the tablet data.
+  RunTabletCopy() # Download the tablet data.
 ```
 
 The detailed process, on the follower side, of downloading and replacing the
-data is detailed below under "Follower Remote Bootstrap".
+data is detailed below under "Follower Tablet Copy".
 
 ### Tablet directory structure
 
@@ -199,9 +199,9 @@ We can safely implement tablet deletion using the following steps:
    not stripe the WAL. If we were to stripe or multiplex the WAL in the future,
    we could add some kind of tablet-level sequence number, like a generation
    number, that gets incremented at the SuperBlock level when we initiate
-   remote bootstrap. That should keep us pointed at the relevant entries.
+   tablet copy. That should keep us pointed at the relevant entries.
 
-### Follower remote bootstrap
+### Follower tablet copy
 
 Remotely bootstrapping a tablet copies the data from the remote; merges the new
 and old consensus metadata files (if a local one already existed; otherwise the
@@ -315,8 +315,8 @@ possible to do as long as we retain consensus metadata indefinitely, which is
 required for correctness anyway. However this is not a top priority.
 
 One scenario where a `DELETED` tablet may need to vote to make forward progress
-is if a `VOTER` replica falls behind and so starts to remote bootstrap, crashes
-in the middle of remote bootstrap, and deletes itself at startup. Once we
+is if a `VOTER` replica falls behind and so starts to tablet copy, crashes
+in the middle of tablet copy, and deletes itself at startup. Once we
 implement `PRE_VOTER`, and always catch up as a `PRE_VOTER` before becoming a
 `VOTER`, the opportunity for potential problems with `VOTER`s is reduced a lot,
 especially around the initial step of adding a server to the cluster, but still

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/docs/whitepaper/kudu.tex
----------------------------------------------------------------------
diff --git a/docs/whitepaper/kudu.tex b/docs/whitepaper/kudu.tex
index dabc052..7cf9e90 100644
--- a/docs/whitepaper/kudu.tex
+++ b/docs/whitepaper/kudu.tex
@@ -363,11 +363,11 @@ by at most one in each configuration change. In order to grow a 3-replica config
 replicas, two separate configuration changes (3$\rightarrow$4, 4$\rightarrow$5) must be proposed
 and committed.
 
-Kudu implements the addition of new servers through a process called {\em remote bootstrap}.
+Kudu implements the addition of new servers through a process called {\em tablet copy}.
 In our design, in order to add a new replica, we first add it as a new member in the
 Raft configuration, even before notifying the destination server that a new replica will
 be copied to it. When this configuration change has been committed, the current Raft leader
-replica triggers a {\tt StartRemoteBootstrap} RPC, which causes the destination server to pull a
+replica triggers a {\tt StartTabletCopy} RPC, which causes the destination server to pull a
 snapshot of the tablet data and log from the current leader. When the transfer
 is complete, the new server opens the tablet following the same process as after
 a server restart. When the tablet has opened the tablet data and replayed any necessary
@@ -378,11 +378,11 @@ In our current implementation, new servers are added immediately as {\tt VOTER}
 the disadvantage that, after moving from a 3-server configuration to a 4-server configuration, three
 out of the four servers must acknowledge each operation. Because the new server is in the process of
 copying, it is unable to acknowledge operations. If another server were to crash during the
-snapshot-transfer process, the tablet would become unavailable for writes until the remote bootstrap
+snapshot-transfer process, the tablet would become unavailable for writes until the tablet copy
 finished.
 
 To address this issue, we plan to implement a {\tt PRE\_VOTER} replica state. In this
-state, the leader will send Raft updates and trigger remote bootstrap on the
+state, the leader will send Raft updates and trigger tablet copy on the
 target replica, but not count it as a voter when calculating the size of the configuration's
 majority. Upon detecting that the {\tt PRE\_VOTER} replica has fully caught up to
 the current logs, the leader will automatically propose and commit another configuration change to

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus.proto
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus.proto b/src/kudu/consensus/consensus.proto
index 0091080..3c18f84 100644
--- a/src/kudu/consensus/consensus.proto
+++ b/src/kudu/consensus/consensus.proto
@@ -451,7 +451,7 @@ message GetConsensusStateResponsePB {
   optional tserver.TabletServerErrorPB error = 2;
 }
 
-message StartRemoteBootstrapRequestPB {
+message StartTabletCopyRequestPB {
   // UUID of server this request is addressed to.
   optional bytes dest_uuid = 5;
 
@@ -467,7 +467,7 @@ message StartRemoteBootstrapRequestPB {
   optional int64 caller_term = 4 [ default = -1 ];
 }
 
-message StartRemoteBootstrapResponsePB {
+message StartTabletCopyResponsePB {
   optional tserver.TabletServerErrorPB error = 1;
 }
 
@@ -499,5 +499,5 @@ service ConsensusService {
   rpc GetConsensusState(GetConsensusStateRequestPB) returns (GetConsensusStateResponsePB);
 
   // Instruct this server to remotely bootstrap a tablet from another host.
-  rpc StartRemoteBootstrap(StartRemoteBootstrapRequestPB) returns (StartRemoteBootstrapResponsePB);
+  rpc StartTabletCopy(StartTabletCopyRequestPB) returns (StartTabletCopyResponsePB);
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus_peers.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.cc b/src/kudu/consensus/consensus_peers.cc
index 5363dea..2d4fa6c 100644
--- a/src/kudu/consensus/consensus_peers.cc
+++ b/src/kudu/consensus/consensus_peers.cc
@@ -61,13 +61,13 @@ DEFINE_double(fault_crash_after_leader_request_fraction, 0.0,
 TAG_FLAG(fault_crash_on_leader_request_fraction, unsafe);
 
 
-// Allow for disabling remote bootstrap in unit tests where we want to test
+// Allow for disabling tablet copy in unit tests where we want to test
 // certain scenarios without triggering bootstrap of a remote peer.
-DEFINE_bool(enable_remote_bootstrap, true,
-            "Whether remote bootstrap will be initiated by the leader when it "
+DEFINE_bool(enable_tablet_copy, true,
+            "Whether tablet copy will be initiated by the leader when it "
             "detects that a follower is out of date or does not have a tablet "
             "replica. For testing purposes only.");
-TAG_FLAG(enable_remote_bootstrap, unsafe);
+TAG_FLAG(enable_tablet_copy, unsafe);
 
 namespace kudu {
 namespace consensus {
@@ -174,11 +174,11 @@ Status Peer::SignalRequest(bool even_if_queue_empty) {
 
 void Peer::SendNextRequest(bool even_if_queue_empty) {
   // The peer has no pending request nor is sending: send the request.
-  bool needs_remote_bootstrap = false;
+  bool needs_tablet_copy = false;
   int64_t commit_index_before = request_.has_committed_index() ?
       request_.committed_index().index() : kMinimumOpIdIndex;
   Status s = queue_->RequestForPeer(peer_pb_.permanent_uuid(), &request_,
-                                    &replicate_msg_refs_, &needs_remote_bootstrap);
+                                    &replicate_msg_refs_, &needs_tablet_copy);
   int64_t commit_index_after = request_.has_committed_index() ?
       request_.committed_index().index() : kMinimumOpIdIndex;
 
@@ -189,10 +189,10 @@ void Peer::SendNextRequest(bool even_if_queue_empty) {
     return;
   }
 
-  if (PREDICT_FALSE(needs_remote_bootstrap)) {
-    Status s = SendRemoteBootstrapRequest();
+  if (PREDICT_FALSE(needs_tablet_copy)) {
+    Status s = SendTabletCopyRequest();
     if (!s.ok()) {
-      LOG_WITH_PREFIX_UNLOCKED(WARNING) << "Unable to generate remote bootstrap request for peer: "
+      LOG_WITH_PREFIX_UNLOCKED(WARNING) << "Unable to generate tablet copy request for peer: "
                                         << s.ToString();
       sem_.Release();
     }
@@ -294,28 +294,28 @@ void Peer::DoProcessResponse() {
   }
 }
 
-Status Peer::SendRemoteBootstrapRequest() {
-  if (!FLAGS_enable_remote_bootstrap) {
+Status Peer::SendTabletCopyRequest() {
+  if (!FLAGS_enable_tablet_copy) {
     failed_attempts_++;
-    return Status::NotSupported("remote bootstrap is disabled");
+    return Status::NotSupported("tablet copy is disabled");
   }
 
   LOG_WITH_PREFIX_UNLOCKED(INFO) << "Sending request to remotely bootstrap";
-  RETURN_NOT_OK(queue_->GetRemoteBootstrapRequestForPeer(peer_pb_.permanent_uuid(), &rb_request_));
+  RETURN_NOT_OK(queue_->GetTabletCopyRequestForPeer(peer_pb_.permanent_uuid(), &rb_request_));
   controller_.Reset();
-  proxy_->StartRemoteBootstrap(&rb_request_, &rb_response_, &controller_,
-                               boost::bind(&Peer::ProcessRemoteBootstrapResponse, this));
+  proxy_->StartTabletCopy(&rb_request_, &rb_response_, &controller_,
+                               boost::bind(&Peer::ProcessTabletCopyResponse, this));
   return Status::OK();
 }
 
-void Peer::ProcessRemoteBootstrapResponse() {
+void Peer::ProcessTabletCopyResponse() {
   if (controller_.status().ok() && rb_response_.has_error()) {
     // ALREADY_INPROGRESS is expected, so we do not log this error.
     if (rb_response_.error().code() ==
         TabletServerErrorPB::TabletServerErrorPB::ALREADY_INPROGRESS) {
       queue_->NotifyPeerIsResponsiveDespiteError(peer_pb_.permanent_uuid());
     } else {
-      LOG_WITH_PREFIX_UNLOCKED(WARNING) << "Unable to begin remote bootstrap on peer: "
+      LOG_WITH_PREFIX_UNLOCKED(WARNING) << "Unable to begin tablet copy on peer: "
                                         << rb_response_.ShortDebugString();
     }
   }
@@ -392,11 +392,11 @@ void RpcPeerProxy::RequestConsensusVoteAsync(const VoteRequestPB* request,
   consensus_proxy_->RequestConsensusVoteAsync(*request, response, controller, callback);
 }
 
-void RpcPeerProxy::StartRemoteBootstrap(const StartRemoteBootstrapRequestPB* request,
-                                        StartRemoteBootstrapResponsePB* response,
+void RpcPeerProxy::StartTabletCopy(const StartTabletCopyRequestPB* request,
+                                        StartTabletCopyResponsePB* response,
                                         rpc::RpcController* controller,
                                         const rpc::ResponseCallback& callback) {
-  consensus_proxy_->StartRemoteBootstrapAsync(*request, response, controller, callback);
+  consensus_proxy_->StartTabletCopyAsync(*request, response, controller, callback);
 }
 
 RpcPeerProxy::~RpcPeerProxy() {}

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus_peers.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_peers.h b/src/kudu/consensus/consensus_peers.h
index e10856f..f676c4c 100644
--- a/src/kudu/consensus/consensus_peers.h
+++ b/src/kudu/consensus/consensus_peers.h
@@ -160,15 +160,15 @@ class Peer {
   // Run on 'thread_pool'. Does response handling that requires IO or may block.
   void DoProcessResponse();
 
-  // Fetch the desired remote bootstrap request from the queue and send it
-  // to the peer. The callback goes to ProcessRemoteBootstrapResponse().
+  // Fetch the desired tablet copy request from the queue and send it
+  // to the peer. The callback goes to ProcessTabletCopyResponse().
   //
-  // Returns a bad Status if remote bootstrap is disabled, or if the
+  // Returns a bad Status if tablet copy is disabled, or if the
   // request cannot be generated for some reason.
-  Status SendRemoteBootstrapRequest();
+  Status SendTabletCopyRequest();
 
-  // Handle RPC callback from initiating remote bootstrap.
-  void ProcessRemoteBootstrapResponse();
+  // Handle RPC callback from initiating tablet copy.
+  void ProcessTabletCopyResponse();
 
   // Signals there was an error sending the request to the peer.
   void ProcessResponseError(const Status& status);
@@ -191,9 +191,9 @@ class Peer {
   ConsensusRequestPB request_;
   ConsensusResponsePB response_;
 
-  // The latest remote bootstrap request and response.
-  StartRemoteBootstrapRequestPB rb_request_;
-  StartRemoteBootstrapResponsePB rb_response_;
+  // The latest tablet copy request and response.
+  StartTabletCopyRequestPB rb_request_;
+  StartTabletCopyResponsePB rb_response_;
 
   // Reference-counted pointers to any ReplicateMsgs which are in-flight to the peer. We
   // may have loaded these messages from the LogCache, in which case we are potentially
@@ -249,9 +249,9 @@ class PeerProxy {
                                          rpc::RpcController* controller,
                                          const rpc::ResponseCallback& callback) = 0;
 
-  // Instructs a peer to begin a remote bootstrap session.
-  virtual void StartRemoteBootstrap(const StartRemoteBootstrapRequestPB* request,
-                                    StartRemoteBootstrapResponsePB* response,
+  // Instructs a peer to begin a tablet copy session.
+  virtual void StartTabletCopy(const StartTabletCopyRequestPB* request,
+                                    StartTabletCopyResponsePB* response,
                                     rpc::RpcController* controller,
                                     const rpc::ResponseCallback& callback) {
     LOG(DFATAL) << "Not implemented";
@@ -287,8 +287,8 @@ class RpcPeerProxy : public PeerProxy {
                                          rpc::RpcController* controller,
                                          const rpc::ResponseCallback& callback) OVERRIDE;
 
-  virtual void StartRemoteBootstrap(const StartRemoteBootstrapRequestPB* request,
-                                    StartRemoteBootstrapResponsePB* response,
+  virtual void StartTabletCopy(const StartTabletCopyRequestPB* request,
+                                    StartTabletCopyResponsePB* response,
                                     rpc::RpcController* controller,
                                     const rpc::ResponseCallback& callback) OVERRIDE;
 

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus_queue-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue-test.cc b/src/kudu/consensus/consensus_queue-test.cc
index fe10135..204f65f 100644
--- a/src/kudu/consensus/consensus_queue-test.cc
+++ b/src/kudu/consensus/consensus_queue-test.cc
@@ -113,9 +113,9 @@ class ConsensusQueueTest : public KuduTest {
     // Ask for a request. The queue assumes the peer is up-to-date so
     // this should contain no operations.
     vector<ReplicateRefPtr> refs;
-    bool needs_remote_bootstrap;
-    ASSERT_OK(queue_->RequestForPeer(kPeerUuid, request, &refs, &needs_remote_bootstrap));
-    ASSERT_FALSE(needs_remote_bootstrap);
+    bool needs_tablet_copy;
+    ASSERT_OK(queue_->RequestForPeer(kPeerUuid, request, &refs, &needs_tablet_copy));
+    ASSERT_FALSE(needs_tablet_copy);
     ASSERT_EQ(request->ops_size(), 0);
 
     // Refuse saying that the log matching property check failed and
@@ -220,9 +220,9 @@ TEST_F(ConsensusQueueTest, TestStartTrackingAfterStart) {
 
   // Getting a new request should get all operations after 7.50
   vector<ReplicateRefPtr> refs;
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(50, request.ops_size());
 
   SetLastReceivedAndLastCommitted(&response, request.ops(49).id());
@@ -230,8 +230,8 @@ TEST_F(ConsensusQueueTest, TestStartTrackingAfterStart) {
   ASSERT_FALSE(more_pending) << "Queue still had requests pending";
 
   // if we ask for a new request, it should come back empty
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(0, request.ops_size());
 
   // extract the ops from the request to avoid double free
@@ -281,9 +281,9 @@ TEST_F(ConsensusQueueTest, TestGetPagedMessages) {
   for (int i = 0; i < 11; i++) {
     VLOG(1) << "Making request " << i;
     vector<ReplicateRefPtr> refs;
-    bool needs_remote_bootstrap;
-    ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-    ASSERT_FALSE(needs_remote_bootstrap);
+    bool needs_tablet_copy;
+    ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+    ASSERT_FALSE(needs_tablet_copy);
     ASSERT_EQ(kOpsPerRequest, request.ops_size());
     last = request.ops(request.ops_size() -1).id();
     SetLastReceivedAndLastCommitted(&response, last);
@@ -292,9 +292,9 @@ TEST_F(ConsensusQueueTest, TestGetPagedMessages) {
     ASSERT_TRUE(more_pending);
   }
   vector<ReplicateRefPtr> refs;
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(1, request.ops_size());
   last = request.ops(request.ops_size() -1).id();
   SetLastReceivedAndLastCommitted(&response, last);
@@ -337,9 +337,9 @@ TEST_F(ConsensusQueueTest, TestPeersDontAckBeyondWatermarks) {
   ASSERT_OPID_EQ(queue_->GetMajorityReplicatedOpIdForTests(), MinimumOpId());
 
   vector<ReplicateRefPtr> refs;
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(50, request.ops_size());
 
   AppendReplicateMessagesToQueue(queue_.get(), clock_, 101, 100);
@@ -354,8 +354,8 @@ TEST_F(ConsensusQueueTest, TestPeersDontAckBeyondWatermarks) {
   ASSERT_OPID_EQ(queue_->GetAllReplicatedIndexForTests(), MakeOpId(14, 100));
 
   // if we ask for a new request, it should come back with the rest of the messages
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(100, request.ops_size());
 
   OpId expected = request.ops(99).id();
@@ -499,9 +499,9 @@ TEST_F(ConsensusQueueTest, TestQueueLoadsOperationsForPeer) {
   // When we get another request for the peer the queue should load
   // the missing operations.
   vector<ReplicateRefPtr> refs;
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(request.ops_size(), 50);
 
   // The messages still belong to the queue so we have to release them.
@@ -558,9 +558,9 @@ TEST_F(ConsensusQueueTest, TestQueueHandlesOperationOverwriting) {
 
   // Ask for a request. The queue assumes the peer is up-to-date so
   // this should contain no operations.
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(request.ops_size(), 0);
   ASSERT_OPID_EQ(request.preceding_id(), MakeOpId(2, 20));
   ASSERT_OPID_EQ(request.committed_index(), committed_index);
@@ -598,8 +598,8 @@ TEST_F(ConsensusQueueTest, TestQueueHandlesOperationOverwriting) {
 
   // Generate another request for the remote peer, which should include
   // all of the ops since the peer's last-known committed index.
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_OPID_EQ(MakeOpId(1, 5), request.preceding_id());
   ASSERT_EQ(16, request.ops_size());
 
@@ -713,9 +713,9 @@ TEST_F(ConsensusQueueTest, TestOnlyAdvancesWatermarkWhenPeerHasAPrefixOfOurLog)
 
   // When we get operations for this peer we should get them starting immediately after
   // the committed index, for a total of 9 operations.
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(request.ops_size(), 9);
   ASSERT_OPID_EQ(request.ops(0).id(), MakeOpId(72, 32));
   const OpId* last_op = &request.ops(request.ops_size() - 1).id();
@@ -736,8 +736,8 @@ TEST_F(ConsensusQueueTest, TestOnlyAdvancesWatermarkWhenPeerHasAPrefixOfOurLog)
   // Another request for this peer should get another page of messages. Still not
   // on the queue's term (and thus without advancing watermarks).
   request.mutable_ops()->ExtractSubrange(0, request.ops().size(), nullptr);
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(request.ops_size(), 9);
   ASSERT_OPID_EQ(request.ops(0).id(), MakeOpId(72, 41));
   last_op = &request.ops(request.ops_size() - 1).id();
@@ -755,8 +755,8 @@ TEST_F(ConsensusQueueTest, TestOnlyAdvancesWatermarkWhenPeerHasAPrefixOfOurLog)
   // The last page of request should overwrite the peer's operations and the
   // response should finally advance the watermarks.
   request.mutable_ops()->ExtractSubrange(0, request.ops().size(), nullptr);
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
   ASSERT_EQ(request.ops_size(), 4);
   ASSERT_OPID_EQ(request.ops(0).id(), MakeOpId(73, 50));
 
@@ -774,8 +774,8 @@ TEST_F(ConsensusQueueTest, TestOnlyAdvancesWatermarkWhenPeerHasAPrefixOfOurLog)
   request.mutable_ops()->ExtractSubrange(0, request.ops().size(), nullptr);
 }
 
-// Test that remote bootstrap is triggered when a "tablet not found" error occurs.
-TEST_F(ConsensusQueueTest, TestTriggerRemoteBootstrapIfTabletNotFound) {
+// Test that tablet copy is triggered when a "tablet not found" error occurs.
+TEST_F(ConsensusQueueTest, TestTriggerTabletCopyIfTabletNotFound) {
   queue_->Init(MinimumOpId());
   queue_->SetLeaderMode(MinimumOpId(), MinimumOpId().term(), BuildRaftConfigPBForTests(3));
   AppendReplicateMessagesToQueue(queue_.get(), clock_, 1, 100);
@@ -787,9 +787,9 @@ TEST_F(ConsensusQueueTest, TestTriggerRemoteBootstrapIfTabletNotFound) {
 
   // Create request for new peer.
   vector<ReplicateRefPtr> refs;
-  bool needs_remote_bootstrap;
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_FALSE(needs_remote_bootstrap);
+  bool needs_tablet_copy;
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_FALSE(needs_tablet_copy);
 
   // Peer responds with tablet not found.
   response.mutable_error()->set_code(tserver::TabletServerErrorPB::TABLET_NOT_FOUND);
@@ -797,16 +797,16 @@ TEST_F(ConsensusQueueTest, TestTriggerRemoteBootstrapIfTabletNotFound) {
   bool more_pending = false;
   queue_->ResponseFromPeer(kPeerUuid, response, &more_pending);
 
-  // If the peer needs remote bootstrap, more_pending should be set to true.
+  // If the peer needs tablet copy, more_pending should be set to true.
   ASSERT_TRUE(more_pending);
 
   // On the next request, we should find out that the queue wants us to remotely bootstrap.
   request.Clear();
-  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_remote_bootstrap));
-  ASSERT_TRUE(needs_remote_bootstrap);
+  ASSERT_OK(queue_->RequestForPeer(kPeerUuid, &request, &refs, &needs_tablet_copy));
+  ASSERT_TRUE(needs_tablet_copy);
 
-  StartRemoteBootstrapRequestPB rb_req;
-  ASSERT_OK(queue_->GetRemoteBootstrapRequestForPeer(kPeerUuid, &rb_req));
+  StartTabletCopyRequestPB rb_req;
+  ASSERT_OK(queue_->GetTabletCopyRequestForPeer(kPeerUuid, &rb_req));
 
   ASSERT_TRUE(rb_req.IsInitialized()) << rb_req.ShortDebugString();
   ASSERT_EQ(kTestTablet, rb_req.tablet_id());

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus_queue.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.cc b/src/kudu/consensus/consensus_queue.cc
index c936b4b..83039a5 100644
--- a/src/kudu/consensus/consensus_queue.cc
+++ b/src/kudu/consensus/consensus_queue.cc
@@ -83,11 +83,11 @@ METRIC_DEFINE_gauge_int64(tablet, in_progress_ops, "Leader Operations in Progres
 std::string PeerMessageQueue::TrackedPeer::ToString() const {
   return Substitute("Peer: $0, Is new: $1, Last received: $2, Next index: $3, "
                     "Last known committed idx: $4, Last exchange result: $5, "
-                    "Needs remote bootstrap: $6",
+                    "Needs tablet copy: $6",
                     uuid, is_new, OpIdToString(last_received), next_index,
                     last_known_committed_idx,
                     is_last_exchange_successful ? "SUCCESS" : "ERROR",
-                    needs_remote_bootstrap);
+                    needs_tablet_copy);
 }
 
 #define INSTANTIATE_METRIC(x) \
@@ -275,7 +275,7 @@ Status PeerMessageQueue::AppendOperations(const vector<ReplicateRefPtr>& msgs,
 Status PeerMessageQueue::RequestForPeer(const string& uuid,
                                         ConsensusRequestPB* request,
                                         vector<ReplicateRefPtr>* msg_refs,
-                                        bool* needs_remote_bootstrap) {
+                                        bool* needs_tablet_copy) {
   TrackedPeer* peer = nullptr;
   OpId preceding_id;
   {
@@ -313,12 +313,12 @@ Status PeerMessageQueue::RequestForPeer(const string& uuid,
     }
   }
 
-  if (PREDICT_FALSE(peer->needs_remote_bootstrap)) {
-    VLOG_WITH_PREFIX_UNLOCKED(1) << "Peer needs remote bootstrap: " << peer->ToString();
-    *needs_remote_bootstrap = true;
+  if (PREDICT_FALSE(peer->needs_tablet_copy)) {
+    VLOG_WITH_PREFIX_UNLOCKED(1) << "Peer needs tablet copy: " << peer->ToString();
+    *needs_tablet_copy = true;
     return Status::OK();
   }
-  *needs_remote_bootstrap = false;
+  *needs_tablet_copy = false;
 
   // If we've never communicated with the peer, we don't know what messages to
   // send, so we'll send a status-only request. Otherwise, we grab requests
@@ -387,8 +387,8 @@ Status PeerMessageQueue::RequestForPeer(const string& uuid,
   return Status::OK();
 }
 
-Status PeerMessageQueue::GetRemoteBootstrapRequestForPeer(const string& uuid,
-                                                          StartRemoteBootstrapRequestPB* req) {
+Status PeerMessageQueue::GetTabletCopyRequestForPeer(const string& uuid,
+                                                          StartTabletCopyRequestPB* req) {
   TrackedPeer* peer = nullptr;
   {
     std::lock_guard<simple_spinlock> lock(queue_lock_);
@@ -400,7 +400,7 @@ Status PeerMessageQueue::GetRemoteBootstrapRequestForPeer(const string& uuid,
     }
   }
 
-  if (PREDICT_FALSE(!peer->needs_remote_bootstrap)) {
+  if (PREDICT_FALSE(!peer->needs_tablet_copy)) {
     return Status::IllegalState("Peer does not need to remotely bootstrap", uuid);
   }
   req->Clear();
@@ -409,7 +409,7 @@ Status PeerMessageQueue::GetRemoteBootstrapRequestForPeer(const string& uuid,
   req->set_bootstrap_peer_uuid(local_peer_pb_.permanent_uuid());
   *req->mutable_bootstrap_peer_addr() = local_peer_pb_.last_known_addr();
   req->set_caller_term(queue_state_.current_term);
-  peer->needs_remote_bootstrap = false; // Now reset the flag.
+  peer->needs_tablet_copy = false; // Now reset the flag.
   return Status::OK();
 }
 
@@ -499,8 +499,8 @@ void PeerMessageQueue::ResponseFromPeer(const std::string& peer_uuid,
       CHECK_EQ(tserver::TabletServerErrorPB::TABLET_NOT_FOUND, response.error().code())
           << response.ShortDebugString();
 
-      peer->needs_remote_bootstrap = true;
-      VLOG_WITH_PREFIX_UNLOCKED(1) << "Marked peer as needing remote bootstrap: "
+      peer->needs_tablet_copy = true;
+      VLOG_WITH_PREFIX_UNLOCKED(1) << "Marked peer as needing tablet copy: "
                                      << peer->ToString();
       *more_pending = true;
       return;

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/consensus_queue.h
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/consensus_queue.h b/src/kudu/consensus/consensus_queue.h
index 6c22f68..bba6d41 100644
--- a/src/kudu/consensus/consensus_queue.h
+++ b/src/kudu/consensus/consensus_queue.h
@@ -75,7 +75,7 @@ class PeerMessageQueue {
           last_known_committed_idx(MinimumOpId().index()),
           is_last_exchange_successful(false),
           last_successful_communication_time(MonoTime::Now(MonoTime::FINE)),
-          needs_remote_bootstrap(false),
+          needs_tablet_copy(false),
           last_seen_term_(0) {}
 
     // Check that the terms seen from a given peer only increase
@@ -112,8 +112,8 @@ class PeerMessageQueue {
     // successful communication ever took place.
     MonoTime last_successful_communication_time;
 
-    // Whether the follower was detected to need remote bootstrap.
-    bool needs_remote_bootstrap;
+    // Whether the follower was detected to need tablet copy.
+    bool needs_tablet_copy;
 
    private:
     // The last term we saw from a given peer.
@@ -193,13 +193,13 @@ class PeerMessageQueue {
   virtual Status RequestForPeer(const std::string& uuid,
                                 ConsensusRequestPB* request,
                                 std::vector<ReplicateRefPtr>* msg_refs,
-                                bool* needs_remote_bootstrap);
+                                bool* needs_tablet_copy);
 
-  // Fill in a StartRemoteBootstrapRequest for the specified peer.
+  // Fill in a StartTabletCopyRequest for the specified peer.
   // If that peer should not remotely bootstrap, returns a non-OK status.
-  // On success, also internally resets peer->needs_remote_bootstrap to false.
-  virtual Status GetRemoteBootstrapRequestForPeer(const std::string& uuid,
-                                                  StartRemoteBootstrapRequestPB* req);
+  // On success, also internally resets peer->needs_tablet_copy to false.
+  virtual Status GetTabletCopyRequestForPeer(const std::string& uuid,
+                                                  StartTabletCopyRequestPB* req);
 
   // Update the last successful communication timestamp for the given peer
   // to the current time. This should be called when a non-network related

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/log_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/log_util.cc b/src/kudu/consensus/log_util.cc
index 80468e1..84043b6 100644
--- a/src/kudu/consensus/log_util.cc
+++ b/src/kudu/consensus/log_util.cc
@@ -215,7 +215,7 @@ Status LogEntryReader::HandleReadError(const Status& s) const {
   LOG(INFO) << "Ignoring log segment corruption in " << seg_->path_ << " because "
             << "there are no log entries following the corrupted one. "
             << "The server probably crashed in the middle of writing an entry "
-            << "to the write-ahead log or downloaded an active log via remote bootstrap. "
+            << "to the write-ahead log or downloaded an active log via tablet copy. "
             << "Error detail: " << corruption_status.ToString();
   return Status::EndOfFile("");
 }

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/consensus/raft_consensus-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/consensus/raft_consensus-test.cc b/src/kudu/consensus/raft_consensus-test.cc
index 52dfa97..6c6819e 100644
--- a/src/kudu/consensus/raft_consensus-test.cc
+++ b/src/kudu/consensus/raft_consensus-test.cc
@@ -81,7 +81,7 @@ class MockQueue : public PeerMessageQueue {
   MOCK_METHOD4(RequestForPeer, Status(const std::string& uuid,
                                       ConsensusRequestPB* request,
                                       std::vector<ReplicateRefPtr>* msg_refs,
-                                      bool* needs_remote_bootstrap));
+                                      bool* needs_tablet_copy));
   MOCK_METHOD3(ResponseFromPeer, void(const std::string& peer_uuid,
                                       const ConsensusResponsePB& response,
                                       bool* more_pending));

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/client_failover-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/client_failover-itest.cc b/src/kudu/integration-tests/client_failover-itest.cc
index de32b5f..1542679 100644
--- a/src/kudu/integration-tests/client_failover-itest.cc
+++ b/src/kudu/integration-tests/client_failover-itest.cc
@@ -59,7 +59,7 @@ TEST_P(ClientFailoverParamITest, TestDeleteLeaderWhileScanning) {
   const MonoDelta kTimeout = MonoDelta::FromSeconds(30);
 
   vector<string> ts_flags = { "--enable_leader_failure_detection=false",
-                              "--enable_remote_bootstrap=false" };
+                              "--enable_tablet_copy=false" };
   vector<string> master_flags = { "--master_add_server_when_underreplicated=false",
                                   "--catalog_manager_wait_for_new_tablets_to_elect_leader=false" };
 
@@ -171,13 +171,13 @@ TEST_P(ClientFailoverParamITest, TestDeleteLeaderWhileScanning) {
                       boost::none, kTimeout));
   HostPort hp;
   ASSERT_OK(HostPortFromPB(leader->registration.rpc_addresses(0), &hp));
-  ASSERT_OK(StartRemoteBootstrap(to_add, tablet_id, leader->uuid(), hp, 1, kTimeout));
+  ASSERT_OK(StartTabletCopy(to_add, tablet_id, leader->uuid(), hp, 1, kTimeout));
 
   const string& new_ts_uuid = cluster_->tablet_server(missing_replica_index)->uuid();
   InsertOrDie(&replica_indexes, missing_replica_index);
   InsertOrDie(&active_ts_map, new_ts_uuid, ts_map_[new_ts_uuid]);
 
-  // Wait for remote bootstrap to complete. Then elect the new node.
+  // Wait for tablet copy to complete. Then elect the new node.
   ASSERT_OK(WaitForServersToAgree(kTimeout, active_ts_map, tablet_id,
                                   workload.batches_completed() + 5));
   leader_index = missing_replica_index;

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/cluster_itest_util.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.cc b/src/kudu/integration-tests/cluster_itest_util.cc
index dd8e028..e9306c6 100644
--- a/src/kudu/integration-tests/cluster_itest_util.cc
+++ b/src/kudu/integration-tests/cluster_itest_util.cc
@@ -774,14 +774,14 @@ Status DeleteTablet(const TServerDetails* ts,
   return Status::OK();
 }
 
-Status StartRemoteBootstrap(const TServerDetails* ts,
+Status StartTabletCopy(const TServerDetails* ts,
                             const string& tablet_id,
                             const string& bootstrap_source_uuid,
                             const HostPort& bootstrap_source_addr,
                             int64_t caller_term,
                             const MonoDelta& timeout) {
-  consensus::StartRemoteBootstrapRequestPB req;
-  consensus::StartRemoteBootstrapResponsePB resp;
+  consensus::StartTabletCopyRequestPB req;
+  consensus::StartTabletCopyResponsePB resp;
   RpcController rpc;
   rpc.set_timeout(timeout);
 
@@ -791,7 +791,7 @@ Status StartRemoteBootstrap(const TServerDetails* ts,
   RETURN_NOT_OK(HostPortToPB(bootstrap_source_addr, req.mutable_bootstrap_peer_addr()));
   req.set_caller_term(caller_term);
 
-  RETURN_NOT_OK(ts->consensus_proxy->StartRemoteBootstrap(req, &resp, &rpc));
+  RETURN_NOT_OK(ts->consensus_proxy->StartTabletCopy(req, &resp, &rpc));
   if (resp.has_error()) {
     return StatusFromPB(resp.error().status());
   }

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/cluster_itest_util.h
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/cluster_itest_util.h b/src/kudu/integration-tests/cluster_itest_util.h
index 596e4a2..5ba3a8d 100644
--- a/src/kudu/integration-tests/cluster_itest_util.h
+++ b/src/kudu/integration-tests/cluster_itest_util.h
@@ -288,9 +288,9 @@ Status DeleteTablet(const TServerDetails* ts,
                     const MonoDelta& timeout,
                     tserver::TabletServerErrorPB::Code* error_code = NULL);
 
-// Cause the remote to initiate remote bootstrap using the specified host as a
+// Cause the remote to initiate tablet copy using the specified host as a
 // source.
-Status StartRemoteBootstrap(const TServerDetails* ts,
+Status StartTabletCopy(const TServerDetails* ts,
                             const std::string& tablet_id,
                             const std::string& bootstrap_source_uuid,
                             const HostPort& bootstrap_source_addr,

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/delete_table-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/delete_table-test.cc b/src/kudu/integration-tests/delete_table-test.cc
index 6a0d349..272efed 100644
--- a/src/kudu/integration-tests/delete_table-test.cc
+++ b/src/kudu/integration-tests/delete_table-test.cc
@@ -413,13 +413,13 @@ TEST_F(DeleteTableTest, TestDeleteTableWithConcurrentWrites) {
 }
 
 // Test that a tablet replica is automatically tombstoned on startup if a local
-// crash occurs in the middle of remote bootstrap.
-TEST_F(DeleteTableTest, TestAutoTombstoneAfterCrashDuringRemoteBootstrap) {
+// crash occurs in the middle of tablet copy.
+TEST_F(DeleteTableTest, TestAutoTombstoneAfterCrashDuringTabletCopy) {
   NO_FATALS(StartCluster());
   const MonoDelta timeout = MonoDelta::FromSeconds(10);
   const int kTsIndex = 0; // We'll test with the first TS.
 
-  // We'll do a config change to remote bootstrap a replica here later. For
+  // We'll do a config change to tablet copy a replica here later. For
   // now, shut it down.
   LOG(INFO) << "Shutting down TS " << cluster_->tablet_server(kTsIndex)->uuid();
   cluster_->tablet_server(kTsIndex)->Shutdown();
@@ -442,12 +442,12 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterCrashDuringRemoteBootstrap) {
   }
   workload.StopAndJoin();
 
-  // Enable a fault crash when remote bootstrap occurs on TS 0.
+  // Enable a fault crash when tablet copy occurs on TS 0.
   ASSERT_OK(cluster_->tablet_server(kTsIndex)->Restart());
   const string& kFaultFlag = "fault_crash_after_rb_files_fetched";
   ASSERT_OK(cluster_->SetFlag(cluster_->tablet_server(kTsIndex), kFaultFlag, "1.0"));
 
-  // Figure out the tablet id to remote bootstrap.
+  // Figure out the tablet id to tablet copy.
   vector<string> tablets = inspect_->ListTabletsOnTS(1);
   ASSERT_EQ(1, tablets.size());
   const string& tablet_id = tablets[0];
@@ -467,7 +467,7 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterCrashDuringRemoteBootstrap) {
   cluster_->tablet_server(1)->Shutdown();
   cluster_->tablet_server(2)->Shutdown();
 
-  // Now we restart the TS. It will clean up the failed remote bootstrap and
+  // Now we restart the TS. It will clean up the failed tablet copy and
   // convert it to TABLET_DATA_TOMBSTONED. It crashed, so we have to call
   // Shutdown() then Restart() to bring it back up.
   cluster_->tablet_server(kTsIndex)->Shutdown();
@@ -476,9 +476,9 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterCrashDuringRemoteBootstrap) {
 }
 
 // Test that a tablet replica automatically tombstones itself if the remote
-// bootstrap source server fails in the middle of the remote bootstrap process.
+// bootstrap source server fails in the middle of the tablet copy process.
 // Also test that we can remotely bootstrap a tombstoned tablet.
-TEST_F(DeleteTableTest, TestAutoTombstoneAfterRemoteBootstrapRemoteFails) {
+TEST_F(DeleteTableTest, TestAutoTombstoneAfterTabletCopyRemoteFails) {
   vector<string> ts_flags = {
       "--enable_leader_failure_detection=false",  // Make test deterministic.
       "--log_segment_size_mb=1"                   // Faster log rolls.
@@ -490,7 +490,7 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterRemoteBootstrapRemoteFails) {
   const MonoDelta kTimeout = MonoDelta::FromSeconds(20);
   const int kTsIndex = 0; // We'll test with the first TS.
 
-  // We'll do a config change to remote bootstrap a replica here later. For
+  // We'll do a config change to tablet copy a replica here later. For
   // now, shut down TS-0.
   LOG(INFO) << "Shutting down TS " << cluster_->tablet_server(kTsIndex)->uuid();
   cluster_->tablet_server(kTsIndex)->Shutdown();
@@ -525,7 +525,7 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterRemoteBootstrapRemoteFails) {
     SleepFor(MonoDelta::FromMilliseconds(10));
   }
 
-  // Remote bootstrap doesn't see the active WAL segment, and we need to
+  // Tablet Copy doesn't see the active WAL segment, and we need to
   // download a file to trigger the fault in this test. Due to the log index
   // chunks, that means 3 files minimum: One in-flight WAL segment, one index
   // chunk file (these files grow much more slowly than the WAL segments), and
@@ -552,7 +552,7 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterRemoteBootstrapRemoteFails) {
   NO_FATALS(WaitForTabletTombstonedOnTS(kTsIndex, tablet_id, CMETA_NOT_EXPECTED));
 
   // Now bring the other replicas back, re-elect the previous leader (TS-1),
-  // and wait for the leader to remote bootstrap the tombstoned replica. This
+  // and wait for the leader to tablet copy the tombstoned replica. This
   // will have replaced a tablet with no consensus metadata.
   ASSERT_OK(cluster_->tablet_server(1)->Restart());
   ASSERT_OK(cluster_->tablet_server(2)->Restart());
@@ -584,7 +584,7 @@ TEST_F(DeleteTableTest, TestAutoTombstoneAfterRemoteBootstrapRemoteFails) {
                             workload.rows_inserted()));
 }
 
-// Test for correct remote bootstrap merge of consensus metadata.
+// Test for correct tablet copy merge of consensus metadata.
 TEST_F(DeleteTableTest, TestMergeConsensusMetadata) {
   // Enable manual leader selection.
   vector<string> ts_flags, master_flags;
@@ -598,7 +598,7 @@ TEST_F(DeleteTableTest, TestMergeConsensusMetadata) {
   workload.Setup();
   ASSERT_OK(inspect_->WaitForReplicaCount(3));
 
-  // Figure out the tablet id to remote bootstrap.
+  // Figure out the tablet id to tablet copy.
   vector<string> tablets = inspect_->ListTabletsOnTS(1);
   ASSERT_EQ(1, tablets.size());
   const string& tablet_id = tablets[0];
@@ -658,7 +658,7 @@ TEST_F(DeleteTableTest, TestMergeConsensusMetadata) {
   ASSERT_OK(itest::WaitUntilLeader(leader, tablet_id, timeout));
 
   // Bring our special little guy back up.
-  // Wait until he gets remote bootstrapped.
+  // Wait until he gets tablet copyped.
   LOG(INFO) << "Bringing TS " << cluster_->tablet_server(kTsIndex)->uuid()
             << " back up...";
   ASSERT_OK(cluster_->tablet_server(kTsIndex)->Restart());
@@ -670,9 +670,9 @@ TEST_F(DeleteTableTest, TestMergeConsensusMetadata) {
   ASSERT_EQ(ts->uuid(), cmeta_pb.voted_for());
 
   // Now do the same thing as above, where we tombstone TS 0 then trigger a new
-  // term (term 3) on the other machines. TS 0 will get remotely bootstrapped
+  // term (term 3) on the other machines. TS 0 will get copied
   // again, but this time the vote record on TS 0 for term 2 should not be
-  // retained after remote bootstrap occurs.
+  // retained after tablet copy occurs.
   cluster_->tablet_server(1)->Shutdown();
   cluster_->tablet_server(2)->Shutdown();
 
@@ -1047,7 +1047,7 @@ TEST_P(DeleteTableTombstonedParamTest, TestTabletTombstone) {
   workload.StopAndJoin();
 
   // Shut down the master and the other tablet servers so they don't interfere
-  // by attempting to create tablets or remote bootstrap while we delete tablets.
+  // by attempting to create tablets or tablet copy while we delete tablets.
   cluster_->master()->Shutdown();
   cluster_->tablet_server(1)->Shutdown();
   cluster_->tablet_server(2)->Shutdown();

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/raft_consensus-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/raft_consensus-itest.cc b/src/kudu/integration-tests/raft_consensus-itest.cc
index 467d222..4a1d5f7 100644
--- a/src/kudu/integration-tests/raft_consensus-itest.cc
+++ b/src/kudu/integration-tests/raft_consensus-itest.cc
@@ -2090,7 +2090,7 @@ TEST_F(RaftConsensusITest, TestEarlyCommitDespiteMemoryPressure) {
   WaitForRowCount(replica_ts->tserver_proxy.get(), kNumOps, &rows);
 }
 
-// Test that we can create (vivify) a new tablet via remote bootstrap.
+// Test that we can create (vivify) a new tablet via tablet copy.
 TEST_F(RaftConsensusITest, TestAutoCreateReplica) {
   FLAGS_num_tablet_servers = 3;
   FLAGS_num_replicas = 2;
@@ -2481,7 +2481,7 @@ TEST_F(RaftConsensusITest, TestMasterReplacesEvictedFollowers) {
   NO_FATALS(CauseFollowerToFallBehindLogGC(&leader_uuid, &orig_term, &follower_uuid));
 
   // The follower will be evicted. Now wait for the master to cause it to be
-  // remotely bootstrapped.
+  // copied.
   ASSERT_OK(WaitForServersToAgree(timeout, tablet_servers_, tablet_id_, 2));
 
   ClusterVerifier v(cluster_.get());

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/remote_bootstrap-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/remote_bootstrap-itest.cc b/src/kudu/integration-tests/remote_bootstrap-itest.cc
index 9c9d0c7..0ada5fc 100644
--- a/src/kudu/integration-tests/remote_bootstrap-itest.cc
+++ b/src/kudu/integration-tests/remote_bootstrap-itest.cc
@@ -40,13 +40,13 @@
 #include "kudu/util/test_util.h"
 
 DEFINE_int32(test_delete_leader_num_iters, 3,
-             "Number of iterations to run in TestDeleteLeaderDuringRemoteBootstrapStressTest.");
+             "Number of iterations to run in TestDeleteLeaderDuringTabletCopyStressTest.");
 DEFINE_int32(test_delete_leader_min_rows_per_iter, 20,
-             "Number of writer threads in TestDeleteLeaderDuringRemoteBootstrapStressTest.");
+             "Number of writer threads in TestDeleteLeaderDuringTabletCopyStressTest.");
 DEFINE_int32(test_delete_leader_payload_bytes, 16 * 1024,
-             "Payload byte size in TestDeleteLeaderDuringRemoteBootstrapStressTest.");
+             "Payload byte size in TestDeleteLeaderDuringTabletCopyStressTest.");
 DEFINE_int32(test_delete_leader_num_writer_threads, 1,
-             "Number of writer threads in TestDeleteLeaderDuringRemoteBootstrapStressTest.");
+             "Number of writer threads in TestDeleteLeaderDuringTabletCopyStressTest.");
 
 using kudu::client::KuduClient;
 using kudu::client::KuduClientBuilder;
@@ -59,7 +59,7 @@ using kudu::itest::TServerDetails;
 using kudu::tablet::TABLET_DATA_DELETED;
 using kudu::tablet::TABLET_DATA_TOMBSTONED;
 using kudu::tserver::ListTabletsResponsePB;
-using kudu::tserver::RemoteBootstrapClient;
+using kudu::tserver::TabletCopyClient;
 using std::string;
 using std::unordered_map;
 using std::vector;
@@ -73,7 +73,7 @@ METRIC_DECLARE_counter(glog_error_messages);
 
 namespace kudu {
 
-class RemoteBootstrapITest : public KuduTest {
+class TabletCopyITest : public KuduTest {
  public:
   virtual void TearDown() OVERRIDE {
     if (HasFatalFailure()) {
@@ -106,7 +106,7 @@ class RemoteBootstrapITest : public KuduTest {
   unordered_map<string, TServerDetails*> ts_map_;
 };
 
-void RemoteBootstrapITest::StartCluster(const vector<string>& extra_tserver_flags,
+void TabletCopyITest::StartCluster(const vector<string>& extra_tserver_flags,
                                         const vector<string>& extra_master_flags,
                                         int num_tablet_servers) {
   ExternalMiniClusterOptions opts;
@@ -127,7 +127,7 @@ void RemoteBootstrapITest::StartCluster(const vector<string>& extra_tserver_flag
   ASSERT_OK(cluster_->CreateClient(builder, &client_));
 }
 
-// If a rogue (a.k.a. zombie) leader tries to remote bootstrap a tombstoned
+// If a rogue (a.k.a. zombie) leader tries to tablet copy a tombstoned
 // tablet, make sure its term isn't older than the latest term we observed.
 // If it is older, make sure we reject the request, to avoid allowing old
 // leaders to create a parallel universe. This is possible because config
@@ -135,7 +135,7 @@ void RemoteBootstrapITest::StartCluster(const vector<string>& extra_tserver_flag
 // because only one node can be elected leader for a given term.
 //
 // A leader can "go rogue" due to a VM pause, CTRL-z, partition, etc.
-TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
+TEST_F(TabletCopyITest, TestRejectRogueLeader) {
   // This test pauses for at least 10 seconds. Only run in slow-test mode.
   if (!AllowSlowTests()) {
     LOG(INFO) << "Skipping test in fast-test mode.";
@@ -180,7 +180,7 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
   // Come out of the blue and try to remotely bootstrap a running server while
   // specifying an old term. That running server should reject the request.
   // We are essentially masquerading as a rogue leader here.
-  Status s = itest::StartRemoteBootstrap(ts, tablet_id, zombie_leader_uuid,
+  Status s = itest::StartTabletCopy(ts, tablet_id, zombie_leader_uuid,
                                          HostPort(cluster_->tablet_server(1)->bound_rpc_addr()),
                                          0, // Say I'm from term 0.
                                          timeout);
@@ -201,7 +201,7 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
 
   // Wait for the NO_OP entry from the term 2 election to propagate to the
   // remaining nodes' logs so that we are guaranteed to reject the rogue
-  // leader's remote bootstrap request when we bring it back online.
+  // leader's tablet copy request when we bring it back online.
   int log_index = workload.batches_completed() + 2; // 2 terms == 2 additional NO_OP entries.
   ASSERT_OK(WaitForServersToAgree(timeout, active_ts_map, tablet_id, log_index));
   // TODO: Write more rows to the new leader once KUDU-1034 is fixed.
@@ -211,7 +211,7 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
   ASSERT_OK(itest::DeleteTablet(ts, tablet_id, TABLET_DATA_TOMBSTONED, boost::none, timeout));
 
   // Zombies!!! Resume the rogue zombie leader.
-  // He should attempt to remote bootstrap TS 0 but fail.
+  // He should attempt to tablet copy TS 0 but fail.
   ASSERT_OK(cluster_->tablet_server(zombie_leader_index)->Resume());
 
   // Loop for a few seconds to ensure that the tablet doesn't transition to READY.
@@ -225,7 +225,7 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
   }
 
   // Force the rogue leader to step down.
-  // Then, send a remote bootstrap start request from a "fake" leader that
+  // Then, send a tablet copy start request from a "fake" leader that
   // sends an up-to-date term in the RB request but the actual term stored
   // in the bootstrap source's consensus metadata would still be old.
   LOG(INFO) << "Forcing rogue leader T " << tablet_id << " P " << zombie_leader_uuid
@@ -235,12 +235,12 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
   // It's not necessarily part of the API but this could return faliure due to
   // rejecting the remote. We intend to make that part async though, so ignoring
   // this return value in this test.
-  ignore_result(itest::StartRemoteBootstrap(ts, tablet_id, zombie_leader_uuid,
+  ignore_result(itest::StartTabletCopy(ts, tablet_id, zombie_leader_uuid,
                                             HostPort(zombie_ets->bound_rpc_addr()),
                                             2, // Say I'm from term 2.
                                             timeout));
 
-  // Wait another few seconds to be sure the remote bootstrap is rejected.
+  // Wait another few seconds to be sure the tablet copy is rejected.
   deadline = MonoTime::Now(MonoTime::FINE);
   deadline.AddDelta(MonoDelta::FromSeconds(5));
   while (MonoTime::Now(MonoTime::FINE).ComesBefore(deadline)) {
@@ -251,13 +251,13 @@ TEST_F(RemoteBootstrapITest, TestRejectRogueLeader) {
   }
 }
 
-// Start remote bootstrap session and delete the tablet in the middle.
+// Start tablet copy session and delete the tablet in the middle.
 // It should actually be possible to complete bootstrap in such a case, because
-// when a remote bootstrap session is started on the "source" server, all of
+// when a tablet copy session is started on the "source" server, all of
 // the relevant files are either read or opened, meaning that an in-progress
-// remote bootstrap can complete even after a tablet is officially "deleted" on
+// tablet copy can complete even after a tablet is officially "deleted" on
 // the source server. This is also a regression test for KUDU-1009.
-TEST_F(RemoteBootstrapITest, TestDeleteTabletDuringRemoteBootstrap) {
+TEST_F(TabletCopyITest, TestDeleteTabletDuringTabletCopy) {
   MonoDelta timeout = MonoDelta::FromSeconds(10);
   const int kTsIndex = 0; // We'll test with the first TS.
   NO_FATALS(StartCluster());
@@ -280,7 +280,7 @@ TEST_F(RemoteBootstrapITest, TestDeleteTabletDuringRemoteBootstrap) {
   workload.StopAndJoin();
   ASSERT_OK(WaitForServersToAgree(timeout, ts_map_, tablet_id, workload.batches_completed()));
 
-  // Set up an FsManager to use with the RemoteBootstrapClient.
+  // Set up an FsManager to use with the TabletCopyClient.
   FsManagerOpts opts;
   string testbase = GetTestPath("fake-ts");
   ASSERT_OK(env_->CreateDir(testbase));
@@ -291,8 +291,8 @@ TEST_F(RemoteBootstrapITest, TestDeleteTabletDuringRemoteBootstrap) {
   ASSERT_OK(fs_manager->Open());
 
   {
-    // Start up a RemoteBootstrapClient and open a remote bootstrap session.
-    RemoteBootstrapClient rb_client(tablet_id, fs_manager.get(),
+    // Start up a TabletCopyClient and open a tablet copy session.
+    TabletCopyClient rb_client(tablet_id, fs_manager.get(),
                                     cluster_->messenger());
     scoped_refptr<tablet::TabletMetadata> meta;
     ASSERT_OK(rb_client.Start(cluster_->tablet_server(kTsIndex)->bound_rpc_hostport(),
@@ -317,9 +317,9 @@ TEST_F(RemoteBootstrapITest, TestDeleteTabletDuringRemoteBootstrap) {
 // This test ensures that a leader can remote-bootstrap a tombstoned replica
 // that has a higher term recorded in the replica's consensus metadata if the
 // replica's last-logged opid has the same term (or less) as the leader serving
-// as the remote bootstrap source. When a tablet is tombstoned, its last-logged
+// as the tablet copy source. When a tablet is tombstoned, its last-logged
 // opid is stored in a field its on-disk superblock.
-TEST_F(RemoteBootstrapITest, TestRemoteBootstrapFollowerWithHigherTerm) {
+TEST_F(TabletCopyITest, TestTabletCopyFollowerWithHigherTerm) {
   vector<string> ts_flags, master_flags;
   ts_flags.push_back("--enable_leader_failure_detection=false");
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
@@ -383,18 +383,18 @@ TEST_F(RemoteBootstrapITest, TestRemoteBootstrapFollowerWithHigherTerm) {
   ASSERT_OK(cluster_->tablet_server(kFollowerIndex)->Restart());
 
   // Now wake the leader. It should detect that the follower needs to be
-  // remotely bootstrapped and proceed to bring it back up to date.
+  // copied and proceed to bring it back up to date.
   ASSERT_OK(cluster_->tablet_server(kLeaderIndex)->Resume());
 
   // Wait for the follower to come back up.
   ASSERT_OK(WaitForServersToAgree(timeout, ts_map_, tablet_id, workload.batches_completed()));
 }
 
-// Test that multiple concurrent remote bootstraps do not cause problems.
+// Test that multiple concurrent tablet copys do not cause problems.
 // This is a regression test for KUDU-951, in which concurrent sessions on
-// multiple tablets between the same remote bootstrap client host and remote
+// multiple tablets between the same tablet copy client host and remote
 // bootstrap source host could corrupt each other.
-TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
+TEST_F(TabletCopyITest, TestConcurrentTabletCopys) {
   if (!AllowSlowTests()) {
     LOG(INFO) << "Skipping test in fast-test mode.";
     return;
@@ -414,7 +414,7 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
   const MonoDelta timeout = MonoDelta::FromSeconds(60);
 
   // Create a table with several tablets. These will all be simultaneously
-  // remotely bootstrapped to a single target node from the same leader host.
+  // copied to a single target node from the same leader host.
   const int kNumTablets = 10;
   KuduSchema client_schema(KuduSchemaFromSchema(GetSimpleTestSchema()));
   vector<const KuduPartialRow*> splits;
@@ -497,9 +497,9 @@ TEST_F(RemoteBootstrapITest, TestConcurrentRemoteBootstraps) {
 }
 
 // Test that repeatedly runs a load, tombstones a follower, then tombstones the
-// leader while the follower is remotely bootstrapping. Regression test for
+// leader while the follower is copying. Regression test for
 // KUDU-1047.
-TEST_F(RemoteBootstrapITest, TestDeleteLeaderDuringRemoteBootstrapStressTest) {
+TEST_F(TabletCopyITest, TestDeleteLeaderDuringTabletCopyStressTest) {
   // This test takes a while due to failure detection.
   if (!AllowSlowTests()) {
     LOG(INFO) << "Skipping test in fast-test mode.";
@@ -561,7 +561,7 @@ TEST_F(RemoteBootstrapITest, TestDeleteLeaderDuringRemoteBootstrapStressTest) {
     ASSERT_OK(itest::DeleteTablet(follower_ts, tablet_id, TABLET_DATA_TOMBSTONED, boost::none,
                                   timeout));
 
-    // Wait for remote bootstrap to start.
+    // Wait for tablet copy to start.
     ASSERT_OK(inspect_->WaitForTabletDataStateOnTS(
         follower_index, tablet_id,
         { tablet::TABLET_DATA_COPYING, tablet::TABLET_DATA_READY },
@@ -574,7 +574,7 @@ TEST_F(RemoteBootstrapITest, TestDeleteLeaderDuringRemoteBootstrapStressTest) {
 
     // Quiesce and rebuild to full strength. This involves electing a new
     // leader from the remaining three, which requires a unanimous vote, and
-    // that leader then remotely bootstrapping the old leader.
+    // that leader then copying the old leader.
     workload.StopAndJoin();
     ASSERT_OK(WaitForServersToAgree(timeout, ts_map_, tablet_id, 1));
   }
@@ -628,15 +628,15 @@ int64_t CountLogMessages(ExternalTabletServer* ets) {
 }
 } // anonymous namespace
 
-// Test that if remote bootstrap is disabled by a flag, we don't get into
+// Test that if tablet copy is disabled by a flag, we don't get into
 // tight loops after a tablet is deleted. This is a regression test for situation
 // similar to the bug described in KUDU-821: we were previously handling a missing
 // tablet within consensus in such a way that we'd immediately send another RPC.
-TEST_F(RemoteBootstrapITest, TestDisableRemoteBootstrap_NoTightLoopWhenTabletDeleted) {
+TEST_F(TabletCopyITest, TestDisableTabletCopy_NoTightLoopWhenTabletDeleted) {
   MonoDelta timeout = MonoDelta::FromSeconds(10);
   vector<string> ts_flags, master_flags;
   ts_flags.push_back("--enable_leader_failure_detection=false");
-  ts_flags.push_back("--enable_remote_bootstrap=false");
+  ts_flags.push_back("--enable_tablet_copy=false");
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(StartCluster(ts_flags, master_flags));
 
@@ -688,13 +688,13 @@ TEST_F(RemoteBootstrapITest, TestDisableRemoteBootstrap_NoTightLoopWhenTabletDel
   EXPECT_LT(num_logs_per_second, 20);
 }
 
-// Test that if a remote bootstrap is taking a long time but the client peer is still responsive,
+// Test that if a tablet copy is taking a long time but the client peer is still responsive,
 // the leader won't mark it as failed.
-TEST_F(RemoteBootstrapITest, TestSlowBootstrapDoesntFail) {
+TEST_F(TabletCopyITest, TestSlowBootstrapDoesntFail) {
   MonoDelta timeout = MonoDelta::FromSeconds(30);
   vector<string> ts_flags, master_flags;
   ts_flags.push_back("--enable_leader_failure_detection=false");
-  ts_flags.push_back("--remote_bootstrap_dowload_file_inject_latency_ms=5000");
+  ts_flags.push_back("--tablet_copy_dowload_file_inject_latency_ms=5000");
   ts_flags.push_back("--follower_unavailable_considered_failed_sec=2");
   master_flags.push_back("--catalog_manager_wait_for_new_tablets_to_elect_leader=false");
   NO_FATALS(StartCluster(ts_flags, master_flags));
@@ -732,7 +732,7 @@ TEST_F(RemoteBootstrapITest, TestSlowBootstrapDoesntFail) {
   ASSERT_OK(itest::DeleteTablet(replica_ts, tablet_id, TABLET_DATA_TOMBSTONED, boost::none,
                                 timeout));
 
-  // Wait for remote bootstrap to start.
+  // Wait for tablet copy to start.
   ASSERT_OK(inspect_->WaitForTabletDataStateOnTS(1, tablet_id,
                                                  { tablet::TABLET_DATA_COPYING }, timeout));
 
@@ -745,11 +745,11 @@ TEST_F(RemoteBootstrapITest, TestSlowBootstrapDoesntFail) {
                             workload.rows_inserted()));
 }
 
-// Attempting to start remote bootstrap on a tablet that was deleted with
+// Attempting to start tablet copy on a tablet that was deleted with
 // TABLET_DATA_DELETED should fail. This behavior helps avoid thrashing when
 // a follower tablet is deleted and the leader notices before it has processed
 // its own DeleteTablet RPC, thinking that it needs to bring its follower back.
-TEST_F(RemoteBootstrapITest, TestRemoteBootstrappingDeletedTabletFails) {
+TEST_F(TabletCopyITest, TestTabletCopypingDeletedTabletFails) {
   // Delete the leader with TABLET_DATA_DELETED
   // Attempt to manually bootstrap the leader from a follower
   // Should get an error saying it's illegal
@@ -783,7 +783,7 @@ TEST_F(RemoteBootstrapITest, TestRemoteBootstrappingDeletedTabletFails) {
   // bring back the leader after that until restarting the process.
   ASSERT_OK(itest::DeleteTablet(leader, tablet_id, TABLET_DATA_DELETED, boost::none, kTimeout));
 
-  Status s = itest::StartRemoteBootstrap(leader, tablet_id,
+  Status s = itest::StartTabletCopy(leader, tablet_id,
                                          cluster_->tablet_server(1)->uuid(),
                                          HostPort(cluster_->tablet_server(1)->bound_rpc_addr()),
                                          1, // We are in term 1.
@@ -792,11 +792,11 @@ TEST_F(RemoteBootstrapITest, TestRemoteBootstrappingDeletedTabletFails) {
   ASSERT_STR_CONTAINS(s.ToString(), "Cannot transition from state TABLET_DATA_DELETED");
 
   // Restart the server so that it won't remember the tablet was permanently
-  // deleted and we can remote bootstrap the server again.
+  // deleted and we can tablet copy the server again.
   cluster_->tablet_server(0)->Shutdown();
   ASSERT_OK(cluster_->tablet_server(0)->Restart());
 
-  ASSERT_OK(itest::StartRemoteBootstrap(leader, tablet_id,
+  ASSERT_OK(itest::StartTabletCopy(leader, tablet_id,
                                         cluster_->tablet_server(1)->uuid(),
                                         HostPort(cluster_->tablet_server(1)->bound_rpc_addr()),
                                         1, // We are in term 1.

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/integration-tests/tablet_replacement-itest.cc
----------------------------------------------------------------------
diff --git a/src/kudu/integration-tests/tablet_replacement-itest.cc b/src/kudu/integration-tests/tablet_replacement-itest.cc
index 7418238..e12cdef 100644
--- a/src/kudu/integration-tests/tablet_replacement-itest.cc
+++ b/src/kudu/integration-tests/tablet_replacement-itest.cc
@@ -219,7 +219,7 @@ TEST_F(TabletReplacementITest, TestEvictAndReplaceDeadFollower) {
 // bootstrap will attempt to replay committed (and applied) config change
 // operations. This is achieved by delaying application of a write at the
 // tablet level that precedes the config change operations in the WAL, then
-// initiating a remote bootstrap to a follower. The follower will not have the
+// initiating a tablet copy to a follower. The follower will not have the
 // COMMIT for the write operation, so will ignore COMMIT messages for the
 // applied config change operations. At startup time, the newly
 // remotely-bootstrapped tablet should detect that these config change

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/master/catalog_manager.cc
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.cc b/src/kudu/master/catalog_manager.cc
index 88382df..babe43c 100644
--- a/src/kudu/master/catalog_manager.cc
+++ b/src/kudu/master/catalog_manager.cc
@@ -186,7 +186,7 @@ using consensus::ConsensusStatePB;
 using consensus::GetConsensusRole;
 using consensus::OpId;
 using consensus::RaftPeerPB;
-using consensus::StartRemoteBootstrapRequestPB;
+using consensus::StartTabletCopyRequestPB;
 using rpc::RpcContext;
 using strings::Substitute;
 using tablet::TABLET_DATA_DELETED;
@@ -2088,10 +2088,10 @@ const NodeInstancePB& CatalogManager::NodeInstance() const {
   return master_->instance_pb();
 }
 
-Status CatalogManager::StartRemoteBootstrap(
-    const StartRemoteBootstrapRequestPB& req,
+Status CatalogManager::StartTabletCopy(
+    const StartTabletCopyRequestPB& req,
     boost::optional<kudu::tserver::TabletServerErrorPB::Code>* error_code) {
-  return Status::NotSupported("Remote bootstrap not yet implemented for the master tablet");
+  return Status::NotSupported("Tablet Copy not yet implemented for the master tablet");
 }
 
 // Interface used by RetryingTSRpcTask to pick the tablet server to

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/master/catalog_manager.h
----------------------------------------------------------------------
diff --git a/src/kudu/master/catalog_manager.h b/src/kudu/master/catalog_manager.h
index 29119f5..36a8f0c 100644
--- a/src/kudu/master/catalog_manager.h
+++ b/src/kudu/master/catalog_manager.h
@@ -500,8 +500,8 @@ class CatalogManager : public tserver::TabletPeerLookupIf {
 
   bool IsInitialized() const;
 
-  virtual Status StartRemoteBootstrap(
-      const consensus::StartRemoteBootstrapRequestPB& req,
+  virtual Status StartTabletCopy(
+      const consensus::StartTabletCopyRequestPB& req,
       boost::optional<kudu::tserver::TabletServerErrorPB::Code>* error_code) OVERRIDE;
 
   // Returns this CatalogManager's role in a consensus configuration. CatalogManager

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/tablet/metadata.proto
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/metadata.proto b/src/kudu/tablet/metadata.proto
index eb80611..5fae07a 100644
--- a/src/kudu/tablet/metadata.proto
+++ b/src/kudu/tablet/metadata.proto
@@ -53,9 +53,9 @@ enum TabletDataState {
   TABLET_DATA_UNKNOWN = 999;
 
   // The tablet is set to TABLET_DATA_COPYING state when in the middle of
-  // remote bootstrap while copying data files from a remote peer. If a tablet
+  // tablet copy while copying data files from a remote peer. If a tablet
   // server crashes with a tablet in this state, the tablet must be deleted and
-  // the remote bootstrap process must be restarted for that tablet.
+  // the tablet copy process must be restarted for that tablet.
   TABLET_DATA_COPYING = 0;
 
   // Fresh empty tablets and successfully copied tablets are set to the

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/tablet/tablet_bootstrap-test.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_bootstrap-test.cc b/src/kudu/tablet/tablet_bootstrap-test.cc
index 17de026..dd211a8 100644
--- a/src/kudu/tablet/tablet_bootstrap-test.cc
+++ b/src/kudu/tablet/tablet_bootstrap-test.cc
@@ -179,8 +179,8 @@ TEST_F(BootstrapTest, TestBootstrap) {
 }
 
 // Tests attempting a local bootstrap of a tablet that was in the middle of a
-// remote bootstrap before "crashing".
-TEST_F(BootstrapTest, TestIncompleteRemoteBootstrap) {
+// tablet copy before "crashing".
+TEST_F(BootstrapTest, TestIncompleteTabletCopy) {
   ASSERT_OK(BuildLog());
 
   ASSERT_OK(PersistTestTabletMetadataState(TABLET_DATA_COPYING));

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/tablet/tablet_bootstrap.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_bootstrap.cc b/src/kudu/tablet/tablet_bootstrap.cc
index 0fe9e09..300ac75 100644
--- a/src/kudu/tablet/tablet_bootstrap.cc
+++ b/src/kudu/tablet/tablet_bootstrap.cc
@@ -153,7 +153,7 @@ class FlushedStoresSnapshot {
 // has been appointed LEADER of that particular consensus configuration.
 //
 // NOTE: this does not handle pulling data from other replicas in the cluster. That
-// is handled by the 'RemoteBootstrap' classes, which copy blocks and metadata locally
+// is handled by the 'TabletCopy' classes, which copy blocks and metadata locally
 // before invoking this local bootstrap functionality.
 //
 // TODO Because the table that is being rebuilt is never flushed/compacted, consensus
@@ -468,7 +468,7 @@ Status TabletBootstrap::Bootstrap(shared_ptr<Tablet>* rebuilt_tablet,
                         "Unable to load Consensus metadata");
 
   // Make sure we don't try to locally bootstrap a tablet that was in the middle
-  // of a remote bootstrap. It's likely that not all files were copied over
+  // of a tablet copy. It's likely that not all files were copied over
   // successfully.
   TabletDataState tablet_data_state = meta_->tablet_data_state();
   if (tablet_data_state != TABLET_DATA_READY) {

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/tablet/tablet_metadata.h
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_metadata.h b/src/kudu/tablet/tablet_metadata.h
index 1d373c1..eea8aa2 100644
--- a/src/kudu/tablet/tablet_metadata.h
+++ b/src/kudu/tablet/tablet_metadata.h
@@ -132,7 +132,7 @@ class TabletMetadata : public RefCountedThreadSafe<TabletMetadata> {
     return partition_schema_;
   }
 
-  // Set / get the remote bootstrap / tablet data state.
+  // Set / get the tablet copy / tablet data state.
   void set_tablet_data_state(TabletDataState state);
   TabletDataState tablet_data_state() const;
 
@@ -323,7 +323,7 @@ class TabletMetadata : public RefCountedThreadSafe<TabletMetadata> {
   // Protected by 'data_lock_'.
   std::unordered_set<BlockId, BlockIdHash, BlockIdEqual> orphaned_blocks_;
 
-  // The current state of remote bootstrap for the tablet.
+  // The current state of tablet copy for the tablet.
   TabletDataState tablet_data_state_;
 
   // Record of the last opid logged by the tablet before it was last

http://git-wip-us.apache.org/repos/asf/kudu/blob/a6cb942e/src/kudu/tablet/tablet_peer.cc
----------------------------------------------------------------------
diff --git a/src/kudu/tablet/tablet_peer.cc b/src/kudu/tablet/tablet_peer.cc
index 013653e..c8e3646 100644
--- a/src/kudu/tablet/tablet_peer.cc
+++ b/src/kudu/tablet/tablet_peer.cc
@@ -390,7 +390,7 @@ string TabletPeer::HumanReadableState() const {
     return Substitute("$0 ($1): $2", TabletStatePB_Name(state_),
                       TabletDataState_Name(data_state),
                       error_.ToString());
-  // If it's remotely bootstrapping, or tombstoned, that is the important thing
+  // If it's copying, or tombstoned, that is the important thing
   // to show.
   } else if (data_state != TABLET_DATA_READY) {
     return TabletDataState_Name(data_state);


Mime
View raw message