public async Task CustomBlockingObeyed()
{
var processor = CreateProcessor();
processor.Start();
// Start up the first task that won't complete until we're sure both tasks started
var item1CompletionSource = new TaskCompletionSource <object>();
processor.Enqueue(testItemType, async _ =>
{
await item1CompletionSource.Task;
});
var didItem2Finish = false;
var blockedType = new QueueItemType("blocked", 1, isBlocked: (_, type) => !processor.IsQueueIdle(testItemType));
var item2 = new QueueItem(blockedType, async _ => didItem2Finish = true);
item2.StateChanged += (item, state) =>
{
if (state == QueueItemState.Waiting)
{
item1CompletionSource.SetResult(null);
}
};
processor.Enqueue(item2);
// Wait for everything to finish.
await processor.WaitForIdle();
Assert.IsTrue(didItem2Finish);
}
public QueueItem(QueueItemType type, string data)
{
Id = Guid.NewGuid();
Type = type;
Data = data;
QueueDate = DateTime.UtcNow;
}
public ProductionQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign, string fleetName) : base()
{
this.type = type;
this.quantity = quantity;
this.shipDesign = shipDesign;
this.fleetName = fleetName;
}
/// <summary>
/// ClearQueueItems
/// </summary>
/// <param name="type"></param>
public void ClearQueueItems(QueueItemType type)
{
switch (type)
{
case QueueItemType.QueueItems:
case QueueItemType.AllItems:
Q.Clear();
break;
}
}
public void Execute(IQueueable queueable, QueueItemType type)
{
using (var context = new QueueContext(_appSettingsService.ConnectionString))
{
var queueItem = new QueueItem(type, JsonConvert.SerializeObject(queueable));
context.QueueItems.Add(queueItem);
context.SaveChanges();
}
}
bool productionQueueHasType(List <ProductionQueueItem> items, QueueItemType type)
{
bool result = false;
foreach (ProductionQueueItem item in items)
{
result |= (item.getType() == type);
}
return(result);
}
private FeedQueueItem GetQueueItem(VkGroup @group, QueueItemType dataFeedType)
{
FeedQueueItem item = new FeedQueueItem()
{
VkGroupId = @group.Id,
QueueItemType = dataFeedType,
CreationDate = this.dateTimeHelper.GetDateTimeNow(),
};
return(item);
}
public QueueItem(GameObject item, QueueItemType type)
{
this.item = item;
buildTime = 15;
elapsedBuildTime = 0;
completed = false;
itemType = type;
if (type == QueueItemType.Building || type == QueueItemType.BuildingResources)
{
refundReturn = item.buyCost;
}
}
int productionQueueIndex(List <ProductionQueueItem> items, QueueItemType type)
{
int index = 0;
foreach (ProductionQueueItem item in items)
{
if (item.getType() == type)
{
break;
}
index++;
}
return(index);
}
public static LinkRest MakeQueueItemLink(QueueItemType itemType, Guid id)
{
string relation;
switch (itemType)
{
case QueueItemType.Message:
relation = RestRelations.MessageQueueItemRelation;
break;
default:
throw new ArgumentOutOfRangeException(nameof(itemType), itemType, null);
}
return new LinkRest(relation, "/" + QueueItemUrl.Replace("{id:guid}", id.ToString()));
}
/// <summary>
/// AddQueueItemToInboundFrame
/// Adds an RPC queue item to the outbound frame
/// </summary>
/// <param name="qItemType">type of rpc (client or server)</param>
/// <param name="timeStamp">when it was received</param>
/// <param name="sourceNetworkId">who sent the rpc</param>
/// <param name="message">the message being received</param>
internal void AddQueueItemToInboundFrame(QueueItemType qItemType, float timeStamp, ulong sourceNetworkId, NetworkBuffer message)
{
long originalPosition = message.Position;
NetworkUpdateStage updateStage;
using (var reader = PooledNetworkReader.Get(message))
{
var longValue = reader.ReadUInt64Packed(); // NetworkObjectId (temporary, we reset position just below)
var shortValue = reader.ReadUInt16Packed(); // NetworkBehaviourId (temporary, we reset position just below)
updateStage = (NetworkUpdateStage)reader.ReadByteDirect();
}
message.Position = originalPosition;
var rpcQueueHistoryItem = GetQueueHistoryFrame(RpcQueueHistoryFrame.QueueFrameType.Inbound, updateStage);
rpcQueueHistoryItem.IsDirty = true;
long StartPosition = rpcQueueHistoryItem.QueueBuffer.Position;
//Write the packed version of the queueItem to our current queue history buffer
rpcQueueHistoryItem.QueueWriter.WriteUInt16((ushort)qItemType);
rpcQueueHistoryItem.QueueWriter.WriteSingle(timeStamp);
rpcQueueHistoryItem.QueueWriter.WriteUInt64(sourceNetworkId);
//Inbound we copy the entire packet and store the position offset
long streamSize = message.Length;
rpcQueueHistoryItem.QueueWriter.WriteInt64(streamSize);
rpcQueueHistoryItem.QueueWriter.WriteInt64(message.Position);
rpcQueueHistoryItem.QueueWriter.WriteBytes(message.GetBuffer(), streamSize);
//Add the packed size to the offsets for parsing over various entries
rpcQueueHistoryItem.QueueItemOffsets.Add((uint)rpcQueueHistoryItem.QueueBuffer.Position);
//Calculate the packed size based on stream progression
rpcQueueHistoryItem.TotalSize += (uint)(rpcQueueHistoryItem.QueueBuffer.Position - StartPosition);
}
public QueueItem(QueueItemType t, Vec2 pt, int button)
{
type = t;
p.set(pt);
this.button = button;
}
public QueueItem(QueueItemType t)
{
type = t;
}
public QueueItem()
{
type = QueueItemType.LaunchBomb;
}
/**
* Add a ship that is to be built into a fleet to the Planet's ProductionQueue
*/
public void addQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign, string fleetName)
{
queue.getItems().Add(new ProductionQueueItem(type, quantity, shipDesign, fleetName));
}
/**
* Add an item to the Planet's ProductionQueue
*/
public void addQueueItem(QueueItemType type, int quantity)
{
queue.getItems().Add(new ProductionQueueItem(type, quantity));
}
public SimpleQueueItem(QueueItemType type, string id)
{
Id = id;
_type = type;
}
public ProductionQueueItem(QueueItemType type, int quantity) : base()
{
this.type = type;
this.quantity = quantity;
}
private IDequeueResolver GetDequeueResolverFor(QueueItemType queueItemType)
{
return(_dequeueResolvers.FirstOrDefault(dr => dr.ResolvesQueueItemType(queueItemType)));
}
/// <summary>
/// BeginAddQueueItemToOutboundFrame
/// Adds a queue item to the outbound queue frame
/// </summary>
/// <param name="qItemType">type of rpc (client or server)</param>
/// <param name="timeStamp">when it was scheduled to be sent</param>
/// <param name="networkChannel">the channel to send it on</param>
/// <param name="sourceNetworkId">who is sending the rpc</param>
/// <param name="targetNetworkIds">who the rpc is being sent to</param>
/// <returns></returns>
public PooledNetworkWriter BeginAddQueueItemToFrame(QueueItemType qItemType, float timeStamp, NetworkChannel networkChannel, ulong sourceNetworkId, ulong[] targetNetworkIds,
RpcQueueHistoryFrame.QueueFrameType queueFrameType, NetworkUpdateStage updateStage)
{
bool getNextFrame = NetworkManager.Singleton.IsHost && queueFrameType == RpcQueueHistoryFrame.QueueFrameType.Inbound;
var rpcQueueHistoryItem = GetQueueHistoryFrame(queueFrameType, updateStage, getNextFrame);
rpcQueueHistoryItem.IsDirty = true;
//Write the packed version of the queueItem to our current queue history buffer
rpcQueueHistoryItem.QueueWriter.WriteUInt16((ushort)qItemType);
rpcQueueHistoryItem.QueueWriter.WriteSingle(timeStamp);
rpcQueueHistoryItem.QueueWriter.WriteUInt64(sourceNetworkId);
if (queueFrameType != RpcQueueHistoryFrame.QueueFrameType.Inbound)
{
rpcQueueHistoryItem.QueueWriter.WriteByte((byte)networkChannel);
if (targetNetworkIds != null && targetNetworkIds.Length != 0)
{
//In the event the host is one of the networkIds, for outbound we want to ignore it (at this spot only!!)
//Get a count of clients we are going to send to (and write into the buffer)
var numberOfClients = 0;
for (int i = 0; i < targetNetworkIds.Length; i++)
{
if (NetworkManager.Singleton.IsHost && targetNetworkIds[i] == NetworkManager.Singleton.ServerClientId)
{
continue;
}
numberOfClients++;
}
//Write our total number of clients
rpcQueueHistoryItem.QueueWriter.WriteInt32(numberOfClients);
//Now write the cliend ids
for (int i = 0; i < targetNetworkIds.Length; i++)
{
if (NetworkManager.Singleton.IsHost && targetNetworkIds[i] == NetworkManager.Singleton.ServerClientId)
{
continue;
}
rpcQueueHistoryItem.QueueWriter.WriteUInt64(targetNetworkIds[i]);
}
}
else
{
rpcQueueHistoryItem.QueueWriter.WriteInt32(0);
}
}
//Mark where we started in the stream to later determine the actual RPC message size (position before writing RPC message vs position after write has completed)
rpcQueueHistoryItem.MarkCurrentStreamPosition();
//Write a filler dummy size of 0 to hold this position in order to write to it once the RPC is done writing.
rpcQueueHistoryItem.QueueWriter.WriteInt64(0);
if (NetworkManager.Singleton.IsHost && queueFrameType == RpcQueueHistoryFrame.QueueFrameType.Inbound)
{
if (!IsUsingBatching())
{
rpcQueueHistoryItem.QueueWriter.WriteInt64(1);
}
else
{
rpcQueueHistoryItem.QueueWriter.WriteInt64(0);
}
rpcQueueHistoryItem.HasLoopbackData = true; //The only case for this is when it is the Host
}
//Return the writer to the invoking method.
return(rpcQueueHistoryItem.QueueWriter);
}
public void AddQueueItem(GameObject item, QueueItemType type)
{
queueItems.Add(new QueueItem(item, type));
queueLength = queueItems.Count;
}
public QueueItem(QueueItemType itemType)
{
QueueItemType = (int)itemType;
}
public ProductionQueueItem(QueueItemType type, int quantity, ShipDesign shipDesign) : base()
{
this.type = type;
this.quantity = quantity;
this.shipDesign = shipDesign;
}
public QueueItem(QueueItemType t, char cr, int cd)
{
type = t;
c = cr;
code = cd;
}
public bool ResolvesQueueItemType(QueueItemType queueItemType) => queueItemType == QueueItemType.Email;
public bool ResolvesQueueItemType(QueueItemType queueItemType) => queueItemType == QueueItemType.Audit;
public void setType(QueueItemType type)
{
this.type = type;
}
