private RedisConnectionWrapper GetRedisConnectionWrapperWithUniqueSession(ProviderConfiguration pc) { string id = Guid.NewGuid().ToString(); uniqueSessionNumber++; // Initial connection with redis RedisConnectionWrapper.sharedConnection = null; RedisConnectionWrapper redisConn = new RedisConnectionWrapper(pc, id); return redisConn; }
public static void Main() { var servConfig = new ProviderConfiguration(); servConfig.ApiDomain = "api.aaa.com"; var clientConfig = new ConsumerConfiguration(); var registry = new GenericRegistry(null,null); SeifApplication.Initialize(registry, servConfig,clientConfig, null); SeifApplication.ExposeService<IMockService, MockService>(new ServiceConfiguration()); }
public async Task SendAndReceiveFromSQS() { var properties = new Dictionary <string, string> { { SQSAdapterFactory.DataConnectionStringPropertyName, AWSTestConstants.DefaultSQSConnectionString }, { SQSAdapterFactory.DeploymentIdPropertyName, deploymentId } }; var config = new ProviderConfiguration(properties, "type", "name"); var adapterFactory = new SQSAdapterFactory(); adapterFactory.Init(config, SQS_STREAM_PROVIDER_NAME, new LoggerWrapper <SQSAdapter>(NullLoggerFactory.Instance), this.fixture.Services); await SendAndReceiveFromQueueAdapter(adapterFactory, config); }
public ArrayList GetUpgradeLogList() { var objProviderConfiguration = ProviderConfiguration.GetProviderConfiguration("data"); var strProviderPath = DataProvider.Instance().GetProviderPath(); var arrScriptFiles = new ArrayList(); var arrFiles = Directory.GetFiles(strProviderPath, "*." + objProviderConfiguration.DefaultProvider); foreach (var strFile in arrFiles) { arrScriptFiles.Add(Path.GetFileNameWithoutExtension(strFile)); } arrScriptFiles.Sort(); return(arrScriptFiles); }
public async Task SendAndReceiveFromAzureQueue() { var properties = new Dictionary <string, string> { { AzureQueueAdapterFactory.DataConnectionStringPropertyName, TestDefaultConfiguration.DataConnectionString }, { AzureQueueAdapterFactory.DeploymentIdPropertyName, deploymentId } }; var config = new ProviderConfiguration(properties, "type", "name"); var adapterFactory = new AzureQueueAdapterFactory(); adapterFactory.Init(config, AZURE_QUEUE_STREAM_PROVIDER_NAME, LogManager.GetLogger("AzureQueueAdapter", LoggerType.Application), null); await SendAndReceiveFromQueueAdapter(adapterFactory, config); }
public static string GetDbObjectQualifier() { ProviderConfiguration providerConfiguration = ProviderConfiguration.GetProviderConfiguration("data"); Provider provider = (Provider)providerConfiguration.Providers[providerConfiguration.DefaultProvider]; string objectQualifier = provider.Attributes["objectQualifier"]; if (!string.IsNullOrEmpty(objectQualifier) && !objectQualifier.EndsWith("_")) { objectQualifier += "_"; } return(objectQualifier); }
private async Task <ShardedStorageProvider> ConfigureShardedStorageProvider(string name, StorageProviderManager storageProviderMgr) { var composite = new ShardedStorageProvider(); var provider1 = (IStorageProvider)storageProviderMgr.GetProvider("Store1"); var provider2 = (IStorageProvider)storageProviderMgr.GetProvider("Store2"); List <IProvider> providers = new List <IProvider>(); providers.Add(provider1); providers.Add(provider2); var cfg = new ProviderConfiguration(providerCfgProps, providers); await composite.Init(name, storageProviderMgr, cfg); return(composite); }
public async Task SendAndReceiveFromSQS() { var properties = new Dictionary <string, string> { { SQSAdapterFactory.DataConnectionStringPropertyName, AWSTestConstants.DefaultSQSConnectionString }, { SQSAdapterFactory.DeploymentIdPropertyName, deploymentId } }; var config = new ProviderConfiguration(properties, "type", "name"); var adapterFactory = new SQSAdapterFactory(); adapterFactory.Init(config, SQS_STREAM_PROVIDER_NAME, LogManager.GetLogger("SQSAdapter", LoggerType.Application), null); await SendAndReceiveFromQueueAdapter(adapterFactory, config); }
public async Task SendAndReceiveFromAzureQueue() { var properties = new Dictionary <string, string> { { AzureQueueAdapterFactory.DATA_CONNECTION_STRING, StorageTestConstants.DataConnectionString }, { AzureQueueAdapterFactory.DEPLOYMENT_ID, deploymentId } }; var config = new ProviderConfiguration(properties, "type", "name"); var adapterFactory = new AzureQueueAdapterFactory(); adapterFactory.Init(config, AZURE_QUEUE_STREAM_PROVIDER_NAME, TraceLogger.GetLogger("AzureQueueAdapter", TraceLogger.LoggerType.Application), new DefaultServiceProvider()); await SendAndReceiveFromQueueAdapter(adapterFactory, config); }
public void TryUpdateIfLockIdMatch_WithOnlyUpdateAndNoDelete() { ProviderConfiguration pc = Utility.GetDefaultConfigUtility(); using (RedisServer redisServer = new RedisServer()) { RedisConnectionWrapper redisConn = GetRedisConnectionWrapperWithUniqueSession(); // Inserting data into redis server ChangeTrackingSessionStateItemCollection data = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc)); data["key1"] = "value1"; data["key2"] = "value2"; data["key3"] = "value3"; redisConn.Set(data, 900); int lockTimeout = 900; DateTime lockTime = DateTime.Now; object lockId; ISessionStateItemCollection dataFromRedis; int sessionTimeout; Assert.True(redisConn.TryTakeWriteLockAndGetData(lockTime, lockTimeout, out lockId, out dataFromRedis, out sessionTimeout)); Assert.Equal(lockTime.Ticks.ToString(), lockId.ToString()); Assert.Equal(3, dataFromRedis.Count); Assert.Equal("value1", dataFromRedis["key1"]); Assert.Equal("value2", dataFromRedis["key2"]); Assert.Equal("value3", dataFromRedis["key3"]); dataFromRedis["key2"] = "value2-updated"; redisConn.TryUpdateAndReleaseLockIfLockIdMatch(lockId, dataFromRedis, 900); // Get actual connection and get data from redis IDatabase actualConnection = GetRealRedisConnection(redisConn); HashEntry[] sessionDataFromRedis = actualConnection.HashGetAll(redisConn.Keys.DataKey); Assert.Equal(3, sessionDataFromRedis.Length); ChangeTrackingSessionStateItemCollection sessionDataFromRedisAsCollection = new ChangeTrackingSessionStateItemCollection(new RedisUtility(pc)); foreach (HashEntry entry in sessionDataFromRedis) { sessionDataFromRedisAsCollection[entry.Name] = RedisUtility.GetObjectFromBytes(entry.Value).ToString(); } Assert.Equal("value1", sessionDataFromRedisAsCollection["key1"]); Assert.Equal("value2-updated", sessionDataFromRedisAsCollection["key2"]); Assert.Equal("value3", sessionDataFromRedisAsCollection["key3"]); // check lock removed and remove data from redis actualConnection.KeyDelete(redisConn.Keys.DataKey); Assert.False(actualConnection.KeyExists(redisConn.Keys.LockKey)); DisposeRedisConnectionWrapper(redisConn); } }
private void BindUpgradeLogs() { ProviderConfiguration objProviderConfiguration = ProviderConfiguration.GetProviderConfiguration("data"); string strProviderPath = DataProvider.Instance().GetProviderPath(); var arrScriptFiles = new ArrayList(); string[] arrFiles = Directory.GetFiles(strProviderPath, "*." + objProviderConfiguration.DefaultProvider); foreach (string strFile in arrFiles) { arrScriptFiles.Add(Path.GetFileNameWithoutExtension(strFile)); } arrScriptFiles.Sort(); cboVersion.DataSource = arrScriptFiles; cboVersion.DataBind(); }
public void Constructor_DatabaseIdFromConfigurationProperty() { using (RedisServer redisServer = new RedisServer()) { int databaseId = 7; ProviderConfiguration configuration = Utility.GetDefaultConfigUtility(); configuration.DatabaseId = databaseId; StackExchangeClientConnection connection = new StackExchangeClientConnection(configuration); Assert.Equal(databaseId, connection.RealConnection.Database); connection.Close(); } }
public DynamoDBStorageProviderTests() { DefaultProviderRuntime = new StorageProviderManager(new GrainFactory(), null); ((StorageProviderManager)DefaultProviderRuntime).LoadEmptyStorageProviders(new ClientProviderRuntime(new GrainFactory(), null)).WaitWithThrow(TestConstants.InitTimeout); SerializationManager.InitializeForTesting(); var properties = new Dictionary <string, string>(); properties["DataConnectionString"] = $"Service={AWSTestConstants.Service}"; var config = new ProviderConfiguration(properties, null); var provider = new DynamoDBStorageProvider(); provider.Init("DynamoDBStorageProviderTests", DefaultProviderRuntime, config).Wait(); PersistenceStorageTests = new CommonStorageTests(provider); }
public async Task SendAndReceiveFromAzureQueue() { var properties = new Dictionary <string, string> { { AzureQueueAdapterConstants.DataConnectionStringPropertyName, TestDefaultConfiguration.DataConnectionString }, { AzureQueueAdapterConstants.DeploymentIdPropertyName, deploymentId }, { AzureQueueAdapterConstants.MessageVisibilityTimeoutPropertyName, "00:00:30" } }; var config = new ProviderConfiguration(properties, "type", "name"); var adapterFactory = new AzureQueueAdapterFactory <AzureQueueDataAdapterV2>(); adapterFactory.Init(config, AZURE_QUEUE_STREAM_PROVIDER_NAME, this.fixture.Services); await SendAndReceiveFromQueueAdapter(adapterFactory, config); }
public void Constructor_DatabaseIdFromConnectionString() { using (RedisServer redisServer = new RedisServer()) { int databaseId = 3; ProviderConfiguration configuration = Utility.GetDefaultConfigUtility(); configuration.ConnectionString = string.Format("localhost, defaultDatabase={0}", databaseId); StackExchangeClientConnection connection = new StackExchangeClientConnection(configuration); Assert.Equal(databaseId, connection.RealConnection.Database); connection.Close(); } }
public static SchedulingProvider Instance() { string strCacheKey = ProviderType + "provider"; // -------------------------------------------------------------- // Use the cache because the reflection used later is expensive // -------------------------------------------------------------- ConstructorInfo objConstructor = (ConstructorInfo)DataCache.GetCache(strCacheKey); if (objConstructor == null) { // -------------------------------------------------------------- // Get the name of the provider // -------------------------------------------------------------- ProviderConfiguration objProviderConfiguration = ProviderConfiguration.GetProviderConfiguration(ProviderType); // -------------------------------------------------------------- // The assembly should be in \bin or GAC, so we simply need to // get an instance of the type // -------------------------------------------------------------- try { // -------------------------------------------------------------- // Get the typename of the LoggingProvider from web.config // -------------------------------------------------------------- string strTypeName = ((Provider)objProviderConfiguration.Providers[objProviderConfiguration.DefaultProvider]).Type; // -------------------------------------------------------------- // Use reflection to store the constructor of the class that implements LoggingProvider // -------------------------------------------------------------- Type t = Type.GetType(strTypeName, true); objConstructor = t.GetConstructor(System.Type.EmptyTypes); // -------------------------------------------------------------- // Insert the type into the cache // -------------------------------------------------------------- //DataCache.SetCache(strCacheKey, objConstructor); } catch { // -------------------------------------------------------------- // Could not load the provider - this is likely due to binary compatibility issues // -------------------------------------------------------------- } } return((SchedulingProvider)objConstructor.Invoke(null)); }
public void InstallComponents(IContainer container) { ProviderConfiguration config = ProviderConfiguration.GetProviderConfiguration(_ProviderType); if (config != null) { InstallProvider(container, (Provider)config.Providers[config.DefaultProvider]); foreach (Provider provider in config.Providers.Values) { if (!config.DefaultProvider.Equals(provider.Name, StringComparison.OrdinalIgnoreCase)) { InstallProvider(container, provider); } } } }
private static ConfigurationOptions GetConfigurationOptions(ProviderConfiguration configuration) { if (string.IsNullOrEmpty(configuration.ConnectionString)) { throw new ArgumentException("Connection string cannot be null or empty", nameof(configuration)); } var configOption = ConfigurationOptions.Parse(configuration.ConnectionString); // Setting explicitly 'abortconnect' to false. It will overwrite customer provided value for 'abortconnect' // As it doesn't make sense to allow to customer to set it to true as we don't give them access to ConnectionMultiplexer // in case of failure customer can not create ConnectionMultiplexer so right choice is to automatically create it by providing AbortOnConnectFail = false configOption.AbortOnConnectFail = false; return(configOption); }
public void Config_StorageProvider_Azure1() { const string filename = "Config_StorageProvider_Azure1.xml"; const int numProviders = 1; var orleansConfig = new ClusterConfiguration(); orleansConfig.LoadFromFile(filename); var providerConfigs = orleansConfig.Globals.ProviderConfigurations["Storage"]; ValidateProviderConfigs(providerConfigs, numProviders); ProviderConfiguration pCfg = (ProviderConfiguration)providerConfigs.Providers.Values.ToList()[0]; Assert.Equal("orleanstest1", pCfg.Name); // Provider name #1 Assert.Equal("AzureTable", pCfg.Type); // Provider type #1 }
private static void SetupCustomConfigProviders( IDictionary <string, IAuthenticationProvider> authenticationProviders, IList <Type> discoveredProviders, ProviderConfiguration providerConfig) { authenticationProviders.ThrowIfNull("authenticationProviders"); discoveredProviders.ThrowIfNull("discoveredProviders"); providerConfig.ThrowIfNull("providerConfig"); providerConfig.Providers.ThrowIfNull("providerConfig.Providers"); foreach (ProviderKey provider in providerConfig.Providers) { var discoveredProvider = DiscoverProvider(discoveredProviders, provider); AddProviderToDictionary(authenticationProviders, discoveredProvider, false); } }
/// <summary> /// Reads the associated configuration for the database instance and sets it up if /// it is a localdb instance requiring initialization. /// </summary> public void InitialiseDatabaseServer() { ProviderConfiguration config = (ProviderConfiguration)ConfigurationManager.GetSection("dbTestMonkey/" + ConfigurationSectionName); if (config.IsLocalDbInstance) { SetupLocalDbInstance(config); } else { // SQL Server instance must already be set up. LogAction("Configured SQL Server instance is not LocalDB. Assuming user has already created and started the instance."); return; } }
internal static ProviderConfiguration GetDefaultConfigUtility() { ProviderConfiguration configuration = new ProviderConfiguration(); configuration.SessionTimeout = new TimeSpan(0, 15, 0); //15 min configuration.RequestTimeout = new TimeSpan(0, 1, 30); //1.5 min configuration.Host = "127.0.0.1"; configuration.Port = 0; configuration.AccessKey = null; configuration.UseSsl = false; configuration.DatabaseId = 0; configuration.ApplicationName = null; configuration.ConnectionTimeoutInMilliSec = 5000; configuration.OperationTimeoutInMilliSec = 1000; configuration.RetryTimeout = TimeSpan.Zero; configuration.ThrowOnError = true; return configuration; }
/// <summary> /// Recupera os dados das colunas da tabela. /// </summary> /// <param name="map">Tabela</param> private void GetColumnData(TableMap map) { IDbConnection conn = ProviderConfiguration.CreateConnection(); IDbCommand cmd = conn.CreateCommand(); cmd.Connection = conn; string sql = String.Format(@"SELECT Column_Name AS Field, Column_Type AS Type, Is_Nullable, Column_Key, Column_Default, Extra, Column_Comment FROM Information_Schema.Columns WHERE Table_Schema='{0}' AND Table_Name='{1}';", conn.Database, map.TableName); cmd.CommandText = sql; if (conn.State != ConnectionState.Open) { conn.Open(); } try { IDataReader dr = cmd.ExecuteReader(); while (dr.Read()) { string columnName = dr["Field"].ToString(); FieldMap fm = map.GetFieldMapFromColumn(columnName); if (fm == null) { fm = new FieldMap(map, columnName); map.Fields.Add(fm); } string typeinfo = dr["Type"].ToString(); bool isUnsigned; fm.SetDbType(ExtractType(typeinfo, out isUnsigned), isUnsigned); fm.Size = ExtractSize(typeinfo); fm.IsNullable = (dr["Is_Nullable"].ToString() == "YES"); fm.IsPrimaryKey = (dr["Column_Key"].ToString() == "PRI"); if (fm.IsPrimaryKey) { fm.IsAutoGenerated = (dr["Extra"].ToString() == "auto_increment"); } fm.Comment = dr.GetString(dr.GetOrdinal("Column_Comment")); } } finally { conn.Close(); } }
public static IDbConnection GetConnection() { const string providerType = "data"; ProviderConfiguration providerConfiguration = ProviderConfiguration.GetProviderConfiguration(providerType); var objProvider = ((Provider)providerConfiguration.Providers[providerConfiguration.DefaultProvider]); string connectionString; connectionString = ConfigurationManager.ConnectionStrings["SiteSqlServer"].ConnectionString; IDbConnection newConnection = new System.Data.SqlClient.SqlConnection { ConnectionString = connectionString }; newConnection.Open(); return(newConnection); }
private string GetFullyQualifiedName(string name) { ProviderConfiguration providerConfiguration = ProviderConfiguration.GetProviderConfiguration(ProviderType); Provider objProvider = (Provider)providerConfiguration.Providers[providerConfiguration.DefaultProvider]; objectQualifier = objProvider.Attributes["objectQualifier"]; if (!String.IsNullOrEmpty(objectQualifier) && objectQualifier.EndsWith("_") == false) { objectQualifier += "_"; } databaseOwner = objProvider.Attributes["databaseOwner"]; if (!String.IsNullOrEmpty(databaseOwner) && databaseOwner.EndsWith(".") == false) { databaseOwner += "."; } return(databaseOwner + objectQualifier + name); }
/// <summary> /// Instances this instance. /// </summary> /// <returns></returns> public static LogProvider Instance() { // Use the cache because the reflection used later is expensive Cache cache = HttpRuntime.Cache; string cacheKey; // Get the names of providers ProviderConfiguration config; config = ProviderConfiguration.GetProviderConfiguration(providerType); //If config not found (missing web.config) if (config == null) { //Try to provide a default anyway XmlDocument defaultNode = new XmlDocument(); defaultNode.LoadXml( "<log defaultProvider=\"Log4NetLog\"><providers><clear /><add name=\"Log4NetLog\" type=\"Rainbow.Framework.Logging.Log4NetLogProvider, Rainbow.Provider.Implementation\" /></providers></log>"); // Get the names of providers config = new ProviderConfiguration(); config.LoadValuesFromConfigurationXml(defaultNode.DocumentElement); } // Read specific configuration information for this provider ProviderSettings providerSettings = (ProviderSettings)config.Providers[config.DefaultProvider]; // In the cache? cacheKey = "Rainbow::Configuration::Log::" + config.DefaultProvider; if (cache[cacheKey] == null) { // The assembly should be in \bin or GAC, so we simply need // to get an instance of the type try { cache.Insert(cacheKey, ProviderHelper.InstantiateProvider(providerSettings, typeof(LogProvider))); } catch (Exception e) { throw new Exception("Unable to load provider", e); } } return((LogProvider)cache[cacheKey]); }
/// <summary> /// Recupera as informações sobre a chave identidade da tabela. /// </summary> /// <param name="map"></param> protected void GetIdentityInformation(TableMap map) { if (map != null) { IDbConnection conn = ProviderConfiguration.CreateConnection(); GDAConnectionManager.NotifyConnectionCreated(conn); IDbCommand cmd = conn.CreateCommand(); cmd.Connection = conn; if (conn.State != ConnectionState.Open) { conn.Open(); GDAConnectionManager.NotifyConnectionOpened(conn); } try { foreach (FieldMap fm in map.Fields) { if (fm.IsPrimaryKey) { if (!map.IsView) { cmd.CommandText = String.Format("select COLUMNPROPERTY(OBJECT_ID('{0}'), '{1}', 'IsIdentity') as IsIdentity ", map.TableName, fm.ColumnName); using (IDataReader reader = cmd.ExecuteReader()) { if (reader.Read()) { fm.IsAutoGenerated = (reader["IsIdentity"].ToString() == "1"); } } } } } } catch (Exception ex) { GDAOperations.CallDebugTrace(this, String.Format("Unable to determine whether PK column of table {0} is an identity column.", map.TableName)); GDAOperations.CallDebugTrace(this, ex.Message); } finally { conn.Close(); conn.Dispose(); } } }
public DynamoDBStorageProviderTests(TestEnvironmentFixture fixture) { if (!AWSTestConstants.IsDynamoDbAvailable) { throw new SkipException("Unable to connect to DynamoDB simulator"); } DefaultProviderRuntime = new ClientProviderRuntime(fixture.InternalGrainFactory, fixture.Services, NullLoggerFactory.Instance); var properties = new Dictionary <string, string>(); properties["DataConnectionString"] = $"Service={AWSTestConstants.Service}"; var config = new ProviderConfiguration(properties); var provider = new DynamoDBStorageProvider(); provider.Init("DynamoDBStorageProviderTests", DefaultProviderRuntime, config).Wait(); PersistenceStorageTests = new CommonStorageTests(fixture.InternalGrainFactory, provider); }
internal static ProviderConfiguration GetDefaultConfigUtility() { ProviderConfiguration configuration = new ProviderConfiguration(); configuration.SessionTimeout = new TimeSpan(0, 15, 0); //15 min configuration.RequestTimeout = new TimeSpan(0, 1, 30); //1.5 min configuration.Host = "127.0.0.1"; configuration.Port = 0; configuration.AccessKey = null; configuration.UseSsl = false; configuration.DatabaseId = 0; configuration.ApplicationName = null; configuration.ConnectionTimeoutInMilliSec = 5000; configuration.OperationTimeoutInMilliSec = 1000; configuration.RetryTimeout = TimeSpan.Zero; configuration.ThrowOnError = true; return(configuration); }
private static CollectorCSPConfiguration CollectorInternalToMessage(EventTracingDataContract.CollectorInner collector) { Logger.Log("Reading collector CSP desired configuration...", LoggingLevel.Information); CollectorCSPConfiguration cspConfiguration = new CollectorCSPConfiguration(); cspConfiguration.LogFileFolder = collector.logFileFolder; cspConfiguration.LogFileName = collector.logFileName; cspConfiguration.LogFileSizeLimitMB = collector.logFileSizeLimitMB; cspConfiguration.TraceLogFileMode = EventTracingDataContract.TraceModeToJsonString(collector.traceMode); cspConfiguration.Started = collector.started; foreach (EventTracingDataContract.Provider provider in collector.providers) { ProviderConfiguration msgProvider = ProviderToMessage(provider); cspConfiguration.Providers.Add(msgProvider); } return(cspConfiguration); }
/// <summary> /// 获取平台配置 /// </summary> /// <param name="configKey">配置名</param> /// <returns></returns> public static ProviderConfiguration Configuration(string configKey) { var path = AppDataPath(String.Format("WebADNuke\\{0}.config", configKey)); if (System.IO.File.Exists(path)) { return(ProviderConfiguration.GetProvider(path)); } else { path = AppDataPath(String.Format("WebADNuke\\{0}.xml", configKey)); if (System.IO.File.Exists(path)) { return(ProviderConfiguration.GetProvider(path)); } } return(null); }
/// ----------------------------------------------------------------------------- /// <summary> /// BindData fetches the data from the database and updates the controls /// </summary> /// <history> /// [cnurse] 9/27/2004 Updated to reflect design changes for Help, 508 support /// and localisation /// </history> /// ----------------------------------------------------------------------------- private void BindConfiguration() { lblProduct.Text = DotNetNukeContext.Current.Application.Description; lblVersion.Text = Globals.FormatVersion(DotNetNukeContext.Current.Application.Version, true); betaRow.Visible = (DotNetNukeContext.Current.Application.Status != ReleaseMode.Stable); chkBetaNotice.Checked = Entities.Host.Host.DisplayBetaNotice; chkUpgrade.Checked = Entities.Host.Host.CheckUpgrade; hypUpgrade.ImageUrl = Upgrade.UpgradeIndicator(DotNetNukeContext.Current.Application.Version, Request.IsLocal, Request.IsSecureConnection); if (String.IsNullOrEmpty(hypUpgrade.ImageUrl)) { hypUpgrade.Visible = false; } else { hypUpgrade.NavigateUrl = Upgrade.UpgradeRedirect(); } lblDataProvider.Text = ProviderConfiguration.GetProviderConfiguration("data").DefaultProvider; lblFramework.Text = Globals.NETFrameworkVersion.ToString(2); if (!Upgrade.IsNETFrameworkCurrent("3.5")) { UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("FrameworkDownLevel", LocalResourceFile), ModuleMessage.ModuleMessageType.YellowWarning); } if (WindowsIdentity.GetCurrent() != null) { // ReSharper disable PossibleNullReferenceException lblIdentity.Text = WindowsIdentity.GetCurrent().Name; // ReSharper restore PossibleNullReferenceException } lblHostName.Text = Dns.GetHostName(); lblIPAddress.Text = Dns.GetHostEntry(lblHostName.Text).AddressList[0].ToString(); lblPermissions.Text = SecurityPolicy.Permissions; if (string.IsNullOrEmpty(lblPermissions.Text)) { lblPermissions.Text = Localization.GetString("None", LocalResourceFile); } lblApplicationPath.Text = string.IsNullOrEmpty(Globals.ApplicationPath) ? "/" : Globals.ApplicationPath; lblApplicationMapPath.Text = Globals.ApplicationMapPath; lblServerTime.Text = DateTime.Now.ToString(); lblGUID.Text = Entities.Host.Host.GUID; chkWebFarm.Checked = CachingProvider.Instance().IsWebFarm(); }
public void ClientConfig_SqlServer_StatsProvider() { const string filename = "DevTestClientConfiguration.xml"; ClientConfiguration config = ClientConfiguration.LoadFromFile(filename); output.WriteLine(config); Assert.Equal(1, config.ProviderConfigurations.Count); // Number of Providers Types Assert.Equal("Statistics", config.ProviderConfigurations.Keys.First()); // Client Stats Providers ProviderCategoryConfiguration statsProviders = config.ProviderConfigurations["Statistics"]; Assert.Equal(1, statsProviders.Providers.Count); // Number of Stats Providers Assert.Equal("SQL", statsProviders.Providers.Keys.First()); // Stats provider name ProviderConfiguration providerConfig = (ProviderConfiguration)statsProviders.Providers["SQL"]; // Note: Use string here instead of typeof(SqlStatisticsPublisher).FullName to prevent cascade load of this type Assert.Equal("Orleans.Providers.SqlServer.SqlStatisticsPublisher", providerConfig.Type); // Stats provider class name }