public override IQueryConnection CreateQueryConnection( QuerySource sourceType, InstanceInfo instance ) { IQueryConnection connection; lock (this._connectionPoolLock) { if (!this._connectionCache.ContainsKey(instance)) { connection = base.CreateQueryConnection(sourceType, instance); this._connectionCache.Add(instance, connection); } connection = this._connectionCache[instance]; } if (connection != null) { if (connection.State != ConnectionState.Closed) { connection.Close(); } } return connection; }
/// <summary> /// Initializes a new instance of the <see cref="BaseGroupResolver"/> class. /// </summary> /// <param name="instance"> /// The instance. /// </param> /// <param name="executeSqlFunction"> /// The execute SQL function. /// </param> protected BaseGroupResolver( InstanceInfo instance, BaseResolverDelegate executeSqlFunction ) { this.Instance = instance; this.ExecuteSqlFunction = executeSqlFunction; }
public SqliteInternalQueryConnection( CurrentStorage currentStorage, InstanceInfo instance ) : base(ConnectionFactory.CreateSQLiteConnection(currentStorage.FileName, false)) { this._instance = instance; this._currentScope = currentStorage; }
/// <summary> /// Initializes a new instance of the <see cref="BaseQueryExecutor" /> class. /// </summary> /// <param name="instance">The instance.</param> /// <param name="executeQueryItemFunction">The query item function.</param> protected BaseQueryExecutor( InstanceInfo instance, BaseResolverQueryItemDelegate executeQueryItemFunction ) { this.Instance = instance; this.ExecuteQueryItemFunction = executeQueryItemFunction; }
/// <summary> /// Initializes a new instance of the <see cref="DatabaseScopeQueryExecutor"/> class. /// </summary> /// <param name="instance"> /// The instance. /// </param> /// <param name="executeQueryItemFunction"> /// The query item function. /// </param> /// <param name="executeSqlFunction"> /// The execute SQL Function. /// </param> public DatabaseScopeQueryExecutor( InstanceInfo instance, BaseResolverQueryItemDelegate executeQueryItemFunction, BaseResolverDelegate executeSqlFunction) : base(instance, executeQueryItemFunction) { this.executeSqlFunction = executeSqlFunction; }
public SqliteInternalQueryCommand( SQLiteCommand command, CurrentStorage currentScope, InstanceInfo instanceInfo ) : base(command) { this._instanceInfo = instanceInfo; this._currentStorage = currentScope; }
public static TdConnection CreateTdConnection(InstanceInfo instanceInfo, bool validateLicense = false) { if (validateLicense) { instanceInfo.ValidateLicense(true).ThrowIfNotCorrect(); } return new TdConnection(instanceInfo.GetConnectionString()); }
/// <summary> /// Initializes a new instance of the <see cref="QueryExecutorFactory"/> class. /// </summary> /// <param name="instance"> /// The instance. /// </param> /// <param name="executeQueryItemFunction"> /// The query item function. /// </param> /// <param name="executeSqlFunction"> /// The execute sql function. /// </param> public QueryExecutorFactory( InstanceInfo instance, BaseResolverQueryItemDelegate executeQueryItemFunction, BaseResolverDelegate executeSqlFunction) { this.instance = instance; this.executeQueryItemFunction = executeQueryItemFunction; this.executeSqlFunction = executeSqlFunction; }
private static InstanceInfo CreateNonDatabaseSelectConnection(string connection, QuerySource sourceType) { var instanceInfo = new InstanceInfo(true) { Instance = connection, IsEnabled = true, IsODBC = false, Name = connection, Authentication = new AuthenticationInfo { IsWindows = false, Password = string.Empty, Username = string.Empty }, DbType = sourceType.ToString() }; return instanceInfo; }
private object GenerateTypeName(AnalysisValue baseClass, bool isRef) { ClassInfo ci = baseClass as ClassInfo; if (ci != null) { return(GetTypeName(((ProjectEntry)ci.DeclaringModule).GetModuleInfo().Name, ci.ClassDefinition.Name)); } BuiltinClassInfo bci = baseClass as BuiltinClassInfo; if (bci != null) { return(GenerateTypeName(bci._type)); } IterableValue iteri = baseClass as IterableValue; if (iteri != null) { return(GenerateTypeName(iteri.PythonType, isRef, iteri.IndexTypes)); } InstanceInfo ii = baseClass as InstanceInfo; if (ii != null) { return(GenerateTypeName(ii.ClassInfo, isRef)); } BuiltinInstanceInfo bii = baseClass as BuiltinInstanceInfo; if (bii != null) { return(GenerateTypeName(bii.ClassInfo, isRef)); } return(GenerateTypeName(baseClass.PythonType)); }
public void ConfigureServices(IServiceCollection services) { var instanceInfo = new InstanceInfo(); services.AddSingleton(instanceInfo); CustomLogs.SetupCustomLogs.ConfigureServices(instanceInfo); SetupDefaultWebMetrics.ConfigureServices(instanceInfo, services); SetupTracing.ConfigureServices(instanceInfo, services, false); ServiceClients.ConfigureServices(services, CustomLogs.SetupCustomLogs.Logger()); SetupCustomCache.ConfigureServices(services, out var redisCacheOptions); CustomLogs.SetupCustomLogs.PrintAllEnv(); var connection = Environment.GetEnvironmentVariable($"sqlCon") ?? throw new Exception("Database connection string required 'sqlCon'"); services.AddDbContext <ApplicationDbContext>(options => options.UseNpgsql(connection)); _ServiceRegisterInjections.Configure(services); services.AddMvc(options => { options.Filters.Add(typeof(GlobalValidatorAttribute)); options.MaxModelValidationErrors = 10; }); services.AddHealthChecks(checks => { //However, the MVC web application has multiple dependencies on the rest of the microservices. Therefore, it calls one AddUrlCheck method for each microservice checks.AddPostgreSqlCheck("any_text", connection, TimeSpan.FromSeconds(10)); // https://github.com/sindrunas/aspnetcore.healthcheck.postgresqlextension //checks.AddSqlCheck("CatalogDb", Configuration["ConnectionString"]); //checks.AddUrlCheck(Configuration["CatalogUrl"]); checks.AddRedisCheck(redisCacheOptions, TimeSpan.FromSeconds(10)); //If the microservice does not have a dependency on a service or on SQL Server, you should just add a Healthy("Ok") check. // checks.AddValueTaskCheck("HTTP Endpoint", // () => new ValueTask<IHealthCheckResult>(HealthCheckResult.Healthy("Ok"))); }); }
public HttpResponseMessage GetModulesMetadata([FromUri] InstanceConfig config, [FromUri] string category = null) { try { var instance = new InstanceInfo(config); var version = instance.Version; // Get all modules of given version var modules = ModuleLoader.Modules .Select(x => x.GetModuleMetadata()) .Where(x => x.SupportedVersions.Contains(version)); // Filter modules by category - return either specified category, or the rest if (String.IsNullOrEmpty(category)) { foreach (var separateCategory in SeparateCategories) { modules = modules.Where(x => x.Category == null || !x.Category.StartsWith(separateCategory, StringComparison.InvariantCultureIgnoreCase)); } } else { modules = modules.Where(x => x.Category != null && x.Category.StartsWith(category, StringComparison.InvariantCultureIgnoreCase)); } if (!modules.Any()) { return(Request.CreateResponse(HttpStatusCode.BadRequest, String.Format("There are no modules available for version {0}.", version))); } return(Request.CreateResponse(HttpStatusCode.OK, modules)); } catch (Exception e) { return(Request.CreateResponse(HttpStatusCode.BadRequest, e.Message)); } }
protected async Task <EurekaHttpResponse <InstanceInfo> > DoGetInstanceAsync(string path) { var requestUri = GetRequestUri(_serviceUrl + path); var request = GetRequestMessage(HttpMethod.Get, requestUri); HttpClient client = GetHttpClient(_config); try { using (HttpResponseMessage response = await client.SendAsync(request)) { Stream stream = await response.Content.ReadAsStreamAsync(); JsonInstanceInfoRoot jroot = JsonInstanceInfoRoot.Deserialize(stream); InstanceInfo infoResp = null; if (jroot != null) { infoResp = InstanceInfo.FromJsonInstance(jroot.Instance); } Trace.TraceInformation("DoGetInstanceAsync {0}, status: {1}, instanceInfo: {2}", requestUri.ToString(), response.StatusCode, (infoResp != null) ? infoResp.ToString() : "null"); EurekaHttpResponse <InstanceInfo> resp = new EurekaHttpResponse <InstanceInfo>(response.StatusCode, infoResp) { Headers = response.Headers }; return(resp); } } catch (Exception e) { Trace.TraceError("DoGetInstanceAsync Exception: {0}", e); throw; } finally { DisposeHttpClient(client); } }
public ILifetimeConfig <TClass> RegisterWithLifetime <TClass>(InstanceLifetime lifetime) where TClass : class { lock (this.@lock) { var classType = typeof(TClass); // IInstanceLifetime resultLifetime; #if WIN8 if (classType.GetTypeInfo().IsInterface) #else if (classType.IsInterface) #endif { throw new ArgumentException("An interface cannot be registered alone"); } if (this.interfaceToClassMap.ContainsKey(classType)) { this.interfaceToClassMap[classType] = null; lifetime = new DummyInstanceHelper(); } else { this.interfaceToClassMap.Add(classType, null); var ii = new InstanceInfo(classType, classType, lifetime); this.instanceInfos.Add(classType, ii); } if (this.factories.ContainsKey(classType)) { this.factories.Remove(classType); } var ilm = new LifetimeManager <TClass>(lifetime); lifetime.LifetimeManager = ilm; return(ilm); } }
private long SaveDatabaseResult( TemplateNodeQueryInfo templateNodeQuery, InstanceInfo instance, QueryDatabaseResultInfo dbResult, Int64?queryId ) { long totalRows = 0L; Int64 recordSet = 1L; foreach (DataTable table in dbResult.DataTables) { Debug.Assert(table != null); long?savedRows = this.SaveResults( instance, templateNodeQuery, recordSet, table, queryId ); if (savedRows.HasValue) { totalRows += savedRows.Value; } recordSet++; } this.UpdateHistory( instance, templateNodeQuery, queryId.Value ); return(totalRows); }
public ModuleResults GetResults(InstanceInfo instanceInfo) { var dbService = instanceInfo.DBService; var newslettersWithDisabledQueue = dbService.ExecuteAndGetTableFromFile("OMNewslettersWithoutQueue.sql"); if (newslettersWithDisabledQueue.Rows.Count > 0) { return(new ModuleResults { Result = newslettersWithDisabledQueue, ResultComment = @"Enable email queue in all newsletters. (UPDATE Newsletter_Newsletter SET NewsletterUseEmailQueue = 1)", Status = Status.Error, }); } else { return(new ModuleResults { ResultComment = "All existing newsletters have email queue turned ON.", Status = Status.Good }); } }
private bool ReleaseUnusedInstancesInternal() { foreach (KeyValuePair <int, List <InstanceInfo> > kv in mCachedInstances) { ResourcesData data; if (!mLoaded.TryGetValue(kv.Key, out data)) { continue; } List <InstanceInfo> infoList = kv.Value; for (int i = 0, imax = infoList.Count; i < imax; i++) { data.refCount--; InstanceInfo to = infoList[i]; mResourcesToPath.Remove(GetResourcesKey(to.type, to.obj)); Object.Destroy(to.obj); } infoList.Clear(); cached_instance_list.Enqueue(infoList); } mCachedInstances.Clear(); return(mUsingInstances.Count <= 0); }
public ModuleResults GetResults(InstanceInfo instanceInfo) { var dbService = instanceInfo.DBService; DataSet results = dbService.ExecuteAndGetDataSetFromFile("DocumentsConsistencyIssuesModule.sql"); RemoveEmptyTables(results); if (results.Tables.Count != 0) { return(new ModuleResults { Result = results, ResultComment = "Consistency issues found!", Status = Status.Error, }); } return(new ModuleResults { Status = Status.Good, ResultComment = "No consistency issues found." }); }
static Point BuildPoint(InstanceInfo instance, DistrictInfo district, CharacterInfo character) { var point = new Point(); point.Measurement = "instance_data"; point.Fields = new Dictionary <string, object> { { "enforcers", instance.Enforcers }, { "criminals", instance.Criminals }, { "queue_size", instance.QueueSize }, { "district_status", instance.DistrictStatus }, }; point.Tags = new Dictionary <string, object> { { "threat", instance.Threat }, { "instance_num", instance.InstanceNum }, { "district_uid", instance.DistrictUid }, { "world_uid", character.WorldUID }, { "district_instance_type_sdd", district.DistrictInstanceTypeSdd }, }; return(point); }
public async Task <ConnectionState> Connect(InstanceInfo registration) { await CallService(); endpoint = simulation.RegisterConnection(InstanceID); endpoint.EventFired += FireEventReceived; // TODO remove MonitoredAccounts from registration //await Monitor(registration.MonitoredAccounts); switch (ServiceState) { case ServiceState.Operational: return(ConnectionState.Online); case ServiceState.Limited: return(ConnectionState.Connected); case ServiceState.Down: default: throw new ApplicationException(); } }
internal protected async Task <bool> UnregisterAsync() { InstanceInfo inst = ApplicationInfoManager.Instance.InstanceInfo; if (inst == null) { return(false); } try { EurekaHttpResponse resp = await HttpClient.CancelAsync(inst.AppName, inst.InstanceId); _logger?.LogDebug("Unregister {0}/{1} returned: {2}", inst.AppName, inst.InstanceId, resp.StatusCode); return(resp.StatusCode == HttpStatusCode.OK); } catch (Exception e) { _logger?.LogError("Unregister failed, Exception:", e); } _logger?.LogDebug("Unregister failed"); return(false); }
private void UpdateLoginList() { cmbLogin.Enabled = false; ClearLoginList(); ConnectionGroupInfo group = SelectedGroup; InstanceInfo instance = SelectedInstance; TemplateRow template = SelectedTemplate; if (group != null && instance != null && template != null) { List <LoginRow> logins = this._loginManager.GetLogins( template.Name, group.Name, instance.Name, instance.DbType ); if (logins.Count > 0) { foreach (LoginRow loginRow in logins) { BindingWrapper <LoginRow> loginWrapper = new BindingWrapper <LoginRow>( loginRow, DisplayLogin ); cmbLogin.Items.Add(loginWrapper); } cmbLogin.SelectedIndex = 0; } } cmbLogin.Enabled = true; }
protected void RunSelectConnectionDialog(MsSqlAuditorModel model) { BindingWrapper <ConnectionType> connectionWrapper = cmbDataBaseType.SelectedItem as BindingWrapper <ConnectionType>; if (connectionWrapper != null) { ConnectionType connectionType = connectionWrapper.Item; QuerySource querySource; if (!Enum.TryParse(connectionType.Id, true, out querySource)) { return; } IConnectionStringDialog dialog = ConnectionStringDialogFactory.CreateDialog( querySource, model ); if (dialog.ShowDialog() == DialogResult.OK) { DbConnectionStringBuilder builder = GetConnectionStringBuilder( querySource, dialog.ConnectionString, dialog.IsOdbc ); InstanceInfo newInstance = InstanceInfoResolver.ResolveInstance( builder, dialog.IsOdbc, querySource ); SelectInstance(newInstance); } } }
public async void RenewAsync_Registers_When404StatusReturned() { var startup = new TestConfigServerStartup("", 404); var server = TestServer.Create(startup.Configure); var uri = "http://localhost:8888/"; server.BaseAddress = new Uri(uri); EurekaClientConfig config = new EurekaClientConfig() { ShouldFetchRegistry = false, ShouldRegisterWithEureka = false, EurekaServerServiceUrls = uri.ToString() }; InstanceInfo inst = new InstanceInfo() { InstanceId = "localhost:foo", HostName = "localhost", AppName = "FOO", IpAddr = "192.168.56.1", Status = InstanceStatus.STARTING }; ApplicationInfoManager.Instance.InstanceInfo = inst; var httpClient = new EurekaHttpClient(config, server.CreateClient()); DiscoveryClient client = new DiscoveryClient(config, httpClient); var result = await client.RenewAsync(); // Verify Register done Assert.NotNull(startup.LastRequest); Assert.Equal("POST", startup.LastRequest.Method); Assert.Equal("localhost:8888", startup.LastRequest.Host.Value); Assert.Equal("/apps/FOO", startup.LastRequest.Path.Value); // Still false as register returns 404 still Assert.False(result); }
public async void SendHeartBeatAsync_InvokesServer_ReturnsStatusCodeAndHeaders() { IHostingEnvironment envir = new HostingEnvironment(); TestConfigServerStartup.Response = ""; TestConfigServerStartup.ReturnStatus = 200; var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName); var server = new TestServer(builder); var uri = "http://localhost:8888/"; server.BaseAddress = new Uri(uri); EurekaInstanceConfig config = new EurekaInstanceConfig() { AppName = "foo", InstanceId = "id1" }; InstanceInfo info = InstanceInfo.FromInstanceConfig(config); var cconfig = new EurekaClientConfig() { EurekaServerServiceUrls = uri }; var client = new EurekaHttpClient(cconfig, server.CreateClient()); EurekaHttpResponse <InstanceInfo> resp = await client.SendHeartBeatAsync("foo", "id1", info, InstanceStatus.UNKNOWN); Assert.NotNull(resp); Assert.Equal(HttpStatusCode.OK, resp.StatusCode); Assert.NotNull(resp.Headers); Assert.Equal("PUT", TestConfigServerStartup.LastRequest.Method); Assert.Equal("localhost:8888", TestConfigServerStartup.LastRequest.Host.Value); Assert.Equal("/apps/FOO/id1", TestConfigServerStartup.LastRequest.Path.Value); var time = DateTimeConversions.ToJavaMillis(new DateTime(info.LastDirtyTimestamp, DateTimeKind.Utc)); Assert.Equal("?status=STARTING&lastDirtyTimestamp=" + time, TestConfigServerStartup.LastRequest.QueryString.Value); }
public void UpdateGroupInstances(ConnectionGroupInfo group, string protocolType) { ConnectionGroupRow savedGroupRow = this._groupManager.GetGroupByName(group.Name); if (savedGroupRow == null) { return; } long id = savedGroupRow.Identity; List <ServerInstanceRow> savedRows = this._instanceManager .GetAllGroupInstances(id, protocolType); List <InstanceInfo> newInstances = group.Connections; foreach (ServerInstanceRow savedRow in savedRows) { InstanceInfo savedInstance = CreateFromRow(savedRow); bool exist = newInstances.Any(Predicates.MatchesTo(savedInstance)); if (savedRow.IsDeleted) { if (exist) { this._instanceManager.RestoreInstance(savedRow); } } else { if (!exist) { this._instanceManager.DeleteInstance(savedRow); } } } }
// 获得一个实例的信息 public ServiceControlResult GetInstanceInfo(string strInstanceName, out InstanceInfo info) { info = null; ServiceControlResult result = new ServiceControlResult(); try { if (strInstanceName == ".") { info = new InstanceInfo(); info.InstanceName = strInstanceName; info.State = "running"; result.Value = 1; // 表示 dp2capo 正在运行状态 return(result); } Instance instance = ServerInfo.FindInstance(strInstanceName); if (instance == null) { result.Value = 0; return(result); } info = new InstanceInfo(); info.InstanceName = instance.Name; info.State = instance.Running ? "running" : "stopped"; result.Value = 1; return(result); } catch (Exception ex) { result.Value = -1; result.ErrorInfo = "GetInstanceInfo() 出现异常: " + ex.Message; return(result); } }
private void btnAddConnectionString_Click(object sender, EventArgs e) { if (ValidateAddConnectionForm()) { InstanceInfo instance = this.cmbConnection.SelectedItem as InstanceInfo; if (instance != null) { string cnnString = instance.GetConnectionString(); IEnumerable <InstanceInfo> instances = this.lstConnectionStrings.Items.OfType <InstanceInfo>(); if (!instances.Any(x => cnnString.Equals(x.GetConnectionString()))) { lstConnectionStrings.Items.Add(instance); UpdateControlsState(); } this._updatesMade = true; return; } ConnectionGroupInfo groupInfo = cmbConnection.SelectedItem as ConnectionGroupInfo; if (groupInfo != null) { lstConnectionStrings.Items.Clear(); InstanceInfo[] instances = groupInfo.Connections.ToArray(); lstConnectionStrings.Items.AddRange(instances); UpdateControlsState(); } this._updatesMade = true; } }
public BusinessAssemblyBridge(InstanceInfo instanceInfo, IGlobalConfiguration configuration, ILogger logger) { _logger = logger; _instanceInfo = instanceInfo; _configuration = configuration; _instanceName = instanceInfo.InstanceName; var containerConfiguration = new ContainerConfiguration(); Assembly assembly; if (string.IsNullOrWhiteSpace(instanceInfo.LoadBusinessFromAssemblyName)) { assembly = LoadAssemblyFromPath(); } else { assembly = AppDomain.CurrentDomain.GetAssemblies() .FirstOrDefault(x => x.GetName().Name == instanceInfo.LoadBusinessFromAssemblyName); if (assembly == null) { _logger.LogError($"Could find assembly:{instanceInfo.LoadBusinessFromAssemblyName}"); } } if (assembly == null) { return; } try { containerConfiguration.WithAssembly(assembly); _container = containerConfiguration.CreateContainer(); } catch (Exception ex) { _logger.LogError(ex, $"Could not compose assembly:{assembly.FullName}"); } }
public static DbConnection CreateDbConnection(InstanceInfo instanceInfo, bool validateLicense = false) { if (instanceInfo.IsODBC) { return CreateOdbcConnection(instanceInfo, validateLicense); } switch (instanceInfo.Type) { case QuerySource.MSSQL: return CreateSqlConnection(instanceInfo, validateLicense); case QuerySource.TDSQL: return CreateTdConnection(instanceInfo, validateLicense); default: string errorMessage = string.Format( "Can not create DbConnection for Query type:{0}", instanceInfo.Type ); Log.ErrorFormat(errorMessage); throw new ArgumentException(errorMessage); } }
public ModuleResults GetResults(InstanceInfo instanceInfo) { List <string> report = new List <string>(); bool isWebSite = ProjectCodeFilesHelper.Current.IsWebSiteProject(instanceInfo.Directory); List <string> customerCodeFiles = ProjectCodeFilesHelper.Current.GetCustomerProjectCodeFiles(instanceInfo.Directory, instanceInfo.Version, isWebSite, true).ToList(); if (customerCodeFiles.Count == 0) { return(new ModuleResults { ResultComment = "No customer files found.", Status = Status.Good }); } report.AddRange(customerCodeFiles); VulnerabilityAnalysisResults results = new VulnerabilityAnalysisResults(); AnalyseVulnerabilities(instanceInfo.Directory, customerCodeFiles, ref results); string resultString = PrintResults(results); if (!String.IsNullOrEmpty(resultString)) { report.Add(String.Empty); report.AddRange(resultString.Split(new[] { "<br />" }, StringSplitOptions.None)); } return(new ModuleResults { Result = report, Trusted = true }); }
protected internal void RefreshInstanceInfo() { InstanceInfo info = _appInfoManager.InstanceInfo; if (info == null) { return; } _appInfoManager.RefreshLeaseInfo(); InstanceStatus?status = null; if (IsHealthCheckHandlerEnabled()) { try { status = HealthCheckHandler.GetStatus(info.Status); _logger?.LogDebug("RefreshInstanceInfo called, returning {status}", status); } catch (Exception e) { _logger?.LogError( e, "RefreshInstanceInfo HealthCheck handler. App: {Application}, Instance: {Instance} marked DOWN", info.AppName, info.InstanceId); status = InstanceStatus.DOWN; } } if (status.HasValue) { _appInfoManager.InstanceStatus = status.Value; } }
protected internal async T.Task <bool> UnregisterAsync() { InstanceInfo inst = _appInfoManager.InstanceInfo; if (inst == null) { return(false); } try { EurekaHttpResponse resp = await HttpClient.CancelAsync(inst.AppName, inst.InstanceId).ConfigureAwait(false); _logger?.LogDebug("Unregister {Application}/{Instance} returned: {StatusCode}", inst.AppName, inst.InstanceId, resp.StatusCode); return(resp.StatusCode == HttpStatusCode.OK); } catch (Exception e) { _logger?.LogError(e, "Unregister Failed"); } _logger?.LogDebug("Unregister failed"); return(false); }
public async System.Threading.Tasks.Task RenewAsync_ReturnsTrue_WhenOKStatusReturned() { var envir = HostingHelpers.GetHostingEnvironment(); TestConfigServerStartup.Response = string.Empty; TestConfigServerStartup.ReturnStatus = 200; var builder = new WebHostBuilder().UseStartup <TestConfigServerStartup>().UseEnvironment(envir.EnvironmentName); var server = new TestServer(builder); var uri = "http://localhost:8888/"; server.BaseAddress = new Uri(uri); var config = new EurekaClientConfig() { ShouldFetchRegistry = false, ShouldRegisterWithEureka = false, EurekaServerServiceUrls = uri.ToString() }; var inst = new InstanceInfo() { InstanceId = "localhost:foo", HostName = "localhost", AppName = "FOO", IpAddr = "192.168.56.1", Status = InstanceStatus.STARTING }; ApplicationInfoManager.Instance.InstanceInfo = inst; var httpClient = new EurekaHttpClient(config, server.CreateClient()); var client = new DiscoveryClient(config, httpClient); var result = await client.RenewAsync(); Assert.True(result); }
public ModuleResults GetResults(InstanceInfo instanceInfo) { // Prepare result DataTable result = new DataTable(); result.Columns.Add("Key", typeof(string)); result.Columns.Add("Actual value", typeof(string)); result.Columns.Add("Recommended value", typeof(string)); // Update web.config path with "CMS" folder for Kentico 8 and newer versions var kenticoVersion = instanceInfo.Version; string pathToWebConfig = instanceInfo.Directory.ToString(); if ((kenticoVersion >= new Version("8.0")) && !(instanceInfo.Directory.ToString().EndsWith("\\CMS\\") || instanceInfo.Directory.ToString().EndsWith("\\CMS"))) { pathToWebConfig += "\\CMS"; } var fileMap = new ExeConfigurationFileMap { ExeConfigFilename = pathToWebConfig + "\\web.config" }; var configuration = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None); # region "Debug mode"
public static ActiveDirectoryConnection CreateActiveDirectoryConnection(InstanceInfo instanceInfo) { string connectionPath = instanceInfo.GetConnectionString(); return new ActiveDirectoryConnection(connectionPath); }
/// <summary> /// Initializes a new instance of the <see cref="InstanceGroupGroupsResolver" /> class. /// </summary> /// <param name="instance">The instance.</param> /// <param name="executeSqlFunction">The execute SQL function.</param> public InstanceGroupGroupsResolver( InstanceInfo instance, BaseResolverDelegate executeSqlFunction) : base(instance, executeSqlFunction) { }
public override void DrawPrimitive(GamePrimitive primitive, GameTime time) { string key = primitive.GameObjectCategory; InstancedPrimitive instancedPrimitive; if (!cacheInstancedPrimitives.ContainsKey (key)) { cacheInstancedPrimitives [key] = instancedPrimitive = new InstancedPrimitive () { Primitive = primitive.Primitive, World = primitive.World, Texture = GetTexture (primitive), Instances = new InstanceInfo [100], InstanceCount = 0, InstanceUniqueHash = 0, IsSkyObject = primitive.IsSkyObject }; } else { instancedPrimitive = cacheInstancedPrimitives [key]; } if (instancedPrimitive.InstanceCount + 1 >= instancedPrimitive.Instances.Length) { Array.Resize (ref instancedPrimitive.Instances, instancedPrimitive.Instances.Length + 200); } InstanceInfo instanceInfo = new InstanceInfo { WorldMatrix = primitive.WorldMatrix * primitive.World.Camera.WorldMatrix, TransposeInverseWorldMatrix = primitive.WorldMatrixInverseTranspose * primitive.World.Camera.WorldMatrix, Alpha = primitive.Coloring.Alpha, IsLightingEnabled = primitive.IsLightingEnabled ? 1 : 0, SingleColor = primitive.IsSingleColored ? primitive.Coloring.MixedColor.ToVector4 () : Vector4.Zero }; instancedPrimitive.Instances [instancedPrimitive.InstanceCount++] = instanceInfo; instancedPrimitive.InstanceUniqueHash += primitive.Position.LengthSquared (); }
public void LoadFromFile(string filename) { StreamReader streamRead = new StreamReader(filename); string[] digits = Regex.Split(streamRead.ReadToEnd(), @"\D+"); mSize = Convert.ToInt32(digits[0]); int instanceId = 0; InstanceInfo currInstance = null; int pos = 1; while (pos < (digits.Length-1)) { currInstance = new InstanceInfo(); for (int i = 0; i < mSize; ++i) currInstance._ExecutionTime.Add(Convert.ToInt32(digits[pos++])); for (int i = 0; i < mSize; ++i) currInstance._Wages.Add(Convert.ToInt32(digits[pos++])); for (int i = 0; i < mSize; ++i) currInstance._Deadlines.Add(Convert.ToInt32(digits[pos++])); mInstances.Add(currInstance); ++instanceId; } }
/// <inheritdoc/> protected override void CreateOrTransformObject(ref ObjectContext objectContext) { base.CreateOrTransformObject(ref objectContext); // Allow to deserialize the old way if (!objectContext.SerializerContext.IsSerializing && objectContext.Reader.Accept<SequenceStart>()) return; // Ignore collections flagged as having non-identifiable items if (!AreCollectionItemsIdentifiable(ref objectContext)) return; // Store the information on the actual instance before transforming. var info = new InstanceInfo(objectContext.Instance, objectContext.Descriptor); objectContext.Properties.Add(InstanceInfoKey, info); if (objectContext.SerializerContext.IsSerializing && objectContext.Instance != null) { // Store deleted items in the context CollectionItemIdentifiers identifier; if (CollectionItemIdHelper.TryGetCollectionItemIds(objectContext.Instance, out identifier)) { var deletedItems = identifier.DeletedItems.ToList(); deletedItems.Sort(); objectContext.Properties.Add(DeletedItemsKey, deletedItems); } // We're serializing, transform the collection to a dictionary of <id, items> objectContext.Instance = TransformForSerialization(objectContext.Descriptor, objectContext.Instance); } else { // We're deserializing, create an empty dictionary of <id, items> objectContext.Instance = CreatEmptyContainer(objectContext.Descriptor); } }
public IQueryConnection CreateQueryConnection(QuerySource sourceType, InstanceInfo instance) { bool isOdbc = instance.IsODBC; QuerySource queryType = instance.Type; instance.SetSettings(this._model.Settings); if (sourceType == QuerySource.SQLite) { IStorageManager storageManager = this._model.GetVaultProcessor( instance.ConnectionGroup ?? new ConnectionGroupInfo() ); AttachingSqliteQueryConnection sqliteQueryConnection; string connectionString = instance.GetConnectionString(); SqliteConnectionParameters connectionParameters = SqliteConnectionParameters.Parse(connectionString); if (connectionParameters.IsValid) { sqliteQueryConnection = new SqliteInnerQueryConnection( storageManager.CurrentStorage, connectionParameters ); } else { sqliteQueryConnection = new SqliteInternalQueryConnection( storageManager.CurrentStorage, instance ); } if (storageManager.HistoryStorage != null) { foreach (var historyStorage in storageManager.HistoryStorage) { sqliteQueryConnection.AddDatabaseToAttach( historyStorage.Alias, historyStorage.FileName ); } } if (storageManager.ReportStorage != null) { sqliteQueryConnection.AddDatabaseToAttach( "report", storageManager.ReportStorage.FileName ); } return sqliteQueryConnection; } if (isOdbc) { OdbcConnection odbcConnection = ConnectionFactory.CreateOdbcConnection(instance, true); return new OdbcQueryConnection(odbcConnection); } if (sourceType == queryType) { switch (sourceType) { case QuerySource.MSSQL: SqlConnection sqlConnection = ConnectionFactory.CreateSqlConnection(instance, true); return new MsSqlQueryConnection(sqlConnection); case QuerySource.TDSQL: TdConnection tdConnection = ConnectionFactory.CreateTdConnection(instance, true); return new TeradataSqlQueryConnection(tdConnection); case QuerySource.SQLiteExternal: SQLiteConnection sqliteConnection = ConnectionFactory.CreateSQLiteExternalConnection(instance); return new SqliteExternalQueryConnection(sqliteConnection); case QuerySource.ActiveDirectory: ActiveDirectoryConnection activeDirectoryConnection = ConnectionFactory.CreateActiveDirectoryConnection(instance); return new ActiveDirectoryQueryConnection(activeDirectoryConnection); case QuerySource.EventLog: EventLogConnection eventLogConnection = ConnectionFactory.CreateEventLogConnection(instance); return new EventLogQueryConnection(eventLogConnection); case QuerySource.NetworkInformation: NetworkInformationConnection networkInfoConnection = ConnectionFactory.CreateNetworkInformationConnection(instance); return new NetworkInformationQueryConnection(networkInfoConnection); } } string errorMessage = String.Format( "There is no QueryConnection defined. QuerySource: {0}, QueryType: {1}", sourceType, queryType ); Log.ErrorFormat(errorMessage); throw new ArgumentException(errorMessage); }
public static SQLiteConnection CreateSQLiteExternalConnection(InstanceInfo instanceInfo) { return new SQLiteConnection(instanceInfo.GetConnectionString()); }
public override void DrawPrimitive(GamePrimitive primitive, GameTime time) { string key = primitive.GameObjectCategory; InstancedPrimitive instancedPrimitive; if (!cacheInstancedPrimitives.ContainsKey (key)) { cacheInstancedPrimitives [key] = instancedPrimitive = new InstancedPrimitive () { Primitive = primitive.Primitive, World = primitive.World, Texture = GetTexture (primitive), Instances = new InstanceInfo [100], InstanceCount = 0, InstanceUniqueHash = 0 }; } else { instancedPrimitive = cacheInstancedPrimitives [key]; } if (instancedPrimitive.InstanceCount + 1 >= instancedPrimitive.Instances.Length) { Array.Resize (ref instancedPrimitive.Instances, instancedPrimitive.Instances.Length + 200); } InstanceInfo instanceInfo = new InstanceInfo { WorldMatrix = primitive.WorldMatrix * primitive.World.Camera.WorldMatrix, TransposeInverseWorldMatrix = primitive.WorldMatrixInverseTranspose * primitive.World.Camera.WorldMatrix }; instancedPrimitive.Instances [instancedPrimitive.InstanceCount++] = instanceInfo; instancedPrimitive.InstanceUniqueHash += primitive.Position.LengthSquared (); }
internal EurekaServiceInstance(InstanceInfo info) { this._info = info; }
private string FindLine(string name) { return(InstanceInfo.FirstOrDefault(x => x.StartsWith(name, StringComparison.InvariantCultureIgnoreCase))); }
public static string ResolveClass(Abc46 abc, InstanceInfo info) { return ResolveMultiname(abc, (MultinameInfo)abc.ConstantPool.MultinameTable[(int)info.Name.Value]); }
public virtual IQueryConnection CreateQueryConnection(QuerySource sourceType, InstanceInfo instance) { return this._connectionFactory.CreateQueryConnection(sourceType, instance); }
/// <summary> /// 添加流程实例 /// </summary> /// qiy 16.04.29 /// <param name="value">值</param> /// <returns></returns> public bool Add(InstanceInfo value) { instanceMapper.Insert(value); return(value.InstanceId > 0); }
/// <summary> /// Initializes a new instance of the <see cref="InstanceScopeQueryExecutor" /> class. /// </summary> /// <param name="instance">The instance.</param> /// <param name="executeQueryItemFunction">The query item function.</param> public InstanceScopeQueryExecutor( InstanceInfo instance, BaseResolverQueryItemDelegate executeQueryItemFunction) : base(instance, executeQueryItemFunction) { }
public void FromJsonInstance_Correct() { JsonInstanceInfo jinfo = new JsonInstanceInfo() { InstanceId = "InstanceId", AppName = "AppName", AppGroupName = "AppGroupName", IpAddr = "IpAddr", Sid = "Sid", Port = new JsonInstanceInfo.JsonPortWrapper(true, 100), SecurePort = new JsonInstanceInfo.JsonPortWrapper(false, 100), HomePageUrl = "HomePageUrl", StatusPageUrl = "StatusPageUrl", HealthCheckUrl = "HealthCheckUrl", SecureHealthCheckUrl = "SecureHealthCheckUrl", VipAddress = "VipAddress", SecureVipAddress = "SecureVipAddress", CountryId = 1, DataCenterInfo = new JsonInstanceInfo.JsonDataCenterInfo("", "MyOwn"), HostName = "HostName", Status = InstanceStatus.DOWN, OverriddenStatus = InstanceStatus.OUT_OF_SERVICE, LeaseInfo = new JsonLeaseInfo() { RenewalIntervalInSecs = 1, DurationInSecs = 2, RegistrationTimestamp = 1457973741708, LastRenewalTimestamp = 1457973741708, LastRenewalTimestampLegacy = 1457973741708, EvictionTimestamp = 1457973741708, ServiceUpTimestamp = 1457973741708 }, IsCoordinatingDiscoveryServer = false, Metadata = new Dictionary <string, string>() { { "@class", "java.util.Collections$EmptyMap" } }, LastUpdatedTimestamp = 1457973741708, LastDirtyTimestamp = 1457973741708, Actiontype = ActionType.ADDED, AsgName = "AsgName" }; InstanceInfo info = InstanceInfo.FromJsonInstance(jinfo); Assert.NotNull(info); // Verify Assert.Equal("InstanceId", info.InstanceId); Assert.Equal("AppName", info.AppName); Assert.Equal("AppGroupName", info.AppGroupName); Assert.Equal("IpAddr", info.IpAddr); Assert.Equal("Sid", info.Sid); Assert.Equal(100, info.Port); Assert.True(info.IsUnsecurePortEnabled); Assert.Equal(100, info.SecurePort); Assert.False(info.IsSecurePortEnabled); Assert.Equal("HomePageUrl", info.HomePageUrl); Assert.Equal("StatusPageUrl", info.StatusPageUrl); Assert.Equal("HealthCheckUrl", info.HealthCheckUrl); Assert.Equal("SecureHealthCheckUrl", info.SecureHealthCheckUrl); Assert.Equal("VipAddress", info.VipAddress); Assert.Equal("SecureVipAddress", info.SecureVipAddress); Assert.Equal(1, info.CountryId); Assert.Equal("MyOwn", info.DataCenterInfo.Name.ToString()); Assert.Equal("HostName", info.HostName); Assert.Equal(InstanceStatus.DOWN, info.Status); Assert.Equal(InstanceStatus.OUT_OF_SERVICE, info.OverriddenStatus); Assert.NotNull(info.LeaseInfo); Assert.Equal(1, info.LeaseInfo.RenewalIntervalInSecs); Assert.Equal(2, info.LeaseInfo.DurationInSecs); Assert.Equal(635935705417080000L, info.LeaseInfo.RegistrationTimestamp); Assert.Equal(635935705417080000L, info.LeaseInfo.LastRenewalTimestamp); Assert.Equal(635935705417080000L, info.LeaseInfo.LastRenewalTimestampLegacy); Assert.Equal(635935705417080000L, info.LeaseInfo.EvictionTimestamp); Assert.Equal(635935705417080000L, info.LeaseInfo.ServiceUpTimestamp); Assert.False(info.IsCoordinatingDiscoveryServer); Assert.NotNull(info.Metadata); Assert.Equal(0, info.Metadata.Count); Assert.Equal(635935705417080000L, info.LastUpdatedTimestamp); Assert.Equal(635935705417080000L, info.LastDirtyTimestamp); Assert.Equal(ActionType.ADDED, info.Actiontype); Assert.Equal("AsgName", info.AsgName); }
/// <summary> /// /// </summary> public void LoadScene() { string sXml = string.Empty; string sShotBoxID = null; bool isTicker; sXml = Util.getSGFromWSL(m_scorebugscenepath); string filetype = Path.GetExtension(m_scorebugscenepath).Split(new string[] { "." }, StringSplitOptions.None)[1]; if (!string.IsNullOrEmpty(sXml)) { objScorePlayer = AppLink.GetShotBox(sXml, out sShotBoxID, out isTicker) as ShotBox; if (!Equals(objScorePlayer, null)) { objScorePlayer.SetEngineUrl(m_serverurl); InstanceInfo o = new InstanceInfo() { Type = filetype, InstanceId = m_scorebugscenepath, TemplateId = string.Empty, ThemeId = "default" }; if (objScorePlayer is IAddinInfo) (objScorePlayer as IAddinInfo).Init(o); objScorePlayer.OnShotBoxStatus += objPlayer1_OnShotBoxStatus; objScorePlayer.OnShotBoxControllerStatus += objPlayer1_OnShotBoxStatus; objScorePlayer.Prepare(m_serverurl, 10, RENDERMODE.PROGRAM); }//end (if) } }
public static EventLogConnection CreateEventLogConnection(InstanceInfo instanceInfo) { string strMachineName = instanceInfo.Instance; return new EventLogConnection(strMachineName); }
private static InstanceInfo CreateDatabaseSelectConnection(string connection, QuerySource sourceType, bool isOdbcConnection) { bool AuthenticationInfoIsWindows = false; string AuthenticationInfoUsername = string.Empty; string AuthenticationInfoPassword = string.Empty; var connectionDialog = new DataConnectionDialog(); connectionDialog.DataSources.Add(DataSource.OdbcDataSource); connectionDialog.DataSources.Add(DataSource.SqlDataSource); connectionDialog.SelectedDataSource = isOdbcConnection ? DataSource.OdbcDataSource : DataSource.SqlDataSource; connectionDialog.UnspecifiedDataSource.Providers.Add(DataProvider.SqlDataProvider); connectionDialog.ConnectionString = connection; var properties = connectionDialog.ConnectionProperties; if (sourceType == QuerySource.MSSQL) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.TDSQL) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.SQLite) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.SQLiteExternal) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.ActiveDirectory) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.EventLog) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else if (sourceType == QuerySource.NetworkInformation) { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } else { AuthenticationInfoIsWindows = true; AuthenticationInfoUsername = string.Empty; AuthenticationInfoPassword = string.Empty; } if (properties["Integrated Security"] != null) { if (properties["Integrated Security"] as bool) { AuthenticationInfoIsWindows = true; } else { AuthenticationInfoIsWindows = false; } } if (properties["uid"] != null) { if (!string.IsNullOrEmpty(properties["uid"] as string)) { AuthenticationInfoIsWindows = false; AuthenticationInfoUsername = properties["uid"] as string; } } if (properties["User ID"] != null) { if (!string.IsNullOrEmpty(properties["User ID"] as string)) { AuthenticationInfoIsWindows = false; AuthenticationInfoUsername = properties["User ID"] as string; } } if (properties["pwd"] != null) { if (!string.IsNullOrEmpty(properties["pwd"] as string)) { AuthenticationInfoIsWindows = false; AuthenticationInfoPassword = properties["pwd"] as string; } } if (properties["Password"] != null) { if (!string.IsNullOrEmpty(properties["Password"] as string)) { AuthenticationInfoIsWindows = false; AuthenticationInfoPassword = properties["Password"] as string; } } log.InforFormat("IsWindows:'{0}';Username:'******';Password:'******', AuthenticationInfoIsWindows AuthenticationInfoUsername, AuthenticationInfoPassword, ); var instance = new InstanceInfo(true) { Authentication = new AuthenticationInfo { // IsWindows = properties["Integrated Security"] as bool? ?? false, // Username = (properties["uid"] as string) ?? (properties["User ID"] as string) ?? string.Empty, // Password = (properties["pwd"] as string) ?? (properties["Password"] as string) ?? string.Empty IsWindows = AuthenticationInfoIsWindows, Username = AuthenticationInfoUsername, Password = AuthenticationInfoPassword }, Instance = (properties["Dsn"] as string) ?? (properties["Data Source"] as string), IsEnabled = true, Name = (properties["Dsn"] as string) ?? (properties["Data Source"] as string), IsODBC = isOdbcConnection, DbType = sourceType.ToString() }; if (instance.IsODBC) { instance.SetInnerODBCCOnnectionString(connection); } return instance; }
public void AddOrUpdate(InstanceInfo instanceinfo) { InstanceList[instanceinfo.GetUniqueId()] = instanceinfo; }
public static NetworkInformationConnection CreateNetworkInformationConnection(InstanceInfo instanceInfo) { return NetworkInformationConnection.Parse( instanceInfo.GetConnectionString() ); }