internal static async Task <IPAddress> ResolveIPAddressAsync(string addressOrHost, AddressFamily family)
{
var loopback = family == AddressFamily.InterNetwork ? IPAddress.Loopback : IPAddress.IPv6Loopback;
if (addressOrHost.Equals("loopback", StringComparison.OrdinalIgnoreCase))
{
return(loopback);
}
if (IPAddress.TryParse(addressOrHost, out var address))
{
return(address);
}
var candidates = await Dns.GetHostAddressesAsync(addressOrHost);
var chosen = candidates.OrderBy(x => x, IPAddressComparer.Instance).FirstOrDefault();
if (chosen == null)
{
var error = new ConfigurationError($"Hostname {addressOrHost} with family {family} is not a valid IP address or DNS name");
throw new ConfigurationException(error);
}
return(chosen);
}
public ConfigurationError FactoryConfigureICSCommModule(string strEDLFileName, string strGatewayAddress,
ushort usERTUtilityID)
{
ConfigurationError ConfigurationResult = ConfigurationError.SUCCESS;
IPAddress GatewayAddress = null;
try
{
IPAddress.TryParse(strGatewayAddress, out GatewayAddress);
}
catch
{
ConfigurationResult = ConfigurationError.INVALID_ICS_GATEWAY_ADDRESS;
}
if (ConfigurationError.SUCCESS == ConfigurationResult)
{
m_ConfigureDevice.IsFactoryConfig = true;
m_ConfigureDevice.FactoryConfigType = AMIConfigureDevice.ConfigurationOptions.ICSCommModuleOnly;
m_ConfigureDevice.GatewayAddress = GatewayAddress;
if (0 != usERTUtilityID)
{
m_ConfigureDevice.ERTUtilityID = usERTUtilityID;
}
ConfigurationResult = m_ConfigureDevice.Configure(strEDLFileName);
}
return(ConfigurationResult);
}
public async Task ConnectAsync()
{
var addressParts = projectionHost.Split(':');
if (addressParts.Length < 2 || !int.TryParse(addressParts[1], out var port))
{
port = 2113;
}
var endpoints = await Dns.GetHostAddressesAsync(addressParts[0]);
var endpoint = new IPEndPoint(endpoints.First(x => x.AddressFamily == AddressFamily.InterNetwork), port);
projectionsManager =
new ProjectionsManager(
connection.Settings.Log, endpoint,
connection.Settings.OperationTimeout);
try
{
await projectionsManager.ListAllAsync(connection.Settings.DefaultUserCredentials);
}
catch (Exception ex)
{
var error = new ConfigurationError($"GetEventStore cannot connect to event store projections: {projectionHost}.");
throw new ConfigurationException(error, ex);
}
}
public void AddTest()
{
ConfigurationError error = new ConfigurationError(new MyNode(), "Argument Exception");
errors.Add(error);
Assert.AreEqual(1, errors.Count);
Assert.AreSame(error, errors[0]);
}
protected ConfigurationResult ConfigureExtendedSelfRead(AMIConfigureDevice ConfigureDevice)
{
ConfigurationResult Result = ConfigurationResult.SUCCESS;
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
if (Table00.IsTableUsed(2265) &&
(Table00.DeviceClass.ToUpper().Equals(ITRD_DEVICE_CLASS) ||
Table00.DeviceClass.ToUpper().Equals(ITRE_DEVICE_CLASS) ||
Table00.DeviceClass.ToUpper().Equals(ITRF_DEVICE_CLASS) ||
Table00.DeviceClass.ToUpper().Equals(ITRJ_DEVICE_CLASS) ||
Table00.DeviceClass.ToUpper().Equals(ITRK_DEVICE_CLASS)))
{
ConfigError = ConfigureDevice.WriteTableByElementRange(
CentronTblEnum.MfgTbl217SelfReadTwoLogicalIdentifier,
new int[1] {
0
},
CentronTblEnum.MfgTbl217SelfReadTwoLogicalIdentifierQualifier,
new int[1] {
ConfigureDevice.GetFieldArrayLastIndex(CentronTblEnum.MfgTbl217SelfReadTwoLogicalIdentifierQualifier)
});
}
else
{
ConfigError = ConfigurationError.OPERATION_NOT_POSSIBLE;
}
// Translate to the ItronDevice ConfigurationResult error code since
// the factory is using ConfigurationError and we do not want to always
// rely on having the version in AMIConfiguration.dll
Result = TranslateConfigError(ConfigError);
return(Result);
}
/// <summary>
/// Configures the meter instrumentation profile config block
/// with the specified program
/// </summary>
/// <param name="ConfigureDevice">AMIConfigureDevice object with the correct table set already loaded</param>
/// <returns></returns>
/// Revision History
/// MM/DD/YY who Version Issue# Description
/// -------- --- ------- ------ ---------------------------------------
/// 03/06/12 JKW Created - Lithium
///
protected ConfigurationResult ConfigureInstrumentationProfile(AMIConfigureDevice ConfigureDevice)
{
ConfigurationResult Result = ConfigurationResult.SUCCESS;
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
if (Table00.IsTableUsed(2265))
{
ConfigError = ConfigureDevice.WriteTableByElementRange(
CentronTblEnum.MfgTbl217InstrumentationProfileIntervalLength,
null,
CentronTblEnum.MfgTbl217InstrumentationProfilePulseWeightSetTwo,
new int[1] {
ConfigureDevice.GetFieldArrayLastIndex(CentronTblEnum.MfgTbl217InstrumentationProfilePulseWeightSetTwo)
});
}
else
{
ConfigError = ConfigurationError.OPERATION_NOT_POSSIBLE;
}
// Translate to the ItronDevice ConfigurationResult error code since
// the factory is using ConfigurationError and we do not want to always
// rely on having the version in AMIConfiguration.dll
Result = TranslateConfigError(ConfigError);
return(Result);
}
public ConfigurationResult Configure(string sProgramName)
#endif
{
AMIConfigureCentronII ConfigureDevice = new AMIConfigureCentronII(m_PSEM);
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
// Set up the progress bar event handlers
ConfigureDevice.ShowProgressEvent += this.ShowProgressEvent;
ConfigureDevice.StepProgressEvent += this.StepProgressEvent;
ConfigureDevice.HideProgressEvent += this.HideProgressEvent;
ConfigureDevice.IsCanadian = IsCanadian;
// We always need to set the Prompt for data so we should just use what is
// currently in the meter.
ConfigureDevice.UnitID = UnitID;
ConfigureDevice.CustomerSerialNumber = SerialNumber;
ConfigureDevice.InitialDateTime = null;
ConfigError = ConfigureDevice.Configure(sProgramName);
// Translate to the ItronDevice ConfigurationResult error code since
// the factory is using ConfigurationError and we do not want to always
// rely on having the version in AMIConfiguration.dll
return(TranslateConfigError(ConfigError));
}
public void ConfigureServices(IServiceCollection services, IConfiguration config)
{
var fullTextType = config.GetValue <string>("fullText:type");
if (string.Equals(fullTextType, "elastic", StringComparison.OrdinalIgnoreCase))
{
var elasticConfiguration = config.GetValue <string>("fullText:elastic:configuration");
if (string.IsNullOrWhiteSpace(elasticConfiguration))
{
var error = new ConfigurationError("Value is required.", "fullText:elastic:configuration");
throw new ConfigurationException(error);
}
var indexName = config.GetValue <string>("fullText:elastic:indexName");
if (string.IsNullOrWhiteSpace(indexName))
{
indexName = "squidex-index";
}
services.AddSingleton(
c => new ElasticSearchTextIndex(elasticConfiguration, indexName));
services.AddSingleton <ITextIndex>(
c => c.GetRequiredService <ElasticSearchTextIndex>());
services.AddSingleton <IInitializable>(
c => c.GetRequiredService <ElasticSearchTextIndex>());
}
}
public ConfigurationResult Configure(string sProgramName, PromptForData PFData)
#endif
{
AMIConfigureCentronII ConfigureDevice = new AMIConfigureCentronII(m_PSEM);
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
// Set up the progress bar event handlers
ConfigureDevice.ShowProgressEvent += this.ShowProgressEvent;
ConfigureDevice.StepProgressEvent += this.StepProgressEvent;
ConfigureDevice.HideProgressEvent += this.HideProgressEvent;
ConfigureDevice.IsCanadian = IsCanadian;
ConfigureDevice.UnitID = PFData.UnitID;
ConfigureDevice.CustomerSerialNumber = PFData.SerialNumber;
ConfigureDevice.InitialDateTime = PFData.InitialDateTime;
ConfigError = ConfigureDevice.Configure(sProgramName);
// Translate to the ItronDevice ConfigurationResult error code since
// the factory is using ConfigurationError and we do not want to always
// rely on having the version in AMIConfiguration.dll
return(TranslateConfigError(ConfigError));
}
public void AddTest()
{
ConfigurationError error = new ConfigurationError(new MyNode(), "Argument Exception");
errors.Add(error);
Assert.AreEqual(1, errors.Count);
Assert.AreSame(error, errors[0]);
}
public void AddCreateTest()
{
errors.Add(new MyNode(), "Argument Exception");
Assert.AreEqual(1, errors.Count);
ConfigurationError error = errors[0];
Assert.AreEqual("Argument Exception", error.Message);
}
private ConfigurationError[] Convert(IList <Exception> errors)
{
var result = new ConfigurationError[errors.Count];
for (int i = 0; i < result.Length; i++)
{
result[i] = new ConfigurationError(errors[i]);
}
return(result);
}
public static void AddSquidexEventPublisher(this IServiceCollection services, IConfiguration config)
{
var eventPublishers = config.GetSection("eventPublishers");
foreach (var child in eventPublishers.GetChildren())
{
var eventPublisherType = child.GetValue <string>("type");
if (string.IsNullOrWhiteSpace(eventPublisherType))
{
var error = new ConfigurationError("Value is required.", "eventPublishers:{child.Key}:type");
throw new ConfigurationException(error);
}
var eventsFilter = child.GetValue <string>("eventsFilter");
var enabled = child.GetValue <bool>("enabled");
if (string.Equals(eventPublisherType, "RabbitMq", StringComparison.OrdinalIgnoreCase))
{
var publisherConfig = child.GetValue <string>("configuration");
if (string.IsNullOrWhiteSpace(publisherConfig))
{
var error = new ConfigurationError("Value is required.", "eventPublishers:{child.Key}:configuration");
throw new ConfigurationException(error);
}
var exchange = child.GetValue <string>("exchange");
if (string.IsNullOrWhiteSpace(exchange))
{
var error = new ConfigurationError("Value is required.", "eventPublishers:{child.Key}:exchange");
throw new ConfigurationException(error);
}
var name = $"EventPublishers_{child.Key}";
if (enabled)
{
services.AddSingletonAs(c => new RabbitMqEventConsumer(c.GetRequiredService <IJsonSerializer>(), name, publisherConfig, exchange, eventsFilter))
.As <IEventConsumer>();
}
}
else
{
var error = new ConfigurationError($"Unsupported value '{child.Key}", "eventPublishers:{child.Key}:type.");
throw new ConfigurationException(error);
}
}
}
public string BuildUrl(string path, bool trailingSlash = true)
{
if (string.IsNullOrWhiteSpace(BaseUrl))
{
var error = new ConfigurationError("urls:baseurl", "Value is required.");
throw new ConfigurationException(error);
}
return(BaseUrl.BuildFullUrl(path, trailingSlash));
}
public HostString BuildHost()
{
if (!TryBuildHost(baseUrl, out var host))
{
var error = new ConfigurationError("urls:baseurl", "Value is required.");
throw new ConfigurationException(error);
}
return(host);
}
public static string GetRequiredValue(this IConfiguration config, string path)
{
var value = config.GetValue <string>(path);
if (string.IsNullOrWhiteSpace(value))
{
var error = new ConfigurationError("Value is required.", path);
throw new ConfigurationException(error);
}
return(value);
}
public async Task InitializeAsync(
CancellationToken ct)
{
try
{
await client.SoftDeleteAsync(Guid.NewGuid().ToString(), StreamState.Any, cancellationToken : ct);
}
catch (Exception ex)
{
var error = new ConfigurationError("GetEventStore cannot connect to event store.");
throw new ConfigurationException(error, ex);
}
}
public async Task InitializeAsync(CancellationToken ct = default)
{
try
{
await connection.ConnectAsync();
}
catch (Exception ex)
{
var error = new ConfigurationError("GetEventStore cannot connect to event store.");
throw new ConfigurationException(error, ex);
}
await projectionClient.ConnectAsync();
}
public async Task InitializeAsync(CancellationToken ct = default)
{
try
{
CreateCollection();
await SetupCollectionAsync(Collection, ct);
}
catch (Exception ex)
{
var error = new ConfigurationError($"MongoDb connection failed to connect to database {Database.DatabaseNamespace.DatabaseName}.");
throw new ConfigurationException(error, ex);
}
}
public ConfigurationErrorListViewItem(ConfigurationError error) : base()
{
this.error = error;
if (error.ConfigurationNode != null)
{
Text = error.ConfigurationNode.Name;
}
StateImageIndex = 0;
SubItems.Add(String.Empty);
SubItems.Add(error.Message);
if (error.ConfigurationNode != null)
{
SubItems.Add(error.ConfigurationNode.Path);
}
}
public void ConfigurationError()
{
var payload = new ConfigurationErrorPayload
{
ConfigurationName = "config",
Message = "some message",
UsedConfiguration = "some value"
};
foreach (ConfigurationErrorType value in Enum.GetValues(typeof(ConfigurationErrorType)))
{
payload.ErrorType = value;
var obj = new ConfigurationError(new ConfigurationErrorPayload[] { payload });
obj.ValidateSchema();
}
}
public async Task ConnectAsync()
{
var addressParts = projectionHost.Split(':');
if (addressParts.Length < 2 || !int.TryParse(addressParts[1], out var port))
{
port = 2113;
}
var endpoints = await Dns.GetHostAddressesAsync(addressParts[0]);
var endpoint = new IPEndPoint(endpoints.First(x => x.AddressFamily == AddressFamily.InterNetwork), port);
async Task ConnectToSchemaAsync(string schema)
{
projectionsManager =
new ProjectionsManager(
connection.Settings.Log, endpoint,
connection.Settings.OperationTimeout,
null,
schema);
await projectionsManager.ListAllAsync(connection.Settings.DefaultUserCredentials);
}
try
{
try
{
await ConnectToSchemaAsync("https");
}
catch (HttpRequestException)
{
await ConnectToSchemaAsync("http");
}
catch (AggregateException ex) when(ex.Flatten().InnerException is HttpRequestException)
{
await ConnectToSchemaAsync("http");
}
}
catch (Exception ex)
{
var error = new ConfigurationError($"GetEventStore cannot connect to event store projections: {projectionHost}.");
throw new ConfigurationException(error, ex);
}
}
public static string ConfigureByOption(this IConfiguration config, string path, Alternatives options)
{
var value = config.GetRequiredValue(path);
if (options.TryGetValue(value, out var action))
{
action();
}
else
{
var error = new ConfigurationError($"Unsupported value '{value}', supported: {string.Join(" ", options.Keys)}.", path);
throw new ConfigurationException(error);
}
return(value);
}
/// <summary>
/// Event handler for OnFailedToParseConfiguration
/// </summary>
/// <param name="mismatchedTypeConfigurations">failed to parse configurations</param>
private void CreateTypeMismatchEvent(IList <string> mismatchedTypeConfigurations)
{
//Remove previous events, they are no longer relevant
RemoveEvents();
var ev = new ConfigurationError(new[]
{
new ConfigurationErrorPayload
{
ErrorType = ConfigurationErrorType.TypeMismatch,
ConfigurationName = nameof(RemoteConfiguration),
UsedConfiguration = AgentConfiguration.RemoteConfiguration.ToString(),
Message = $"Couldn't parse the following configurations: {string.Join(", ", mismatchedTypeConfigurations)}"
}
}
);
_events.Add(ev);
}
/// <summary>
/// Loads the Factory prompt for values into the program tables
/// </summary>
/// <returns>ConfigurationError Code</returns>
// Revison History:
// MM/DD/YY who Version Issue# Description
// -------- --- ------- ------ ---------------------------------------
// 07/08/10 AF 2.42.02 Created
// 07/08/10 AF 2.42.03 Updated to use C1219Tables.LandisGyr.Gateway dll
//
protected override ConfigurationError LoadFactoryPromptForItems()
{
ConfigurationError ConfigError = ConfigurationError.SUCCESS;
try
{
// Load the Unit ID
m_GatewayTables.SetValue(StdTableEnum.STDTBL6_DEVICE_ID, null, m_strUnitID);
// Load the Customer Serial Number
m_GatewayTables.SetValue(StdTableEnum.STDTBL6_UTIL_SER_NO, null, m_strCustomerSerialNumber);
}
catch (Exception)
{
ConfigError = ConfigurationError.ITEM_NOT_FOUND;
}
return(ConfigError);
}
public virtual ConfigurationError GetValue(uint uiID, out object objValue)
{
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
object objOutput = null;
switch (uiID)
{
case (uint)AMIConfigurationItem.UNIT_ID:
{
objOutput = (object)m_ConfigureDevice.UnitID;
ConfigError = ConfigurationError.SUCCESS;
break;
}
case (uint)AMIConfigurationItem.CUSTOMER_SERIAL_NUMBER:
{
objOutput = (object)m_ConfigureDevice.CustomerSerialNumber;
ConfigError = ConfigurationError.SUCCESS;
break;
}
case (uint)AMIConfigurationItem.CANADIAN_METER:
{
objOutput = (object)m_ConfigureDevice.IsCanadian;
ConfigError = ConfigurationError.SUCCESS;
break;
}
default:
{
objOutput = null;
ConfigError = ConfigurationError.ITEM_NOT_FOUND;
break;
}
}
objValue = objOutput;
return(ConfigError);
}
protected ConfigurationResult ConfigureNonBillingEnergyandLoadProfile(AMIConfigureDevice ConfigureDevice)
{
ConfigurationResult Result = ConfigurationResult.SUCCESS;
ConfigurationError ConfigError = ConfigurationError.GENERAL_ERROR;
if (Table00.IsTableUsed(2265) &&
(Table00.DeviceClass.ToUpper().Equals(ITRE_DEVICE_CLASS) || Table00.DeviceClass.ToUpper().Equals(ITRF_DEVICE_CLASS)) ||
(Table00.DeviceClass.ToUpper().Equals(ITRK_DEVICE_CLASS)))
{
ConfigError = ConfigureDevice.WriteTableByElementRange(
CentronTblEnum.MfgTbl217NonBillableEnergyId,
new int[1] {
0
},
CentronTblEnum.MfgTbl217NonBillableEnergyId,
new int[1] {
ConfigureDevice.GetFieldArrayLastIndex(CentronTblEnum.MfgTbl217NonBillableEnergyId)
});
if (ConfigError == ConfigurationError.SUCCESS)
{
ConfigError = ConfigureDevice.WriteTableByElementRange(
CentronTblEnum.MfgTbl217NonBillingLoadProfileIntervalLength,
null,
CentronTblEnum.MfgTbl217NonBillingLoadProfilePulseWeightSetTwo,
new int[1] {
ConfigureDevice.GetFieldArrayLastIndex(CentronTblEnum.MfgTbl217NonBillingLoadProfilePulseWeightSetTwo)
});
}
}
else
{
ConfigError = ConfigurationError.OPERATION_NOT_POSSIBLE;
}
// Translate to the ItronDevice ConfigurationResult error code since
// the factory is using ConfigurationError and we do not want to always
// rely on having the version in AMIConfiguration.dll
Result = TranslateConfigError(ConfigError);
return(Result);
}
public void ConfigureServices(IServiceCollection services, IConfiguration config)
{
var fullTextType = config.GetValue <string>("fullText:type");
if (string.Equals(fullTextType, "Azure", StringComparison.OrdinalIgnoreCase))
{
var serviceEndpoint = config.GetValue <string>("fullText:azure:serviceEndpoint");
if (string.IsNullOrWhiteSpace(serviceEndpoint))
{
var error = new ConfigurationError("Value is required.", "fullText:azure:serviceEndpoint");
throw new ConfigurationException(error);
}
var serviceApiKey = config.GetValue <string>("fullText:azure:apiKey");
if (string.IsNullOrWhiteSpace(serviceApiKey))
{
var error = new ConfigurationError("Value is required.", "fullText:azure:apiKey");
throw new ConfigurationException(error);
}
var indexName = config.GetValue <string>("fullText:azure:indexName");
if (string.IsNullOrWhiteSpace(indexName))
{
indexName = "squidex-index";
}
services.AddSingleton(
c => new AzureTextIndex(serviceEndpoint, serviceApiKey, indexName));
services.AddSingleton <ITextIndex>(
c => c.GetRequiredService <AzureTextIndex>());
services.AddSingleton <IInitializable>(
c => c.GetRequiredService <AzureTextIndex>());
}
}
private static (int, int) GetPorts(IConfiguration config)
{
var orleansPortSilo = config.GetOptionalValue("orleans:siloPort", 11111);
var orleansPortGateway = config.GetOptionalValue("orleans:gatewayPort", 40000);
var privatePorts = config.GetOptionalValue("WEBSITE_PRIVATE_PORTS", string.Empty);
if (!string.IsNullOrWhiteSpace(privatePorts) && config.GetValue <bool>("orleans:useAzureNetwork"))
{
var ports = privatePorts.Split(',');
if (ports.Length < 1 || !int.TryParse(ports[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out orleansPortSilo))
{
var error = new ConfigurationError("Insufficient private ports configured.", "WEBSITE_PRIVATE_PORTS");
throw new ConfigurationException(error);
}
}
return(orleansPortSilo, orleansPortGateway);
}
/// <summary>
/// 根据上游请求找到下游请求对象
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public DownstreamRoute Get(DownstreamContext context)
{
var configuration = context.Configuration;
var httpContextRequest = context.HttpContext.Request;
var upstreamUrlPath = httpContextRequest.Path.ToString();
var upstreamQueryString = httpContextRequest.QueryString.ToString();
var upstreamHost = httpContextRequest.Headers["Host"];
var configRoutes = configuration.Routes;
if (configRoutes == null || configRoutes.Count == 0)
{
var error = new ConfigurationError(upstreamUrlPath);
_errors.Add(error);
return(null);
}
var upstreamUri = $"{upstreamHost}{upstreamUrlPath}";
//从配置文件里面查找进行
var configRoute = configRoutes.FirstOrDefault(x => x.UpstreamHost + x.UpstreamPathTemplate == upstreamUri);
if (configRoute == null)
{
var error = new ConfigurationError(upstreamUrlPath);
_errors.Add(error);
return(null);
}
DownstreamRoute route = GetDownstreamRoute(configRoute, upstreamQueryString);
return(route);
}
public Task InitializeAsync(CancellationToken ct = default)
{
try
{
var currentConnection = connection.Value;
if (!currentConnection.IsOpen)
{
var error = new ConfigurationError($"RabbitMq event bus failed to connect to {connectionFactory.Endpoint}.");
throw new ConfigurationException(error);
}
return(Task.CompletedTask);
}
catch (Exception ex)
{
var error = new ConfigurationError($"RabbitMq event bus failed to connect to {connectionFactory.Endpoint}.");
throw new ConfigurationException(error, ex);
}
}
public void FixtureSetUp()
{
node = new ApplicationConfigurationNode(ApplicationData.FromCurrentAppDomain());
message = "Test";
error = new ConfigurationError(node, message);
}
public void TestInitialize()
{
node = new ConfigurationApplicationNode(ConfigurationApplicationFile.FromCurrentAppDomain());
message = "Test";
error = new ConfigurationError(node, message);
}
private void DisplayConfigurationError(ConfigurationError error)
{
Console.WriteLine("DisplayConfigurationError:" + error.Message);
}
