Changing file name and record field names ...

... in order to extend rebalance progress to per stage rebalance
information.

Change-Id: I3c3a27468632c2cc0f21397f589d57a49b34137a
Reviewed-on: http://review.couchbase.org/101817
Reviewed-by: Aliaksey Artamonau <[email protected]>
Tested-by: Abhijeeth Nuthan <[email protected]>

Author: anuthan

src/ns_rebalance_observer.erl

@@ -44,16 +44,16 @@
 -record(state, {bucket :: bucket_name() | undefined,
                 buckets_count :: pos_integer(),
                 bucket_number :: non_neg_integer(),
-                progress :: rebalance_progress:progress(),
+                stage_info :: rebalance_progress:stage_info(),
                 nodes_info :: [{atom(), [node()]}],
                 type :: atom(),
                 done_moves :: [#move_state{}],
                 current_moves :: [#move_state{}],
                 pending_moves :: [#move_state{}]
                }).
 
-start_link(Services, NodesInfo, Type) ->
-    gen_server:start_link(?SERVER, ?MODULE, {Services, NodesInfo, Type}, []).
+start_link(Stages, NodesInfo, Type) ->
+    gen_server:start_link(?SERVER, ?MODULE, {Stages, NodesInfo, Type}, []).
 
 generic_get_call(Call) ->
     generic_get_call(Call, 10000).
@@ -71,8 +71,8 @@ get_detailed_progress() ->
 get_aggregated_progress(Timeout) ->
     generic_get_call(get_aggregated_progress, Timeout).
 
-update_progress(Service, ServiceProgress) ->
-    gen_server:cast(?SERVER, {update_progress, Service, ServiceProgress}).
+update_progress(Stage, StageProgress) ->
+    gen_server:cast(?SERVER, {update_progress, Stage, StageProgress}).
 
 is_interesting_master_event({_, bucket_rebalance_started, _Bucket, _Pid}) ->
     fun handle_bucket_rebalance_started/2;
@@ -85,7 +85,7 @@ is_interesting_master_event({_, vbucket_move_done, _BucketName, _VBucketId}) ->
 is_interesting_master_event(_) ->
     undefined.
 
-init({Services, NodesInfo, Type}) ->
+init({Stages, NodesInfo, Type}) ->
     Self = self(),
     ns_pubsub:subscribe_link(master_activity_events,
                              fun (Event, _Ignored) ->
@@ -98,14 +98,14 @@ init({Services, NodesInfo, Type}) ->
                              end, []),
 
     {active_nodes, ActiveNodes} = lists:keyfind(active_nodes, 1, NodesInfo),
-    Progress = rebalance_progress:init(ActiveNodes, Services),
+    StageInfo = rebalance_stage_info:init(ActiveNodes, Stages),
     BucketsCount = length(ns_bucket:get_buckets()),
     proc_lib:spawn_link(erlang, apply, [fun docs_left_updater_init/1, [Self]]),
 
     {ok, #state{bucket = undefined,
                 buckets_count = BucketsCount,
                 bucket_number = 0,
-                progress = Progress,
+                stage_info = StageInfo,
                 nodes_info = NodesInfo,
                 type = Type,
                 done_moves  = [],
@@ -117,8 +117,8 @@ handle_call(get, _From, State) ->
 handle_call(get_detailed_progress, _From, State) ->
     {reply, do_get_detailed_progress(State), State};
 handle_call(get_aggregated_progress, _From,
-            #state{progress = Progress} = State) ->
-    {reply, dict:to_list(rebalance_progress:get_progress(Progress)), State};
+            #state{stage_info = StageInfo} = State) ->
+    {reply, dict:to_list(rebalance_stage_info:get_progress(StageInfo)), State};
 handle_call(Req, From, State) ->
     ?log_error("Got unknown request: ~p from ~p", [Req, From]),
     {reply, unknown_request, State}.
@@ -172,10 +172,11 @@ handle_cast({update_stats, VBucket, NodeToDocsLeft}, State) ->
                         Move#move_state{stats = NewStats}
                 end)};
 
-handle_cast({update_progress, Service, ServiceProgress},
-            #state{progress = Old} = State) ->
-    NewProgress = rebalance_progress:update(Service, ServiceProgress, Old),
-    {noreply, State#state{progress = NewProgress}};
+handle_cast({update_progress, Stage, StageProgress},
+            #state{stage_info = Old} = State) ->
+    NewStageInfo = rebalance_stage_info:update_progress(
+                     Stage, StageProgress, Old),
+    {noreply, State#state{stage_info = NewStageInfo}};
 
 handle_cast(Req, _State) ->
     ?log_error("Got unknown cast: ~p", [Req]),

src/rebalance_progress.erl renamed to src/rebalance_stage_info.erl

@@ -13,64 +13,65 @@
 %% See the License for the specific language governing permissions and
 %% limitations under the License.
 %%
--module(rebalance_progress).
+-module(rebalance_stage_info).
 
--export([init/2, get_progress/1, update/3]).
--export_type([progress/0]).
+-export([init/2, get_progress/1, update_progress/3]).
+-export_type([stage_info/0]).
 
--record(progress, {
-          per_service :: dict:dict(),
+-record(stage_info, {
+          per_stage_progress :: dict:dict(),
           aggregated  :: dict:dict()
          }).
 
--type progress() :: #progress{}.
+-type stage_info() :: #stage_info{}.
 
-init(LiveNodes, Services) ->
+init(LiveNodes, Stages) ->
     do_init([{S, ns_cluster_membership:service_nodes(LiveNodes, S)} ||
-                S <- Services]).
+             S <- Stages]).
 
-do_init(Services) ->
-    aggregate(init_per_service(Services)).
+do_init(Stages) ->
+    aggregate(init_per_stage(Stages)).
 
-init_per_service(Services) ->
-    dict:from_list([{Service, init_service(Nodes)} ||
-                       {Service, Nodes} <- Services]).
+init_per_stage(Stages) ->
+    dict:from_list([{Stage, init_stage(Nodes)} ||
+                    {Stage, Nodes} <- Stages]).
 
-init_service(Nodes) ->
+init_stage(Nodes) ->
     dict:from_list([{N, 0} || N <- Nodes]).
 
-get_progress(#progress{aggregated = Aggregated}) ->
+get_progress(#stage_info{aggregated = Aggregated}) ->
     Aggregated.
 
-update(Service, ServiceProgress, #progress{per_service = PerService}) ->
-    aggregate(do_update(Service, ServiceProgress, PerService)).
+update_progress(Stage, StageProgress,
+                #stage_info{per_stage_progress = PerStage}) ->
+    aggregate(do_update_progress(Stage, StageProgress, PerStage)).
 
-do_update(Service, ServiceProgress, PerService) ->
-    dict:update(Service,
-                fun (OldServiceProgress) ->
+do_update_progress(Stage, StageProgress, PerStage) ->
+    dict:update(Stage,
+                fun (OldStageProgress) ->
                         dict:merge(fun (_, _, New) ->
                                            New
-                                   end, OldServiceProgress, ServiceProgress)
-                end, PerService).
+                                   end, OldStageProgress, StageProgress)
+                end, PerStage).
 
-aggregate(PerService) ->
+aggregate(PerStage) ->
     Aggregated0 =
         dict:fold(
-          fun (_, ServiceProgress, AggAcc) ->
+          fun (_, StageProgress, AggAcc) ->
                   dict:fold(
                     fun (Node, NodeProgress, Acc) ->
                             misc:dict_update(
                               Node,
                               fun ({Count, Sum}) ->
                                       {Count + 1, Sum + NodeProgress}
                               end, {0, 0}, Acc)
-                    end, AggAcc, ServiceProgress)
-          end, dict:new(), PerService),
+                    end, AggAcc, StageProgress)
+          end, dict:new(), PerStage),
 
     Aggregated =
         dict:map(fun (_, {Count, Sum}) ->
                          Sum / Count
                  end, Aggregated0),
 
-    #progress{per_service = PerService,
-              aggregated = Aggregated}.
+    #stage_info{per_stage_progress = PerStage,
+                aggregated = Aggregated}.