anchor.diff:              {reply, abort, State}
       end;
   
  +%% TODO: sending empty writeset to clocksi_downstream_generatro
  +%% Just a workaround, need to delete downstream_generator_vnode
  +%% eventually.
   handle_command({commit, Transaction, TxCommitTime}, _Sender,
                  #state{partition=_Partition,
                         committed_tx=CommittedTx,
  
positive.code:                                       Transaction#transaction.vec_snapshot_time}},
      Updates = ets:lookup(WriteSet, TxId),
      [{_, {Key, Type, {_Op, _Actor}}} | _Rest] = Updates,
      Result = floppy_rep_vnode:append(Key, Type, LogRecord),
      case Result of
          {ok, _} ->
              true = ets:insert(CommittedTx, {TxId, TxCommitTime}),
              _Return = clocksi_downstream_generator_vnode:trigger(
                      Key, {TxId,
                            Updates,
                            Transaction#transaction.vec_snapshot_time,
                            TxCommitTime}),
              clean_and_notify(TxId, Key, State),
              {reply, committed, State};
          {error, timeout} ->
              {reply, {error, timeout}, State}
      end;
  
negative.code:         false ->
              check_keylog(TxId, T, CommittedTx)
      end.
  
  update_materializer(Updates, TxId, SnapshotTime, TxCommitTime) ->
      DcId = dc_utilities:get_my_dc_id(),
      UpdateFunction = fun (Op, AccIn) -> 
                              {_, {OpKey, OpType, Param}} = Op,
                              CommittedDownstreamOp = #clocksi_payload{key = OpKey, 
                                                  type = OpType,        
                                                  op_param = Param,
                                                  snapshot_time = SnapshotTime,
                                                  commit_time = {DcId, TxCommitTime},
                                                  txid= TxId},
                              [AccIn || materializer_vnode:update_cache(OpKey, CommittedDownstreamOp)]
                      end,
      Results = lists:foldl(UpdateFunction, [], Updates),
      Failures = lists:filter(fun(Elem) -> Elem /= ok end, Results),
      case length(Failures) of
          0 ->
              ok;
          _ ->
              error
      end. 
  