/// <summary> /// Initialises the uploader and batch client. Asks user for an Azure licence file and saves the credentials /// if the credentials have not previously been set. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void GetCredentials(object sender, EventArgs e) { if (AzureCredentialsSetup.CredentialsExist()) { // store credentials storageAuth = StorageCredentials.FromConfiguration(); batchAuth = BatchCredentials.FromConfiguration(); poolOptions = PoolSettings.FromConfiguration(); storageAccount = new CloudStorageAccount(new Microsoft.WindowsAzure.Storage.Auth.StorageCredentials(storageAuth.Account, storageAuth.Key), true); uploader = new FileUploader(storageAccount); var sharedCredentials = new Microsoft.Azure.Batch.Auth.BatchSharedKeyCredentials(batchAuth.Url, batchAuth.Account, batchAuth.Key); try { batchCli = BatchClient.Open(sharedCredentials); } catch (UriFormatException) { ShowErrorMessage("Error opening Azure Batch client: credentials are invalid."); AzureCredentialsSetup cred = new AzureCredentialsSetup(); cred.Finished += GetCredentials; } catch (Exception ex) { ShowError(ex); } } else { // ask user for a credentials file AzureCredentialsSetup cred = new AzureCredentialsSetup(); cred.Finished += GetCredentials; } }
/// <summary> /// Creates the reservoir structure configuration consisting of two interconnected pools. /// </summary> /// <param name="structName">The name of the reservoir structure.</param> /// <param name="pool1Name">The name of the first pool.</param> /// <param name="pool2Name">The name of the second pool.</param> private ReservoirStructureSettings CreateResStructCfg(string structName, string pool1Name, string pool2Name) { //Our pools will have the 5x5x5 cube shape each. So 125 neurons in each pool and 250 neurons in total. const int DimX = 5, DimY = 5, DimZ = 5; //Each pool will have random internal interconnection of the density = 0.05. In our case it means that //each neuron will receive synapses from 0.05 * 125 = 6 other randomly selected neurons. const double RandomInterconnectionDensity = 0.05; //Create pools PoolSettings pool1Cfg = CreateAnalogPoolCfg(pool1Name, DimX, DimY, DimZ, RandomInterconnectionDensity); PoolSettings pool2Cfg = CreateAnalogPoolCfg(pool2Name, DimX, DimY, DimZ, RandomInterconnectionDensity); //Pool to pool interconnection //Connections from Pool1 to Pool2. We use targetPoolDensity=1 and sourcePoolDensity=0.02, so each neuron from //Pool2 will be randomly connected to 125 * 0.02 = 3 neurons from Pool1 InterPoolConnSettings pool1To2ConnCfg = new InterPoolConnSettings(pool2Name, 1d, pool1Name, 0.02d); //Connections from Pool2 to Pool1. We use targetPoolDensity=1 and sourcePoolDensity=0.02, so each neuron from //Pool1 will be randomly connected to 125 * 0.02 = 3 neurons from Pool2 InterPoolConnSettings pool2To1ConnCfg = new InterPoolConnSettings(pool1Name, 1d, pool2Name, 0.02d); //Create the reservoir structure configuration ReservoirStructureSettings resStructCfg = new ReservoirStructureSettings(structName, new PoolsSettings(pool1Cfg, pool2Cfg), new InterPoolConnsSettings(pool1To2ConnCfg, pool2To1ConnCfg) ); return(resStructCfg); }
private PoolInformation GetPoolInfo(PoolSettings settings) { if (string.IsNullOrEmpty(settings.PoolName)) { return(new PoolInformation { AutoPoolSpecification = new AutoPoolSpecification { PoolLifetimeOption = PoolLifetimeOption.Job, PoolSpecification = new PoolSpecification { MaxTasksPerComputeNode = settings.MaxTasksPerVM, // This specifies the OS that our VM will be running. // OS Family 5 means .NET 4.6 will be installed. // For more info see https://docs.microsoft.com/en-us/azure/cloud-services/cloud-services-guestos-update-matrix#releases CloudServiceConfiguration = new CloudServiceConfiguration("5"), ResizeTimeout = TimeSpan.FromMinutes(15), TargetDedicatedComputeNodes = settings.VMCount, VirtualMachineSize = settings.VMSize, TaskSchedulingPolicy = new TaskSchedulingPolicy(ComputeNodeFillType.Spread) } } }); } return(new PoolInformation { PoolId = settings.PoolName }); }
public ParallelAPSIM( Storage.StorageCredentials storageCredentials, Batch.BatchCredentials batchCredentials, PoolSettings poolSettings) { _storageAccount = new CloudStorageAccount( new StorageCredentials( storageCredentials.Account, storageCredentials.Key), true); _batchClient = BatchClient.Open( new BatchSharedKeyCredentials( batchCredentials.Url, batchCredentials.Account, batchCredentials.Key)); _batchClient.CustomBehaviors.Add( RetryPolicyProvider.LinearRetryProvider(TimeSpan.FromSeconds(3), 10)); _fileUploader = new FileUploader(_storageAccount); _storageCredentials = storageCredentials; _batchCredentials = batchCredentials; _poolSettings = poolSettings; }
private PoolInformation GetPoolInfo(PoolSettings poolSettings) { if (string.IsNullOrEmpty(poolSettings.PoolName)) { return(new PoolInformation { AutoPoolSpecification = new AutoPoolSpecification { PoolLifetimeOption = PoolLifetimeOption.Job, PoolSpecification = new PoolSpecification { MaxTasksPerComputeNode = poolSettings.MaxTasksPerVM, CloudServiceConfiguration = new CloudServiceConfiguration("5"), ResizeTimeout = TimeSpan.FromMinutes(15), TargetDedicated = poolSettings.VMCount, VirtualMachineSize = poolSettings.VMSize, TaskSchedulingPolicy = new TaskSchedulingPolicy(ComputeNodeFillType.Spread), } } }); } return(new PoolInformation { PoolId = poolSettings.PoolName }); }
public void ConvertTemperatureToPumpDuration() { var settings = new PoolSettings(); settings.TemperatureRunTime.Clear(); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 15, RunTimeHours = 1 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 20, RunTimeHours = 3 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 25, RunTimeHours = 10 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 30, RunTimeHours = 16 }); Assert.AreEqual(1, settings.GetHoursPumpingTimePerDay(10)); Assert.AreEqual(1, settings.GetHoursPumpingTimePerDay(15)); Assert.AreEqual(1, settings.GetHoursPumpingTimePerDay(15.2)); Assert.AreEqual(3, settings.GetHoursPumpingTimePerDay(20)); Assert.AreEqual(10, settings.GetHoursPumpingTimePerDay(29.9)); Assert.AreEqual(16, settings.GetHoursPumpingTimePerDay(30)); Assert.AreEqual(16, settings.GetHoursPumpingTimePerDay(35)); }
private void InitAndBindPool <TItemContract, TPool>(PoolSettings poolSettings) where TPool : IMemoryPool { Container.BindMemoryPool <TItemContract, TPool>() .WithInitialSize(poolSettings.InitialSize) .FromComponentInNewPrefab(poolSettings.Prefab) .UnderTransformGroup(poolSettings.TransformGroup); }
/// <summary> /// Load settings and state from local files /// </summary> private void LoadSettingsAndStates() { this.logger.LogDebug($"Reading '{settingsFileName}' file"); this.poolSettings = this.storeService.ReadPoolSettings(settingsFileName); this.logger.LogDebug($"Reading '{currentStateFileName}' file"); this.systemState = this.storeService.ReadSystemState(currentStateFileName); }
/// <summary> /// Initializes a new instance of the <see cref="PoolControlPump"/> class. /// </summary> public PoolControlPump( PoolSettings poolSettings, SystemState systemState, IHardwareManager hardwareManager) { this.poolSettings = poolSettings; this.systemState = systemState; this.hardwareManager = hardwareManager; }
/// <summary> /// Constructor /// </summary> /// <param name="dispName"></param> /// <param name="zipFileSas"></param> /// <param name="packagePath"></param> /// <param name="packageVersion"></param> /// <param name="recipient"></param> /// <param name="batch"></param> /// <param name="storage"></param> /// <param name="pool"></param> public APSIMJob(string dispName, string zipFileSas, string packagePath, string packageVersion, string recipient, BatchCredentials batch, StorageCredentials storage, PoolSettings pool) { DisplayName = dispName; ModelZipFileSas = zipFileSas; ApplicationPackagePath = packagePath; ApsimApplicationPackageVersion = packageVersion; Recipient = recipient; BatchAuth = batch; StorageAuth = storage; PoolInfo = pool; }
public GameObjectPool(PoolSettings _settings) { settings = _settings; if (poolContainer == null) { poolContainer = new GameObject(_settings.prefabs[0].name + "_Container").transform; } PreparePool(); }
public ReplicaSetPoolManager(int count, PoolSettings poolSettings) { replicaInfos = Enumerable.Range(0, count).ToDictionary(x => x, x => new ReplicaInfo { Key = new ReplicaKey("replica" + x), IsDead = false }); replicaSetPool = ReplicaSetPool.Create <Item, ItemKey, ReplicaKey>( replicaInfos.Values.Select(x => x.Key).ToArray(), (x, z) => new Pool <Item>(y => CreateReplicaConnection(z, x), new SilentLog()), poolSettings, new SilentLog()); }
public void ReadWritePoolSettings() { var storeService = new StoreService(); var poolSettings = new PoolSettings(); poolSettings.WorkingMode = PoolWorkingMode.Winter; poolSettings.CoverCylcleDurationInSeconds = 100; poolSettings.SummerPumpingCycles.Add(new PumpCycleGroupSetting() { MinimumTemperature = 0 }); poolSettings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(1), PumpCycleType = PumpCycleType.StartAt }); poolSettings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(12), PumpCycleType = PumpCycleType.StopAt }); poolSettings.WinterPumpingCycles.Add(new PumpCycleGroupSetting() { MinimumTemperature = 0 }); poolSettings.WinterPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(15), PumpCycleType = PumpCycleType.StopAt }); poolSettings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 15, RunTimeHours = 1 }); poolSettings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 20, RunTimeHours = 4 }); storeService.WritePoolSettings(poolSettings, "poolsettings.json"); var results = storeService.ReadPoolSettings("poolsettings.json"); Assert.AreEqual(PoolWorkingMode.Winter, results.WorkingMode); Assert.AreEqual(100, results.CoverCylcleDurationInSeconds); Assert.AreEqual(1, results.SummerPumpingCycles.Count); Assert.AreEqual(2, results.SummerPumpingCycles[0].PumpingCycles.Count); Assert.AreEqual(PumpCycleType.StartAt, results.SummerPumpingCycles[0].PumpingCycles[0].PumpCycleType); Assert.AreEqual(TimeSpan.FromHours(12), results.SummerPumpingCycles[0].PumpingCycles[1].DecisionTime); Assert.AreEqual(PumpCycleType.StopAt, results.SummerPumpingCycles[0].PumpingCycles[1].PumpCycleType); }
private ReplicaSetPool <IThriftConnection, string, IPEndPoint> CreateDataConnectionPool(ICassandraClusterSettings settings) { var replicaSetPool = ReplicaSetPool.Create <IThriftConnection, string, IPEndPoint>( settings.Endpoints, (key, replicaKey) => GetDataConnectionPool(settings, replicaKey, key), c => ((ThriftConnectionInPoolWrapper)c).ReplicaKey, c => ((ThriftConnectionInPoolWrapper)c).KeyspaceName, settings.ConnectionIdleTimeout, PoolSettings.CreateDefault(), logger); return(replicaSetPool); }
private ReplicaSetPool <IThriftConnection, string, IPEndPoint> CreateFierceConnectionPool(ICassandraClusterSettings settings) { var result = ReplicaSetPool.Create <IThriftConnection, string, IPEndPoint>( new[] { settings.EndpointForFierceCommands }, (key, replicaKey) => CreateFiercePool(settings, replicaKey, key), c => ((ThriftConnectionInPoolWrapper)c).ReplicaKey, c => ((ThriftConnectionInPoolWrapper)c).KeyspaceName, settings.ConnectionIdleTimeout, PoolSettings.CreateDefault(), logger); return(result); }
//Constructor /// <summary> /// Creates an initialized instance. /// </summary> /// <param name="poolCfg">The configuration of the pool of neurons.</param> public PoolStat(PoolSettings poolCfg) { PoolName = poolCfg.Name; NumOfNeurons = 0; NeuronGroups = new NeuronGroupStat[poolCfg.NeuronGroupsCfg.GroupCfgCollection.Count]; for (int i = 0; i < poolCfg.NeuronGroupsCfg.GroupCfgCollection.Count; i++) { NeuronGroups[i] = new NeuronGroupStat(poolCfg.NeuronGroupsCfg.GroupCfgCollection[i].Name); } Synapses = new SynapsesByRoleStat(); NeuronsAnomalies = new NeuronsAnomaliesStat(); return; }
protected T CreatePool <T>(GameObject prefab, string name, out PoolSettings settings) where T : Component, IPool <PoolMember> { var poolGO = new GameObject(name); poolGO.transform.SetParent(transform); var pool = poolGO.AddComponent <T>(); settings = defaultPoolSettings.Clone(); settings.prefab = prefab; return(pool); }
private static PoolSettings GetPoolSettings() { var settings = new PoolSettings(); settings.SummerPumpingCycles.Clear(); settings.SummerPumpingCycles.Add(new PumpCycleGroupSetting()); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(8), PumpCycleType = PumpCycleType.StartAt, ChlorineInhibition = true, PhRegulationInhibition = false, }); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(16), PumpCycleType = PumpCycleType.StartAt, ChlorineInhibition = false, PhRegulationInhibition = true, }); settings.WinterPumpingCycles.Clear(); settings.WinterPumpingCycles.Add(new PumpCycleGroupSetting()); settings.WinterPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(5), PumpCycleType = PumpCycleType.StartAt, }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 15, RunTimeHours = 1 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 20, RunTimeHours = 4 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 25, RunTimeHours = 8 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 30, RunTimeHours = 12 }); return(settings); }
public void ReadSettings() { PoolSet = FileProcessor.ReadFile(_poolSet, filePath); if (!Directory.Exists(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MiningPoolMonitor"))) { try { Directory.CreateDirectory(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MiningPoolMonitor")); } catch (Exception ex) { MessageBox.Show(ex.Message); } } }
// Initialization void Start() { poolDictionary = new Dictionary <string, Queue <GameObject> >(); for (int i = 0; i < pools.Length; ++i) { PoolSettings poolSettings = pools[i]; Queue <GameObject> pool = new Queue <GameObject>(); for (int j = 0; j < poolSettings.size; ++j) { GameObject obj = Instantiate(poolSettings.prefab, level); obj.SetActive(false); pool.Enqueue(obj); } poolDictionary.Add(poolSettings.type, pool); } }
/// <summary> /// Change the settings. /// </summary> /// <returns></returns> public void SavePoolSettings(PoolSettings settings) { if (settings.SummerPumpingCycles.Count == 0 || settings.WinterPumpingCycles.Count == 0) { throw new ArgumentException("Invalid cycles"); } this.poolSettings.CoverCylcleDurationInSeconds = settings.CoverCylcleDurationInSeconds; this.poolSettings.SummerPumpingCycles = settings.SummerPumpingCycles; this.poolSettings.WinterPumpingCycles = settings.WinterPumpingCycles; this.poolSettings.FrostProtection = settings.FrostProtection; this.poolSettings.WorkingMode = settings.WorkingMode; this.poolSettings.TemperatureRunTime = settings.TemperatureRunTime; this.storeService.WritePoolSettings(this.poolSettings, settingsFileName); this.poolControlLoop.ResetSettings(this.poolSettings); }
public void CyclesWithRatios() { var settings = new PoolSettings(); settings.SummerPumpingCycles.Clear(); settings.SummerPumpingCycles.Add(new PumpCycleGroupSetting()); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(1), PumpCycleType = PumpCycleType.StartAt, Ratio = 0, }); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(11), PumpCycleType = PumpCycleType.StopAt, Ratio = 2, }); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(17), PumpCycleType = PumpCycleType.StartAt, Ratio = 100, }); // ======== SUMMER MODE ============ settings.WorkingMode = PoolWorkingMode.Summer; var time = DateTime.Now.Date; var result = settings.GetNextPumpCycles(time.AddHours(1), 25d, TimeSpan.FromHours(4), 3).ToList(); Assert.AreEqual(9, result.Count); Assert.AreEqual(time.AddHours(1), result[0].StartTime); Assert.AreEqual(time.AddHours(2), result[0].EndTime); Assert.AreEqual(time.AddHours(9), result[1].StartTime); Assert.AreEqual(time.AddHours(11), result[1].EndTime); Assert.AreEqual(time.AddHours(17), result[2].StartTime); Assert.AreEqual(time.AddHours(18), result[2].EndTime); }
/// <summary> /// Creates the 3D pool of analog neurons. /// </summary> /// <param name="poolName">The name of the pool.</param> /// <param name="dimX">Size on X dimension.</param> /// <param name="dimY">Size on Y dimension.</param> /// <param name="dimZ">Size on Z dimension.</param> /// <param name="randomInterconnectionDensity">The density of the random interconnection.</param> private PoolSettings CreateAnalogPoolCfg(string poolName, int dimX, int dimY, int dimZ, double randomInterconnectionDensity) { //Create TanH group of neurons AnalogNeuronGroupSettings grpCfg = CreateTanHGroup("Exc-TanH-Grp", 1); //We use two interconnection schemas //Chain schema (circle shaped). We use ratio 1 so all the neurons within the pool will be connected into the circle shaped chain. ChainSchemaSettings chainSchemaCfg = new ChainSchemaSettings(1d, true); //Random schema RandomSchemaSettings randomSchemaCfg = new RandomSchemaSettings(randomInterconnectionDensity); //Create pool configuration PoolSettings poolCfg = new PoolSettings(poolName, new ProportionsSettings(dimX, dimY, dimZ), new NeuronGroupsSettings(grpCfg), new InterconnSettings(chainSchemaCfg, randomSchemaCfg) ); return(poolCfg); }
void Start() { //Инициализируется словарь пула и наполняется poolDictionary = new Dictionary <string, Queue <GameObject> >(); for (int i = 0; i < pools.Length; ++i) { PoolSettings poolSettings = pools[i]; Queue <GameObject> pool = new Queue <GameObject>(); for (int j = 0; j < poolSettings.size; ++j) { GameObject obj = Instantiate(poolSettings.prefab, container); obj.SetActive(false); pool.Enqueue(obj); } poolDictionary.Add(poolSettings.type, pool); } }
/*! \cond UNITY */ protected override void Awake() { base.Awake(); name = "_CurvyGlobal_"; transform.SetAsLastSibling(); Object.DontDestroyOnLoad(this); mPoolManager = GetComponent <PoolManager>(); var s = new PoolSettings() { MinItems = 0, Threshold = 50, Prewarm = true, AutoCreate = true, AutoEnableDisable = true }; mControlPointPool = mPoolManager.CreateComponentPool <CurvySplineSegment>(s); }
public void JsonSerialiation() { var settings = new PoolSettings(); settings.TemperatureRunTime.Clear(); settings.SummerPumpingCycles.Clear(); settings.WinterPumpingCycles.Clear(); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 15, RunTimeHours = 1 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 20, RunTimeHours = 3 }); settings.TemperatureRunTime.Add(new TemperatureRunTime() { Temperature = 25, RunTimeHours = 10 }); settings.SummerPumpingCycles.Add(new PumpCycleGroupSetting()); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(8), PumpCycleType = PumpCycleType.StopAt }); settings.SummerPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(13), PumpCycleType = PumpCycleType.StartAt }); settings.WinterPumpingCycles.Add(new PumpCycleGroupSetting()); settings.WinterPumpingCycles[0].PumpingCycles.Add(new PumpCycleSetting() { DecisionTime = TimeSpan.FromHours(13), PumpCycleType = PumpCycleType.StartAt }); var result = JsonConvert.DeserializeObject <PoolSettings>(JsonConvert.SerializeObject(settings)); Assert.AreEqual(3, result.TemperatureRunTime.Count); Assert.AreEqual(1, result.SummerPumpingCycles.Count); Assert.AreEqual(2, result.SummerPumpingCycles[0].PumpingCycles.Count); Assert.AreEqual(1, result.WinterPumpingCycles.Count); }
/*! \cond UNITY */ public override void Awake() { base.Awake(); name = "_CurvyGlobal_"; transform.SetAsLastSibling(); // Unity 5.3 introduces bug that hides GameObject when calling this outside playmode! if (Application.isPlaying) { Object.DontDestroyOnLoad(this); } mPoolManager = GetComponent <PoolManager>(); var s = new PoolSettings() { MinItems = 0, Threshold = 50, Prewarm = true, AutoCreate = true, AutoEnableDisable = true }; mControlPointPool = mPoolManager.CreateComponentPool <CurvySplineSegment>(s); }
public static async void GetPoolData() { string filePath = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "MiningPoolMonitor\\config.cfg"); poolSettings = FileProcessor.ReadFile(poolSettings, filePath); Stats = await Task.Run(() => PoolStatusProccesor.GetPoolStats(poolSettings.MinerAddress, poolSettings.Pool)); //if (_windowManager != null) //{ // DashboardViewModel dVm = new DashboardViewModel(Stats, poolSettings); // dVm.BindPoolData(Stats); //} if (Stats != null) { ReportedHashrate = Stats.ReportedHashrate; if (ReportedHashrate < poolSettings.MinHeshRate) { notifyIcon.Icon = Properties.Resources.NotReadyIcon; notifyIcon.ShowBalloonTip(500, "Warning", "Low Hash-rate!", ToolTipIcon.Warning); } else { notifyIcon.Icon = Properties.Resources.ReadyIcon; } } else { ReportedHashrate = 0; notifyIcon.Icon = Properties.Resources.NotReadyIcon; notifyIcon.ShowBalloonTip(500, "Error", "No connection!", ToolTipIcon.Error); } }
public void Initialize(string ident, PoolSettings settings, params GameObject[] prefabs) { Identifier = ident; m_Settings = settings; Prefabs = new List<GameObject>(prefabs); mLastTime = DTTime.TimeSinceStartup + UnityEngine.Random.Range(0, Settings.Speed); if (Settings.Prewarm) Reset(); }
private static ReplicaSetPool <TItem, TItemKey, TReplicaKey> CreatePool <TItem, TItemKey, TReplicaKey>( TReplicaKey[] replicas, Func <TItemKey, TReplicaKey, Pool <TItem> > poolFactory ) where TItem : class, IDisposable, IPoolKeyContainer <TItemKey, TReplicaKey>, ILiveness where TItemKey : IEquatable <TItemKey> where TReplicaKey : IEquatable <TReplicaKey> { return(new ReplicaSetPool <TItem, TItemKey, TReplicaKey>(replicas, poolFactory, EqualityComparer <TReplicaKey> .Default, EqualityComparer <TItemKey> .Default, i => i.ReplicaKey, i => i.PoolKey, PoolSettings.CreateDefault(), new SilentLog(), null)); }
public void TestRemoveUnusedConnection() { using (var pool = ReplicaSetPool.Create <Item, ItemKey, ReplicaKey>(new[] { new ReplicaKey("replica1") }, (x, z) => new Pool <Item>(y => new Item(x, z), new SilentLog()), PoolSettings.CreateDefault(), TimeSpan.FromMilliseconds(100), new SilentLog())) { var item1 = pool.Acquire(null); var item2 = pool.Acquire(null); pool.Release(item1); Thread.Sleep(500); pool.Release(item2); var item3 = pool.Acquire(null); var item4 = pool.Acquire(null); Assert.That(item3, Is.EqualTo(item2)); Assert.That(item4, Is.Not.EqualTo(item1) & Is.Not.EqualTo(item2)); } }