public SeriesIndexSearch(IServerConfigurationManager configurationManager, IHttpClient httpClient)
{
_configurationManager = configurationManager;
_httpClient = httpClient;
_cache = new Dictionary<string, string[]>();
_lock = new AsyncLock();
}
public void TestGuardLock2()
{
for (int i = 0; i != 10; ++i)
{
using (var guard = new AsyncLock())
{
var results = new ConcurrentQueue<int>();
var t2 = Task.Run(
async () =>
{
Thread.Sleep(TimeSpan.FromMilliseconds(200));
using (await guard.LockAsync(CancellationToken.None))
results.Enqueue(2);
});
var t1 = Task.Run(
async () =>
{
using (await guard.LockAsync(CancellationToken.None))
{
Thread.Sleep(TimeSpan.FromMilliseconds(400));
results.Enqueue(1);
}
});
Task.WaitAll(t1, t2);
var resultsData = results.ToArray();
Assert.Equal(1, resultsData[0]);
Assert.Equal(2, resultsData[1]);
}
}
}
public async Task Simple()
{
var _lock = new AsyncLock();
using( await _lock ) {
Console.WriteLine( "Locked" );
}
}
public async Task SyncIntellisenseFiles()
{
var mutex = new AsyncLock();
using (mutex.LockAsync())
{
if (_lastCheck > DateTime.Now.AddDays(-_days))
return;
_lastCheck = DateTime.Now;
try
{
string catalog = await GetCataLog();
if (!string.IsNullOrEmpty(catalog))
{
await DownloadIntellisenseFiles(catalog);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
}
public void MaybeScheduleCompaction(AsyncLock.LockScope locker)
{
Debug.Assert(locker != null && locker.Locked);
if (state.BackgroundCompactionScheduled)
{
return; // already scheduled, nothing to do
}
if (state.CancellationToken.IsCancellationRequested)
{
return; // DB is being disposed; no more background compactions
}
if (manualCompactor != null && manualCompactor.InProgress)
{
return; // manual already in progress
}
if (state.ImmutableMemTable == null &&
state.VersionSet.NeedsCompaction == false)
{
// No work to be done
return;
}
state.BackgroundCompactionScheduled = true;
Background.Work(ScheduleCompactionAsync());
}
public async Task WritePayloadAsync(NetworkStream ns, object payload, AsyncLock writerLock, CancellationToken cancellationToken = default(CancellationToken)) {
var ms = memoryStreamPool.TakeObject();
Serialize.To(ms, payload);
using (await writerLock.LockAsync(cancellationToken).ConfigureAwait(false)) {
await WriteMemoryStreamAsync(ns, ms, 0, (int)ms.Position, cancellationToken).ConfigureAwait(false);
}
ms.SetLength(0);
memoryStreamPool.ReturnObject(ms);
}
public async Task ReentrantAware()
{
var _lock = new AsyncLock();
using( await _lock ) {
Console.WriteLine( "In lock" );
using( await _lock ) {
Console.WriteLine( "Re-entrant lock" );
}
}
}
public async Task LockReleaseLockRelease()
{
var _lock = new AsyncLock();
using( await _lock ) {
Console.WriteLine( "Locked" );
}
using( await _lock ) {
Console.WriteLine( "Locked again" );
}
}
public async Task ExceptionShouldUnlockTheLock()
{
var _lock = new AsyncLock();
Assert.That( _lock.HasLock, Is.False );
try {
using( await _lock ) {
Assert.That( _lock.HasLock, Is.True );
throw new Exception();
}
}
catch( Exception e ) { }
Assert.That( _lock.HasLock, Is.False );
}
public async Task ExceptionShouldFlow()
{
var _lock = new AsyncLock();
try {
using( await _lock ) {
throw new Exception( "Hello World" );
}
Assert.Fail( "Should never hit this line of code" );
}
catch( Exception e ) {
Assert.That( e.Message, Is.EqualTo( "Hello World" ) );
Trace.WriteLine( "Got Exception" );
}
}
protected Task RunCompactionAsync(AsyncLock.LockScope locker)
{
Debug.Assert(state.BackgroundCompactionScheduled);
state.BackgroundTask = Task.Factory.StartNew(async () =>
{
using (LogManager.OpenMappedContext("storage", state.DatabaseName))
using (await locker.LockAsync())
{
try
{
bool needToWait = false;
try
{
await semaphore.WaitAsync();
await BackgroundCompactionAsync(locker).ConfigureAwait(false);
}
catch (Exception e)
{
log.ErrorException(string.Format("Compaction error: {0}", e.Message), e);
needToWait = true;
}
// Wait a little bit before retrying background compaction in
// case this is an environmental problem and we do not want to
// chew up resources for failed compactions for the duration of
// the problem.
if (needToWait)
{
locker.Exit();
await Task.Delay(1000).ConfigureAwait(false);
await locker.LockAsync().ConfigureAwait(false);
}
await BackgroundCompactionAsync(locker).ConfigureAwait(false);
}
finally
{
semaphore.Release();
state.BackgroundCompactionScheduled = false;
}
}
return 1; // make R# happy
}, TaskCreationOptions.LongRunning).Unwrap();
return state.BackgroundTask;
}
public async Task AsyncLock()
{
var _lock = new AsyncLock();
using( await _lock ) {
// warmup
}
var start = Stopwatch.GetTimestamp();
for( var i = 0; i < Iterations; i++ ) {
using( await _lock ) {
i--;
i++;
}
}
ReportTime( start );
}
static async Task TestAsyncLockAsync(int iterations, bool isContended)
{
var mutex = new AsyncLock();
if (isContended)
{
var waits = new Task<IDisposable>[iterations];
using (await mutex.LockAsync())
for (int i = 0; i < iterations; i++)
waits[i] = mutex.LockAsync();
for (int i = 0; i < iterations; i++)
using (await waits[i]) { }
}
else
{
for (int i = 0; i < iterations; i++)
using (await mutex.LockAsync()) { }
}
}
public void TestGuardLock1()
{
Skip.IfNot(Environment.ProcessorCount > 1, "Only works on multi-core systems");
for (int i = 0; i != 10; ++i)
{
using (var evt = new AutoResetEvent(false))
{
using (var guard = new AsyncLock())
{
var results = new ConcurrentQueue<int>();
var t1 = Task.Run(
async () =>
{
using (await guard.LockAsync(CancellationToken.None))
{
evt.Set();
evt.WaitOne();
Thread.Sleep(TimeSpan.FromMilliseconds(500));
results.Enqueue(1);
}
});
evt.WaitOne();
var t2 = Task.Run(
async () =>
{
evt.Set();
using (await guard.LockAsync(CancellationToken.None))
{
results.Enqueue(2);
}
});
Task.WaitAll(t1, t2);
var resultsData = results.ToArray();
Assert.Equal(1, resultsData[0]);
Assert.Equal(2, resultsData[1]);
}
}
}
}
private Task EnsureTableFileCreated(AsyncLock.LockScope lockScope)
{
return state.MakeRoomForWriteAsync(force: true, lockScope: lockScope); // force to create an ImmutableMemtable
}
private volatile bool _disposedValue = false; // To detect redundant calls
public Coordinator(Network network, BlockNotifier blockNotifier, string folderPath, IRPCClient rpc, CoordinatorRoundConfig roundConfig)
{
Network = Guard.NotNull(nameof(network), network);
BlockNotifier = Guard.NotNull(nameof(blockNotifier), blockNotifier);
FolderPath = Guard.NotNullOrEmptyOrWhitespace(nameof(folderPath), folderPath, trim: true);
RpcClient = Guard.NotNull(nameof(rpc), rpc);
RoundConfig = Guard.NotNull(nameof(roundConfig), roundConfig);
Rounds = new List <CoordinatorRound>();
RoundsListLock = new AsyncLock();
CoinJoins = new List <uint256>();
UnconfirmedCoinJoins = new List <uint256>();
CoinJoinsLock = new AsyncLock();
LastSuccessfulCoinJoinTime = DateTimeOffset.UtcNow;
Directory.CreateDirectory(FolderPath);
UtxoReferee = new UtxoReferee(Network, FolderPath, RpcClient, RoundConfig);
if (File.Exists(CoinJoinsFilePath))
{
try
{
var getTxTasks = new List <(Task <Transaction> txTask, string line)>();
var batch = RpcClient.PrepareBatch();
var toRemove = new List <string>();
string[] allLines = File.ReadAllLines(CoinJoinsFilePath);
foreach (string line in allLines)
{
try
{
getTxTasks.Add((batch.GetRawTransactionAsync(uint256.Parse(line)), line));
}
catch (Exception ex)
{
toRemove.Add(line);
var logEntry = ex is RPCException rpce && rpce.RPCCode == RPCErrorCode.RPC_INVALID_ADDRESS_OR_KEY
? $"CoinJoins file contains invalid transaction ID {line}"
: $"CoinJoins file got corrupted. Deleting offending line \"{line.Substring(0, 20)}\".";
Logger.LogWarning($"{logEntry}. {ex.GetType()}: {ex.Message}");
}
}
batch.SendBatchAsync().GetAwaiter().GetResult();
foreach (var task in getTxTasks)
{
try
{
var tx = task.txTask.GetAwaiter().GetResult();
CoinJoins.Add(tx.GetHash());
}
catch (Exception ex)
{
toRemove.Add(task.line);
var logEntry = ex is RPCException rpce && rpce.RPCCode == RPCErrorCode.RPC_INVALID_ADDRESS_OR_KEY
? $"CoinJoins file contains invalid transaction ID {task.line}"
: $"CoinJoins file got corrupted. Deleting offending line \"{task.line.Substring(0, 20)}\".";
Logger.LogWarning($"{logEntry}. {ex.GetType()}: {ex.Message}");
}
}
if (toRemove.Count != 0) // a little performance boost, it'll be empty almost always
{
var newAllLines = allLines.Where(x => !toRemove.Contains(x));
File.WriteAllLines(CoinJoinsFilePath, newAllLines);
}
}
catch (Exception ex)
{
Logger.LogWarning($"CoinJoins file got corrupted. Deleting {CoinJoinsFilePath}. {ex.GetType()}: {ex.Message}");
File.Delete(CoinJoinsFilePath);
}
uint256[] mempoolHashes = RpcClient.GetRawMempoolAsync().GetAwaiter().GetResult();
UnconfirmedCoinJoins.AddRange(CoinJoins.Intersect(mempoolHashes));
}
try
{
string roundCountFilePath = Path.Combine(folderPath, "RoundCount.txt");
if (File.Exists(roundCountFilePath))
{
string roundCount = File.ReadAllText(roundCountFilePath);
CoordinatorRound.RoundCount = long.Parse(roundCount);
}
else
{
// First time initializes (so the first constructor will increment it and we'll start from 1.)
CoordinatorRound.RoundCount = 0;
}
}
catch (Exception ex)
{
CoordinatorRound.RoundCount = 0;
Logger.LogInfo($"{nameof(CoordinatorRound.RoundCount)} file was corrupt. Resetting to 0.");
Logger.LogDebug(ex);
}
BlockNotifier.OnBlock += BlockNotifier_OnBlockAsync;
}
/// <summary>
/// Performs a backup on the game
/// </summary>
/// <param name="backupInformation">The backup information</param>
/// <returns>True if the backup was successful</returns>
public async Task <bool> BackupAsync(IBackupInfo backupInformation)
{
using (await AsyncLock.LockAsync())
{
RL.Logger?.LogInformationSource($"A backup has been requested for {backupInformation.GameDisplayName}");
try
{
// Make sure we have write access to the backup location
if (!FileManager.CheckDirectoryWriteAccess(RCPServices.Data.BackupLocation + AppViewModel.BackupFamily))
{
RL.Logger?.LogInformationSource($"Backup failed - backup location lacks write access");
// Request to restart as admin
await RCPServices.App.RequestRestartAsAdminAsync();
return(false);
}
// Get the backup information and group items by ID
var backupInfoByID = backupInformation.BackupDirectories.GroupBy(x => x.ID).ToList();
RL.Logger?.LogDebugSource($"{backupInfoByID.Count} backup directory ID groups were found");
// Get the backup info
var backupInfo = new List <BackupDir>();
// Get the latest save info from each group
foreach (var group in backupInfoByID)
{
if (group.Count() == 1)
{
backupInfo.Add(group.First());
continue;
}
RL.Logger?.LogDebugSource($"ID {group.Key} has multiple items");
// Find which group is the latest one
var groupItems = new Dictionary <BackupDir, DateTime>();
foreach (BackupDir item in group)
{
// ReSharper disable once ConvertIfStatementToConditionalTernaryExpression
if (!item.DirPath.DirectoryExists)
{
groupItems.Add(item, DateTime.MinValue);
}
else
{
groupItems.Add(item, Directory.GetFiles(item.DirPath, item.SearchPattern, item.SearchOption).Select(x => new FileInfo(x).LastWriteTime).OrderByDescending(x => x).FirstOrDefault());
}
}
// Get the latest directory
var latestDir = groupItems.OrderByDescending(x => x.Value).First().Key;
// Add the latest directory
backupInfo.Add(latestDir);
RL.Logger?.LogDebugSource($"The most recent backup directory was found under {latestDir.DirPath}");
}
// Make sure all the directories to back up exist
if (!backupInfo.Select(x => x.DirPath).DirectoriesExist())
{
RL.Logger?.LogInformationSource($"Backup failed - the input directories could not be found");
await Services.MessageUI.DisplayMessageAsync(String.Format(Resources.Backup_MissingDirectoriesError, backupInformation.GameDisplayName), Resources.Backup_FailedHeader, MessageType.Error);
return(false);
}
// Check if the backup should be compressed
bool compress = RCPServices.Data.CompressBackups;
RL.Logger?.LogDebugSource(compress ? $"The backup will be compressed" : $"The backup will not be compressed");
// Perform the backup and keep track if it succeeded
bool success = await(compress ?
PerformCompressedBackupAsync(backupInfo, backupInformation.CompressedBackupLocation, backupInformation.GameDisplayName) :
PerformBackupAsync(backupInfo, backupInformation.BackupLocation, backupInformation.GameDisplayName));
if (!success)
{
return(false);
}
// Remove old backups for the game
try
{
var newBackup = compress ? backupInformation.CompressedBackupLocation : backupInformation.BackupLocation;
foreach (RCPBackup existingBackup in backupInformation.ExistingBackups)
{
// Ignore the newly created backup
if (existingBackup.Path.CorrectPathCasing().Equals(newBackup.CorrectPathCasing()))
{
continue;
}
if (existingBackup.IsCompressed)
{
// Delete the file
FileManager.DeleteFile(existingBackup.Path);
RL.Logger?.LogInformationSource("Compressed leftover backup was deleted");
}
else
{
// Delete the directory
FileManager.DeleteDirectory(existingBackup.Path);
RL.Logger?.LogInformationSource("Non-compressed leftover backup was deleted");
}
}
}
catch (Exception ex)
{
ex.HandleError("Deleting leftover backups");
}
return(true);
}
catch (Exception ex)
{
// Handle error
ex.HandleError("Backing up game", backupInformation);
// Display message to user
await Services.MessageUI.DisplayExceptionMessageAsync(ex, String.Format(Resources.Backup_Failed, backupInformation.GameDisplayName), Resources.Backup_FailedHeader);
// Return that backup did not succeed
return(false);
}
}
}
private async Task <InputRegistrationResponse> RegisterInputCoreAsync(InputRegistrationRequest request, CancellationToken cancellationToken)
{
var coin = await OutpointToCoinAsync(request, cancellationToken).ConfigureAwait(false);
using (await AsyncLock.LockAsync(cancellationToken).ConfigureAwait(false))
{
var round = GetRound(request.RoundId);
var registeredCoins = Rounds.Where(x => !(x.Phase == Phase.Ended && !x.WasTransactionBroadcast))
.SelectMany(r => r.Alices.Select(a => a.Coin));
if (registeredCoins.Any(x => x.Outpoint == coin.Outpoint))
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.AliceAlreadyRegistered);
}
if (round.IsInputRegistrationEnded(Config.MaxInputCountByRound))
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.WrongPhase);
}
if (round is BlameRound blameRound && !blameRound.BlameWhitelist.Contains(coin.Outpoint))
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.InputNotWhitelisted);
}
// Compute but don't commit updated coinjoin to round state, it will
// be re-calculated on input confirmation. This is computed in here
// for validation purposes.
_ = round.Assert <ConstructionState>().AddInput(coin);
var coinJoinInputCommitmentData = new CoinJoinInputCommitmentData("CoinJoinCoordinatorIdentifier", round.Id);
if (!OwnershipProof.VerifyCoinJoinInputProof(request.OwnershipProof, coin.TxOut.ScriptPubKey, coinJoinInputCommitmentData))
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.WrongOwnershipProof);
}
// Generate a new GUID with the secure random source, to be sure
// that it is not guessable (Guid.NewGuid() documentation does
// not say anything about GUID version or randomness source,
// only that the probability of duplicates is very low).
var id = new Guid(Random.GetBytes(16));
var isPayingZeroCoordinationFee = InMemoryCoinJoinIdStore.Contains(coin.Outpoint.Hash);
if (!isPayingZeroCoordinationFee)
{
// If the coin comes from a tx that all of the tx inputs are coming from a CJ (1 hop - no pay).
Transaction tx = await Rpc.GetRawTransactionAsync(coin.Outpoint.Hash, true, cancellationToken).ConfigureAwait(false);
if (tx.Inputs.All(input => InMemoryCoinJoinIdStore.Contains(input.PrevOut.Hash)))
{
isPayingZeroCoordinationFee = true;
}
}
var alice = new Alice(coin, request.OwnershipProof, round, id, isPayingZeroCoordinationFee);
if (alice.CalculateRemainingAmountCredentials(round.FeeRate, round.CoordinationFeeRate) <= Money.Zero)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.UneconomicalInput);
}
if (alice.TotalInputAmount < round.MinAmountCredentialValue)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.NotEnoughFunds);
}
if (alice.TotalInputAmount > round.MaxAmountCredentialValue)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.TooMuchFunds);
}
if (alice.TotalInputVsize > round.MaxVsizeAllocationPerAlice)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.TooMuchVsize);
}
var amountCredentialTask = round.AmountCredentialIssuer.HandleRequestAsync(request.ZeroAmountCredentialRequests, cancellationToken);
var vsizeCredentialTask = round.VsizeCredentialIssuer.HandleRequestAsync(request.ZeroVsizeCredentialRequests, cancellationToken);
if (round.RemainingInputVsizeAllocation < round.MaxVsizeAllocationPerAlice)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.VsizeQuotaExceeded);
}
var commitAmountCredentialResponse = await amountCredentialTask.ConfigureAwait(false);
var commitVsizeCredentialResponse = await vsizeCredentialTask.ConfigureAwait(false);
alice.SetDeadlineRelativeTo(round.ConnectionConfirmationTimeFrame.Duration);
round.Alices.Add(alice);
return(new(alice.Id,
commitAmountCredentialResponse,
commitVsizeCredentialResponse,
alice.IsPayingZeroCoordinationFee));
}
}
public AsyncLockObserver(IObserver <T> observer, AsyncLock gate)
{
_gate = gate;
_observer = observer;
}
public async Task TestGuardLockEarlyDispose()
{
Skip.IfNot(Environment.ProcessorCount > 1, "Only works on multi-core systems");
var cts = new CancellationTokenSource();
var guard = new AsyncLock();
var task = Task.Run(
async () =>
{
using (await guard.LockAsync(cts.Token))
{
await Task.Delay(200, CancellationToken.None);
cts.Token.ThrowIfCancellationRequested();
}
},
cts.Token);
await Task.Delay(100, CancellationToken.None);
cts.Cancel();
guard.Dispose();
await Task.Delay(200, CancellationToken.None);
Assert.Equal(TaskStatus.Canceled, task.Status);
}
public async Task ProperlyWaitsForReleaseAndCallsBackThruContext()
{
var _lock = new AsyncLock();
var successfullSteps = 0;
Action<int> next = expected => {
var oldValue = Interlocked.CompareExchange( ref successfullSteps, expected + 1, expected );
if( oldValue != expected ) {
Trace.WriteLine( string.Format( "Expected {0} but was {1}", expected, oldValue ) );
}
};
await Task.Run( async () => {
var subTask = Task.Run( async () => {
await Task.Delay( 50 );
// assumes the lock is taken at this point
Assert.That( _lock.HasLock, Is.True );
using( var l = await _lock ) {
Console.WriteLine( l );
var properCallback1 = StackHelper.CurrentCallStack.Any( f => f.GetMethod().DeclaringType == typeof( ExecutionContext ) );
Assert.That( properCallback1, Is.True );
next( 2 );
}
} );
using( var l = await _lock ) {
Console.WriteLine( l );
next( 0 );
await Task.Delay( 500 );
next( 1 );
}
await subTask;
} );
Assert.That( successfullSteps, Is.EqualTo( 3 ) );
}
public CcjCoordinator(Network network, string folderPath, RPCClient rpc, CcjRoundConfig roundConfig)
{
Network = Guard.NotNull(nameof(network), network);
FolderPath = Guard.NotNullOrEmptyOrWhitespace(nameof(folderPath), folderPath, trim: true);
RpcClient = Guard.NotNull(nameof(rpc), rpc);
RoundConfig = Guard.NotNull(nameof(roundConfig), roundConfig);
Rounds = new List <CcjRound>();
RoundsListLock = new AsyncLock();
CoinJoins = new List <uint256>();
UnconfirmedCoinJoins = new List <uint256>();
CoinJoinsLock = new AsyncLock();
Directory.CreateDirectory(FolderPath);
UtxoReferee = new UtxoReferee(Network, FolderPath, RpcClient);
// Initialize RsaKey
string rsaKeyPath = Path.Combine(FolderPath, "RsaKey.json");
if (File.Exists(rsaKeyPath))
{
string rsaKeyJson = File.ReadAllText(rsaKeyPath, encoding: Encoding.UTF8);
RsaKey = BlindingRsaKey.CreateFromJson(rsaKeyJson);
}
else
{
RsaKey = new BlindingRsaKey();
File.WriteAllText(rsaKeyPath, RsaKey.ToJson(), encoding: Encoding.UTF8);
Logger.LogInfo <CcjCoordinator>($"Created RSA key at: {rsaKeyPath}");
}
if (File.Exists(CoinJoinsFilePath))
{
try
{
var toRemove = new List <string>();
string[] allLines = File.ReadAllLines(CoinJoinsFilePath);
foreach (string line in allLines)
{
uint256 txHash = new uint256(line);
RPCResponse getRawTransactionResponse = RpcClient.SendCommand(RPCOperations.getrawtransaction, txHash.ToString(), true);
if (string.IsNullOrWhiteSpace(getRawTransactionResponse?.ResultString))
{
toRemove.Add(line);
}
else
{
CoinJoins.Add(txHash);
if (getRawTransactionResponse.Result.Value <int>("confirmations") <= 0)
{
UnconfirmedCoinJoins.Add(txHash);
}
}
}
if (toRemove.Count != 0) // a little performance boost, it'll be empty almost always
{
var newAllLines = allLines.Where(x => !toRemove.Contains(x));
File.WriteAllLines(CoinJoinsFilePath, newAllLines);
}
}
catch (Exception ex)
{
Logger.LogWarning <CcjCoordinator>($"CoinJoins file got corrupted. Deleting {CoinJoinsFilePath}. {ex.GetType()}: {ex.Message}");
File.Delete(CoinJoinsFilePath);
}
}
}
public CcjCoordinator(Network network, TrustedNodeNotifyingBehavior trustedNodeNotifyingBehavior, string folderPath, RPCClient rpc, CcjRoundConfig roundConfig)
{
Network = Guard.NotNull(nameof(network), network);
TrustedNodeNotifyingBehavior = Guard.NotNull(nameof(trustedNodeNotifyingBehavior), trustedNodeNotifyingBehavior);
FolderPath = Guard.NotNullOrEmptyOrWhitespace(nameof(folderPath), folderPath, trim: true);
RpcClient = Guard.NotNull(nameof(rpc), rpc);
RoundConfig = Guard.NotNull(nameof(roundConfig), roundConfig);
Rounds = new List <CcjRound>();
RoundsListLock = new AsyncLock();
CoinJoins = new List <uint256>();
CoinJoinsLock = new AsyncLock();
Directory.CreateDirectory(FolderPath);
UtxoReferee = new UtxoReferee(Network, FolderPath, RpcClient, RoundConfig);
if (File.Exists(CoinJoinsFilePath))
{
try
{
var toRemove = new List <string>();
string[] allLines = File.ReadAllLines(CoinJoinsFilePath);
foreach (string line in allLines)
{
try
{
uint256 txHash = new uint256(line);
RPCResponse getRawTransactionResponse = RpcClient.SendCommand(RPCOperations.getrawtransaction, txHash.ToString(), true);
CoinJoins.Add(txHash);
}
catch (Exception ex)
{
toRemove.Add(line);
var logEntry = ex is RPCException rpce && rpce.RPCCode == RPCErrorCode.RPC_INVALID_ADDRESS_OR_KEY
? $"CoinJoins file contains invalid transaction ID {line}"
: $"CoinJoins file got corrupted. Deleting offending line \"{line.Substring(0, 20)}\".";
Logger.LogWarning <CcjCoordinator>($"{logEntry}. {ex.GetType()}: {ex.Message}");
}
}
if (toRemove.Count != 0) // a little performance boost, it'll be empty almost always
{
var newAllLines = allLines.Where(x => !toRemove.Contains(x));
File.WriteAllLines(CoinJoinsFilePath, newAllLines);
}
}
catch (Exception ex)
{
Logger.LogWarning <CcjCoordinator>($"CoinJoins file got corrupted. Deleting {CoinJoinsFilePath}. {ex.GetType()}: {ex.Message}");
File.Delete(CoinJoinsFilePath);
}
}
try
{
string roundCountFilePath = Path.Combine(folderPath, "RoundCount.txt");
if (File.Exists(roundCountFilePath))
{
string roundCount = File.ReadAllText(roundCountFilePath);
CcjRound.RoundCount = long.Parse(roundCount);
}
else
{
// First time initializes (so the first constructor will increment it and we'll start from 1.)
CcjRound.RoundCount = 0;
}
}
catch (Exception ex)
{
CcjRound.RoundCount = 0;
Logger.LogInfo <CcjCoordinator>($"{nameof(CcjRound.RoundCount)} file was corrupt. Resetting to 0.");
Logger.LogDebug <CcjCoordinator>(ex);
}
TrustedNodeNotifyingBehavior.Block += TrustedNodeNotifyingBehavior_BlockAsync;
}
private async void Run(object host)
{
#endif
var readMutex = new AsyncLock();
while (this._isRunning)
{
try
{
await this._reader.LoadAsync(4);
Logger.WriteLine("[message available]");
using (await readMutex.LockAsync())
{
Logger.WriteLine("[message unlocked]");
uint payloadLength;
uint endpoint;
if (this._reader.UnconsumedBufferLength > 0)
{
IBuffer buffer = this._reader.ReadBuffer(4);
this.GetLengthAndEndpoint(buffer, out payloadLength, out endpoint);
Logger.WriteLine(">> RECEIVED MESSAGE FOR ENDPOINT: " + ((Endpoint)endpoint).ToString() + " (" + endpoint.ToString() + ") - " + payloadLength.ToString() + " bytes");
if (endpoint > 0 && payloadLength > 0)
{
byte[] payload = new byte[payloadLength];
await this._reader.LoadAsync(payloadLength);
this._reader.ReadBytes(payload);
P3bbleMessage msg = this.ReadMessage(payload, endpoint);
if (msg != null && this.MessageReceived != null)
{
this.MessageReceived(msg);
}
}
else
{
Logger.WriteLine(">> RECEIVED MESSAGE WITH BAD ENDPOINT OR LENGTH: " + endpoint.ToString() + ", " + payloadLength.ToString());
}
}
}
}
catch
{
}
#if NETFX_CORE
await Task.Delay(100);
#endif
}
#if NETFX_CORE
},
public static (IAsyncObserver <TSource>, IAsyncObserver <TSource>) Amb <TSource>(IAsyncObserver <TSource> observer, IAsyncDisposable first, IAsyncDisposable second)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
if (first == null)
{
throw new ArgumentNullException(nameof(first));
}
if (second == null)
{
throw new ArgumentNullException(nameof(second));
}
var gate = new AsyncLock();
var state = AmbState.None;
return
(
Create <TSource>(
async x =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.First;
await second.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.First)
{
await observer.OnNextAsync(x).ConfigureAwait(false);
}
}
},
async ex =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.First;
await second.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.First)
{
await observer.OnErrorAsync(ex).ConfigureAwait(false);
}
}
},
async() =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.First;
await second.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.First)
{
await observer.OnCompletedAsync().ConfigureAwait(false);
}
}
}
),
Create <TSource>(
async x =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.Second;
await first.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.Second)
{
await observer.OnNextAsync(x).ConfigureAwait(false);
}
}
},
async ex =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.Second;
await first.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.Second)
{
await observer.OnErrorAsync(ex).ConfigureAwait(false);
}
}
},
async() =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (state == AmbState.None)
{
state = AmbState.Second;
await first.DisposeAsync().ConfigureAwait(false);
}
if (state == AmbState.Second)
{
await observer.OnCompletedAsync().ConfigureAwait(false);
}
}
}
)
);
}
public static IAsyncObserver <TSource>[] Amb <TSource>(IAsyncObserver <TSource> observer, IAsyncDisposable[] subscriptions)
{
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
if (subscriptions == null)
{
throw new ArgumentNullException(nameof(subscriptions));
}
var gate = new AsyncLock();
var winner = default(int?);
var count = subscriptions.Length;
async Task ElectWinnerAsync(int index)
{
winner = index;
var dispose = new List <Task>(count - 1);
for (var i = 0; i < count; i++)
{
if (i != index)
{
dispose.Add(subscriptions[i].DisposeAsync());
}
}
await Task.WhenAll(dispose).ConfigureAwait(false);
}
IAsyncObserver <TSource> CreateObserver(int index) =>
Create <TSource>(
async x =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (winner == null)
{
await ElectWinnerAsync(index).ConfigureAwait(false);
}
if (winner == index)
{
await observer.OnNextAsync(x).ConfigureAwait(false);
}
}
},
async ex =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (winner == null)
{
await ElectWinnerAsync(index).ConfigureAwait(false);
}
if (winner == index)
{
await observer.OnErrorAsync(ex).ConfigureAwait(false);
}
}
},
async() =>
{
using (await gate.LockAsync().ConfigureAwait(false))
{
if (winner == null)
{
await ElectWinnerAsync(index).ConfigureAwait(false);
}
if (winner == index)
{
await observer.OnCompletedAsync().ConfigureAwait(false);
}
}
}
);
var res = new IAsyncObserver <TSource> [count];
for (var i = 0; i < count; i++)
{
res[i] = CreateObserver(i);
}
return(res);
}
/// <param name="ipEndPoint">Opt out Tor with null.</param>
internal TorSocks5Client(IPEndPoint ipEndPoint)
{
TorSocks5EndPoint = ipEndPoint;
TcpClient = new TcpClient();
AsyncLock = new AsyncLock();
}
internal TaskManager(bool stopOnCompletion)
{
_lock = new AsyncLock();
StopOnCompletion = stopOnCompletion;
}
public async Task TestGuardLockMultipleDispose()
{
Skip.IfNot(Environment.ProcessorCount > 1, "Only works on multi-core systems");
var guard = new AsyncLock();
var task = Task.Run(
async () =>
{
using (await guard.LockAsync(CancellationToken.None))
{
await Task.Delay(100);
return Int32.MaxValue;
}
});
await Task.Delay(50);
await Task.WhenAll(Enumerable.Repeat(Task.Run((Action)guard.Dispose), 100));
Assert.Equal(Int32.MaxValue, await task);
}
public AlteredCache(IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy, ObjectCache cache, AsyncLock cacheLock) : base(async(request) =>
{
var key = $"{f.GetType().GUID}:{getKey(request)}";
using (await cacheLock.LockAsync())
{
var response = cache.Get(key) as TResponse;
if (response == null)
{
response = await f.Execute(request);
cache.AddOrGetExisting(key, response, cacheItemPolicy);
}
return(response);
}
})
{
}
public async Task TestGuardLockMultipleDispose()
{
var guard = new AsyncLock();
var task = Task.Run(
async () =>
{
using (await guard.LockAsync(CancellationToken.None))
{
await Task.Delay(100);
return Int32.MaxValue;
}
});
await Task.Delay(50);
await Task.WhenAll(Enumerable.Repeat(Task.Run((Action)guard.Dispose), 100));
Assert.Equal(Int32.MaxValue, await task);
}
public static IAlteredPipeline <TRequest, TResponse> WithAlteredCache <TRequest, TResponse>(this IAlteredPipeline <TRequest, TResponse> f, Func <TRequest, string> getKey, CacheItemPolicy cacheItemPolicy = null, ObjectCache cache = null, AsyncLock cacheLock = null)
where TResponse : class
{
cache = cache ?? MemoryCache.Default;
cacheItemPolicy = cacheItemPolicy ?? DefaultCacheItemPolicy;
cacheLock = cacheLock ?? new AsyncLock();
return(new AlteredCache <TRequest, TResponse>(f, getKey, cacheItemPolicy, cache, cacheLock));
}
private async Task BackgroundCompactionAsync(AsyncLock.LockScope locker)
{
state.CancellationToken.ThrowIfCancellationRequested();
if (state.ImmutableMemTable != null)
{
await CompactMemTableAsync(locker).ConfigureAwait(false);
}
var compaction = CompactionToProcess();
if (compaction == null)
{
return;
}
if (IsManual == false && compaction.IsTrivialMove())
{
Debug.Assert(compaction.GetNumberOfInputFiles(0) == 1);
var file = compaction.GetInput(0, 0);
compaction.Edit.DeleteFile(compaction.Level, file.FileNumber);
compaction.Edit.AddFile(compaction.Level + 1, file);
await state.LogAndApplyAsync(compaction.Edit, locker).ConfigureAwait(false);
log.Info("Moved {0} to level-{1} {2} bytes", file.FileNumber, compaction.Level + 1, file.FileSize);
}
else
{
using (var compactionState = new CompactionState(compaction))
{
try
{
await DoCompactionWorkAsync(compactionState, locker).ConfigureAwait(false);
}
finally
{
CleanupCompaction(compactionState);
}
}
compaction.ReleaseInputs();
DeleteObsoleteFiles();
}
}
internal LockReleaser(AsyncLock target)
{
this.target = target;
}
private async Task <ConnectionConfirmationResponse> ConfirmConnectionCoreAsync(ConnectionConfirmationRequest request, CancellationToken cancellationToken)
{
Round round;
Alice alice;
var realAmountCredentialRequests = request.RealAmountCredentialRequests;
var realVsizeCredentialRequests = request.RealVsizeCredentialRequests;
using (await AsyncLock.LockAsync(cancellationToken).ConfigureAwait(false))
{
round = GetRound(request.RoundId, Phase.InputRegistration, Phase.ConnectionConfirmation);
alice = GetAlice(request.AliceId, round);
if (alice.ConfirmedConnection)
{
Prison.Ban(alice, round.Id);
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.AliceAlreadyConfirmedConnection, $"Round ({request.RoundId}): Alice ({request.AliceId}) already confirmed connection.");
}
if (realVsizeCredentialRequests.Delta != alice.CalculateRemainingVsizeCredentials(round.MaxVsizeAllocationPerAlice))
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.IncorrectRequestedVsizeCredentials, $"Round ({request.RoundId}): Incorrect requested vsize credentials.");
}
var remaining = alice.CalculateRemainingAmountCredentials(round.FeeRate, round.CoordinationFeeRate);
if (realAmountCredentialRequests.Delta != remaining)
{
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.IncorrectRequestedAmountCredentials, $"Round ({request.RoundId}): Incorrect requested amount credentials.");
}
}
var amountZeroCredentialTask = round.AmountCredentialIssuer.HandleRequestAsync(request.ZeroAmountCredentialRequests, cancellationToken);
var vsizeZeroCredentialTask = round.VsizeCredentialIssuer.HandleRequestAsync(request.ZeroVsizeCredentialRequests, cancellationToken);
Task <CredentialsResponse>?amountRealCredentialTask = null;
Task <CredentialsResponse>?vsizeRealCredentialTask = null;
if (round.Phase is Phase.ConnectionConfirmation)
{
amountRealCredentialTask = round.AmountCredentialIssuer.HandleRequestAsync(realAmountCredentialRequests, cancellationToken);
vsizeRealCredentialTask = round.VsizeCredentialIssuer.HandleRequestAsync(realVsizeCredentialRequests, cancellationToken);
}
using (await AsyncLock.LockAsync(cancellationToken).ConfigureAwait(false))
{
alice = GetAlice(request.AliceId, round);
switch (round.Phase)
{
case Phase.InputRegistration:
{
var commitAmountZeroCredentialResponse = await amountZeroCredentialTask.ConfigureAwait(false);
var commitVsizeZeroCredentialResponse = await vsizeZeroCredentialTask.ConfigureAwait(false);
alice.SetDeadlineRelativeTo(round.ConnectionConfirmationTimeFrame.Duration);
return(new(
commitAmountZeroCredentialResponse,
commitVsizeZeroCredentialResponse));
}
case Phase.ConnectionConfirmation:
{
// If the phase was InputRegistration before then we did not pre-calculate real credentials.
amountRealCredentialTask ??= round.AmountCredentialIssuer.HandleRequestAsync(realAmountCredentialRequests, cancellationToken);
vsizeRealCredentialTask ??= round.VsizeCredentialIssuer.HandleRequestAsync(realVsizeCredentialRequests, cancellationToken);
ConnectionConfirmationResponse response = new(
await amountZeroCredentialTask.ConfigureAwait(false),
await vsizeZeroCredentialTask.ConfigureAwait(false),
await amountRealCredentialTask.ConfigureAwait(false),
await vsizeRealCredentialTask.ConfigureAwait(false));
// Update the coinjoin state, adding the confirmed input.
round.CoinjoinState = round.Assert <ConstructionState>().AddInput(alice.Coin);
alice.ConfirmedConnection = true;
return(response);
}
default:
throw new WabiSabiProtocolException(WabiSabiProtocolErrorCode.WrongPhase, $"Round ({request.RoundId}): Wrong phase ({round.Phase}).");
}
}
}
/// <summary>
/// Creates the key for a lock.
/// </summary>
/// <param name="asyncLock">The lock to release. May not be <c>null</c>.</param>
public Key(AsyncLock asyncLock)
{
this.asyncLock = asyncLock;
}
static BackupManager()
{
AsyncLock = new AsyncLock();
}
/// <param name="endPoint">Opt out Tor with null.</param>
internal TorSocks5Client(EndPoint endPoint)
{
TorSocks5EndPoint = endPoint;
TcpClient = endPoint is null ? new TcpClient() : new TcpClient(endPoint.AddressFamily);
AsyncLock = new AsyncLock();
}
/// <summary>
/// Restores a backup on the game
/// </summary>
/// <param name="backupInformation">The backup information</param>
/// <returns>True if the backup was successful</returns>
public async Task <bool> RestoreAsync(IBackupInfo backupInformation)
{
using (await AsyncLock.LockAsync())
{
RL.Logger?.LogInformationSource($"A backup restore has been requested for {backupInformation.GameDisplayName}");
try
{
// Get the backup directory
var existingBackup = backupInformation.ExistingBackups.FirstOrDefault();
// Make sure a backup exists
if (existingBackup == null)
{
RL.Logger?.LogInformationSource($"Restore failed - the input location could not be found");
await Services.MessageUI.DisplayMessageAsync(String.Format(Resources.Restore_MissingBackup, backupInformation.GameDisplayName), Resources.Restore_FailedHeader, MessageType.Error);
return(false);
}
// Get the backup information
var backupInfo = backupInformation.RestoreDirectories;
// Make sure we have write access to the restore destinations
if (backupInfo.Any(x => !FileManager.CheckDirectoryWriteAccess(x.DirPath)))
{
RL.Logger?.LogInformationSource($"Restore failed - one or more restore destinations lack write access");
// Request to restart as admin
await RCPServices.App.RequestRestartAsAdminAsync();
return(false);
}
using (var tempDir = new TempDirectory(true))
{
using var archiveTempDir = new TempDirectory(true);
bool hasCreatedTempBackup = false;
try
{
// If the backup is an archive, extract it to temp
if (existingBackup.IsCompressed)
{
using var file = File.OpenRead(existingBackup.Path);
using var zip = new ZipArchive(file, ZipArchiveMode.Read);
zip.ExtractToDirectory(archiveTempDir.TempPath);
}
// Move existing files to temp in case the restore fails
foreach (BackupDir item in backupInfo)
{
// Make sure the directory exists
if (!item.DirPath.DirectoryExists)
{
continue;
}
// Get the destination directory
var destDir = tempDir.TempPath + item.ID;
// Check if the entire directory should be moved
if (item.IsEntireDir())
{
// Move the directory
FileManager.MoveDirectory(item.DirPath, destDir, true, true);
}
else
{
FileManager.MoveFiles(item, destDir, true);
}
}
hasCreatedTempBackup = true;
// Restore each backup directory
foreach (BackupDir item in backupInfo)
{
// Get the combined directory path
var dirPath = (existingBackup.IsCompressed ? archiveTempDir.TempPath : existingBackup.Path) + item.ID;
// Restore the backup
if (dirPath.DirectoryExists)
{
FileManager.CopyDirectory(dirPath, item.DirPath, false, true);
}
}
}
catch
{
// Delete restored files if restore began
if (hasCreatedTempBackup)
{
foreach (BackupDir item in backupInfo)
{
// Make sure the directory exists
if (!item.DirPath.DirectoryExists)
{
continue;
}
// Check if the entire directory should be deleted
if (item.IsEntireDir())
{
// Delete the directory
FileManager.DeleteDirectory(item.DirPath);
}
else
{
// Delete each file
foreach (FileSystemPath file in Directory.GetFiles(item.DirPath, item.SearchPattern, item.SearchOption))
{
// Delete the file
FileManager.DeleteFile(file);
}
}
}
}
// Restore temp backup
foreach (BackupDir item in backupInfo)
{
// Get the combined directory path
var dirPath = tempDir.TempPath + item.ID;
// Make sure there is a directory to restore
if (!dirPath.DirectoryExists)
{
continue;
}
// Restore
FileManager.MoveDirectory(dirPath, item.DirPath, false, false);
}
RL.Logger?.LogInformationSource($"Restore failed - clean up succeeded");
throw;
}
}
RL.Logger?.LogInformationSource($"Restore complete");
return(true);
}
catch (Exception ex)
{
ex.HandleError("Restoring game", backupInformation);
await Services.MessageUI.DisplayExceptionMessageAsync(ex, String.Format(Resources.Restore_Failed, backupInformation.GameDisplayName), Resources.Restore_FailedHeader);
return(false);
}
}
}
/// <summary>
/// Default constructor for a specific game
/// </summary>
/// <param name="game">The DosBox game</param>
/// <param name="gameType">The type of game</param>
protected BaseDosBoxConfigViewModel(Games game, GameType gameType)
{
Game = game;
GameType = gameType;
// Create the async lock
AsyncLock = new AsyncLock();
// Create the commands
SaveCommand = new AsyncRelayCommand(SaveAsync);
UseRecommendedCommand = new RelayCommand(UseRecommended);
// Set up the available resolution values
AvailableResolutionValues = new ObservableCollection <string>();
const double ratio = 16d / 10d;
const int minHeight = 200;
double maxHeight = SystemParameters.PrimaryScreenHeight;
AvailableResolutionValues.Add($"Original");
for (int height = minHeight; height <= maxHeight; height += minHeight)
{
AvailableResolutionValues.Add($"{height * ratio}x{height}");
}
// NOTE: Below options are not localized
// Set available DosBox outputs
AvailableDosBoxOutputs = new string[]
{
"default",
"surface",
"overlay",
"opengl",
"openglnb",
"ddraw"
};
// Set available DosBox scalers
AvailableDosBoxScalers = new string[]
{
"default",
"none",
"normal2x",
"normal3x",
"advmame2x",
"advmame3x",
"hq2x",
"hq3x",
"2xsai",
"super2xsai",
"supereagle",
"advinterp2x",
"advinterp3x",
"tv2x",
"tv3x",
"rgb2x",
"rgb3x",
"scan2x",
"scan3x"
};
// Set available DosBox core modes
AvailableDosBoxCoreModes = new string[]
{
"default",
"normal",
"simple",
"dynamic",
"auto"
};
// Set available DosBox cycle modes
AvailableDosBoxCycleModes = new string[]
{
"default",
"auto",
"max"
};
}
public ClientProviderRuntime(IGrainFactory grainFactory)
{
caoTable = new Dictionary <Type, Tuple <IGrainExtension, IAddressable> >();
lockable = new AsyncLock();
GrainFactory = grainFactory;
}
public AsyncLockWaiter( AsyncLock @lock )
: base(@lock)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncConcurrentDictionary{TKey, TValue}"/> class.
/// </summary>
public AsyncConcurrentDictionary()
{
_locker = new AsyncLock();
_dictionary = new Dictionary <TKey, TValue>();
}
static DownloadsService()
{
DownloadsService.AsyncLock = new AsyncLock();
}
public AsyncLockTest()
{
_lock = new AsyncLock();
}
/// <summary>
/// Release the lock.
/// </summary>
public void Dispose()
{
if (asyncLock == null)
return;
asyncLock.ReleaseLock();
asyncLock = null;
}
static SecretCodeManager()
{
AsyncLock = new AsyncLock();
Codes = new Dictionary <Key[], Func <Task> >()
{
{
// Konami code
new Key[]
{
Key.Up,
Key.Up,
Key.Down,
Key.Down,
Key.Left,
Key.Right,
Key.Left,
Key.Right,
Key.B,
Key.A
},
async() =>
{
Application.Current.SetTheme(Services.Data.Theme_DarkMode, false, "Red");
await Services.MessageUI.DisplayMessageAsync(Resources.SecretCodes_Konami, Resources.SecretCodes_KonamiHeader, MessageType.Success);
}
},
{
// RayCarrot code
new Key[]
{
Key.R,
Key.A,
Key.Y,
Key.C,
Key.A,
Key.R,
Key.R,
Key.O,
Key.T,
},
async() =>
{
Application.Current.SetTheme(Services.Data.Theme_DarkMode, false, "Orange");
await Services.MessageUI.DisplayMessageAsync(Resources.SecretCodes_RayCarrot, Resources.SecretCodes_RayCarrotHeader, MessageType.Success);
}
},
{
// Lime code
new Key[]
{
Key.S,
Key.O,
Key.U,
Key.R,
},
async() =>
{
Application.Current.SetTheme(Services.Data.Theme_DarkMode, false, "Lime");
await Services.MessageUI.DisplayMessageAsync(Resources.SecretCodes_Lime, Resources.SecretCodes_LimeHeader, MessageType.Success);
}
},
{
// Secret code
new Key[]
{
Key.S,
Key.E,
Key.C,
Key.R,
Key.E,
Key.T,
},
async() =>
{
await Services.MessageUI.DisplayMessageAsync(Resources.SecretCodes_Secret, Resources.SecretCodes_SecretHeader, MessageType.Success);
}
},
};
CurrentInput = new List <Key>(Codes.OrderBy(x => x.Key.Length).First().Key.Length);
}
public SocksConnection()
{
EndPoint = null;
_asyncLock = new AsyncLock();
}
public async Task TestGuardLockEarlyDispose()
{
var cts = new CancellationTokenSource();
var guard = new AsyncLock();
var task = Task.Run(
async () =>
{
using (await guard.LockAsync(cts.Token))
{
await Task.Delay(200, CancellationToken.None);
cts.Token.ThrowIfCancellationRequested();
}
},
cts.Token);
await Task.Delay(100, CancellationToken.None);
cts.Cancel();
guard.Dispose();
await Task.Delay(200, CancellationToken.None);
Assert.Equal(TaskStatus.Canceled, task.Status);
}
public ItemRepository(AsyncLock mutex, SQLiteAsyncConnection sqliteConnection) : base(mutex, sqliteConnection)
{
}
/// <summary>
/// Creates a new instance of the AniDbTitleMatcher class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="downloader">The AniDB title downloader.</param>
public AniDbTitleMatcher(ILogger logger, IAniDbTitleDownloader downloader)
{
_logger = logger;
_downloader = downloader;
_lock = new AsyncLock();
}
public async Task InitializeTask()
{
try
{
_isInitialize = true;
_mutex = new AsyncLock();
_mutexRead = new AsyncLock();
//1.
Services = new ServiceCollection();
this.Services.AddOptions();
//2.Configuration
//string basePath = Directory.GetCurrentDirectory() + @"\..\..\..\..";
string basePath = Directory.GetCurrentDirectory();
this.ConfigurationBuilder = new ConfigurationBuilder()
.SetBasePath(basePath)
.AddJsonFile(path: "appsettings.json", optional: true, reloadOnChange: false);
this.Configuration = ConfigurationBuilder.Build();
Services.Configure <PipeSettings>((pipeSettings) =>
{
this.Configuration.Bind("Pipe", pipeSettings);
});
Services.Configure <BlockSettings>((blockSettings) =>
{
this.Configuration.Bind("Block", blockSettings);
});
Services.Configure <DataProviderSettings>((dataProviderSettings) =>
{
this.Configuration.Bind("DataProvider", dataProviderSettings);
});
Services.Configure <DataSourceTypeSettings>((dataSourceTypeSettings) =>
{
this.Configuration.Bind("DataSource", dataSourceTypeSettings);
});
//3.Logging
Services.AddLogging(builder =>
{
var loggingSection = this.Configuration.GetSection("Logging");
var includeScopes = loggingSection.GetValue <bool>("IncludeScopes");
builder.AddConfiguration(loggingSection);
//加入一个ConsoleLoggerProvider
builder.AddConsole(consoleLoggerOptions =>
{
consoleLoggerOptions.IncludeScopes = includeScopes;
});
//加入一个DebugLoggerProvider
builder.AddDebug();
});
//DbContext
Services.AddScoped <ContosoContext, SqliteContosoContext>((sp) =>
{
var logFactory = sp.GetRequiredService <ILoggerFactory>();
string sqliteConnectionString = this.Configuration.GetConnectionString("ContosoSqlite");
//var sqliteContosoContext = new SqliteContosoContext(new DbContextOptionsBuilder<ContosoContext>().UseLoggerFactory(logFactory)
// .UseSqlite(sqliteConnectionString).Options);
var sqliteContosoContext = new SqliteContosoContext(new DbContextOptionsBuilder <ContosoContext>()
.UseSqlite(sqliteConnectionString).Options);
return(sqliteContosoContext);
});
Services.AddScoped <ContosoContext, SqlServerContosoContext>((sp) =>
{
var logFactory = sp.GetRequiredService <ILoggerFactory>();
string sqlServerConnectString = this.Configuration.GetConnectionString("ContosoSqlServer");
//var sqlServerContosoContext = new SqlServerContosoContext(new DbContextOptionsBuilder<ContosoContext>().UseLoggerFactory(logFactory)
// .UseSqlServer(sqlServerConnectString).Options);
var sqlServerContosoContext = new SqlServerContosoContext(new DbContextOptionsBuilder <ContosoContext>()
.UseSqlServer(sqlServerConnectString).Options);
return(sqlServerContosoContext);
});
Services.AddScoped <IDbContextFactory <ContosoContext>, DbContextFactory>();
Services.AddScoped(typeof(IDataflowBulkInserter <,>), typeof(DataflowBulkInserter <,>));
Services.AddScoped(typeof(IDataflowPipeBulkInserter <,>), typeof(DataflowPipeBulkInserter <,>));
Services.AddScoped(typeof(IPipeBulkInserter <,>), typeof(PipeBulkInserter <,>));
//Services.AddScoped<IDataflowBulkInserter<Order, Order>, DataflowBulkInserter<Order, Order>>();
// Services.AddScoped<IDataflowPipeBulkInserter<Order, Order>, DataflowPipeBulkInserter<Order, Order>>();
// Services.AddScoped<IPipeBulkInserter<Order, Order>, PipeBulkInserter<Order, Order>>();
//Repository
Services.AddScoped <ISqlOrderRepository, SqlOrderRepository>();
//Mapper
Services.AddAutoMapper(typeof(Contoso.DataSource.AutoMapper.AutoMapperProfileConfiguration));
//DataSource
Services.AddScoped <ISqlServerOrderDataSource, DataSource.SqlServer.SqlServerOrderDataSource>();
//DataSourceFactory
Services.AddScoped <IContosoDataSource, SqlServerContosoDataSource>();
Services.AddScoped <IDataSourceFactory <IContosoDataSource>, ContosoDataSourceFactory>();
// Services.AddSingleton<IPipeWebApiSender<PurchaseOrderDto, int>, PipeWebApiSender<PurchaseOrderDto, int>>();
//4.
this.ServiceProvider = this.Services.BuildServiceProvider();
//5.
_loggerFactory = ServiceProvider.GetRequiredService <ILoggerFactory>();
_logger = _loggerFactory.CreateLogger <WebApiSender>();
var repositoryFactory = this.ServiceProvider.GetRequiredService <IDbContextFactory <ContosoContext> >();
var dbContext = repositoryFactory.CreateDbContext();
var dataflowBulkInserter = this.ServiceProvider.GetRequiredService <IDataflowBulkInserter <OrderDto, OrderDto> >();
var dataflowPipeBulkInserter = this.ServiceProvider.GetRequiredService <IDataflowPipeBulkInserter <OrderDto, OrderDto> >();
var pipeBulkInserter = this.ServiceProvider.GetRequiredService <IPipeBulkInserter <OrderDto, OrderDto> >();
var mapper = this.ServiceProvider.GetRequiredService <IMapper>();
var contosoDataSourceFactory = this.ServiceProvider.GetRequiredService <IDataSourceFactory <IContosoDataSource> >();
var orderDataSource = contosoDataSourceFactory.Current.OrderDataSource;
_cancellationTokenSource = new CancellationTokenSource();
_durationManage = new DurationManage();
await OrderJsonProvider.InitializeTask();
// return Task.CompletedTask;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
// return Task.FromException(ex);
}
}
public NonBlockedWaiter( AsyncLock @lock )
: base(@lock)
{
}
protected BasePageViewModel()
{
App.SelectedPageChanged += App_SelectedPageChangedAsync;
_pageChangedLock = new AsyncLock();
}
/// <summary>
/// Creates a new instance of the AniDbTitleMatcher class.
/// </summary>
/// <param name="logger">The logger.</param>
/// <param name="downloader">The AniDB title downloader.</param>
public AniDbTitleMatcher(ILogger logger, IAniDbTitleDownloader downloader)
{
_logger = logger;
_downloader = downloader;
_lock = new AsyncLock();
}
public WebSocketClientHandle(WebSocketServer server, WebSocket socket)
{
this.id = Helpers.RandomString(16);
this.socket = socket;
this.sendLock = AsyncLock.Create("WebSocketClientHandle-" + this.id);
this.onClose = () => { };
var socketDestroyer = new CancellationTokenSource();
Console.WriteLine(" --> New WebSocketClient {0}", this.id);
byte[] buffer = new byte[65536]; // 8 KB buffer
Helpers.AsyncTaskLoop(() =>
{
if (socket.State == WebSocketState.Open)
{
return(socket.ReceiveAsync(new ArraySegment <byte>(buffer), socketDestroyer.Token)
.ContinueWith(prev =>
{
try
{
var received = prev.Result;
// Console.WriteLine("WebSocket {0}: {1} {2} {3}", this.id, received.Count, received.MessageType, received.EndOfMessage);
if (prev.Result.MessageType == WebSocketMessageType.Close)
{
Console.WriteLine(" !!! WebSocket Client {0} dropped connection", this.id);
Console.WriteLine(" !!! Closing WebSocket {0}", this.id);
socketDestroyer.Cancel();
// return Task.CompletedTask;
return socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close OK", CancellationToken.None)
.ContinueWith(_ =>
{
this.onClose();
this.socket.Dispose();
});
}
else
{
string message = Encoding.UTF8.GetString(buffer, 0, prev.Result.Count);
// Console.WriteLine(" !!! Message from WebSocket {0}: {1}", this.id, message);
// Spawning a new task to make the message handler "non-blocking"
// TODO: Errors thrown inside here will become silent, so that needs to be handled
// Also, now that the single execution flow is broken, the requests are under race conditions
return Task.Run(() => this.onMessage(message));
}
}
catch (AggregateException ae)
{
Console.WriteLine(" !!! Exception during async communication with Client {0}", this.id);
Console.WriteLine(" ... Connection closed... if this was not expected, inspect the AggregateException here");
foreach (var ie in ae.Flatten().InnerExceptions)
{
Console.WriteLine("Exception -------------------");
Console.WriteLine(ie.Message);
Console.WriteLine(ie.InnerException.Message);
Console.WriteLine(ie.InnerException.StackTrace);
Console.WriteLine("-----------------------------\n");
}
socketDestroyer.Cancel();
this.onClose();
this.socket.Dispose();
return Task.CompletedTask;
}
}).Unwrap());
}
else
{
Console.WriteLine(" !!! WebSocket {0} Connection Dropped!", this.id);
socketDestroyer.Cancel();
this.onClose();
this.socket.Dispose();
return(Task.CompletedTask);
}
}, socketDestroyer.Token);
}
/// <summary>
/// Creates the key for a lock.
/// </summary>
/// <param name="asyncLock">The lock to release. May not be <c>null</c>.</param>
public Key(AsyncLock asyncLock)
{
this.asyncLock = asyncLock;
}
public LockHelper()
{
_mutex = new AsyncLock();
}
public ByteArrayListStream()
{
// Initially we have nothing to read so Reads should be parked
readStreamLock = AsyncLock.CreateLocked(out lockRelease);
}
public CrossBleRadioAdapter()
{
PeripheralSearchLock = new AsyncLock();
AdapterManagementLock = new AsyncLock();
PeripheralCache = new Dictionary <Guid, CrossBleRadioPeripheral>();
}
