public void SetUp()
{
factory = new OracleProcessorFactory();
connectionString = "Data Source=localhost/XE;User Id=Something;Password=Something";
announcer = new NullAnnouncer();
options = new ProcessorOptions();
}
public IProcessor Create(ProcessorOptions options, ILogger logger)
{
var generatorOptions = new GeneratorOptions();
var generator = new SQLiteGenerator(generatorOptions);
return(new SQLiteProcessor(generator, logger, options, new SQLiteBatchParser()));
}
public void SetUp()
{
_runnerContextMock = new Mock <IRunnerContext>(MockBehavior.Loose);
_processorMock = new Mock <IMigrationProcessor>(MockBehavior.Loose);
_migrationLoaderMock = new Mock <IMigrationLoader>(MockBehavior.Loose);
_profileLoaderMock = new Mock <IProfileLoader>(MockBehavior.Loose);
_announcer = new Mock <IAnnouncer>();
_stopWatch = new Mock <IStopWatch>();
var options = new ProcessorOptions
{
PreviewOnly = true
};
_processorMock.SetupGet(x => x.Options).Returns(options);
_runnerContextMock.SetupGet(x => x.Namespace).Returns("FluentMigrator.Tests.Integration.Migrations");
_runnerContextMock.SetupGet(x => x.Announcer).Returns(_announcer.Object);
_runnerContextMock.SetupGet(x => x.StopWatch).Returns(_stopWatch.Object);
_runnerContextMock.SetupGet(x => x.Target).Returns(Assembly.GetExecutingAssembly().ToString());
_runnerContextMock.SetupGet(x => x.Connection).Returns(IntegrationTestOptions.SqlServer.ConnectionString);
_runnerContextMock.SetupGet(x => x.Database).Returns("sqlserver");
_runner = new MigrationRunner(Assembly.GetAssembly(typeof(MigrationRunnerTests)), _runnerContextMock.Object, _processorMock.Object)
{
MigrationLoader = _migrationLoaderMock.Object,
ProfileLoader = _profileLoaderMock.Object
};
}
public Postgres92Processor(Postgres92Generator generator,
ILogger <PostgresProcessor> logger,
ProcessorOptions options,
PostgresOptions pgOptions)
: base(generator, logger, options, pgOptions)
{
}
#pragma warning disable 0612
public Migrator(string connectionString)
{
var announcer = new ConsoleAnnouncer()
{
ShowSql = true,
};
var options = new ProcessorOptions()
{
ConnectionString = connectionString,
};
var factory = new FluentMigrator.Runner.Processors.MySql.MySql5ProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var context = new RunnerContext(announcer)
{
AllowBreakingChange = true,
};
_runner = new MigrationRunner(
typeof(Migrator).Assembly,
context,
processor);
}
public SocketOperationsImpl(EntityCache <CustomSocket> socketCache, EntityCache <SocketGroup> socketGroupCache,
SocketExchange.SocketExchangeClient client, SocketOperationsOptions options)
{
_client = client;
_socketCache = socketCache;
_socketGroupCache = socketGroupCache;
_options = options;
var sockets = _socketCache.GetAll();
var productionRulesGenerator = new ProductionRulesGenerator();
var logicRulesGenerator = new LogicRulesGenerator();
var fuzzyRulesGenerator = new FuzzyRulesGenerator();
var neuralRulesGenerator = new NeuralRulesGenerator();
// Продукционный вывод
var rulesGraph = productionRulesGenerator.GenerateRules(sockets);
// Логический вывод
var logicRules = logicRulesGenerator.GenerateRules(sockets);
// Нечеткий вывод
var fuzzyDomains = fuzzyRulesGenerator.GetFuzzyDomains(sockets);
var fuzzyFacts = fuzzyRulesGenerator.GetFuzzyFacts(fuzzyDomains, sockets);
// Нейро-нечеткий вывод
var neuralNetwork = neuralRulesGenerator.GetNeuralNetwork(sockets);
var processorOptions = new ProcessorOptions {
Debug = _options.Debug
};
_productionProcessor = new ProductionProcessor(rulesGraph, processorOptions);
_logicProcessor = new LogicProcessor(logicRules, processorOptions);
_fuzzyProcessor = new FuzzyProcessor(fuzzyDomains, fuzzyFacts, processorOptions);
_neuralProcessor = new NeuralProcessor(neuralNetwork, processorOptions);
}
public void ShouldConvertMarkdown(string fileName)
{
var options = new ProcessorOptions();
fileName = $"{fileName}.md";
CompareFiles(fileName, fileName, options);
}
protected void SetUp(IMigrationProcessorFactory processorFactory)
{
this.factory = processorFactory;
this.connectionString = "Data Source=localhost/XE;User Id=Something;Password=Something";
this.announcer = new NullAnnouncer();
this.options = new ProcessorOptions();
}
private static void ReadFile(string filePath)
{
var processor = new Processor();
try
{
processor.ProgressEvent += ProcessorProgressEvent;
var options = new ProcessorOptions
{
SourceToTargetCopier = new SourceToTargetHandler
{
CopySourceToTaret = false,
Preserve = true
}
};
var segmentInfos = processor.ReadFile(filePath, options);
if (segmentInfos == null)
{
return;
}
foreach (var segmentInfo in segmentInfos)
{
Console.WriteLine("Paragraph {0}: ", segmentInfo.ParagraphId);
Console.WriteLine("Segment {0}: ", segmentInfo.SegmentId);
Console.WriteLine();
Console.WriteLine("Source Segment");
Console.WriteLine("Text: {0}", segmentInfo.TokenizedSegment.SourceSegment.ToPlain());
WriteTokens(segmentInfo.TokenizedSegment.SourceSegment.Tokens);
Console.WriteLine();
Console.WriteLine("Target Segment");
Console.WriteLine("Text: {0}", segmentInfo.TokenizedSegment.TargetSegment.ToPlain());
WriteTokens(segmentInfo.TokenizedSegment.TargetSegment.Tokens);
Console.WriteLine();
Console.WriteLine("Statistics");
Console.WriteLine(" - Words: {0}", segmentInfo.TokenizedSegment.SourceWordCounts.Words);
Console.WriteLine(" - Characters: {0}", segmentInfo.TokenizedSegment.SourceWordCounts.Characters);
Console.WriteLine(" - Placeables: {0}", segmentInfo.TokenizedSegment.SourceWordCounts.Placeables);
Console.WriteLine(" - Tags: {0}", segmentInfo.TokenizedSegment.SourceWordCounts.Tags);
Console.WriteLine();
Console.WriteLine("-".PadRight(40, '-'));
Console.WriteLine();
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
processor.ProgressEvent -= ProcessorProgressEvent;
}
}
public void CheckAliveUrls()
{
var logger = new Logger();
var options = new ProcessorOptions {
CheckLinks = true
};
var textFile = new TextFile(@"<https://github.com/KvanTTT/MarkConv>
<https://github.com/KvanTTT/MarkConv1>
[Incorrect Link Format]((http://asdf.qwer))
[Incorrect Link Format 2]((http://zxcv.qwer))
[Correct Header](#header)
[Broken Header](#broken-header)
[Correct Link](http://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%A5%D0%B0%D1%84%D0%B0)
[Redirect from http to https](http://msdn.microsoft.com/en-us/library/bb933790.aspx)
# Header
", "Links.md");
var parser = new Parser(options, logger, textFile);
var parseResult = parser.Parse();
var checker = new Checker(options, logger);
checker.Check(parseResult);
Assert.Equal(4, logger.WarningMessages.Count);
Assert.Single(logger.ErrorMessages);
Assert.Equal("Relative link broken-header at [6,1..32) is broken", logger.ErrorMessages[0]);
}
public UpdateDatabase(String ConnectionString)
{
var announcer = new TextWriterAnnouncer(s => System.Console.WriteLine(s));
var assembly = Assembly.GetAssembly(typeof(SchemaChanges.frm_20170221_1442));
var migrationContext = new RunnerContext(announcer)
{
Namespace = "TimeGo.DataModel.SchemaChanges"
};
IMigrationProcessorOptions options = new ProcessorOptions {
PreviewOnly = false,
Timeout = 60
};
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2008ProcessorFactory();
var processor = factory.Create(ConnectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp();
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutionContext"/>
/// class.
/// </summary>
public ExecutionContext(
IProgress <int> progress,
Func <ICustomDataProcessor, ILogger> loggerFactory,
ICustomDataSource customDataSource,
IEnumerable <IDataSource> dataSources,
IEnumerable <TableDescriptor> tablesToEnable,
IProcessorEnvironment processorEnvironment,
ProcessorOptions commandLineOptions)
{
Guard.NotNull(progress, nameof(progress));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(customDataSource, nameof(customDataSource));
Guard.NotNull(dataSources, nameof(dataSources));
Guard.All(dataSources, x => x != null, nameof(dataSources));
Guard.NotNull(tablesToEnable, nameof(tablesToEnable));
Guard.All(tablesToEnable, x => x != null, nameof(tablesToEnable));
Guard.NotNull(processorEnvironment, nameof(processorEnvironment));
Guard.NotNull(commandLineOptions, nameof(commandLineOptions));
this.ProgressReporter = progress;
this.LoggerFactory = loggerFactory;
this.CustomDataSource = customDataSource;
this.DataSources = dataSources.ToList().AsReadOnly();
this.TablesToEnable = tablesToEnable.ToList().AsReadOnly();
this.ProcessorEnvironment = processorEnvironment;
this.CommandLineOptions = commandLineOptions;
}
public ICustomDataProcessor CreateProcessor(
IEnumerable <IDataSource> dataSources,
IProcessorEnvironment processorEnvironment,
ProcessorOptions options)
{
throw new NotImplementedException();
}
public static ProcessorOptions GetDefaultOptions(MarkdownType?inputMarkdownType, MarkdownType?outputMarkdownType)
{
var options = new ProcessorOptions();
if (inputMarkdownType.HasValue)
{
options.InputMarkdownType = inputMarkdownType.Value;
}
if (outputMarkdownType.HasValue)
{
options.OutputMarkdownType = outputMarkdownType.Value;
}
switch (options.InputMarkdownType)
{
case MarkdownType.Habr:
case MarkdownType.Dev:
options.LinesMaxLength = outputMarkdownType == MarkdownType.GitHub ? 80 : 0;
break;
case MarkdownType.GitHub:
options.LinesMaxLength =
options.OutputMarkdownType == MarkdownType.Habr || outputMarkdownType == MarkdownType.Dev ? -1 : 0;
break;
}
if (options.OutputMarkdownType == MarkdownType.Habr || options.OutputMarkdownType == MarkdownType.Dev)
{
options.IndentString = " ";
options.RemoveTitleHeader = true;
options.CenterImageAlignment = true;
}
return(options);
}
internal List <SegmentInfo> ReadFile(string filePath, ProcessorOptions options)
{
var converter = _fileTypeManager.GetConverterToDefaultBilingual(filePath, filePath + ".out", null);
var contentProcessor = new ParagraphProcessor
{
Segments = new List <SegmentInfo>()
};
if (options.SourceToTargetCopier.CopySourceToTaret)
{
converter.AddBilingualProcessor(new SourceToTargetCopier(
options.SourceToTargetCopier.Preserve
? ExistingContentHandling.Preserve
: ExistingContentHandling.Replace));
}
converter.AddBilingualProcessor(contentProcessor);
try
{
converter.Progress += ConverterProgress;
converter.Parse();
}
finally
{
converter.Progress -= ConverterProgress;
}
return(contentProcessor.Segments);
}
public static void Run(IContainer settingsContainer)
{
var connectionString = settingsContainer.GetInstance <string>("DefaultConnection");
Announcer announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
announcer.ShowSql = true;
Assembly assembly = typeof(CreateTableEstacionamento).Assembly;
IRunnerContext migrationContext = new RunnerContext(announcer);
var options = new ProcessorOptions
{
PreviewOnly = false, // set to true to see the SQL
Timeout = 60
};
try
{
var factory = settingsContainer.GetInstance <MigrationProcessorFactory>(); //new FluentMigrator.Runner.Processors.SQLite.SQLiteProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
catch (Exception ex)
{
throw new InvalidOperationException("connectionString: " + connectionString, ex);
}
}
private static MigrationRunner GetMigrationRunner(StringWriter sw, MigrateDatabaseContext dbItem, Assembly migrationAssembly)
{
Announcer announcer = new TextWriterWithGoAnnouncer(sw)
{
ShowSql = true
};
var runnerCtx = new RunnerContext(announcer)
{
ApplicationContext = dbItem
};
if (string.IsNullOrWhiteSpace(dbItem.CurrentDatabaseNamespace))
{
throw new ArgumentNullException(nameof(dbItem.CurrentDatabaseNamespace), "<DatabaseNamespace> should not null or empty");
}
runnerCtx.Namespace = dbItem.CurrentDatabaseNamespace;
var options = new ProcessorOptions {
PreviewOnly = false, Timeout = dbItem.ConnectionTimeout
};
var factory = new FluentMigrator.Runner.Processors.SqlServer.SqlServer2014ProcessorFactory();
using (var processor = factory.Create(dbItem.ConnectionString, announcer, options))
{
return(new MigrationRunner(migrationAssembly, runnerCtx, processor));
}
}
public async Task ReadAsyncExpectedTimeoutTest()
{
ChangesHandler <MyDocument> handler = (changes, cancelationToken) =>
{
IReadOnlyList <MyDocument> list = changes as IReadOnlyList <MyDocument>;
Assert.IsNotNull(list);
Assert.AreEqual("test", list[0].id);
return(Task.CompletedTask);
};
Mock <PartitionCheckpointer> mockCheckpointer = new Mock <PartitionCheckpointer>();
Mock <FeedIterator> mockIterator = new Mock <FeedIterator>();
mockIterator.Setup(i => i.ReadNextAsync(It.IsAny <CancellationToken>()))
.Returns(async() =>
{
await Task.Delay(200);
return(GetResponse(HttpStatusCode.OK, true));
});
mockIterator.SetupSequence(i => i.HasMoreResults).Returns(true).Returns(false);
CustomSerializer serializer = new CustomSerializer();
ChangeFeedObserverFactoryCore <MyDocument> factory = new ChangeFeedObserverFactoryCore <MyDocument>(handler, new CosmosSerializerCore(serializer));
ProcessorOptions options = new ProcessorOptions()
{
RequestTimeout = TimeSpan.FromMilliseconds(100)
};
FeedProcessorCore processor = new FeedProcessorCore(factory.CreateObserver(), mockIterator.Object, options, mockCheckpointer.Object);
try
{
Task runTask = processor.RunAsync(default);
public SqlServer2000Processor(SqlServer2000Generator generator,
ILogger logger,
ProcessorOptions options,
SqlServerBatchParser batchParser) : base(() => SqlClientFactory.Instance, generator, logger, options)
{
this.batchParser = batchParser;
}
private void CreateDatabaseSchemaInMemory(string connectionString)
{
if (connectionString == null)
{
throw new ArgumentNullException("connectionString");
}
// Enable testing profile in FluentMigrator.
Environment.SetEnvironmentVariable("TestingProfile", "1", EnvironmentVariableTarget.Process);
// Create migration announcer.
var announcer = new ConsoleAnnouncer();
// Create migration context.
var migrationContext = new RunnerContext(announcer);
// Create migration options, factory and runner.
var options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = 60
};
var factory = new SqliteProcessorFactory();
var processor = factory.Create(connectionString, announcer, options);
var runner = new MigrationRunner(Assembly.GetAssembly(typeof(MigrationExtensions)), migrationContext, processor);
// Update database.
runner.MigrateUp(long.MaxValue, true);
}
public void Executa()
{
const BancoDeDados bancoDeDados = BancoDeDados.Postgresql;
var connectionString = bancoDeDados.GetStringConexao();
Announcer announcer = new TextWriterAnnouncer(s => System.Diagnostics.Debug.WriteLine(s));
announcer.ShowSql = true;
var assembly = Assembly.GetExecutingAssembly();
IRunnerContext migrationContext = new RunnerContext(announcer);
var options = new ProcessorOptions
{
PreviewOnly = false, // set to true to see the SQL
Timeout = 60
};
var factory = bancoDeDados.GetFactory();
using (var processor = factory.Create(connectionString, announcer, options))
{
var runner = new MigrationRunner(assembly, migrationContext, processor);
runner.MigrateUp(true);
}
}
public static void MigrateToLatest(string connectionString, string migrationAssemblyName)
{
var assembly = Assembly.Load(new AssemblyName(migrationAssemblyName));
var migrationContext = new RunnerContext(Announcer)
{
Namespace = migrationAssemblyName + ".Migrations"
};
var options = new ProcessorOptions {
PreviewOnly = false, Timeout = DefaultTimeout
};
var factory = new SqlServer2008ProcessorFactory();
var processor = factory.Create(connectionString, Announcer, options);
var runner = new MigrationRunner(assembly, migrationContext, processor);
foreach (var a in runner.MigrationAssemblies.Assemblies)
{
RunScriptGroup(ScriptRunningGroup.PreMigrationScript, a, processor);
}
runner.MigrateUp(true);
foreach (var a in runner.MigrationAssemblies.Assemblies)
{
RunScriptGroup(ScriptRunningGroup.PostMigrationScript, a, processor);
}
}
static void Main()
{
// Create migration announcer.
var announcer = new TextWriterAnnouncer(Console.WriteLine)
{
ShowSql = true
};
// Create migration context.
var migrationContext = new RunnerContext(announcer);
// Create migration options, factory and runner.
var options = new ProcessorOptions
{
PreviewOnly = false,
Timeout = 60
};
var factory = new SqliteProcessorFactory();
var processor = factory.Create(ConnectionString, announcer, options);
var runner = new MigrationRunner(Assembly.GetExecutingAssembly(), migrationContext, processor);
// Update database.
runner.MigrateUp(long.MaxValue, true);
// Rollback database.
runner.MigrateDown(long.MinValue, true);
}
protected override ICustomDataProcessor CreateProcessorCore(
IEnumerable <IDataSource> dataSources,
IProcessorEnvironment processorEnvironment,
ProcessorOptions options)
{
Guard.NotNull(dataSources, nameof(dataSources));
Guard.NotNull(processorEnvironment, nameof(processorEnvironment));
Guard.Any(dataSources, nameof(dataSources));
var sourceParser = new LTTngSourceParser();
var firstDataSource = dataSources.First();
string sourcePath = firstDataSource.Uri.LocalPath;
if (firstDataSource.IsDirectory() && Directory.Exists(sourcePath))
{
// handle open directory
sourceParser.SetFolderInput(sourcePath);
}
else
{
// handle zip archive
sourceParser.SetZippedInput(sourcePath);
}
return(new LTTngDataProcessor(
sourceParser,
options,
this.applicationEnvironment,
processorEnvironment));
}
private static void Compare(int lineMaxLength, string sourceFileName, string expectedFileName)
{
var options = new ProcessorOptions {
LinesMaxLength = lineMaxLength
};
CompareFiles(sourceFileName, expectedFileName, options);
}
public DmesgIsoCustomDataProcessor(
ISourceParser <DmesgIsoLogParsedEntry, LogContext, LogParsedDataKey> sourceParser,
ProcessorOptions options,
IApplicationEnvironment applicationEnvironment,
IProcessorEnvironment processorEnvironment)
: base(sourceParser, options, applicationEnvironment, processorEnvironment)
{
}
public LTTngDataProcessor(
ISourceParser <LTTngEvent, LTTngContext, string> sourceParser,
ProcessorOptions options,
IApplicationEnvironment applicationEnvironment,
IProcessorEnvironment processorEnvironment)
: base(sourceParser, options, applicationEnvironment, processorEnvironment)
{
}
internal QuicEventProcessor(
ISourceParser <QuicEvent, object, Guid> sourceParser,
ProcessorOptions options,
IApplicationEnvironment applicationEnvironment,
IProcessorEnvironment processorEnvironment)
: base(sourceParser, options, applicationEnvironment, processorEnvironment)
{
}
public IProcessor Create(ProcessorOptions options, ILogger logger)
{
var qutoer = new MySqlQuoter();
var generatorOptions = new GeneratorOptions();
var generator = new MySql4Generator(new MySqlColumn(new MySql4TypeMap(), qutoer), qutoer, generatorOptions);
return(new MySql4Processor(generator, logger, options));
}
public IProcessor Create(ProcessorOptions options, ILogger logger)
{
var generatorOptions = new GeneratorOptions();
var quoter = new SqlServer2005Quoter();
var generator = new SqlServer2005Generator(quoter, generatorOptions);
return(new SqlServer2005Processor(logger, generator, options));
}
private static IMigrationProcessor BuildMigrationProcessor(string database, string connection, int timeout, IAnnouncer announcer, bool previewOnly)
{
var processorFactoryProvider = new MigrationProcessorFactoryProvider();
var processorFactory = processorFactoryProvider.GetFactory(database);
var processorOptions = new ProcessorOptions
{
Timeout = timeout,
PreviewOnly = previewOnly
};
var processor = processorFactory.Create(connection, announcer, processorOptions);
return processor;
}
