private void AdjustLoadBalance(BrokerGroup group, int expectedNum, Response response)
{
if (!response.IsOk())
{
_loadBalance.Timeout(group);
return;
}
var result = response.Result;
if (result is Exception)
{
_loadBalance.Timeout(group);
return;
}
var messages = (List <BaseMessage>)result;
if (messages == null || messages.Count == 0)
{
_loadBalance.NoMessage(group);
return;
}
if (messages.Count >= expectedNum)
{
_loadBalance.FetchedEnoughMessages(group);
return;
}
_loadBalance.FetchedMessages(group);
}
private static List <BaseMessage> DeserializePulledMessages(BrokerGroup brokerGroup, byte[] content)
{
var messages = new List <BaseMessage>();
var packet = new Packet(content, 0, content.Length);
if (packet.IsReadable())
{
var pullLogOffset = packet.ReadInt64();
var consumerLogOffset = packet.ReadInt64();
while (packet.IsReadable())
{
var flag = (Flag)packet.ReadByte();
var createdTime = packet.ReadInt64();
var expiredTime = packet.ReadInt64();
var realSubject = RetrySubjectUtils.RealSubject(packet.ReadUTF8());
var messageId = packet.ReadUTF8();
var message = new BaseMessage(realSubject, messageId);
if (Flags.IsDelayMessage(flag))
{
message.SetDelayTime(DateTimeUtils.FromTime(expiredTime));
}
ReadTags(message, flag, packet);
var bodyLength = packet.ReadInt32();
var body = new byte[bodyLength];
packet.Read(body, 0, bodyLength);
var bodyPacket = new Packet(body, 0, bodyLength);
try
{
while (bodyPacket.IsReadable())
{
var key = bodyPacket.ReadUTF8();
var value = bodyPacket.ReadUTF8();
message.SetPropertyForInternal(key, value);
}
}
catch
{
message.SetProperty(BaseMessage.keys.qmq_corruptData, "true");
}
message.SetPropertyForInternal(BaseMessage.keys.qmq_createTime.ToString(), createdTime);
message.SetExpiredTime(DateTimeUtils.FromTime(expiredTime));
message.SetProperty(BaseMessage.keys.qmq_brokerGroupName, brokerGroup.Name);
message.SetProperty(BaseMessage.keys.qmq_pullOffset, pullLogOffset);
message.SetProperty(BaseMessage.keys.qmq_consumerOffset, consumerLogOffset);
messages.Add(message);
pullLogOffset++;
consumerLogOffset++;
}
}
return(messages);
}
private NewQmqClient CreateOrGetClient(BrokerGroup group)
{
var randClient = _clientManager.GetOrCreate(group);
if (randClient.Writtable)
{
return(randClient);
}
return(null);
}
public Response TransformResponse(BrokerGroup brokerGroup, Datagram datagram)
{
switch (datagram.Header.Code)
{
case CommandCode.Success:
return(new Response(datagram.Header.Opaque));
default:
Logger.Error($"ack failed. broker: {brokerGroup.Name}, code: {datagram.Header.Code}");
return(new Response(datagram.Header.Opaque, Response.Error));
}
}
private void Update(BrokerGroup group, double factor, int maxWeight)
{
if (!weights.TryGetValue(group.Name, out int weight))
{
weights.TryAdd(group.Name, DEFAULT_WEIGHT);
weight = DEFAULT_WEIGHT;
}
var newWeight = Math.Min(Math.Max((int)(factor * weight), MIN_WEIGHT), maxWeight);
weights.TryUpdate(group.Name, weight, weight);
}
private NewQmqClient Create(BrokerGroup brokerGroup)
{
var client = new NewQmqClient(brokerGroup, _transformer);
client.OnStateChanged += (sender, args) =>
{
if (args.State == State.Close)
{
_clients.TryRemove(brokerGroup.Master, out NewQmqClient temp);
}
};
return(client);
}
public Task <Response> Pull(BrokerGroup group, PullMessageRequest request)
{
var client = CreateOrGetClient(group);
if (client == null)
{
return(ErrorTask(new NoWritableBrokerException($"Cannot find pullable broker for {request.Subject}/{request.Group}")));
}
var ackHandlerQueue = _ackHandlerQueueManager.GetOrCreate(request.Subject, request.Group, client.BrokerGroupName, request.IsBroadcast);
request.PullOffsetBegin = ackHandlerQueue.MinPullOffset;
request.PullOffsetEnd = ackHandlerQueue.MaxPullOffset;
var timeout = request.TimeoutMillis < 0 ? MinRoundtripMs : (request.TimeoutMillis + MinRoundtripMs);
return(client.Send(new Request(request), timeout));
}
private NewQmqClient GetBrokerGroupClient(string brokerGroupName, string subject, string group)
{
var brokerGroups = _brokerGroupService.ConsumerGetSubjectCluster(subject, group).BrokerGroups;
if (brokerGroups.Count == 0 || !brokerGroups.ContainsKey(brokerGroupName))
{
return(null);
}
var brokerGroup = brokerGroups[brokerGroupName];
if (brokerGroup == null || !BrokerGroup.IsReadable(brokerGroup))
{
return(null);
}
return(_clientManager.GetOrCreate(brokerGroup));
}
public NewQmqClient GetOrCreate(BrokerGroup brokerGroup)
{
_clients.TryGetValue(brokerGroup.Master, out NewQmqClient client);
if (client != null)
{
client.WaitAvailable();
return(client);
}
var newClient = Create(brokerGroup);
var old = _clients.GetOrAdd(brokerGroup.Master, newClient);
if (newClient == old)
{
newClient.Connect();
newClient.WaitAvailable();
return(newClient);
}
old.WaitAvailable();
return(old);
}
public Response TransformResponse(BrokerGroup _, Datagram datagram)
{
switch (datagram.Header.Code)
{
case CommandCode.Success:
return(new Response(datagram.Header.Opaque)
{
Result = DeserializeSendResult(datagram.Body)
});
case CommandCode.BrokerReject:
return(new Response(datagram.Header.Opaque, Response.Error)
{
Result = new BrokerRejectException()
});
default:
return(new Response(datagram.Header.Opaque, Response.Error)
{
Result = new RemoteException()
});
}
}
// TODO(keli.wang): return list of messages or a special object?
public Response TransformResponse(BrokerGroup brokerGroup, Datagram datagram)
{
switch (datagram.Header.Code)
{
case CommandCode.Success:
return(new Response(datagram.Header.Opaque)
{
Result = DeserializePulledMessages(brokerGroup, datagram.Body)
});
case CommandCode.NoMessage:
return(new Response(datagram.Header.Opaque)
{
Result = new List <BaseMessage>()
});
default:
Logger.Error($"pull message failed. broker: {brokerGroup.Name}, code: {datagram.Header.Code}");
return(new Response(datagram.Header.Opaque)
{
Result = new List <BaseMessage>()
});
}
}
public void FetchedEnoughMessages(BrokerGroup group)
{
}
public void NoMessage(BrokerGroup group)
{
}
public void NoMessage(BrokerGroup group)
{
Update(group, 0.75, MAX_WEIGHT);
}
public void FetchedMessages(BrokerGroup group)
{
Update(group, 1.25, DEFAULT_WEIGHT);
}
public void FetchedEnoughMessages(BrokerGroup group)
{
Update(group, 1.5, MAX_WEIGHT);
}
public void Timeout(BrokerGroup group)
{
Update(group, 0.25, DEFAULT_WEIGHT);
}
public void Timeout(BrokerGroup group)
{
}
public void FetchedMessages(BrokerGroup group)
{
}
