private static async Task ExtractMetadataAsync(
UpgradeServiceAccessor services, SqlExecutor executor, SqlWorkerResult result, SqlWorkerTask task,
CancellationToken token)
{
var set = new MetadataSet();
var mapping = new MetadataMapping(services.StorageDriver, services.NameBuilder);
var metadataExtractor = new MetadataExtractor(mapping, executor);
foreach (var metadataTask in services.MappingResolver.GetMetadataTasks()
.Where(metadataTask => !ShouldSkipMetadataExtraction(mapping, result, metadataTask)))
{
try {
if (task.HasFlag(SqlWorkerTask.ExtractMetadataAssemblies))
{
await metadataExtractor.ExtractAssembliesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataTypes))
{
await metadataExtractor.ExtractTypesAsync(set, metadataTask, token).ConfigureAwait(false);
}
if (task.HasFlag(SqlWorkerTask.ExtractMetadataExtension))
{
await metadataExtractor.ExtractExtensionsAsync(set, metadataTask, token).ConfigureAwait(false);
}
}
catch (Exception exception) {
UpgradeLog.Warning(
Strings.LogFailedToExtractMetadataFromXYZ, metadataTask.Catalog, metadataTask.Schema, exception);
}
}
result.Metadata = set;
}
/// <inheritdoc/>
protected override IPathNode VisitFullTextIndexInfo(FullTextIndexInfo fullTextIndex)
{
if (!providerInfo.Supports(ProviderFeatures.FullText))
{
UpgradeLog.Warning(Strings.LogFullTextIndexesAreNotSupportedByCurrentStorageIgnoringIndexX, fullTextIndex.Name);
return(null);
}
var table = GetTable(fullTextIndex.PrimaryIndex.ReflectedType);
var primaryIndex = table.PrimaryIndex;
var ftIndex = new StorageFullTextIndexInfo(table, fullTextIndex.Name);
foreach (var fullTextColumn in fullTextIndex.Columns)
{
var column = table.Columns[fullTextColumn.Name];
string typeColumn = null;
if (providerInfo.Supports(ProviderFeatures.FullTextColumnDataTypeSpecification))
{
if (fullTextColumn.TypeColumn != null)
{
typeColumn = table.Columns[fullTextColumn.TypeColumn.Name].Name;
}
}
else
{
UpgradeLog.Warning(Strings.LogSpecificationOfTypeColumnForFulltextColumnIsNotSupportedByCurrentStorageIgnoringTypeColumnSpecificationForColumnX, fullTextColumn.Column.Name);
}
new FullTextColumnRef(ftIndex, column, fullTextColumn.Configuration, typeColumn);
}
ftIndex.FullTextCatalog =
fulltextCatalogNameBuilder.Build(fullTextIndex.PrimaryIndex.ReflectedType, table);
ftIndex.ChangeTrackingMode = configuration.FullTextChangeTrackingMode;
return(ftIndex);
}
//private HintSet GetSchemaHints(StorageModel extractedSchema, StorageModel targetSchema)
//{
// context.SchemaHints = new HintSet(extractedSchema, targetSchema);
// if (context.Stage==UpgradeStage.Upgrading)
// BuildSchemaHints(extractedSchema);
// return context.SchemaHints;
//}
private void BuildSchemaHints(StorageModel extractedSchema, UpgradeHintsProcessingResult result, StoredDomainModel currentDomainModel)
{
var oldModel = context.ExtractedDomainModel;
if (oldModel == null)
{
return;
}
var handlers = Domain.Demand().Handlers;
// It's important to use same StoredDomainModel of current domain
// in both UpgradeHintsProcessor and HintGenerator instances.
var hintGenerator = new HintGenerator(result.TypeMapping, result.ReverseTypeMapping, result.FieldMapping, result.Hints, handlers, context.Services.MappingResolver, extractedSchema, currentDomainModel, oldModel);
var hints = hintGenerator.Run();
context.UpgradedTypesMapping = hints.UpgradedTypesMapping;
context.Hints.Clear();
foreach (var modelHint in hints.ModelHints)
{
context.Hints.Add(modelHint);
}
foreach (var schemaHint in hints.SchemaHints)
{
try {
context.SchemaHints.Add(schemaHint);
}
catch (Exception error) {
UpgradeLog.Warning(Strings.LogFailedToAddSchemaHintXErrorY, schemaHint, error);
}
}
}
private void ParseStoredDomainModel()
{
var context = UpgradeContext;
var extensions = context.Metadata.Extensions.Where(e => e.Name == WellKnown.DomainModelExtensionName);
try {
var found = false;
var types = new List <StoredTypeInfo>();
foreach (var extension in extensions)
{
found = true;
var part = StoredDomainModel.Deserialize(extension.Value);
types.AddRange(part.Types);
}
if (!found)
{
UpgradeLog.Info(Strings.LogDomainModelIsNotFoundInStorage);
return;
}
var model = new StoredDomainModel {
Types = types.ToArray()
};
model.UpdateReferences();
context.ExtractedDomainModel = model;
}
catch (Exception e) {
UpgradeLog.Warning(e, Strings.LogFailedToExtractDomainModelFromStorage);
}
}
private bool EnsureTableExist(StoredTypeInfo type)
{
var nodeName = GetTableName(type);
if (extractedStorageModel.Tables.Contains(nodeName))
{
return(true);
}
UpgradeLog.Warning(Strings.ExTableXIsNotFound, nodeName);
return(false);
}
public void UpgradeLogTest()
{
if (File.Exists(filePath))
{
File.Delete(filePath);
}
UpgradeLog.Debug("Test message", null);
UpgradeLog.Debug("Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Debug(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Debug("Test message", new object[] { 1 });
UpgradeLog.Debug("Test message {0}", null);
UpgradeLog.Debug(new Exception("Some exeption"));
UpgradeLog.Debug(null, new object[] { 1 });
UpgradeLog.Info("Test message", null);
UpgradeLog.Info("Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Info(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Info("Test message", new object[] { 1 });
UpgradeLog.Info("Test message {0}", null);
UpgradeLog.Info(new Exception("Some exeption"));
UpgradeLog.Info(null, new object[] { 1 });
UpgradeLog.Warning("Test message", null);
UpgradeLog.Warning("Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Warning(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Warning("Test message", new object[] { 1 });
UpgradeLog.Warning("Test message {0}", null);
UpgradeLog.Warning(new Exception("Some exeption"));
UpgradeLog.Warning(null, new object[] { 1 });
UpgradeLog.Error("Test message", null);
UpgradeLog.Error("Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Error(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 });
UpgradeLog.Error("Test message", new object[] { 1 });
UpgradeLog.Error("Test message {0}", null);
UpgradeLog.Error(new Exception("Some exeption"));
UpgradeLog.Error(null, new object[] { 1 });
UpgradeLog.FatalError("Test message", null);
UpgradeLog.FatalError("Test message with parameter {0}", new object[] { 1 });
UpgradeLog.FatalError(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 });
UpgradeLog.FatalError("Test message", new object[] { 1 });
UpgradeLog.FatalError("Test message {0}", null);
UpgradeLog.FatalError(new Exception("Some exeption"));
UpgradeLog.FatalError(null, new object[] { 1 });
Assert.IsTrue(File.Exists(filePath));
Assert.AreEqual(File.ReadAllLines(filePath).Count(), 35);
}
private bool EnsureFieldExist(StoredTypeInfo type, string fieldName)
{
if (!EnsureTableExist(type))
{
return(false);
}
var nodeName = GetTableName(type);
var actualFieldName = nameBuilder.ApplyNamingRules(fieldName);
if (extractedStorageModel.Tables[nodeName].Columns.Contains(actualFieldName))
{
return(true);
}
UpgradeLog.Warning(Strings.ExColumnXIsNotFoundInTableY, actualFieldName, nodeName);
return(false);
}
private SecondaryIndexInfo CreateSecondaryIndex(TableInfo owningTable, string indexName, IndexInfo originalModelIndex)
{
var index = new SecondaryIndexInfo(owningTable, indexName);
if (originalModelIndex.Filter != null)
{
if (providerInfo.Supports(ProviderFeatures.PartialIndexes))
{
index.Filter = new PartialIndexFilterInfo(compiler.Compile(handlers, originalModelIndex));
}
else
{
UpgradeLog.Warning(
Strings.LogStorageXDoesNotSupportPartialIndexesIgnoringFilterForPartialIndexY,
providerInfo.ProviderName, originalModelIndex);
}
}
return(index);
}
public Building Build(BuildingType type, double x, double y)
{
Building building = new Building {
Type = type,
X = x,
Y = y,
Level = 1
};
DatabaseContext.Instance.Buildings.Add(building);
UpgradeLog log = new UpgradeLog {
Island = Island,
Building = building,
Time = DateTime.Now,
Level = 1
};
DatabaseContext.Instance.UpgradeLogs.Add(log);
return(building);
}
private void SynchronizeSchema(
Domain domain, SchemaUpgrader upgrader, SchemaExtractor extractor, SchemaUpgradeMode schemaUpgradeMode)
{
using (UpgradeLog.InfoRegion(Strings.LogSynchronizingSchemaInXMode, schemaUpgradeMode)) {
StorageModel targetSchema = null;
if (schemaUpgradeMode == SchemaUpgradeMode.Skip)
{
if (context.ParentDomain == null)
{
//If we build main domain we should log target model.
//Log of Storage Node target model is not necessary
//because storage target model exactly the same.
targetSchema = GetTargetModel(domain);
context.TargetStorageModel = targetSchema;
if (UpgradeLog.IsLogged(LogLevel.Info))
{
UpgradeLog.Info(Strings.LogTargetSchema);
targetSchema.Dump();
}
}
var builder = ExtractedModelBuilderFactory.GetBuilder(context);
context.ExtractedSqlModelCache = builder.Run();
OnSchemaReady();
return; // Skipping comparison completely
}
var extractedSchema = extractor.GetSchema();
// Hints
var triplet = BuildTargetModelAndHints(extractedSchema);
var hintProcessingResult = triplet.Third;
targetSchema = triplet.First;
context.TargetStorageModel = targetSchema;
var hints = triplet.Second;
if (UpgradeLog.IsLogged(LogLevel.Info))
{
UpgradeLog.Info(Strings.LogExtractedSchema);
extractedSchema.Dump();
UpgradeLog.Info(Strings.LogTargetSchema);
targetSchema.Dump();
}
OnSchemaReady();
var breifExceptionFormat = domain.Configuration.SchemaSyncExceptionFormat == SchemaSyncExceptionFormat.Brief;
var result = SchemaComparer.Compare(extractedSchema, targetSchema,
hints, context.Hints, schemaUpgradeMode, domain.Model, breifExceptionFormat, context.Stage);
var shouldDumpSchema = !schemaUpgradeMode.In(
SchemaUpgradeMode.Skip, SchemaUpgradeMode.ValidateCompatible, SchemaUpgradeMode.Recreate);
if (shouldDumpSchema && UpgradeLog.IsLogged(LogLevel.Info))
{
UpgradeLog.Info(result.ToString());
}
if (UpgradeLog.IsLogged(LogLevel.Info))
{
UpgradeLog.Info(Strings.LogComparisonResultX, result);
}
context.SchemaDifference = (NodeDifference)result.Difference;
context.SchemaUpgradeActions = result.UpgradeActions;
switch (schemaUpgradeMode)
{
case SchemaUpgradeMode.ValidateExact:
if (result.SchemaComparisonStatus != SchemaComparisonStatus.Equal || result.HasColumnTypeChanges)
{
throw new SchemaSynchronizationException(result);
}
if (!hintProcessingResult.AreAllTypesMapped() && hintProcessingResult.SuspiciousTypes.Any())
{
throw new SchemaSynchronizationException(Strings.ExExtractedAndTargetSchemasAreEqualButThereAreChangesInTypeIdentifiersSet);
}
break;
case SchemaUpgradeMode.ValidateCompatible:
if (result.SchemaComparisonStatus != SchemaComparisonStatus.Equal &&
result.SchemaComparisonStatus != SchemaComparisonStatus.TargetIsSubset)
{
throw new SchemaSynchronizationException(result);
}
break;
case SchemaUpgradeMode.PerformSafely:
if (result.HasUnsafeActions)
{
throw new SchemaSynchronizationException(result);
}
goto case SchemaUpgradeMode.Perform;
case SchemaUpgradeMode.Recreate:
case SchemaUpgradeMode.Perform:
upgrader.UpgradeSchema(extractor.GetSqlSchema(), extractedSchema, targetSchema, result.UpgradeActions);
if (result.UpgradeActions.Any())
{
extractor.ClearCache();
}
break;
case SchemaUpgradeMode.ValidateLegacy:
if (result.IsCompatibleInLegacyMode != true)
{
throw new SchemaSynchronizationException(result);
}
break;
default:
throw new ArgumentOutOfRangeException("schemaUpgradeMode");
}
}
}
static void publishUpgradeLog(string exchangeName, string queueName)
{
var rabbitMqProxyLog = new RabbitMqService(new MqConfig
{
AutomaticRecoveryEnabled = true,
HeartBeat = 60,
NetworkRecoveryInterval = new TimeSpan(60),
Host = "localhost",
UserName = "******",
Password = "******"
});
var beingIMEIINumber = 100000000000000;
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
try
{
sw.Start();
Console.WriteLine($"*****************{queueName}消息发布开始******************");
string imei = string.Empty;
int terId = 0;
try
{
while (true)
{
for (int i = 0; i < 50000; i++)
{
imei = (beingIMEIINumber + i).ToString();
var log = new UpgradeLog
{
TerId = 0,
RequestRawData = GetUpgradeBytes(imei),
StatusCode = 0,
LogId = 100001,
IMEI = imei,
Request = "",
ComHost = "",
LocalEndPoint = "192.168.0.38:8886",
CreatedTime = DateTime.Now,
FirewareType = 0,
HardwareVer = "WK_MT6260D_T808_1V0",
SoftwareVer = "9300_2016/10/11,VKEL_T808_20161011",
AppVer = "9315"
};
rabbitMqProxyLog.Publish(exchangeName, queueName, "", log.ToJson());
//rabbitMqProxyLog.Publish(log);
}
}
}
catch (Exception ex)
{
throw;
}
sw.Stop();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("总耗时:" + sw.Elapsed.Milliseconds);
}
static void publishDefault(string exchangeName, string queueName)
{
var factory = new ConnectionFactory()
{
HostName = ConfigurationManager.AppSettings["rabbitMq_HostName"],
Port = Convert.ToInt32(ConfigurationManager.AppSettings["rabbitMq_Port"]),
UserName = ConfigurationManager.AppSettings["rabbitMq_UserName"],
Password = ConfigurationManager.AppSettings["rabbitMq_Password"]
};
using (IConnection conn = factory.CreateConnection())
{
using (var channel = conn.CreateModel())
{
channel.ExchangeDeclare(exchange: exchangeName, type: ConfigurationManager.AppSettings["rabbitMq_Type"], durable: true);
//指定队列
channel.QueueBind(queue: queueName,
exchange: exchangeName,
routingKey: "");
try
{
var beingIMEIINumber = 100000000000000;
string imei = "";
//1秒=10000000ticks
//1毫秒=10000tikcs
//1ticks = 100毫微秒=0.1微秒=0.00001毫秒
#region 循环批量
while (true)
{
for (int i = 60000; i < 70000; i++)
{
imei = (beingIMEIINumber + i).ToString();
var log = new UpgradeLog
{
TerId = 0,
RequestRawData = GetUpgradeBytes(imei),
StatusCode = 0,
LogId = 100001,
IMEI = imei,
Request = "",
CreatedTime = DateTime.Now,
LocalEndPoint = "192.168.30.204:20260",
FirewareType = 0,
HardwareVer = "WK_MT6260D_T808_1V0",
SoftwareVer = "9300_2016/10/11,VKEL_T808_20161011",
AppVer = "9315"
};
var message = Encoding.ASCII.GetBytes(log.ToJson());
channel.BasicPublish(exchange: exchangeName, routingKey: "", basicProperties: null, body: message);
}
//System.Threading.Thread.Sleep(2000);
}
#endregion
#region 单个测试
//var log = new UpgradeLog
//{
// TerId = 0,
// RequestRawData = GetUpgradeBytes("868500023849383"),
// StatusCode = 0,
// LogId = 100001,
// IMEI = "868500023849383",
// Request = "",
// CreatedTime = DateTime.Now,
// LocalEndPoint = "192.168.30.204:20260",
// FirewareType = 0,
// Scheme= "VKEL_MT2503D",//方案号只去下划线前两位
// HardwareVer = "VKEL_MT2503D_S28_1V0",
// SoftwareVer = "BP00_2018/07/14,VKEL_S107_20180822",
// AppVer = "BP24"
//};
//var message = Encoding.ASCII.GetBytes(log.ToJson());
//channel.BasicPublish(exchange: exchangeName, routingKey: "", basicProperties: null, body: message);
#endregion
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
}
