anchor.diff:      Ret.
   
   spawn_vbucket_compactor(BucketName, VBucketAndDb, Config, Force, Options) ->
  +    exit_if_uninhibit_requsted_for_non_parallel_compaction(),
       proc_lib:spawn_link(
         fun () ->
                 case maybe_compact_vbucket(BucketName, VBucketAndDb, Config, Force, Options) of
  
positive.code:                              #compaction_state{compactor_pid = CompactorPid,
                                                 scheduler = Scheduler} = CompactionState
                          } = State) ->
      NewState = case CompactorPid of
                     undefined ->
                         NewCompactionState =
                             CompactionState#compaction_state{
                               scheduler = compaction_scheduler:cancel(Scheduler)},
                         State#state{
                           view_compaction_uninhibit_started = true,
                           views_compaction =
                               compact_views_for_paused_bucket(BinBucketName, NewCompactionState)};
                     _ ->
                         State#state{view_compaction_uninhibit_started = false}
                 end,
      erlang:demonitor(State#state.view_compaction_inhibited_ref),
      {noreply, NewState#state{view_compaction_uninhibit_requested_waiter = From,
                               view_compaction_inhibited_ref = undefined,
                               view_compaction_uninhibit_requested = true}};
  handle_call({uninhibit_view_compaction, _BinBucketName, _MRef} = Msg, _From, State) ->
      ?log_debug("Sending back nack on uninhibit_view_compaction: ~p, state: ~p", [Msg, State]),
      {reply, nack, State};
  
negative.code: handle_call({is_bucket_inhibited, _BinBucketName}, _From, State) ->
      {reply, false, State};
  handle_call(is_uninhibited_requested, _From,
              #state{view_compaction_uninhibit_requested = Requested,
                     view_compaction_uninhibit_stop_kv = StopKV} = State) ->
      {reply, {Requested, StopKV}, State};
  handle_call(Event, _From, State) ->
      ?log_warning("Got unexpected call ~p:~n~p", [Event, State]),
      {reply, ok, State}.
  