How to use org.apache.rocketmq.common.protocol.header.namesrv

public String getKVConfigValue(final String namespace, final String key, final long timeoutMillis)
  throws RemotingException, MQClientException, InterruptedException {
  GetKVConfigRequestHeader requestHeader = new GetKVConfigRequestHeader();
  requestHeader.setNamespace(namespace);
  requestHeader.setKey(key);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.GET_KV_CONFIG, requestHeader);
  RemotingCommand response = this.remotingClient.invokeSync(null, request, timeoutMillis);
  assert response != null;
  switch (response.getCode()) {
    case ResponseCode.SUCCESS: {
      GetKVConfigResponseHeader responseHeader =
        (GetKVConfigResponseHeader) response.decodeCommandCustomHeader(GetKVConfigResponseHeader.class);
      return responseHeader.getValue();
    }
    default:
      break;
  }
  throw new MQClientException(response.getCode(), response.getRemark());
}

public RemotingCommand getKVConfig(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(GetKVConfigResponseHeader.class);
  final GetKVConfigResponseHeader responseHeader = (GetKVConfigResponseHeader) response.readCustomHeader();
  final GetKVConfigRequestHeader requestHeader =
    (GetKVConfigRequestHeader) request.decodeCommandCustomHeader(GetKVConfigRequestHeader.class);
  String value = this.namesrvController.getKvConfigManager().getKVConfig(
    requestHeader.getNamespace(),
    requestHeader.getKey()
  );
  if (value != null) {
    responseHeader.setValue(value);
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
  }
  response.setCode(ResponseCode.QUERY_NOT_FOUND);
  response.setRemark("No config item, Namespace: " + requestHeader.getNamespace() + " Key: " + requestHeader.getKey());
  return response;
}

public RemotingCommand unregisterBroker(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(null);
  final UnRegisterBrokerRequestHeader requestHeader =
    (UnRegisterBrokerRequestHeader) request.decodeCommandCustomHeader(UnRegisterBrokerRequestHeader.class);
  this.namesrvController.getRouteInfoManager().unregisterBroker(
    requestHeader.getClusterName(),
    requestHeader.getBrokerAddr(),
    requestHeader.getBrokerName(),
    requestHeader.getBrokerId());
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  return response;
}

  requestHeader.getClusterName(),
  requestHeader.getBrokerAddr(),
  requestHeader.getBrokerName(),
  requestHeader.getBrokerId(),
  requestHeader.getHaServerAddr(),
  topicConfigWrapper,
  null,
);
responseHeader.setHaServerAddr(result.getHaServerAddr());
responseHeader.setMasterAddr(result.getMasterAddr());

public void unregisterBroker(
  final String namesrvAddr,
  final String clusterName,
  final String brokerAddr,
  final String brokerName,
  final long brokerId
) throws RemotingConnectException, RemotingSendRequestException, RemotingTimeoutException, InterruptedException, MQBrokerException {
  UnRegisterBrokerRequestHeader requestHeader = new UnRegisterBrokerRequestHeader();
  requestHeader.setBrokerAddr(brokerAddr);
  requestHeader.setBrokerId(brokerId);
  requestHeader.setBrokerName(brokerName);
  requestHeader.setClusterName(clusterName);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.UNREGISTER_BROKER, requestHeader);
  RemotingCommand response = this.remotingClient.invokeSync(namesrvAddr, request, 3000);
  assert response != null;
  switch (response.getCode()) {
    case ResponseCode.SUCCESS: {
      return;
    }
    default:
      break;
  }
  throw new MQBrokerException(response.getCode(), response.getRemark());
}

  public static boolean registerBrokerToNameServer(final String nsaddr, final String brokerAddr,
    final long timeoutMillis) {
    RegisterBrokerRequestHeader requestHeader = new RegisterBrokerRequestHeader();
    requestHeader.setBrokerAddr(brokerAddr);

    RemotingCommand request =
      RemotingCommand.createRequestCommand(RequestCode.REGISTER_BROKER, requestHeader);

    try {
      RemotingCommand response = RemotingHelper.invokeSync(nsaddr, request, timeoutMillis);
      if (response != null) {
        return ResponseCode.SUCCESS == response.getCode();
      }
    } catch (Exception e) {
      log.error("Failed to register broker", e);
    }

    return false;
  }
}

public void putKVConfigValue(final String namespace, final String key, final String value, final long timeoutMillis)
  throws RemotingException, MQClientException, InterruptedException {
  PutKVConfigRequestHeader requestHeader = new PutKVConfigRequestHeader();
  requestHeader.setNamespace(namespace);
  requestHeader.setKey(key);
  requestHeader.setValue(value);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.PUT_KV_CONFIG, requestHeader);
  List<String> nameServerAddressList = this.remotingClient.getNameServerAddressList();
  if (nameServerAddressList != null) {
    RemotingCommand errResponse = null;
    for (String namesrvAddr : nameServerAddressList) {
      RemotingCommand response = this.remotingClient.invokeSync(namesrvAddr, request, timeoutMillis);
      assert response != null;
      switch (response.getCode()) {
        case ResponseCode.SUCCESS: {
          break;
        }
        default:
          errResponse = response;
      }
    }
    if (errResponse != null) {
      throw new MQClientException(errResponse.getCode(), errResponse.getRemark());
    }
  }
}

public int wipeWritePermOfBroker(final String namesrvAddr, String brokerName,
  final long timeoutMillis) throws RemotingCommandException,
  RemotingConnectException, RemotingSendRequestException, RemotingTimeoutException, InterruptedException, MQClientException {
  WipeWritePermOfBrokerRequestHeader requestHeader = new WipeWritePermOfBrokerRequestHeader();
  requestHeader.setBrokerName(brokerName);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.WIPE_WRITE_PERM_OF_BROKER, requestHeader);
  RemotingCommand response = this.remotingClient.invokeSync(namesrvAddr, request, timeoutMillis);
  assert response != null;
  switch (response.getCode()) {
    case ResponseCode.SUCCESS: {
      WipeWritePermOfBrokerResponseHeader responseHeader =
        (WipeWritePermOfBrokerResponseHeader) response.decodeCommandCustomHeader(WipeWritePermOfBrokerResponseHeader.class);
      return responseHeader.getWipeTopicCount();
    }
    default:
      break;
  }
  throw new MQClientException(response.getCode(), response.getRemark());
}

public RemotingCommand putKVConfig(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(null);
  final PutKVConfigRequestHeader requestHeader =
    (PutKVConfigRequestHeader) request.decodeCommandCustomHeader(PutKVConfigRequestHeader.class);
  this.namesrvController.getKvConfigManager().putKVConfig(
    requestHeader.getNamespace(),
    requestHeader.getKey(),
    requestHeader.getValue()
  );
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  return response;
}

public void deleteKVConfigValue(final String namespace, final String key, final long timeoutMillis)
  throws RemotingException, MQClientException, InterruptedException {
  DeleteKVConfigRequestHeader requestHeader = new DeleteKVConfigRequestHeader();
  requestHeader.setNamespace(namespace);
  requestHeader.setKey(key);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.DELETE_KV_CONFIG, requestHeader);
  List<String> nameServerAddressList = this.remotingClient.getNameServerAddressList();
  if (nameServerAddressList != null) {
    RemotingCommand errResponse = null;
    for (String namesrvAddr : nameServerAddressList) {
      RemotingCommand response = this.remotingClient.invokeSync(namesrvAddr, request, timeoutMillis);
      assert response != null;
      switch (response.getCode()) {
        case ResponseCode.SUCCESS: {
          break;
        }
        default:
          errResponse = response;
      }
    }
    if (errResponse != null) {
      throw new MQClientException(errResponse.getCode(), errResponse.getRemark());
    }
  }
}

@Override
public void run() {
  try {
    QueryDataVersionRequestHeader requestHeader = new QueryDataVersionRequestHeader();
    requestHeader.setBrokerAddr(brokerAddr);
    requestHeader.setBrokerId(brokerId);
    requestHeader.setBrokerName(brokerName);
    requestHeader.setClusterName(clusterName);
    RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.QUERY_DATA_VERSION, requestHeader);
    request.setBody(topicConfigWrapper.getDataVersion().encode());
        QueryDataVersionResponseHeader queryDataVersionResponseHeader =
          (QueryDataVersionResponseHeader) response.decodeCommandCustomHeader(QueryDataVersionResponseHeader.class);
        changed = queryDataVersionResponseHeader.getChanged();
        byte[] body = response.getBody();
        if (body != null) {

private RemotingCommand wipeWritePermOfBroker(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(WipeWritePermOfBrokerResponseHeader.class);
  final WipeWritePermOfBrokerResponseHeader responseHeader = (WipeWritePermOfBrokerResponseHeader) response.readCustomHeader();
  final WipeWritePermOfBrokerRequestHeader requestHeader =
    (WipeWritePermOfBrokerRequestHeader) request.decodeCommandCustomHeader(WipeWritePermOfBrokerRequestHeader.class);
  int wipeTopicCnt = this.namesrvController.getRouteInfoManager().wipeWritePermOfBrokerByLock(requestHeader.getBrokerName());
  log.info("wipe write perm of broker[{}], client: {}, {}",
    requestHeader.getBrokerName(),
    RemotingHelper.parseChannelRemoteAddr(ctx.channel()),
    wipeTopicCnt);
  responseHeader.setWipeTopicCount(wipeTopicCnt);
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  return response;
}

public RemotingCommand deleteKVConfig(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(null);
  final DeleteKVConfigRequestHeader requestHeader =
    (DeleteKVConfigRequestHeader) request.decodeCommandCustomHeader(DeleteKVConfigRequestHeader.class);
  this.namesrvController.getKvConfigManager().deleteKVConfig(
    requestHeader.getNamespace(),
    requestHeader.getKey()
  );
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  return response;
}

public KVTable getKVListByNamespace(final String namespace, final long timeoutMillis)
  throws RemotingException, MQClientException, InterruptedException {
  GetKVListByNamespaceRequestHeader requestHeader = new GetKVListByNamespaceRequestHeader();
  requestHeader.setNamespace(namespace);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.GET_KVLIST_BY_NAMESPACE, requestHeader);
  RemotingCommand response = this.remotingClient.invokeSync(null, request, timeoutMillis);
  assert response != null;
  switch (response.getCode()) {
    case ResponseCode.SUCCESS: {
      return KVTable.decode(response.getBody(), KVTable.class);
    }
    default:
      break;
  }
  throw new MQClientException(response.getCode(), response.getRemark());
}

public TopicRouteData getTopicRouteInfoFromNameServer(final String topic, final long timeoutMillis,
  boolean allowTopicNotExist) throws MQClientException, InterruptedException, RemotingTimeoutException, RemotingSendRequestException, RemotingConnectException {
  GetRouteInfoRequestHeader requestHeader = new GetRouteInfoRequestHeader();
  requestHeader.setTopic(topic);
  RemotingCommand request = RemotingCommand.createRequestCommand(RequestCode.GET_ROUTEINTO_BY_TOPIC, requestHeader);
  RemotingCommand response = this.remotingClient.invokeSync(null, request, timeoutMillis);
  assert response != null;
  switch (response.getCode()) {
    case ResponseCode.TOPIC_NOT_EXIST: {
      if (allowTopicNotExist && !topic.equals(MixAll.AUTO_CREATE_TOPIC_KEY_TOPIC)) {
        log.warn("get Topic [{}] RouteInfoFromNameServer is not exist value", topic);
      }
      break;
    }
    case ResponseCode.SUCCESS: {
      byte[] body = response.getBody();
      if (body != null) {
        return TopicRouteData.decode(body, TopicRouteData.class);
      }
    }
    default:
      break;
  }
  throw new MQClientException(response.getCode(), response.getRemark());
}

  (RegisterBrokerResponseHeader) response.decodeCommandCustomHeader(RegisterBrokerResponseHeader.class);
RegisterBrokerResult result = new RegisterBrokerResult();
result.setMasterAddr(responseHeader.getMasterAddr());
result.setHaServerAddr(responseHeader.getHaServerAddr());
if (response.getBody() != null) {
  result.setKvTable(KVTable.decode(response.getBody(), KVTable.class));

public RemotingCommand queryBrokerTopicConfig(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(QueryDataVersionResponseHeader.class);
  final QueryDataVersionResponseHeader responseHeader = (QueryDataVersionResponseHeader) response.readCustomHeader();
  final QueryDataVersionRequestHeader requestHeader =
    (QueryDataVersionRequestHeader) request.decodeCommandCustomHeader(QueryDataVersionRequestHeader.class);
  DataVersion dataVersion = DataVersion.decode(request.getBody(), DataVersion.class);
  Boolean changed = this.namesrvController.getRouteInfoManager().isBrokerTopicConfigChanged(requestHeader.getBrokerAddr(), dataVersion);
  if (!changed) {
    this.namesrvController.getRouteInfoManager().updateBrokerInfoUpdateTimestamp(requestHeader.getBrokerAddr());
  }
  DataVersion nameSeverDataVersion = this.namesrvController.getRouteInfoManager().queryBrokerTopicConfig(requestHeader.getBrokerAddr());
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  if (nameSeverDataVersion != null) {
    response.setBody(nameSeverDataVersion.encode());
  }
  responseHeader.setChanged(changed);
  return response;
}

private RemotingCommand getKVListByNamespace(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(null);
  final GetKVListByNamespaceRequestHeader requestHeader =
    (GetKVListByNamespaceRequestHeader) request.decodeCommandCustomHeader(GetKVListByNamespaceRequestHeader.class);
  byte[] jsonValue = this.namesrvController.getKvConfigManager().getKVListByNamespace(
    requestHeader.getNamespace());
  if (null != jsonValue) {
    response.setBody(jsonValue);
    response.setCode(ResponseCode.SUCCESS);
    response.setRemark(null);
    return response;
  }
  response.setCode(ResponseCode.QUERY_NOT_FOUND);
  response.setRemark("No config item, Namespace: " + requestHeader.getNamespace());
  return response;
}

private RemotingCommand deleteTopicInNamesrv(ChannelHandlerContext ctx,
  RemotingCommand request) throws RemotingCommandException {
  final RemotingCommand response = RemotingCommand.createResponseCommand(null);
  final DeleteTopicInNamesrvRequestHeader requestHeader =
    (DeleteTopicInNamesrvRequestHeader) request.decodeCommandCustomHeader(DeleteTopicInNamesrvRequestHeader.class);
  this.namesrvController.getRouteInfoManager().deleteTopic(requestHeader.getTopic());
  response.setCode(ResponseCode.SUCCESS);
  response.setRemark(null);
  return response;
}

private boolean checksum(ChannelHandlerContext ctx, RemotingCommand request,
  RegisterBrokerRequestHeader requestHeader) {
  if (requestHeader.getBodyCrc32() != 0) {
    final int crc32 = UtilAll.crc32(request.getBody());
    if (crc32 != requestHeader.getBodyCrc32()) {
      log.warn(String.format("receive registerBroker request,crc32 not match,from %s",
        RemotingHelper.parseChannelRemoteAddr(ctx.channel())));
      return false;
    }
  }
  return true;
}