/// <summary>
/// Intended for unit test purposes
/// </summary>
internal AzureWebHookDequeueManager(string connectionString, ILogger logger, TimeSpan pollingFrequency, TimeSpan messageTimeout, int maxAttempts, HttpClient httpClient, IStorageManager storageManager)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (pollingFrequency <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("pollingFrequency");
}
if (messageTimeout <= TimeSpan.Zero)
{
throw new ArgumentOutOfRangeException("messageTimeout");
}
_logger = logger;
_pollingFrequency = pollingFrequency;
_messageTimeout = messageTimeout;
_maxAttempts = maxAttempts;
_httpClient = httpClient ?? new HttpClient();
_storageManager = storageManager ?? new StorageManager(logger);
_queue = _storageManager.GetCloudQueue(connectionString, AzureWebHookSender.WebHookQueue);
_sender = new QueuedSender(this, logger);
}
public AuthenticationManager(IStorageManager storageManager)
{
_storageManager = storageManager;
Guest = new BotGroup(GroupNames.Guest, 0);
Registered = new BotGroup(GroupNames.Registered, 10);
Administrator = new BotGroup(GroupNames.Administrator, 20);
Owner = new BotGroup(GroupNames.Owner, 30);
_groups.Add(Guest.Name, Guest);
_groups.Add(Registered.Name, Registered);
_groups.Add(Administrator.Name, Administrator);
_groups.Add(Owner.Name, Owner);
_userData = _storageManager.Global().GetOrCreate<Dictionary<String, UserData>>("Users");
foreach(UserData data in _userData.Values)
{
if(!_groups.ContainsKey(data.GroupName))
{
_logger.Error("User with username " + data.Username + " has invalid group name " + data.GroupName
+ ". User was not added.");
}
else
{
IBotUser user = new BotUser(data.Username, data.Password, _groups[data.GroupName], false);
_users.Add(data.Username, user);
_masks[user] = data.Masks;
}
}
_allMasks = new HashSet<IdentityMask>(_masks.Values);
}
public void Cleanup()
{
storageProvider?.TestCleanup();
storageManager?.Dispose();
storageProvider = null;
storageManager = null;
}
public DatabasesManager(Window parent)
{
TransientFor = parent;
this.Build ();
this.manager = App.Current.DatabaseManager;
ActiveDB = manager.ActiveDB;
SetTreeView ();
}
public static void AddStorageManager(string key, IStorageManager value)
{
if (!Map.ContainsKey(key))
{
Map.Add(key, value);
List.Add(value);
}
}
public UnconfirmedTxesBuilder(ICoreDaemon coreDaemon, ICoreStorage coreStorage, IStorageManager storageManager)
{
this.coreDaemon = coreDaemon;
this.coreStorage = coreStorage;
this.storageManager = storageManager;
this.chain = new Lazy<Chain>(() => LoadChain());
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookStore"/> class with the given <paramref name="manager"/>,
/// <paramref name="settings"/>, <paramref name="protector"/>, and <paramref name="logger"/>.
/// Using this constructor, the data will be encrypted using the provided <paramref name="protector"/>.
/// </summary>
public AzureWebHookStore(IStorageManager manager, SettingsDictionary settings, IDataProtector protector, ILogger logger)
: this(manager, settings, logger)
{
if (protector == null)
{
throw new ArgumentNullException(nameof(protector));
}
_protector = protector;
}
public PruningWorker(WorkerConfig workerConfig, ICoreDaemon coreDaemon, IStorageManager storageManager, ChainStateWorker chainStateWorker)
: base("PruningWorker", workerConfig.initialNotify, workerConfig.minIdleTime, workerConfig.maxIdleTime)
{
this.coreDaemon = coreDaemon;
this.storageManager = storageManager;
this.chainStateWorker = chainStateWorker;
this.prunedChain = new ChainBuilder();
this.Mode = PruningMode.None;
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
)
: this(navigationTarget, viewFactory, lifetimeManager, storageManager
#if !NETFX_CORE
, fileSystem
#endif
, new NavigationStackWithHome())
{
}
/// <summary>
/// Constructor.
/// </summary>
public MDSServer()
{
_settings = MDSSettings.Instance;
_serverGraph = new MDSServerGraph();
_clientApplicationList = new MDSClientApplicationList();
_mdsManager = new MDSController("MDSController");
_storageManager = StorageManagerFactory.CreateStorageManager();
_routingTable = new RoutingTable();
_communicationLayer = new CommunicationLayer();
_organizationLayer = new OrganizationLayer(_communicationLayer, _storageManager, _routingTable, _serverGraph, _clientApplicationList, _mdsManager);
_mdsManager.OrganizationLayer = _organizationLayer;
}
public CoreDaemon(ICoreRules rules, IStorageManager storageManager)
{
this.rules = rules;
this.storageManager = storageManager;
coreStorage = new CoreStorage(storageManager);
// create chain state builder
chainStateBuilder = new ChainStateBuilder(this.rules, coreStorage, this.storageManager);
// create unconfirmed txes builder
unconfirmedTxesBuilder = new UnconfirmedTxesBuilder(this, coreStorage, this.storageManager);
// create workers
targetChainWorker = new TargetChainWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(0), maxIdleTime: TimeSpan.FromSeconds(30)),
ChainParams, coreStorage);
chainStateWorker = new ChainStateWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(0), maxIdleTime: TimeSpan.FromSeconds(5)),
targetChainWorker, chainStateBuilder, this.rules, coreStorage);
unconfirmedTxesWorker = new UnconfirmedTxesWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(0), maxIdleTime: TimeSpan.FromSeconds(5)),
chainStateWorker, unconfirmedTxesBuilder, coreStorage);
pruningWorker = new PruningWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(0), maxIdleTime: TimeSpan.FromMinutes(5)),
this, this.storageManager, chainStateWorker);
defragWorker = new DefragWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMinutes(5), maxIdleTime: TimeSpan.FromMinutes(5)),
this.storageManager);
gcWorker = new WorkerMethod("GC Worker", GcWorker,
initialNotify: true, minIdleTime: TimeSpan.FromMinutes(5), maxIdleTime: TimeSpan.FromMinutes(5));
utxoScanWorker = new WorkerMethod("UTXO Scan Worker", UtxoScanWorker,
initialNotify: true, minIdleTime: TimeSpan.FromSeconds(60), maxIdleTime: TimeSpan.FromSeconds(60));
statsWorker = new StatsWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMinutes(0), maxIdleTime: TimeSpan.MaxValue),
this);
// wire events
chainStateWorker.BlockMissed += HandleBlockMissed;
targetChainWorker.OnTargetChainChanged += HandleTargetChainChanged;
chainStateWorker.OnChainStateChanged += HandleChainStateChanged;
pruningWorker.OnWorkFinished += defragWorker.NotifyWork;
unconfirmedTxesBuilder.UnconfirmedTxAdded += RaiseUnconfirmedTxAdded;
unconfirmedTxesBuilder.TxesConfirmed += RaiseTxesConfirmed;
unconfirmedTxesBuilder.TxesUnconfirmed += RaiseTxesUnconfirmed;
}
/// <summary>
/// Creates a new FaultToleratedStorageManagerWrapper, wraps a IStorageManager.
/// </summary>
/// <param name="storageManager">Original Storage Manager to perform database operations</param>
public FaultToleratedStorageManagerWrapper(IStorageManager storageManager)
{
if (storageManager == null)
{
throw new ArgumentNullException("storageManager", "storageManager parameter can not be null.");
}
_storageManager = storageManager;
_lastRestartTime = DateTime.MinValue;
TimeOut = 90000;
WaitTimeBeforeRetry = 1000;
RestartStorageManagerOnException = true;
}
public RssDataManager(IStorageManager storageManager, IServiceManager serviceManager, ILoginManager loginManager)
{
ServiceManager = serviceManager;
StorageManager = storageManager;
LoginManager = loginManager;
CategoryList = new List<CategoryDTO>();
SourceList = new List<SourceDTO>();
LoginManager.UserChanged += SetCategoryList;
SetCategoryList();
}
public ObjectSaveAsDialog(IStorageManager storageManager)
{
m_StorageManager = storageManager;
m_Dlg = new ModalDialog();
m_Dlg.MinHeight = 200;
m_Dlg.MinWidth = 300;
m_Dlg.Height = 400;
m_Dlg.Width = 500;
m_Dlg.Caption = Localization.SaveAsDialog_Caption;
m_Dlg.DialogOk += new EventHandler <DialogResultArgs>(Dlg_DialogOk);
m_Dlg.DialogClosed += new EventHandler <DialogResultArgs>(m_Dlg_DialogClosed);
Grid LayoutRoot = new Grid();
LayoutRoot.ColumnDefinitions.Add(new ColumnDefinition());
LayoutRoot.ColumnDefinitions.Add(new ColumnDefinition());
m_List = new ObjectDescriptionListControl();
m_List.SelectionChanged += new EventHandler <SelectionChangedEventArgs <ObjectStorageFileDescription> >(m_List_SelectionChanged);
m_List.ObjectSelected += new EventHandler <CustomEventArgs <ObjectStorageFileDescription> >(m_List_ObjectSelected);
m_List.DeleteButtonClick += new EventHandler <CustomEventArgs <ObjectStorageFileDescription> >(m_List_DeleteButtonClick);
m_List.DeleteAllButtonClick += new EventHandler <CustomEventArgs <ObjectStorageFileDescription> >(m_List_DeleteAllButtonClick);
LayoutRoot.Children.Add(m_List);
GridSplitter splitter_Vert = new GridSplitter();
splitter_Vert.IsTabStop = false;
LayoutRoot.Children.Add(splitter_Vert);
Grid.SetColumn(splitter_Vert, 0);
splitter_Vert.Background = new SolidColorBrush(Colors.Transparent);
splitter_Vert.HorizontalAlignment = HorizontalAlignment.Right;
splitter_Vert.VerticalAlignment = VerticalAlignment.Stretch;
splitter_Vert.Width = 3;
m_Description = new ObjectDescriptionControl()
{
Margin = new Thickness(5, 0, 0, 0)
};
m_Description.EndEdit += new EventHandler(m_Description_EndEdit);
LayoutRoot.Children.Add(m_Description);
Grid.SetColumn(m_Description, 1);
m_Dlg.Content = LayoutRoot;
if (m_StorageManager != null)
{
m_StorageManager.InvokeCompleted -= new EventHandler <DataLoaderEventArgs>(m_StorageManager_ActionCompleted);
m_StorageManager.InvokeCompleted += new EventHandler <DataLoaderEventArgs>(m_StorageManager_ActionCompleted);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WeiboDataProvider"/> class.
/// Constructor.
/// </summary>
/// <param name="tokens">OAuth tokens for request.</param>
/// <param name="authenticationBroker">Authentication result interface.</param>
/// <param name="passwordManager">Platform password manager</param>
/// <param name="storageManager">Platform storage provider</param>
public WeiboDataProvider(WeiboOAuthTokens tokens, IAuthenticationBroker authenticationBroker, IPasswordManager passwordManager, IStorageManager storageManager)
{
_tokens = tokens;
_authenticationBroker = authenticationBroker;
_passwordManager = passwordManager;
_storageManager = storageManager;
if (_client == null)
{
HttpClientHandler handler = new HttpClientHandler {
AutomaticDecompression = DecompressionMethods.GZip
};
_client = new HttpClient(handler);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TwitterDataProvider"/> class.
/// Constructor.
/// </summary>
/// <param name="tokens">OAuth tokens for request.</param>
public TwitterDataProvider(TwitterOAuthTokens tokens)
{
_tokens = tokens;
_authenticationBroker = new UwpAuthenticationBroker();
_passwordManager = new UwpPasswordManager();
_storageManager = new UwpStorageManager();
_signatureManager = new UwpSignatureManager();
if (_client == null)
{
HttpClientHandler handler = new HttpClientHandler();
handler.AutomaticDecompression = DecompressionMethods.GZip;
_client = new HttpClient(handler);
}
}
/// <summary>
/// Initialize underlying provider with relevant token information.
/// </summary>
/// <param name="oAuthTokens">Token instance.</param>
/// <param name="authenticationBroker">Authentication result interface.</param>
/// <param name="passwordManager">Password Manager interface, store the password.</param>
/// <param name="storageManager">Storage Manager interface</param>
/// <param name="signatureManager">Signature manager to sign the OAuth request</param>
/// <returns>Success or failure.</returns>
public bool Initialize(TwitterOAuthTokens oAuthTokens, IAuthenticationBroker authenticationBroker, IPasswordManager passwordManager, IStorageManager storageManager, ISignatureManager signatureManager)
{
tokens = oAuthTokens ?? throw new ArgumentNullException(nameof(oAuthTokens));
this.authenticationBroker = authenticationBroker ?? throw new ArgumentNullException(nameof(authenticationBroker));
this.passwordManager = passwordManager ?? throw new ArgumentNullException(nameof(passwordManager));
this.storageManager = storageManager ?? throw new ArgumentNullException(nameof(storageManager));
this.signatureManager = signatureManager ?? throw new ArgumentNullException(nameof(signatureManager));
isInitialized = true;
twitterDataProvider = null;
return(true);
}
public AppServiceManager(RestClient restClient, string subscriptionId, string tenantId) :
base(restClient, subscriptionId, new WebSiteManagementClient(new Uri(restClient.BaseUri),
restClient.Credentials,
restClient.RootHttpHandler,
restClient.Handlers.ToArray())
{
SubscriptionId = subscriptionId
})
{
keyVaultManager = KeyVault.Fluent.KeyVaultManager.Authenticate(restClient, subscriptionId, tenantId);
storageManager = Storage.Fluent.StorageManager.Authenticate(restClient, subscriptionId);
this.tenantId = tenantId;
this.restClient = restClient;
}
public void CanUpdateBlobContainers()
{
using (var context = FluentMockContext.Start(this.GetType().FullName))
{
string storageAccountName = TestUtilities.GenerateName("stgbnx");
string resourceGroupName = TestUtilities.GenerateName("rgstg");
Dictionary <string, string> metadataInitial = new Dictionary <string, string>();
metadataInitial.Add("a", "b");
Dictionary <string, string> metadataTest = new Dictionary <string, string>();
metadataTest.Add("c", "d");
metadataTest.Add("e", "f");
try
{
IStorageManager storageManager = TestHelper.CreateStorageManager();
IStorageAccount storageAccount = storageManager.StorageAccounts.Define(storageAccountName)
.WithRegion(Region.USEast2)
.WithNewResourceGroup(resourceGroupName)
.Create();
IBlobContainers blobContainers = storageManager.BlobContainers;
IBlobContainer blobContainer = blobContainers.DefineContainer("blob-test")
.WithExistingBlobService(resourceGroupName, storageAccountName)
.WithPublicAccess(Microsoft.Azure.Management.Storage.Fluent.Models.PublicAccess.Container)
.WithMetadata(metadataInitial)
.Create();
blobContainer.Update()
.WithPublicAccess(Microsoft.Azure.Management.Storage.Fluent.Models.PublicAccess.Blob)
.WithMetadata("c", "d")
.WithMetadata("e", "f")
.Apply();
Assert.Equal("blob-test", blobContainer.Name);
Assert.Equal(Microsoft.Azure.Management.Storage.Fluent.Models.PublicAccess.Blob, blobContainer.PublicAccess);
Assert.Equal(metadataTest, blobContainer.Metadata);
}
finally
{
try
{
TestHelper.CreateResourceManager().ResourceGroups.BeginDeleteByName(resourceGroupName);
}
catch { }
}
}
}
void Microsoft.Cis.Services.Nephos.Common.Protocols.Rest.IServiceEntry.Initialize(IServiceEntrySink sink)
{
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("[Nephos.Storage] { Initialize");
HttpRestProcessor.HttpProcessorConfigurationDefaultInstance = HttpProcessorConfiguration.LoadDefaultHttpProcessorConfiguration(sink, "UriHostSuffixes", null);
BlobServiceEntry.SharedStorageManager = new DbStorageManager();
BlobServiceEntry.SharedConfig = new ServiceManagerConfiguration();
this.authenticationManager = XFEBlobAuthenticationManager.CreateAuthenticationManager(BlobServiceEntry.SharedStorageManager, false);
this.serviceManager = RealServiceManager.CreateServiceManager(XFEBlobAuthorizationManager.CreateAuthorizationManager(BlobServiceEntry.SharedStorageManager, true), BlobServiceEntry.SharedStorageManager, BlobServiceEntry.SharedConfig);
StorageStamp.TranslateException = new TranslateExceptionDelegate(SqlExceptionManager.ReThrowException);
BlockBlobGarbageCollector.Initialize();
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("[Nephos.Storage] } Initialize");
sink.RegisterRestHandler(this);
}
/// <summary>
/// Configures a Microsoft Azure Table Storage implementation of <see cref="IWebHookStore"/>
/// which provides a persistent store for registered WebHooks used by the custom WebHooks module.
/// </summary>
/// <param name="config">The current <see cref="HttpConfiguration"/>config.</param>
public static void InitializeCustomWebHooksAzureQueueSender(this HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
ILogger logger = config.DependencyResolver.GetLogger();
SettingsDictionary settings = config.DependencyResolver.GetSettings();
IStorageManager storageManager = StorageManager.GetInstance(logger);
IWebHookSender sender = new AzureWebHookSender(storageManager, settings, logger);
CustomServices.SetSender(sender);
}
public HouseManager(
IHousesProvider housesProvider,
IPointCreator pointCreator,
IPlayerInfoManager playerInfoManager,
IHouseEventManager houseEventManager,
IStorageManager storageManager,
IVehicleInfoManager vehicleInfoManager)
{
_housesProvider = housesProvider;
_pointCreator = pointCreator;
_playerInfoManager = playerInfoManager;
_houseEventManager = houseEventManager;
_storageManager = storageManager;
_vehicleInfoManager = vehicleInfoManager;
}
public Bot(IClient client, IStorageManager storage, ICommandManager command, IPluginManager plugin,
IAuthenticationManager authentication, IPermissionManager permission)
{
_client = client;
_storage = storage;
_command = command;
_plugin = plugin;
_authentication = authentication;
_permission = permission;
_data = storage.Global().GetOrCreate<BotData>(_storageIdentifier);
_replyHandler = new ReplyHandler(this, _data);
_messsageHandler = new MessageHandler(this, _replyHandler, _data);
}
/// <summary>
/// Initializes a new instance of the <see cref="EpiWebHookStore"/> class with the given
/// <paramref name="managerObject"/>,
/// and <paramref name="logger"/>.
/// </summary>
public EpiWebHookStore(IStorageManager managerObject, ILogger loggerObject)
{
if (managerObject == null)
{
throw new ArgumentNullException("manager");
}
if (loggerObject == null)
{
throw new ArgumentNullException("logger");
}
this.manager = managerObject;
this.logger = loggerObject;
}
public void Initialize(IServiceEntrySink sink)
{
if (sink == null)
{
throw new ArgumentNullException("sink");
}
Logger <IRestProtocolHeadLogger> .Instance.VerboseDebug.Log("[Nephos.Table] { Initialize");
TableProtocolHead.HttpProcessorConfigurationDefaultInstance = HttpProcessorConfiguration.LoadDefaultHttpProcessorConfiguration(sink, "UriHostSuffixes", null);
TableServiceEntry.SharedStorageManager = new DbStorageManager();
this.authenticationManager = XFETableAuthenticationManager.CreateAuthenticationManager(TableServiceEntry.SharedStorageManager);
TableServiceEntry.SharedTableDataFactory = new DbTableDataContextFactory();
this.tableManager = TableManager.CreateTableManager(NephosAuthorizationManager.CreateAuthorizationManager(TableServiceEntry.SharedStorageManager, false), TableServiceEntry.SharedTableDataFactory, TableServiceEntry.SharedStorageManager);
sink.RegisterRestHandler(this);
}
public SynchronizationPresenter(ISynchronizationView view,
IStorageManager storageManager,
IUnitOfWorkFactory unitOfWorkFactory,
IRepositoryFactory repositoryFactory,
IConfigurationManager configurationManager,
INavigator navigator)
{
_configurationManager = configurationManager;
_view = view;
_storageManager = storageManager;
_unitOfWorkFactory = unitOfWorkFactory;
_repositoryFactory = repositoryFactory;
_navigator = navigator;
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(viewFactory)
{
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
public NavigationManager([Import(AllowDefault = true)]INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
{
this.viewFactory = viewFactory;
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
this.navigationTarget = navigationTarget;
else
this.navigationTarget = new WindowNavigationTarget();
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
/// <summary>
/// Initialize underlying provider with relevent token information.
/// </summary>
/// <param name="oAuthTokens">Token instance.</param>
/// <param name="authentication">Authentication result interface.</param>
/// <param name="passwordManager">Password Manager interface, store the password.</param>
/// <param name="storageManager">Storage Manager interface.</param>
/// <param name="requiredPermissions">Scope / permissions app requires user to sign up for.</param>
/// <returns>Success or failure.</returns>
public bool Initialize(LinkedInOAuthTokens oAuthTokens, IAuthenticationBroker authentication, IPasswordManager passwordManager, IStorageManager storageManager, LinkedInPermissions requiredPermissions = LinkedInPermissions.NotSet)
{
_oAuthTokens = oAuthTokens ?? throw new ArgumentNullException(nameof(oAuthTokens));
_authenticationBroker = authentication ?? throw new ArgumentNullException(nameof(authentication));
_storageManager = storageManager ?? throw new ArgumentNullException(nameof(storageManager));
_passwordManager = passwordManager ?? throw new ArgumentNullException(nameof(passwordManager));
_requiredPermissions = requiredPermissions;
Provider.RequiredPermissions = requiredPermissions;
Provider.Tokens = oAuthTokens;
_isInitialized = true;
return(true);
}
public PresentersFactory(IStorageManager storageManager,
IRepositoryFactory repositoryFactory,
IModelsFactory modelsFactory,
IViewContainer container,
IConfigurationManager configurationManager,
ILocalizationManager localizationManager)
{
_storageManager = storageManager;
_unitOfWorkFactory = new SqLiteUnitOfWorkFactory(_storageManager);
_repositoryFactory = repositoryFactory;
_modelsFactory = modelsFactory;
_configurationManager = configurationManager;
_localizationManager = localizationManager;
_navigator = new Navigator(container, this, _localizationManager);
_lookUpService = new LookUpService(this, localizationManager);
}
private void Load <TStoredObject>(
IStorageManager <TStoredObject> manager,
Action <TStoredObject> onSuccess,
OnErr onError) where TStoredObject : class
{
WrapErr.ToErrReport(9999, () => {
ErrReport report;
WrapErr.ToErrReport(out report, 9999, () => {
onSuccess.Invoke(manager.ReadObjectFromDefaultFile());
});
if (report.Code != 0)
{
onError.Invoke(this.GetText(MsgCode.LoadFailed));
}
});
}
/// <summary>
/// Initializes an instance of <see cref="DefaultOnlinePayment"/>.
/// </summary>
/// <param name="services"></param>
/// <param name="storageManager"></param>
/// <param name="tokenProvider"></param>
/// <param name="gatewayProvider"></param>
/// <param name="messagesOptions"></param>
/// <param name="logger"></param>
public DefaultOnlinePayment(
IServiceProvider services,
IStorageManager storageManager,
IPaymentTokenProvider tokenProvider,
IGatewayProvider gatewayProvider,
IOptions <MessagesOptions> messagesOptions,
ILogger <IOnlinePayment> logger)
{
Services = services;
_storageManager = storageManager;
_tokenProvider = tokenProvider;
_messagesOptions = messagesOptions;
_logger = logger;
_storageManager = storageManager;
_gatewayProvider = gatewayProvider;
}
/// <summary>
/// Initializes an instance of <see cref="DefaultOnlinePayment"/>.
/// </summary>
public DefaultOnlinePayment(
IServiceProvider services,
IStorageManager storageManager,
IPaymentTokenProvider tokenProvider,
IGatewayProvider gatewayProvider,
IOptions <ParbadOptions> options,
IParbadLogger <DefaultOnlinePayment> logger)
{
Services = services;
_storageManager = storageManager;
_tokenProvider = tokenProvider;
_options = options.Value;
_logger = logger;
_storageManager = storageManager;
_gatewayProvider = gatewayProvider;
}
public ObjectSaveAsDialog(IStorageManager storageManager)
{
m_StorageManager = storageManager;
m_Dlg = new ModalDialog();
m_Dlg.MinHeight = 200;
m_Dlg.MinWidth = 300;
m_Dlg.Height = 400;
m_Dlg.Width = 500;
m_Dlg.Caption = Localization.SaveAsDialog_Caption;
m_Dlg.DialogOk += new EventHandler<DialogResultArgs>(Dlg_DialogOk);
m_Dlg.DialogClosed += new EventHandler<DialogResultArgs>(m_Dlg_DialogClosed);
Grid LayoutRoot = new Grid();
LayoutRoot.ColumnDefinitions.Add(new ColumnDefinition());
LayoutRoot.ColumnDefinitions.Add(new ColumnDefinition());
m_List = new ObjectDescriptionListControl();
m_List.SelectionChanged += new EventHandler<SelectionChangedEventArgs<ObjectStorageFileDescription>>(m_List_SelectionChanged);
m_List.ObjectSelected += new EventHandler<CustomEventArgs<ObjectStorageFileDescription>>(m_List_ObjectSelected);
m_List.DeleteButtonClick += new EventHandler<CustomEventArgs<ObjectStorageFileDescription>>(m_List_DeleteButtonClick);
m_List.DeleteAllButtonClick += new EventHandler<CustomEventArgs<ObjectStorageFileDescription>>(m_List_DeleteAllButtonClick);
LayoutRoot.Children.Add(m_List);
GridSplitter splitter_Vert = new GridSplitter();
splitter_Vert.IsTabStop = false;
LayoutRoot.Children.Add(splitter_Vert);
Grid.SetColumn(splitter_Vert, 0);
splitter_Vert.Background = new SolidColorBrush(Colors.Transparent);
splitter_Vert.HorizontalAlignment = HorizontalAlignment.Right;
splitter_Vert.VerticalAlignment = VerticalAlignment.Stretch;
splitter_Vert.Width = 3;
m_Description = new ObjectDescriptionControl() { Margin = new Thickness(5, 0, 0, 0) };
m_Description.EndEdit += new EventHandler(m_Description_EndEdit);
LayoutRoot.Children.Add(m_Description);
Grid.SetColumn(m_Description, 1);
m_Dlg.Content = LayoutRoot;
if (m_StorageManager != null)
{
m_StorageManager.InvokeCompleted -= new EventHandler<DataLoaderEventArgs>(m_StorageManager_ActionCompleted);
m_StorageManager.InvokeCompleted += new EventHandler<DataLoaderEventArgs>(m_StorageManager_ActionCompleted);
}
}
/// <summary>
/// Provides a static method for creating a standalone <see cref="AzureWebHookStore"/> instance.
/// </summary>
/// <param name="logger">The <see cref="ILogger"/> instance to use.</param>
/// <param name="encryptData">Indicates whether the data should be encrypted using <see cref="IDataProtector"/> while persisted.</param>
/// <returns>An initialized <see cref="AzureWebHookStore"/> instance.</returns>
public static IWebHookStore CreateStore(ILogger logger, bool encryptData)
{
SettingsDictionary settings = CommonServices.GetSettings();
IWebHookStore store;
IStorageManager storageManager = StorageManager.GetInstance(logger);
if (encryptData)
{
IDataProtector protector = DataSecurity.GetDataProtector();
store = new AzureWebHookStore(storageManager, settings, protector, logger);
}
else
{
store = new AzureWebHookStore(storageManager, settings, logger);
}
return(store);
}
private async void uiPinFileSignInButton_Click(object sender, RoutedEventArgs e)
{
// If Internet available, Set pin list with root folder file list.
// Otherwise, show internet bad message
if (NetworkInterface.GetIsNetworkAvailable())
{
// Show Loading message and save is login true for pivot moving action while sign in.
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
uiPinFileList.Visibility = Visibility.Collapsed;
uiPinFileMessage.Text = AppResources.DoingSignIn;
uiPinFileMessage.Visibility = Visibility.Visible;
uiPinFileListGrid.Visibility = Visibility.Visible;
uiPinFileSignInPanel.Visibility = Visibility.Collapsed;
});
base.SetProgressRing(uiPinPivotProgressRing, true);
try
{
// Sign in and await that task.
// If sign in success, set list.
IStorageManager iStorageManager = Switcher.GetCurrentStorage();
if (!iStorageManager.IsSigningIn())
{
TaskHelper.AddSignInTask(iStorageManager.GetStorageName(), iStorageManager.SignIn());
}
await TaskHelper.WaitSignInTask(iStorageManager.GetStorageName());
this.SetPinFileListAsync(iStorageManager, AppResources.Loading, null);
}
catch
{
base.ShowMessageDialog(AppResources.BadSignInMessage, OK_MODE);
uiPinFileListGrid.Visibility = Visibility.Collapsed;
uiPinFileSignInPanel.Visibility = Visibility.Visible;
base.SetProgressRing(uiPinPivotProgressRing, false);
}
}
else
{
base.ShowMessageDialog(AppResources.InternetUnavailableMessage, OK_MODE);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookDequeueManager"/> using the given <paramref name="connectionString"/>
/// to identify the Microsoft Azure Storage Queue.
/// </summary>
/// <param name="connectionString">The Microsoft Azure Storage Queue connection string.</param>
/// <param name="logger">The <see cref="ILogger"/> instance to use for logging errors and warnings.</param>
public AzureWebHookDequeueManager(IOptions <WebHooksAzureDequeueManagerOptions> options, ILogger <AzureWebHookDequeueManager> logger)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_options = options.Value;
_logger = logger;
_httpClient = new HttpClient();
_storageManager = new StorageManager(logger);
_sender = new QueuedSender(this, logger);
}
/// <summary>
/// Configures a Microsoft Azure Table Storage implementation of <see cref="IWebHookStore"/>
/// which provides a persistent store for registered WebHooks used by the custom WebHooks module.
/// </summary>
/// <param name="config">The current <see cref="HttpConfiguration"/>config.</param>
public static void InitializeCustomWebHooksAzureStorage(this HttpConfiguration config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
WebHooksConfig.Initialize(config);
ILogger logger = config.DependencyResolver.GetLogger();
SettingsDictionary settings = config.DependencyResolver.GetSettings();
IDataProtector protector = DataSecurity.GetDataProtector();
IStorageManager storageManager = StorageManager.GetInstance(logger);
IWebHookStore store = new AzureWebHookStore(storageManager, settings, protector, logger);
CustomServices.SetStore(store);
}
public CoreStorage(IStorageManager storageManager)
{
for (var i = 0; i < this.presentBlockTxesLocks.Length; i++)
presentBlockTxesLocks[i] = new object();
this.storageManager = storageManager;
this.blockStorage = new Lazy<IBlockStorage>(() => storageManager.BlockStorage);
this.blockTxesStorage = new Lazy<IBlockTxesStorage>(() => storageManager.BlockTxesStorage);
this.cachedHeaders = new Lazy<ConcurrentDictionary<UInt256, ChainedHeader>>(() =>
{
var cachedHeaders = new ConcurrentDictionary<UInt256, ChainedHeader>();
foreach (var chainedHeader in this.blockStorage.Value.ReadChainedHeaders())
cachedHeaders[chainedHeader.Hash] = chainedHeader;
return cachedHeaders;
});
}
/// <summary>
/// Intended for Testing Purposes
/// </summary>
/// <param name="options"></param>
/// <param name="logger"></param>
/// <param name="httpClient"></param>
/// <param name="storageManager"></param>
/// <param name="sender"></param>
public AzureWebHookDequeueManager(IOptions <WebHooksAzureDequeueManagerOptions> options, ILogger <AzureWebHookDequeueManager> logger, HttpClient httpClient, IStorageManager storageManager, WebHookSender webHookSender)
{
if (options == null)
{
throw new ArgumentNullException("options");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_options = options.Value;
_logger = logger;
_httpClient = httpClient;
_storageManager = storageManager;
_sender = webHookSender;
}
public GameManager
(
IButtonManager buttonManager,
ICollisionManager collisionManager,
IConfigManager configManager,
IContentManager contentManager,
IDeviceManager deviceManager,
IImageManager imageManager,
IInputManager inputManager,
IQuestionManager questionManager,
IRandomManager randomManager,
IResolutionManager resolutionManager,
IScoreManager scoreManager,
IScreenManager screenManager,
ISoundManager soundManager,
ISpriteManager spriteManager,
IStorageManager storageManager,
ITextManager textManager,
IThreadManager threadManager,
IFileManager fileManager,
ILogger logger
)
{
ButtonManager = buttonManager;
CollisionManager = collisionManager;
ConfigManager = configManager;
ContentManager = contentManager;
DeviceManager = deviceManager;
ImageManager = imageManager;
InputManager = inputManager;
QuestionManager = questionManager;
RandomManager = randomManager;
ResolutionManager = resolutionManager;
ScoreManager = scoreManager;
ScreenManager = screenManager;
SoundManager = soundManager;
SpriteManager = spriteManager;
StorageManager = storageManager;
TextManager = textManager;
ThreadManager = threadManager;
FileManager = fileManager;
Logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookStore"/> class with the given <paramref name="manager"/>,
/// <paramref name="settings"/>, and <paramref name="logger"/>.
/// </summary>
public AzureWebHookSender(IStorageManager manager, IOptions <WebHooksAzureStorageOptions> options, ILogger logger)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (options == null)
{
throw new ArgumentNullException("options");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_manager = manager;
_options = options.Value;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookStore"/> class with the given <paramref name="manager"/>,
/// <paramref name="settings"/>, and <paramref name="logger"/>.
/// Using this constructor, the data will not be encrypted while persisted to Azure Storage.
/// </summary>
public AzureWebHookStore(IStorageManager manager, SettingsDictionary settings, ILogger logger)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_manager = manager;
_connectionString = manager.GetAzureStorageConnectionString(settings);
_logger = logger;
}
public ChainState(Chain chain, IStorageManager storageManager)
{
CursorCount = Environment.ProcessorCount;
Chain = chain;
// create a cache of cursors that are in an open snapshot transaction with the current chain state
var success = false;
this.cursorCache = new DisposableCache <DisposeHandle <IChainStateCursor> >(CursorCount);
try
{
for (var i = 0; i < this.cursorCache.Capacity; i++)
{
// open the cursor
var handle = storageManager.OpenChainStateCursor();
var cursor = handle.Item;
// cache the cursor
// this must be done before beginning the transaction as caching will rollback any transactions
this.cursorCache.CacheItem(handle);
// begin transaction to take the snapshot
cursor.BeginTransaction(readOnly: true);
// verify the chain state matches the expected chain
var chainTip = cursor.ChainTip;
if (chainTip?.Hash != chain.LastBlock?.Hash)
{
throw new ChainStateOutOfSyncException(chain.LastBlock, chainTip);
}
}
success = true;
}
finally
{
// ensure any opened cursors are cleaned up on an error
if (!success)
{
this.cursorCache.Dispose();
}
}
}
internal PublicClientApplication(
IHttpManager httpManager,
IStorageManager storageManager,
IBrowserFactory browserFactory,
IGuidService guidService,
ITelemetryManager telemetryManager,
EnvironmentMetadata environmentMetadata,
MsalClientConfiguration msalClientConfiguration)
{
_platformProxy = PlatformProxyFactory.GetPlatformProxy();
_httpManager = httpManager ?? new HttpManager(new HttpClientFactory(), msalClientConfiguration);
_storageManager = storageManager ?? _platformProxy.CreateStorageManager();
_browserFactory = browserFactory ?? _platformProxy.CreateBrowserFactory();
_guidService = guidService ?? new GuidService();
_telemetryManager = telemetryManager ?? new TelemetryManager(msalClientConfiguration);
_environmentMetadata = environmentMetadata ?? new EnvironmentMetadata();
_msalClientConfiguration = msalClientConfiguration;
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookStore"/> class with the given <paramref name="manager"/>,
/// <paramref name="settings"/>, and <paramref name="logger"/>.
/// </summary>
public AzureWebHookSender(IStorageManager manager, SettingsDictionary settings, ILogger logger)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
_manager = manager;
_connectionString = manager.GetAzureStorageConnectionString(settings);
_logger = logger;
}
private async void PickFileAsync(IStorageManager storageManager, FileObjectViewItem fileObjectViewItem)
{
// Show Downloading message
base.SetProgressRing(uiPickPivotFileListProgressRing, true);
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
fileObjectViewItem.SelectFileImage = FileObjectViewModel.ING_IMAGE_URI;
fileObjectViewItem.SelectFileImagePress = false;
});
try
{
// Download
await TaskHelper.WaitSignInTask(storageManager.GetStorageName());
await this.CurrentSpot.DownloadFileObjectAsync(storageManager, this.CurrentSpot.GetFileObject(fileObjectViewItem.Id));
await this.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
this.PinFileObjectViewModel.IsDataLoaded = false;
BitmapImage currentEditViewModeBitmapImage = (BitmapImage)uiPickFileListEditViewButtonImage.Source;
string currentEditViewMode = currentEditViewModeBitmapImage.UriSource.ToString();
if (currentEditViewMode.Equals(EDIT_IMAGE_URI)) // View Mode
{
fileObjectViewItem.SelectFileImage = FileObjectViewModel.DOWNLOAD_IMAGE_URI;
fileObjectViewItem.SelectFileImagePress = true;
}
else if (currentEditViewMode.Equals(VIEW_IMAGE_URI)) // Edit Mode
{
fileObjectViewItem.SelectFileImage = FileObjectViewModel.CHECK_NOT_IMAGE_URI;
}
});
}
catch
{
fileObjectViewItem.SelectFileImage = FileObjectViewModel.FAIL_IMAGE_URI;
}
// Hide Progress Indicator
base.SetProgressRing(uiPickPivotFileListProgressRing, false);
}
public async Task <bool> DownloadToCloud(IStorageManager storageManager = null)
{
try
{
if (storageManager == null)
{
storageManager = Switcher.GetMainStorage();
}
Stream instream = await App.BlobStorageManager.DownloadFileStreamAsync(this.Id);
FileObject root = await storageManager.GetRootFolderAsync();
await storageManager.UploadFileStreamAsync(root.Id, this.Name, instream);
}
catch
{
return(false);
}
return(true);
}
public static IStorageManager CreateInstance(StateManager stateManager, SurrogateManager surrogateManager)
{
if (UseTestImpl)
{
return(obj ?? (obj = new TempDictStorageManager()));
}
else
{
var sessionMode = System.Web.HttpContext.Current.Session.Mode;
if (sessionMode == System.Web.SessionState.SessionStateMode.InProc)
{
// A new object is needed each time, otherwise when having more than 1 user and a static StorageManager the single cache for the session keys would be shared among all the active users.
return(new SessionStorageManagerInproc(stateManager, surrogateManager));
}
else
{
return(new SessionStorageManager(stateManager, surrogateManager));
}
}
}
// *** Constructors ***
public NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager)
: base(viewFactory)
{
this.storageManager = storageManager;
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
{
this.navigationTarget = navigationTarget;
}
else
{
this.navigationTarget = new WindowNavigationTarget();
}
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
/*** Pin Methods ***/
protected void SetPinPivot(IStorageManager iStorageManager, LongListSelector list, TextBlock messageTextBlock, string message,
TextBlock pathTextBlock, Grid listGrid, StackPanel signInPanel, ApplicationBarIconButton pinInfoAppBarButton,
FileObjectViewModel viewModel, List<FileObjectViewItem> selectedFile, bool load)
{
// If it wasn't already signed in, show signin button.
// Otherwise, load files
if (!iStorageManager.IsSignIn()) // wasn't signed in.
{
iStorageManager.GetFolderRootTree().Clear();
iStorageManager.GetFoldersTree().Clear();
selectedFile.Clear();
pinInfoAppBarButton.IsEnabled = false;
listGrid.Visibility = Visibility.Collapsed;
signInPanel.Visibility = Visibility.Visible;
}
else // already signed in.
{
listGrid.Visibility = Visibility.Visible;
signInPanel.Visibility = Visibility.Collapsed;
if (NetworkInterface.GetIsNetworkAvailable())
{
if (!viewModel.IsDataLoaded)
{
Stack<FileObjectViewItem> folderRootStack = iStorageManager.GetFolderRootTree();
if (folderRootStack.Count > 0)
this.SetPinInfoListAsync(iStorageManager, list, messageTextBlock, message, pathTextBlock, listGrid, signInPanel, pinInfoAppBarButton,
viewModel, selectedFile, folderRootStack.First(), load);
else
this.SetPinInfoListAsync(iStorageManager, list, messageTextBlock, message, pathTextBlock, listGrid, signInPanel, pinInfoAppBarButton,
viewModel, selectedFile, null, true);
}
}
else
{
base.SetListUnableAndShowMessage(list, messageTextBlock, AppResources.InternetUnavailableMessage);
}
}
}
public DeferredChainStateCursor(IChainState chainState, IStorageManager storageManager)
{
this.chainState = chainState;
this.storageManager = storageManager;
UnspentOutputCount = chainState.UnspentOutputCount;
UnspentTxCount = chainState.UnspentTxCount;
TotalTxCount = chainState.TotalTxCount;
TotalInputCount = chainState.TotalInputCount;
TotalOutputCount = chainState.TotalOutputCount;
headers = new DeferredDictionary<UInt256, ChainedHeader>(
blockHash =>
{
ChainedHeader header;
return Tuple.Create(chainState.TryGetHeader(blockHash, out header), header);
});
unspentTxes = new WorkQueueDictionary<UInt256, UnspentTx>(
txHash =>
{
UnspentTx unspentTx;
return Tuple.Create(chainState.TryGetUnspentTx(txHash, out unspentTx), unspentTx);
});
blockSpentTxes = new DeferredDictionary<int, BlockSpentTxes>(
blockHeight =>
{
BlockSpentTxes spentTxes;
return Tuple.Create(chainState.TryGetBlockSpentTxes(blockHeight, out spentTxes), spentTxes);
});
blockUnmintedTxes = new DeferredDictionary<UInt256, IImmutableList<UnmintedTx>>(
blockHash =>
{
IImmutableList<UnmintedTx> unmintedTxes;
return Tuple.Create(chainState.TryGetBlockUnmintedTxes(blockHash, out unmintedTxes), unmintedTxes);
});
}
public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase)
{
// Durable instancing could not be used with
// singleton instancing.
ServiceBehaviorAttribute serviceBehavior =
serviceDescription.Behaviors.Find <ServiceBehaviorAttribute>();
if (serviceBehavior != null &&
serviceBehavior.InstanceContextMode == InstanceContextMode.Single)
{
throw new InvalidOperationException(
ResourceHelper.GetString("ExSingeltonInstancingNotSupported"));
}
// Use the StorageManagerFactory to create an instance of a
// storage manager.
IStorageManager storageManager =
StorageManagerFactory.GetStorageManager(storageManagerType);
InstanceContextInitializer contextInitializer =
new InstanceContextInitializer(storageManager);
InstanceProvider instanceProvider =
new InstanceProvider(serviceDescription.ServiceType);
foreach (ChannelDispatcherBase cdb in serviceHostBase.ChannelDispatchers)
{
ChannelDispatcher cd = cdb as ChannelDispatcher;
if (cd != null)
{
foreach (EndpointDispatcher ed in cd.Endpoints)
{
ed.DispatchRuntime.InstanceContextInitializers.Add(contextInitializer);
ed.DispatchRuntime.InstanceProvider = instanceProvider;
}
}
}
}
public ChainState(Chain chain, IStorageManager storageManager)
{
CursorCount = Environment.ProcessorCount;
Chain = chain;
// create a cache of cursors that are in an open snapshot transaction with the current chain state
var success = false;
this.cursorCache = new DisposableCache<DisposeHandle<IChainStateCursor>>(CursorCount);
try
{
for (var i = 0; i < this.cursorCache.Capacity; i++)
{
// open the cursor
var handle = storageManager.OpenChainStateCursor();
var cursor = handle.Item;
// cache the cursor
// this must be done before beginning the transaction as caching will rollback any transactions
this.cursorCache.CacheItem(handle);
// begin transaction to take the snapshot
cursor.BeginTransaction(readOnly: true);
// verify the chain state matches the expected chain
var chainTip = cursor.ChainTip;
if (chainTip?.Hash != chain.LastBlock?.Hash)
throw new ChainStateOutOfSyncException(chain.LastBlock, chainTip);
}
success = true;
}
finally
{
// ensure any opened cursors are cleaned up on an error
if (!success)
this.cursorCache.Dispose();
}
}
public CoreDaemon(IBlockchainRules rules, IStorageManager storageManager)
{
this.rules = rules;
this.storageManager = storageManager;
this.coreStorage = new CoreStorage(storageManager);
// create chain state builder
this.chainStateBuilder = new ChainStateBuilder(this.rules, this.coreStorage, this.storageManager);
// create workers
this.targetChainWorker = new TargetChainWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(50), maxIdleTime: TimeSpan.FromSeconds(30)),
this.rules, this.coreStorage);
this.chainStateWorker = new ChainStateWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMilliseconds(0), maxIdleTime: TimeSpan.FromSeconds(5)),
this.targetChainWorker, this.chainStateBuilder, this.rules, this.coreStorage);
this.pruningWorker = new PruningWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromSeconds(0), maxIdleTime: TimeSpan.FromMinutes(5)),
this, this.storageManager, this.chainStateWorker);
this.defragWorker = new DefragWorker(
new WorkerConfig(initialNotify: true, minIdleTime: TimeSpan.FromMinutes(5), maxIdleTime: TimeSpan.FromMinutes(5)),
this.storageManager);
this.gcWorker = new WorkerMethod("GC Worker", GcWorker,
initialNotify: true, minIdleTime: TimeSpan.FromMinutes(5), maxIdleTime: TimeSpan.FromMinutes(5));
this.utxoScanWorker = new WorkerMethod("UTXO Scan Worker", UtxoScanWorker,
initialNotify: true, minIdleTime: TimeSpan.FromSeconds(60), maxIdleTime: TimeSpan.FromSeconds(60));
// wire events
this.chainStateWorker.BlockMissed += HandleBlockMissed;
this.targetChainWorker.OnTargetChainChanged += HandleTargetChainChanged;
this.chainStateWorker.OnChainStateChanged += HandleChainStateChanged;
this.pruningWorker.OnWorkFinished += this.defragWorker.NotifyWork;
}
protected NavigationManager(INavigationTarget navigationTarget, IViewFactory viewFactory, ILifetimeManager lifetimeManager, IStorageManager storageManager
#if !NETFX_CORE
, IFileSystem fileSystem
#endif
, INavigationStack navigationStack)
: base(viewFactory, navigationStack)
{
if (lifetimeManager == null)
throw new ArgumentNullException(nameof(lifetimeManager));
if (storageManager == null)
throw new ArgumentNullException(nameof(storageManager));
_storageManager = storageManager;
#if !NETFX_CORE
if (fileSystem == null)
throw new ArgumentNullException(nameof(fileSystem));
_fileSystem = fileSystem;
#endif
// Use a default INavigationTarget if not specified
if (navigationTarget != null)
_navigationTarget = navigationTarget;
else
#if NETFX_CORE
_navigationTarget = new WindowNavigationTarget();
#else
_navigationTarget = new NavigationViewNavigationTarget();
#endif
// Register with the LifetimeManager
lifetimeManager.Register(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="AzureWebHookStore"/> class with the given <paramref name="manager"/>,
/// <paramref name="settings"/>, <paramref name="protector"/>, and <paramref name="logger"/>.
/// </summary>
public AzureWebHookStore(IStorageManager manager, SettingsDictionary settings, IDataProtector protector, ILogger logger)
{
if (manager == null)
{
throw new ArgumentNullException("manager");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (protector == null)
{
throw new ArgumentNullException("protector");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_manager = manager;
_connectionString = manager.GetAzureStorageConnectionString(settings);
_protector = protector;
_logger = logger;
}
JiraPlugin(IStorageManager storageManager)
: base(storageManager)
{
}
private CoreDaemon CreateExampleDaemon(out BlockProvider embeddedBlocks, out IStorageManager storageManager, int? maxHeight = null)
{
// retrieve first 10,000 testnet3 blocks
embeddedBlocks = new BlockProvider("BitSharp.Examples.Blocks.TestNet3.zip");
// initialize in-memory storage
storageManager = new MemoryStorageManager();
// intialize testnet3 rules (ignore script errors, script engine is not and is not intended to be complete)
var rules = new Testnet3Rules { IgnoreScriptErrors = true };
// initialize & start core daemon
var coreDaemon = new CoreDaemon(rules, storageManager) { MaxHeight = maxHeight, IsStarted = true };
// add embedded blocks
coreDaemon.CoreStorage.AddBlocks(embeddedBlocks.ReadBlocks());
// wait for core daemon to finish processing any available data
coreDaemon.WaitForUpdate();
return coreDaemon;
}
/// <summary>
/// Initializes a new instance of the <see cref="SaveCommand"/> class.
/// </summary>
/// <param name="mainWindowViewModel">
/// The main window view model.
/// </param>
public SaveCommand(IStorageManager storageManager)
{
Contract.Requires(storageManager != null);
this.storageManager = storageManager;
}
