anchor.diff:      Fun = fun(#?BUCKET{name = Bucket1,
                          acls = Permissions1,
                          redundancy_method = RedMethod,
  +                       cp_params = CPParams,
                          ec_params = ECParams,
                          created_at = Created1}, Acc) ->
                     BucketStr = binary_to_list(Bucket1),
                     PermissionsStr = leo_s3_bucket:aclinfo_to_str(Permissions1),
  -                  ECParamsStr = get_redundancy_method_str(RedMethod, ECParams),
  +
  +                  RedOptions = leo_redundant_manager_api:get_options(),
  +                  ECParamsStr = get_redundancy_method_str(
  +                                  RedMethod, CPParams, ECParams, RedOptions),
                     Created2  = case (Created1 > 0) of
                                     true  -> leo_date:date_format(Created1);
                                     false -> []
  
positive.code:                           acls  = Permissions,
                            cluster_id = ClusterId,
                            redundancy_method = RedMethod,
                            ec_params = ECParams,
                            created_at = Created_1}, Acc) ->
                    ClusterIdStr = atom_to_list(ClusterId),
                    BucketStr = binary_to_list(Bucket),
                    OwnerStr = binary_to_list(Owner),
                    PermissionsStr = leo_s3_bucket:aclinfo_to_str(Permissions),
                    ECParamsStr = get_redundancy_method_str(RedMethod, ECParams),
                    Created_2  = case (Created_1 > 0) of
                                    true ->
                                         leo_date:date_format(Created_1);
                                    false ->
                                         []
                                end,
                    Acc ++ io_lib:format("~s | ~s | ~s | ~s | ~s | ~s\r\n",
                                         [
                                          string:left(ClusterIdStr, Col_1_Len),
  
negative.code: 
  %% @doc Retrieve redundancy method str of the bucket
  %% @private
  get_redundancy_method_str(RedMethod, CPParams, ECParams, RedOptions) ->
      case RedMethod of
          'erasure_code' ->
              {ECParam_K, ECParam_M} = ECParams,
              lists:append([atom_to_list(RedMethod),
                            ",",
                            " {k:", integer_to_list(ECParam_K),
                            ", m:", integer_to_list(ECParam_M),
                            "}"
                           ]);
          _ ->
              {N, W, R, D} =
                  case CPParams of
                      {_,_,_,_} ->
                          CPParams;
                      _ ->
                          {leo_misc:get_value('n', RedOptions),
                           leo_misc:get_value('w', RedOptions),
                           leo_misc:get_value('r', RedOptions),
                           leo_misc:get_value('d', RedOptions)}
                  end,
              lists:append([atom_to_list(RedMethod),
                            ",",
                            " {n:", integer_to_list(N),
                            ", w:", integer_to_list(W),
                            ", r:", integer_to_list(R),
                            ", d:", integer_to_list(D),
                            "}"
                           ])
      end.
  
  
  