public MockedCabinetReader(IEnumerable<DataAvailableNotification> notifications)
{
_items = new Queue<DataAvailableNotification>(notifications);
Key = new CabinetKey(
_items.Peek().Recipient,
_items.Peek().Origin,
_items.Peek().ContentType);
}
public async Task SaveAsync_NullNotifications_ThrowsException()
{
// Arrange
var target = CreateTarget();
var cabinetKey = new CabinetKey(
new LegacyActorId(new GlobalLocationNumber("fake_value")),
DomainOrigin.Charges,
new ContentType("fake_value"));
// Act + Assert
await Assert
.ThrowsAsync <ArgumentNullException>(() =>
target.SaveAsync(cabinetKey, null !))
.ConfigureAwait(false);
}
private async Task <ICabinetReader> GetCabinetReaderAsync(CabinetKey cabinetKey)
{
var drawers = new List <CosmosCabinetDrawer>();
var content = new List <Task <IEnumerable <CosmosDataAvailable> > >();
await foreach (var drawer in GetCabinetDrawersAsync(cabinetKey).ConfigureAwait(false))
{
var drawerContent = GetCabinetDrawerContentsAsync(drawer);
drawers.Add(drawer);
content.Add(drawerContent);
}
var cabinetReader = new AsyncCabinetReader(cabinetKey, drawers, content);
await cabinetReader.InitializeAsync().ConfigureAwait(false);
return(cabinetReader);
}
private IAsyncEnumerable <CosmosCabinetDrawer> GetCabinetDrawersAsync(CabinetKey cabinetKey)
{
var partitionKey = string.Join(
'_',
cabinetKey.Recipient.Value,
cabinetKey.Origin,
cabinetKey.ContentType.Value);
var asLinq = _repositoryContainer
.Cabinet
.GetItemLinqQueryable <CosmosCabinetDrawer>();
var query =
from cabinetDrawer in asLinq
where
cabinetDrawer.PartitionKey == partitionKey &&
cabinetDrawer.Position < MaximumCabinetDrawerItemCount
orderby cabinetDrawer.OrderBy
select cabinetDrawer;
return(query.Take(MaximumCabinetDrawersInRequest).AsCosmosIteratorAsync());
}
private Task <CosmosCabinetDrawer?> FindExistingDrawerWithFreeSpaceAsync(CabinetKey cabinetKey)
{
var asLinq = _repositoryContainer
.Cabinet
.GetItemLinqQueryable <CosmosCabinetDrawer>();
var partitionKey = string.Join(
'_',
cabinetKey.Recipient.Value,
cabinetKey.Origin,
cabinetKey.ContentType.Value);
var query =
from cabinetDrawer in asLinq
where
cabinetDrawer.PartitionKey == partitionKey &&
cabinetDrawer.Position < MaximumCabinetDrawerItemCount
orderby cabinetDrawer.OrderBy descending
select cabinetDrawer;
return(query
.AsCosmosIteratorAsync()
.FirstOrDefaultAsync());
}
//private void OnGUI()
//{
// GUI.Label(new Rect(10, 10, 100, 80), "test float: " + testFloat);
//}
public void Save()
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream dataFile = File.Create(Application.persistentDataPath + "/TrainOfBotDataFile.dat");
Data data = new Data();
data.testFloat = 0.0f;
data.storageRoomBoxPos = StorageRoomBox.FindObjectOfType <Transform>().position;
data.testCharacterCanRecieve = true;
data.testCharacterCanGive = true;
//ITEMS
data.bottleOfBoltsTaken = BottleOfBolts.FindObjectOfType <BottleOfBolts>().taken;
data.cabinetKeyTaken = CabinetKey.FindObjectOfType <CabinetKey>().taken;
data.chefsSpoonTaken = ChefsSpoon.FindObjectOfType <ChefsSpoon>().taken;
data.cookedMechanicalDinnerTaken = CookedMechanicalDinner.FindObjectOfType <CookedMechanicalDinner>().taken;
data.earmuffsTaken = Earmuffs.FindObjectOfType <Earmuffs>().taken;
data.frozenMechanicalDinnerTaken = FrozenMechanicalDinner.FindObjectOfType <FrozenMechanicalDinner>().taken;
data.gasCanisterTaken = GasCanister.FindObjectOfType <GasCanister>().taken;
data.passengersEyeTaken = PassengersEye.FindObjectOfType <PassengersEye>().taken;
data.plungerTaken = Plunger.FindObjectOfType <Plunger>().taken;
data.rattleTaken = Rattle.FindObjectOfType <Rattle>().taken;
data.valveTaken = Valve.FindObjectOfType <Valve>().taken;
data.plungerThrown = Plunger.FindObjectOfType <Plunger>().thrown;
//NPCS
data.earmuffsGuyCanGive = EarmuffsGuy.FindObjectOfType <EarmuffsGuy>().canGiveItem;
data.earmuffsGuyCanRecieve = EarmuffsGuy.FindObjectOfType <EarmuffsGuy>().canRecieveItem;
data.eyeRobotCanGive = EyeRobot.FindObjectOfType <EyeRobot>().canGiveItem;
data.eyeRobotCanRecieve = EyeRobot.FindObjectOfType <EyeRobot>().canRecieveItem;
data.chefCanGive = Chef.FindObjectOfType <Chef>().canGiveItem;
data.chefCanRecieve = Chef.FindObjectOfType <Chef>().canRecieveItem;
data.chefFrozen = Chef.FindObjectOfType <Chef>().frozen;
data.womanRobotCanGive = WomanRobot.FindObjectOfType <WomanRobot>().canGiveItem;
data.womanRobotCanRecieve = WomanRobot.FindObjectOfType <WomanRobot>().canRecieveItem;
data.cabinetCanGive = Cabinet.FindObjectOfType <Cabinet>().canGiveItem;
data.cabinetCanRecieve = Cabinet.FindObjectOfType <Cabinet>().canRecieveItem;
data.toiletcanRecieve = Toilet.FindObjectOfType <Toilet>().canRecieveItem;
data.hoboThrew = HoboRobot.FindObjectOfType <HoboRobot>().hoboThrew;
data.nozzleCanRecieve = Nozzle.FindObjectOfType <Nozzle>().canRecieveItem;
//ROBOT SPECIFIC
data.robotLeftBathroom = BathroomRobot.FindObjectOfType <BathroomRobot>().leftBathroom;
//DOG
data.dogEating = Dog.FindObjectOfType <Dog>().eating;
data.dogLocation = Dog.FindObjectOfType <Transform>().position;
//DOG BOWL
data.bowlHasFood = DogBowl.FindObjectOfType <DogBowl>().hasFood;
data.dinnerActive = DogBowl.FindObjectOfType <DogBowl>().dinnerActive;
//WORKTABLE
data.canRecieveChefsSpoon = Worktable.FindObjectOfType <Worktable>().canRecieveChefsSpoon;
data.canRecieveBottle = Worktable.FindObjectOfType <Worktable>().canRecieveBottle;
data.tableCanGiveItem = Worktable.FindObjectOfType <Worktable>().canGiveItem;
//STOVE
data.canRecieveFMD = Stove.FindObjectOfType <Stove>().canRecieveFMD;
data.canRecieveGasCanister = Stove.FindObjectOfType <Stove>().canRecieveGasCanister;
data.stoveCanGiveItem = Stove.FindObjectOfType <Stove>().canGiveItem;
// Data data = new Data
// {
// testFloat = 0.0f
// };
binaryFormatter.Serialize(dataFile, data);
dataFile.Close();
}
public async Task SaveAsync(CabinetKey key, IReadOnlyList <DataAvailableNotification> notifications)
{
ArgumentNullException.ThrowIfNull(key, nameof(key));
ArgumentNullException.ThrowIfNull(notifications, nameof(notifications));
var nextDrawer = await FindExistingDrawerWithFreeSpaceAsync(key).ConfigureAwait(false);
var nextDrawerItemCount = nextDrawer != null
? await CountItemsInDrawerAsync(nextDrawer).ConfigureAwait(false)
: 0;
for (var i = 0; i < notifications.Count; i++)
{
var notification = notifications[i];
Debug.Assert(key == new CabinetKey(notification), "All notifications should belong to the provided key.");
if (await CheckIdempotencyAsync(notification).ConfigureAwait(false))
{
continue;
}
if (nextDrawer is null)
{
nextDrawer = CreateEmptyDrawer(notification);
nextDrawerItemCount = 0;
await _repositoryContainer
.Cabinet
.CreateItemAsync(nextDrawer)
.ConfigureAwait(false);
}
if (nextDrawer.Position == nextDrawerItemCount)
{
var catalogEntry = CreateCatalogEntry(notification);
await _repositoryContainer
.Catalog
.CreateItemAsync(catalogEntry)
.ConfigureAwait(false);
}
var cosmosDataAvailable = CosmosDataAvailableMapper.Map(notification, nextDrawer.Id);
await _repositoryContainer
.Cabinet
.CreateItemAsync(cosmosDataAvailable)
.ConfigureAwait(false);
var itemsLeft = notifications.Count - (i + 1);
var spaceLeft = MaximumCabinetDrawerItemCount - (nextDrawerItemCount + 1);
var itemsToFill = notifications
.Skip(i + 1)
.Take(Math.Min(itemsLeft, spaceLeft));
var itemsInserted = await FillCabinetDrawerAsync(nextDrawer, itemsToFill).ConfigureAwait(false);
i += itemsInserted;
nextDrawerItemCount += itemsInserted;
nextDrawerItemCount++;
Debug.Assert(nextDrawerItemCount <= MaximumCabinetDrawerItemCount, "Too many items were inserted into a single drawer.");
if (nextDrawerItemCount == MaximumCabinetDrawerItemCount)
{
nextDrawer = null;
}
}
}
public async Task <ICabinetReader?> GetNextUnacknowledgedAsync(ActorId recipient, params DomainOrigin[] domains)
{
ArgumentNullException.ThrowIfNull(recipient, nameof(recipient));
ArgumentNullException.ThrowIfNull(domains, nameof(domains));
if (domains.Length == 0)
{
domains = Enum.GetValues <DomainOrigin>();
}
var entryLookups = domains
.Where(domain => domain != DomainOrigin.Unknown)
.Select(domain =>
{
var asLinq = _repositoryContainer
.Catalog
.GetItemLinqQueryable <CosmosCatalogEntry>();
var partitionKey = string.Join('_', recipient.Value, domain);
var query =
from catalogEntry in asLinq
where catalogEntry.PartitionKey == partitionKey
orderby catalogEntry.NextSequenceNumber
select catalogEntry;
var task = query
.Take(1)
.AsCosmosIteratorAsync()
.FirstOrDefaultAsync();
return(new { domain, task });
});
var smallestDomain = DomainOrigin.Unknown;
CosmosCatalogEntry?smallestEntry = null;
foreach (var entryLookup in entryLookups.ToList())
{
var catalogEntry = await entryLookup.task.ConfigureAwait(false);
if (catalogEntry == null)
{
continue;
}
if (smallestEntry == null || smallestEntry.NextSequenceNumber > catalogEntry.NextSequenceNumber)
{
smallestEntry = catalogEntry;
smallestDomain = entryLookup.domain;
}
}
var maximumSequenceNumber = await _sequenceNumberRepository
.GetMaximumSequenceNumberAsync()
.ConfigureAwait(false);
if (smallestEntry == null || smallestEntry.NextSequenceNumber > maximumSequenceNumber.Value)
{
return(null);
}
var cabinetKey = new CabinetKey(
recipient,
smallestDomain,
new ContentType(smallestEntry.ContentType));
var cabinetReader = await GetCabinetReaderAsync(cabinetKey).ConfigureAwait(false);
if (cabinetReader.CanPeek)
{
var nextItem = cabinetReader.Peek();
if (nextItem.SequenceNumber.Value == smallestEntry.NextSequenceNumber)
{
return(cabinetReader);
}
}
// If SaveAsync fails to insert DataAvailable, for example due to crash/timeout,
// there will be a catalog entry pointing to a non-existent item.
await DeleteOldCatalogEntryAsync(smallestEntry).ConfigureAwait(false);
return(null);
}
public Task SaveAsync(CabinetKey key, IReadOnlyList <DataAvailableNotification> notifications)
{
return(_dataAvailableNotificationRepository.SaveAsync(key, notifications));
}
