/// <summary>
/// Initializes global services used by fluent project.
/// </summary>
/// <param name="global">The global instance.</param>
public static void Initialize(Global global, SingleInstanceChecker singleInstanceChecker)
{
Guard.NotNull(nameof(global.DataDir), global.DataDir);
Guard.NotNull(nameof(global.TorSettings), global.TorSettings);
Guard.NotNull(nameof(global.BitcoinStore), global.BitcoinStore);
Guard.NotNull(nameof(global.ExternalHttpClientFactory), global.ExternalHttpClientFactory);
Guard.NotNull(nameof(global.LegalChecker), global.LegalChecker);
Guard.NotNull(nameof(global.Config), global.Config);
Guard.NotNull(nameof(global.WalletManager), global.WalletManager);
Guard.NotNull(nameof(global.TransactionBroadcaster), global.TransactionBroadcaster);
Guard.NotNull(nameof(global.HostedServices), global.HostedServices);
Guard.NotNull(nameof(global.UiConfig), global.UiConfig);
DataDir = global.DataDir;
TorSettings = global.TorSettings;
BitcoinStore = global.BitcoinStore;
ExternalHttpClientFactory = global.ExternalHttpClientFactory;
LegalChecker = global.LegalChecker;
Config = global.Config;
Synchronizer = global.Synchronizer;
WalletManager = global.WalletManager;
TransactionBroadcaster = global.TransactionBroadcaster;
HostedServices = global.HostedServices;
UiConfig = global.UiConfig;
SingleInstanceChecker = singleInstanceChecker;
IsInitialized = true;
}
public Global(string dataDir, string torLogsFile, Config config, UiConfig uiConfig, WalletManager walletManager)
{
using (BenchmarkLogger.Measure())
{
CrashReporter = new CrashReporter();
StoppingCts = new CancellationTokenSource();
DataDir = dataDir;
Config = config;
UiConfig = uiConfig;
TorLogsFile = torLogsFile;
Logger.InitializeDefaults(Path.Combine(DataDir, "Logs.txt"));
HostedServices = new HostedServices();
WalletManager = walletManager;
LegalDocuments = LegalDocuments.TryLoadAgreed(DataDir);
WalletManager.OnDequeue += WalletManager_OnDequeue;
WalletManager.WalletRelevantTransactionProcessed += WalletManager_WalletRelevantTransactionProcessed;
var indexStore = new IndexStore(Network, new SmartHeaderChain());
BitcoinStore = new BitcoinStore(
Path.Combine(DataDir, "BitcoinStore"), Network,
indexStore, new AllTransactionStore(), new MempoolService()
);
SingleInstanceChecker = new SingleInstanceChecker(Network);
}
}
public async Task SingleInstanceTestsAsync()
{
string mainLockName = GenerateLockName(Network.Main);
// Disposal test.
using (SingleInstanceChecker sic = new SingleInstanceChecker(Network.Main, mainLockName))
{
await sic.CheckAsync();
}
// Check different networks.
using (SingleInstanceChecker sic = new SingleInstanceChecker(Network.Main, mainLockName))
{
await sic.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sic.CheckAsync());
using SingleInstanceChecker sicMainNet2 = new SingleInstanceChecker(Network.Main, mainLockName);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicMainNet2.CheckAsync());
string testnetLockName = GenerateLockName(Network.TestNet);
using SingleInstanceChecker sicTestNet = new SingleInstanceChecker(Network.TestNet, testnetLockName);
await sicTestNet.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicTestNet.CheckAsync());
string regtestLockName = GenerateLockName(Network.RegTest);
using SingleInstanceChecker sicRegTest = new SingleInstanceChecker(Network.RegTest, regtestLockName);
await sicRegTest.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicRegTest.CheckAsync());
}
}
public async Task SingleInstanceTestsAsync()
{
// Disposal test.
using (SingleInstanceChecker sic = new SingleInstanceChecker(Network.Main))
{
await sic.CheckAsync();
}
// Check different networks.
using (SingleInstanceChecker sic = new SingleInstanceChecker(Network.Main))
{
await sic.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sic.CheckAsync());
using SingleInstanceChecker sicMainNet2 = new SingleInstanceChecker(Network.Main);
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicMainNet2.CheckAsync());
using SingleInstanceChecker sicTestNet = new SingleInstanceChecker(Network.TestNet);
await sicTestNet.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicTestNet.CheckAsync());
using SingleInstanceChecker sicRegTest = new SingleInstanceChecker(Network.RegTest);
await sicRegTest.CheckAsync();
await Assert.ThrowsAsync <InvalidOperationException>(async() => await sicRegTest.CheckAsync());
}
}
static void Main(string[] args)
{
try
{
Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
CheckForUpgradeSettings();
string dataMartClientId = Properties.Settings.Default.DataMartClientId;
if (dataMartClientId == null || dataMartClientId == string.Empty)
{
dataMartClientId = Properties.Settings.Default.DataMartClientId = Guid.NewGuid().ToString().ToUpper();
}
log4net.GlobalContext.Properties["LogFilePath"] = Properties.Settings.Default.LogFilePath;
XmlConfigurator.ConfigureAndWatch(new FileInfo(AppDomain.CurrentDomain.SetupInformation.ConfigurationFile));
logWatcher = new LogWatcher(Properties.Settings.Default.LogLevel, Properties.Settings.Default.LogFilePath, dataMartClientId);
log.Info("Started DataMart Client Application");
SystemInfo.LogUserMachineInfo();
Configuration.LogNetworkSettingsFile();
log.Info("Check for single instance");
CheckForShortcut();
if (!SingleInstanceChecker.Start())
{
StartupParams.WriteStartupParamsToFile(args);
SingleInstanceChecker.ShowFirstInstance();
return;
}
Dictionary <string, string> AddNetworkStartupParamsDict = StartupParams.GetAddNetworkStartupParamsDictionary(StartupParams.GetStartupParamsXml(args));
log.Info("Run instance");
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12 | System.Net.SecurityProtocolType.Tls11 | System.Net.SecurityProtocolType.Tls;
System.Net.ServicePointManager.CheckCertificateRevocationList = true;
System.Net.ServicePointManager.ServerCertificateValidationCallback += delegate(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
////Commented out for removal of Thumprint Check
// return ValidateCertificate((System.Net.HttpWebRequest)sender, certificate, chain);
return(true);
};
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new RequestListForm(AddNetworkStartupParamsDict));
}
catch (Exception ex)
{
log.Fatal("Following error occured starting DataMartClient: " + ex.Message, ex);
MessageBox.Show("Error occured starting DataMartClient. Please contact administrator.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
SingleInstanceChecker.Stop();
}
public Global(string dataDir, string torLogsFile, Config config, UiConfig uiConfig, WalletManager walletManager)
{
using (BenchmarkLogger.Measure())
{
CrashReporter = new CrashReporter();
StoppingCts = new CancellationTokenSource();
DataDir = dataDir;
Config = config;
UiConfig = uiConfig;
TorSettings = new TorSettings(DataDir, torLogsFile, distributionFolderPath: EnvironmentHelpers.GetFullBaseDirectory());
Logger.InitializeDefaults(Path.Combine(DataDir, "Logs.txt"));
HostedServices = new HostedServices();
WalletManager = walletManager;
LegalDocuments = LegalDocuments.TryLoadAgreed(DataDir);
WalletManager.OnDequeue += WalletManager_OnDequeue;
WalletManager.WalletRelevantTransactionProcessed += WalletManager_WalletRelevantTransactionProcessed;
var networkWorkFolderPath = Path.Combine(DataDir, "BitcoinStore", Network.ToString());
var transactionStore = new AllTransactionStore(networkWorkFolderPath, Network);
var indexStore = new IndexStore(Path.Combine(networkWorkFolderPath, "IndexStore"), Network, new SmartHeaderChain());
var mempoolService = new MempoolService();
var blocks = new FileSystemBlockRepository(Path.Combine(networkWorkFolderPath, "Blocks"), Network);
BitcoinStore = new BitcoinStore(indexStore, transactionStore, mempoolService, blocks);
SingleInstanceChecker = new SingleInstanceChecker(Network);
if (Config.UseTor)
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, () => Config.GetCurrentBackendUri(), Config.TorSocks5EndPoint);
}
else
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, Config.GetFallbackBackendUri(), null);
}
}
}
public async Task InitializeNoWalletAsync()
{
InitializationStarted = true;
AddressManager = null;
var cancel = StoppingCts.Token;
try
{
await SingleInstanceChecker.CheckAsync().ConfigureAwait(false);
Cache = new MemoryCache(new MemoryCacheOptions
{
SizeLimit = 1_000,
ExpirationScanFrequency = TimeSpan.FromSeconds(30)
});
var bstoreInitTask = BitcoinStore.InitializeAsync();
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var addrManTask = InitializeAddressManagerBehaviorAsync();
var userAgent = Constants.UserAgents.RandomElement();
var connectionParameters = new NodeConnectionParameters {
UserAgent = userAgent
};
HostedServices.Register(new UpdateChecker(TimeSpan.FromMinutes(7), Synchronizer), "Software Update Checker");
HostedServices.Register(new SystemAwakeChecker(WalletManager), "System Awake Checker");
#region ProcessKillSubscription
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await DisposeAsync().ConfigureAwait(false);
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
await DisposeAsync().ConfigureAwait(false);
};
#endregion ProcessKillSubscription
cancel.ThrowIfCancellationRequested();
#region TorProcessInitialization
if (Config.UseTor)
{
using (BenchmarkLogger.Measure(operationName: "TorProcessManager.Start"))
{
TorManager = new TorProcessManager(TorSettings, Config.TorSocks5EndPoint);
await TorManager.StartAsync(ensureRunning : true).ConfigureAwait(false);
}
var fallbackRequestTestUri = new Uri(Config.GetFallbackBackendUri(), "/api/software/versions");
TorManager.StartMonitor(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), fallbackRequestTestUri);
}
else
{
TorSocks5EndPoint = null;
}
Logger.LogInfo($"{nameof(TorProcessManager)} is initialized.");
#endregion TorProcessInitialization
cancel.ThrowIfCancellationRequested();
#region BitcoinStoreInitialization
await bstoreInitTask.ConfigureAwait(false);
// Make sure that the height of the wallets will not be better than the current height of the filters.
WalletManager.SetMaxBestHeight(BitcoinStore.IndexStore.SmartHeaderChain.TipHeight);
#endregion BitcoinStoreInitialization
cancel.ThrowIfCancellationRequested();
#region BitcoinCoreInitialization
try
{
if (Config.StartLocalBitcoinCoreOnStartup)
{
BitcoinCoreNode = await CoreNode
.CreateAsync(
new CoreNodeParams(
Network,
BitcoinStore.MempoolService,
HostedServices,
Config.LocalBitcoinCoreDataDir,
tryRestart : false,
tryDeleteDataDir : false,
EndPointStrategy.Default(Network, EndPointType.P2p),
EndPointStrategy.Default(Network, EndPointType.Rpc),
txIndex : null,
prune : null,
mempoolReplacement : "fee,optin",
userAgent : $"/WasabiClient:{Constants.ClientVersion}/",
fallbackFee : null, // ToDo: Maybe we should have it, not only for tests?
Cache),
cancel)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
await HostedServices.StartAllAsync(cancel).ConfigureAwait(false);
var rpcFeeProvider = HostedServices.FirstOrDefault <RpcFeeProvider>();
FeeProviders = new FeeProviders(Synchronizer, rpcFeeProvider);
#endregion BitcoinCoreInitialization
cancel.ThrowIfCancellationRequested();
#region MempoolInitialization
connectionParameters.TemplateBehaviors.Add(BitcoinStore.CreateUntrustedP2pBehavior());
#endregion MempoolInitialization
cancel.ThrowIfCancellationRequested();
#region AddressManagerInitialization
AddressManagerBehavior addressManagerBehavior = await addrManTask.ConfigureAwait(false);
connectionParameters.TemplateBehaviors.Add(addressManagerBehavior);
#endregion AddressManagerInitialization
cancel.ThrowIfCancellationRequested();
#region P2PInitialization
if (Network == Network.RegTest)
{
Nodes = new NodesGroup(Network, requirements: Constants.NodeRequirements);
try
{
EndPoint bitcoinCoreEndpoint = Config.GetBitcoinP2pEndPoint();
Node node = await Node.ConnectAsync(Network.RegTest, bitcoinCoreEndpoint).ConfigureAwait(false);
Nodes.ConnectedNodes.Add(node);
RegTestMempoolServingNode = await Node.ConnectAsync(Network.RegTest, bitcoinCoreEndpoint).ConfigureAwait(false);
RegTestMempoolServingNode.Behaviors.Add(BitcoinStore.CreateUntrustedP2pBehavior());
}
catch (SocketException ex)
{
Logger.LogError(ex);
}
}
else
{
if (Config.UseTor)
{
// onlyForOnionHosts: false - Connect to clearnet IPs through Tor, too.
connectionParameters.TemplateBehaviors.Add(new SocksSettingsBehavior(Config.TorSocks5EndPoint, onlyForOnionHosts: false, networkCredential: null, streamIsolation: true));
// allowOnlyTorEndpoints: true - Connect only to onions and do not connect to clearnet IPs at all.
// This of course makes the first setting unnecessary, but it's better if that's around, in case someone wants to tinker here.
connectionParameters.EndpointConnector = new DefaultEndpointConnector(allowOnlyTorEndpoints: Network == Network.Main);
await AddKnownBitcoinFullNodeAsHiddenServiceAsync(AddressManager).ConfigureAwait(false);
}
Nodes = new NodesGroup(Network, connectionParameters, requirements: Constants.NodeRequirements);
Nodes.MaximumNodeConnection = 12;
RegTestMempoolServingNode = null;
}
Nodes.Connect();
Logger.LogInfo("Start connecting to nodes...");
var regTestMempoolServingNode = RegTestMempoolServingNode;
if (regTestMempoolServingNode is { })
public async Task InitializeNoWalletAsync()
{
InitializationStarted = true;
AddressManager = null;
TorManager = null;
var cancel = StoppingCts.Token;
try
{
await SingleInstanceChecker.CheckAsync().ConfigureAwait(false);
Cache = new MemoryCache(new MemoryCacheOptions
{
SizeLimit = 1_000,
ExpirationScanFrequency = TimeSpan.FromSeconds(30)
});
var bstoreInitTask = BitcoinStore.InitializeAsync();
var addressManagerFolderPath = Path.Combine(DataDir, "AddressManager");
AddressManagerFilePath = Path.Combine(addressManagerFolderPath, $"AddressManager{Network}.dat");
var addrManTask = InitializeAddressManagerBehaviorAsync();
var blocksFolderPath = Path.Combine(DataDir, $"Blocks{Network}");
var userAgent = Constants.UserAgents.RandomElement();
var connectionParameters = new NodeConnectionParameters {
UserAgent = userAgent
};
if (Config.UseTor)
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, () => Config.GetCurrentBackendUri(), Config.TorSocks5EndPoint);
}
else
{
Synchronizer = new WasabiSynchronizer(Network, BitcoinStore, Config.GetFallbackBackendUri(), null);
}
HostedServices.Register(new UpdateChecker(TimeSpan.FromMinutes(7), Synchronizer), "Software Update Checker");
#region ProcessKillSubscription
AppDomain.CurrentDomain.ProcessExit += async(s, e) => await DisposeAsync().ConfigureAwait(false);
Console.CancelKeyPress += async(s, e) =>
{
e.Cancel = true;
Logger.LogWarning("Process was signaled for killing.", nameof(Global));
await DisposeAsync().ConfigureAwait(false);
};
#endregion ProcessKillSubscription
cancel.ThrowIfCancellationRequested();
#region TorProcessInitialization
if (Config.UseTor)
{
TorManager = new TorProcessManager(Config.TorSocks5EndPoint, TorLogsFile);
}
else
{
TorManager = TorProcessManager.Mock();
}
TorManager.Start(false, DataDir);
var fallbackRequestTestUri = new Uri(Config.GetFallbackBackendUri(), "/api/software/versions");
TorManager.StartMonitor(TimeSpan.FromSeconds(3), TimeSpan.FromSeconds(7), DataDir, fallbackRequestTestUri);
Logger.LogInfo($"{nameof(TorProcessManager)} is initialized.");
#endregion TorProcessInitialization
cancel.ThrowIfCancellationRequested();
#region BitcoinStoreInitialization
await bstoreInitTask.ConfigureAwait(false);
// Make sure that the height of the wallets will not be better than the current height of the filters.
WalletManager.SetMaxBestHeight(BitcoinStore.IndexStore.SmartHeaderChain.TipHeight);
#endregion BitcoinStoreInitialization
cancel.ThrowIfCancellationRequested();
#region BitcoinCoreInitialization
try
{
if (Config.StartLocalBitcoinCoreOnStartup)
{
BitcoinCoreNode = await CoreNode
.CreateAsync(
new CoreNodeParams(
Network,
BitcoinStore.MempoolService,
HostedServices,
Config.LocalBitcoinCoreDataDir,
tryRestart : false,
tryDeleteDataDir : false,
EndPointStrategy.Default(Network, EndPointType.P2p),
EndPointStrategy.Default(Network, EndPointType.Rpc),
txIndex : null,
prune : null,
userAgent : $"/WasabiClient:{Constants.ClientVersion}/",
Cache),
cancel)
.ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.LogError(ex);
}
await HostedServices.StartAllAsync(cancel).ConfigureAwait(false);
var feeProviderList = new List <IFeeProvider>
{
Synchronizer
};
var rpcFeeProvider = HostedServices.FirstOrDefault <RpcFeeProvider>();
if (rpcFeeProvider is { })
// Initialization code. Don't use any Avalonia, third-party APIs or any
// SynchronizationContext-reliant code before AppMain is called: things aren't initialized
// yet and stuff might break.
public static int Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
TaskScheduler.UnobservedTaskException += TaskScheduler_UnobservedTaskException;
bool runGui = true;
try
{
if (CrashReporter.TryGetExceptionFromCliArgs(args, out var exceptionToShow))
{
// Show the exception.
Console.WriteLine($"TODO Implement crash reporting. {exceptionToShow}");
runGui = false;
}
}
catch (Exception ex)
{
// Anything happens here just log it and do not run the Gui.
Logger.LogCritical(ex);
runGui = false;
}
Exception? exceptionToReport = null;
SingleInstanceChecker?singleInstanceChecker = null;
if (runGui)
{
try
{
string dataDir = EnvironmentHelpers.GetDataDir(Path.Combine("WalletWasabi", "Client"));
SetupLogger(dataDir, args);
var(uiConfig, config) = LoadOrCreateConfigs(dataDir);
singleInstanceChecker = new SingleInstanceChecker(config.Network);
singleInstanceChecker.EnsureSingleOrThrowAsync().GetAwaiter().GetResult();
Global = CreateGlobal(dataDir, uiConfig, config);
// TODO only required due to statusbar vm... to be removed.
Locator.CurrentMutable.RegisterConstant(Global);
Logger.LogSoftwareStarted("Wasabi GUI");
BuildAvaloniaApp(Global)
.AfterSetup(_ => ThemeHelper.ApplyTheme(Global.UiConfig.DarkModeEnabled))
.StartWithClassicDesktopLifetime(args);
}
catch (OperationCanceledException ex)
{
Logger.LogDebug(ex);
}
catch (Exception ex)
{
exceptionToReport = ex;
Logger.LogCritical(ex);
}
}
// Start termination/disposal of the application.
TerminateService.Terminate();
if (singleInstanceChecker is { } single)
{
Task.Run(async() => await single.DisposeAsync()).Wait();
}
if (exceptionToReport is { })
public IApiEnumResponseBuilder <T> SetData(IEnumerable <T> data)
{
SingleInstanceChecker.CheckBuildStateWhileBuilding();
Response.Data = data;
return(this);
}
public IApiEnumResponse <T> GetResponse()
{
SingleInstanceChecker.CheckBuildStateForFinalBuild();
return(Response);
}
public IApiObjectResponseBuilder <T> SetData(T data)
{
SingleInstanceChecker.CheckBuildStateWhileBuilding();
Response.Data = data;
return(this);
}
