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()
);
}
