private static void WaitUntilServiceIsUp(SqlDServiceModel service)
{
var wait = new ManualResetEvent(false);
using (var endPointMonitor = new EndPointMonitor(service.ToEndPoint()))
{
endPointMonitor.OnUp += (args) =>
{
Log.Out.Info($"Child process {service.Host}:{service.Port}/{service.Database} is up!");
wait.Set();
};
try
{
Log.Out.Info($"Waiting {Constants.END_POINT_UP_WAIT_FOR_TIMEOUT.TotalSeconds}s for child process {service.Host}:{service.Port}/{service.Database}");
wait.WaitOne(Constants.END_POINT_UP_WAIT_FOR_TIMEOUT);
var client = SqlDStart.NewClient().ConnectedTo(service.ToEndPoint());
if (!client.Ping(service.ToEndPoint()))
{
throw new ProcessStartFailedException($"Failed to launch child process {service.Host}:{service.Port}/{service.Database}");
}
}
catch (Exception err)
{
Log.Out.Error($"Failed to start {service.Host}:{service.Port}/{service.Database} as a separate process");
Log.Out.Error(err.ToString());
}
}
}
public void AddServiceToConfigAndStart(ServiceFormViewModel service)
{
var config = this.config.Get();
var sqlDServiceModel = new SqlDServiceModel()
{
Name = service.Name,
Database = service.Database,
Host = service.Host,
Port = service.Port,
Tags = (service.Tags ?? string.Empty).Split(',').ToList(),
};
var registryEntryViewModels = service.Forwards.Where(x => x.Selected).ToList();
if (registryEntryViewModels.Any())
{
sqlDServiceModel.ForwardingTo.AddRange(registryEntryViewModels.Select(y => new SqlDForwardingModel()
{
Host = y.Host,
Port = y.Port
}));
}
config.Services.Add(sqlDServiceModel);
this.config.Set(config);
SqlDStart.SqlDGo(typeof(ServiceService).Assembly, config);
}
private static async Task AssertTargetHasCountMoreThanOrEqualTo(int count = 0)
{
var countSql = typeof(AnyTableB).GetCount();
var targetConnection = SqlDStart.NewDb().ConnectedTo(WellKnown.Listeners.Free1Listener.DatabaseName, SqlDPragmaModel.Default);
var targetResults = await targetConnection.ExecuteScalarAsync <long>(countSql);
Assert.That(targetResults, Is.GreaterThanOrEqualTo(count));
}
private void AssertSourceHasCountMoreThanOrEqualTo(int count = 0)
{
var countSql = typeof(AnyTableB).GetCount();
var sourceConnection = SqlDStart.NewDb().ConnectedTo(WellKnown.Listeners.Free2Listener.DatabaseName, SqlDPragmaModel.Default);
var sourceResultsCount = sourceConnection.ExecuteScalar <long>(countSql);
Assert.That(sourceResultsCount, Is.GreaterThanOrEqualTo(count));
}
public ConnectionClient GetClientOrDefault(QueryContext context, ConfigService config)
{
var sqlDConfiguration = config.Get();
var cfg = sqlDConfiguration.Services.FirstOrDefault(x => x.Tags.Contains("master"));
var client = SqlDStart.NewClient().ConnectedTo(EndPoint.FromUri(context.TargetUri) ?? cfg.ToEndPoint());
return(client);
}
public virtual async Task SetUp()
{
Connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
var createTable = typeof(AnyTableA).GetCreateTable();
await Connection.ExecuteCommandAsync(createTable);
createTable = typeof(AnyTableB).GetCreateTable();
await Connection.ExecuteCommandAsync(createTable);
Instance = await InsertAny <T>();
}
public static void Main(string[] args)
{
var config = typeof(Program).Assembly.SqlDGo("appsettings.json");
try
{
BuildWebHost(args)?.Build().Run();
}
finally
{
SqlDStart.SqlDStop(config);
}
}
public void ConfigureServices(IServiceCollection services)
{
var configuration = SqlDConfig.Get(typeof(Startup).Assembly);
services.AddSingleton(configuration);
services.AddSingleton(EndPoint.FromUri("http://localhost:5000"));
services.AddSingleton(x => SqlDStart.NewDb().ConnectedTo("sql-d/ui", "sql-d.ui.db", SqlDPragmaModel.Default));
services.AddControllersWithViews();
services.AddOpenApiDocument(settings =>
{
settings.DocumentName = "v1";
settings.Title = "[ sql-d/ui ]";
settings.Version = "1.0.0";
});
}
public void ConfigureServices(IServiceCollection services)
{
var configuration = SqlDConfig.Get(StartAssembly);
services.AddSingleton(configuration);
services.AddSingleton(ListenerAddress);
services.AddSingleton(x => SqlDStart.NewDb().ConnectedTo(DbConnectionName, DbConnectionDbName, PragmaOptions));
services.AddCors();
services.AddControllersWithViews().AddNewtonsoftJson();
services.AddResponseCompression();
services.AddOpenApiDocument(settings =>
{
settings.DocumentName = "v1";
settings.Title = "[ sql-d ]";
settings.Version = "1.0.0";
});
}
public void KillService(string host, int port, bool removeFromConfig)
{
var hostToKill = new EndPoint(host, port);
try
{
Log.Out.Info($"Sending remote kill command to {hostToKill.ToUrl()}");
SqlDStart.NewClient(withRetries: false).ConnectedTo(hostToKill).Kill();
}
catch (Exception err)
{
Log.Out.Error(err.Message);
Log.Out.Error(err.StackTrace);
}
try
{
Log.Out.Info($"Unregistering {hostToKill.ToUrl()}");
Registry.Unregister(hostToKill);
}
catch (Exception err)
{
Log.Out.Error(err.Message);
Log.Out.Error(err.StackTrace);
}
if (removeFromConfig)
{
try
{
Log.Out.Info($"Removing {hostToKill.ToUrl()} from config");
var config = this.config.Get();
config.Services = config.Services.Where(x => !x.ToEndPoint().Equals(hostToKill)).ToList();
this.config.Set(config);
}
catch (Exception err)
{
Log.Out.Error(err.Message);
Log.Out.Error(err.StackTrace);
}
}
}
public static void SetUp()
{
lock (Synchronise)
{
RegistryClient = SqlDStart.NewClient().ConnectedTo(EndPoints.Registry);
EndPointMonitor.WaitUntil(RegistryClient.EndPoint, EndPointIs.Up);
AlphaClient = SqlDStart.NewClient().ConnectedTo(EndPoints.Alpha);
EndPointMonitor.WaitUntil(AlphaClient.EndPoint, EndPointIs.Up);
BetaClient = SqlDStart.NewClient().ConnectedTo(EndPoints.Beta);
EndPointMonitor.WaitUntil(BetaClient.EndPoint, EndPointIs.Up);
Free1Client = SqlDStart.NewClient().ConnectedTo(EndPoints.Free1);
EndPointMonitor.WaitUntil(Free1Client.EndPoint, EndPointIs.Up);
Free2Client = SqlDStart.NewClient().ConnectedTo(EndPoints.Free2);
EndPointMonitor.WaitUntil(Free2Client.EndPoint, EndPointIs.Up);
}
}
public static void SetUp()
{
lock (Synchronise)
{
RegistryListener = SqlDStart.NewListener().Hosting(typeof(SqlDStart).Assembly, SqlDStart.NewId(), SqlDStart.NewId(), SqlDPragmaModel.Default, EndPoints.Registry);
EndPointMonitor.WaitUntil(RegistryListener.EndPoint, EndPointIs.Up);
AlphaListener = SqlDStart.NewListener().Hosting(typeof(SqlDStart).Assembly, SqlDStart.NewId(), SqlDStart.NewId(), SqlDPragmaModel.Default, EndPoints.Alpha);
EndPointMonitor.WaitUntil(AlphaListener.EndPoint, EndPointIs.Up);
BetaListener = SqlDStart.NewListener().Hosting(typeof(SqlDStart).Assembly, SqlDStart.NewId(), SqlDStart.NewId(), SqlDPragmaModel.Default, EndPoints.Beta);
EndPointMonitor.WaitUntil(BetaListener.EndPoint, EndPointIs.Up);
Free1Listener = SqlDStart.NewListener().Hosting(typeof(SqlDStart).Assembly, SqlDStart.NewId(), SqlDStart.NewId(), SqlDPragmaModel.Default, EndPoints.Free1, EndPoints.Free2);
EndPointMonitor.WaitUntil(Free1Listener.EndPoint, EndPointIs.Up);
Free2Listener = SqlDStart.NewListener().Hosting(typeof(SqlDStart).Assembly, SqlDStart.NewId(), SqlDStart.NewId(), SqlDPragmaModel.Default, EndPoints.Free2);
EndPointMonitor.WaitUntil(Free2Listener.EndPoint, EndPointIs.Up);
}
}
private async Task MonitorEndPoint()
{
while (Interlocked.Read(ref isRunning) == 1)
{
try
{
var client = SqlDStart.NewClient().ConnectedTo(EndPoint);
var pingResult = await client.PingAsync();
Interlocked.Exchange(ref isUp, pingResult ? 1 : 0);
DoEvents();
}
finally
{
if (Interlocked.Read(ref isRunning) != 1)
{
Thread.Sleep(Constants.END_POINT_MONTIOR_SLEEP_INTERVAL);
}
}
}
}
private async Task ForwardToClients(Func <ConnectionClient, Task <CommandResponse> > clientApiCall)
{
foreach (var forwardAddress in forwardAddresses)
{
try
{
var client = SqlDStart.NewClient().ConnectedTo(forwardAddress);
var commandResponse = await clientApiCall(client);
if (commandResponse.StatusCode != StatusCode.Ok)
{
Logging.Log.Out.Error($"Replicated to {forwardAddress} with {commandResponse.Error}");
}
}
catch (Exception err)
{
Logging.Log.Out.Error(err.ToString());
}
}
}
public virtual void Push(EndPoint target)
{
var targetRegistry = SqlDStart.NewClient().ConnectedTo(target);
var sourceRegistry = SqlDStart.NewClient().ConnectedTo(target);
var registry = sourceRegistry.Get <Registration, RegistrationResponse>(REGISTRY_RESOURCE);
foreach (var registryItem in registry.Registry)
{
if (!registryItem.Tags.Contains(Registry.REGISTRY))
{
targetRegistry.Post <Registration, RegistrationResponse>(
REGISTRY_RESOURCE,
new Registration
{
Name = registryItem.Name,
Database = registryItem.Database,
Source = registryItem.ToEndPoint(),
Tags = registryItem.TagsAsArray
});
}
}
}
public void ShouldBeAbleToLaunchServiceInASeparateProcess()
{
R.GetOrAdd(WellKnown.Listeners.AlphaListener.EndPoint);
var service = new SqlDServiceModel()
{
Name = "separate-process",
Database = SqlDStart.NewId(),
Port = WellKnown.EndPoints.Free2.Port - 100,
Host = WellKnown.EndPoints.Free2.Host,
Pragma = SqlDPragmaModel.Default
};
using (var process = SqlD.Process.Service.Start(typeof(StartTests).Assembly, service))
{
var wait = new ManualResetEvent(false);
using (var endPointMonitor = new EndPointMonitor(service.ToEndPoint()))
{
endPointMonitor.OnUp += (args) => wait.Set();
wait.WaitOne(TimeSpan.FromSeconds(30));
}
process.Kill();
}
}
public void UpdateServiceAndRestart(ServiceFormViewModel service)
{
var config = this.config.Get();
var sqlDServiceModel = config.Services.First(x => x.ToEndPoint().Equals(new EndPoint(service.Host, service.Port)));
var registryEntryViewModels = service.Forwards.Where(x => x.Selected).ToList();
if (registryEntryViewModels.Any())
{
sqlDServiceModel.ForwardingTo = new List <SqlDForwardingModel>();
sqlDServiceModel.ForwardingTo.AddRange(registryEntryViewModels.Select(y => new SqlDForwardingModel()
{
Host = y.Host,
Port = y.Port
}));
}
this.config.Set(config);
KillService(sqlDServiceModel.Host, sqlDServiceModel.Port, removeFromConfig: false);
SqlDStart.SqlDGo(typeof(ServiceService).Assembly, config);
}
public RegistryClient(EndPoint endPoint)
{
this.client = SqlDStart.NewClient().ConnectedTo(endPoint);
}
public void OneTimeSetUp()
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
connection.CreateTable <AnyTableB>();
}
public void OneTimeTearDown()
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
connection.DropTable <AnyTableB>();
}
public void ShouldBeAbleToSustainMultithreadedReadWrites()
{
var numberOfIterations = 10000;
var waitForReads1 = new ManualResetEvent(false);
var waitForReads2 = new ManualResetEvent(false);
var waitForReads3 = new ManualResetEvent(false);
var waitForWrites1 = new ManualResetEvent(false);
var waitForWrites2 = new ManualResetEvent(false);
var waitForWrites3 = new ManualResetEvent(false);
// Writes
var insertInstance = GenFu.GenFu.New <AnyTableB>();
var task1 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
connection.Insert(insertInstance);
Console.Write("+");
}
}
finally
{
waitForWrites1.Set();
}
});
var task2 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
connection.Insert(insertInstance);
Console.Write("+");
}
}
finally
{
waitForWrites2.Set();
}
});
var task3 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
connection.Insert(insertInstance);
Console.Write("+");
}
}
finally
{
waitForWrites3.Set();
}
});
// Reads
var task4 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
var results = connection.Query <AnyTableB>("LIMIT 5");
Console.Write(".");
}
}
finally
{
waitForReads1.Set();
}
});
var task5 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
var results = connection.Query <AnyTableB>("LIMIT 5");
Console.Write(".");
}
}
finally
{
waitForReads2.Set();
}
});
var task6 = Task.Factory.StartNew(() =>
{
try
{
var connection = SqlDStart.NewDb().ConnectedTo("sql-d.db", SqlDPragmaModel.Default);
for (var counter = 0; counter < numberOfIterations; counter++)
{
connection.Query <AnyTableB>("LIMIT 5");
Console.Write(".");
}
}
finally
{
waitForReads3.Set();
}
});
waitForReads1.WaitOne();
waitForReads2.WaitOne();
waitForReads3.WaitOne();
waitForWrites1.WaitOne();
waitForWrites2.WaitOne();
waitForWrites3.WaitOne();
Assert.That(task1.IsFaulted, Is.False, $"{task1.Exception?.Message}");
Assert.That(task2.IsFaulted, Is.False, $"{task2.Exception?.Message}");
Assert.That(task3.IsFaulted, Is.False, $"{task3.Exception?.Message}");
Assert.That(task4.IsFaulted, Is.False, $"{task4.Exception?.Message}");
Assert.That(task5.IsFaulted, Is.False, $"{task5.Exception?.Message}");
Assert.That(task6.IsFaulted, Is.False, $"{task6.Exception?.Message}");
}
private static void Main(string[] args)
{
if (args.Length == 0)
{
CommandParser.Info <Arguments>();
return;
}
var entryAssembly = typeof(Program).Assembly;
var config = SqlDConfig.Get(entryAssembly);
try
{
config.ProcessModel.Distributed = false;
var arguments = ArgumentsParser.Parse <Arguments>(args);
if (arguments.Registries.Any())
{
config.Registries.Clear();
config.Registries.AddRange(
arguments.Registries.Select(x =>
new SqlDRegistryModel()
{
Host = x.Split(':')[0],
Port = int.Parse(x.Split(':')[1])
}));
}
if (!string.IsNullOrEmpty(arguments.Service))
{
if (!arguments.Registries.Any())
{
config.Registries.Add(
new SqlDRegistryModel()
{
Host = arguments.Service.Split(':')[0],
Port = int.Parse(arguments.Service.Split(':')[1])
});
}
config.Services.Clear();
config.Services.Add(
new SqlDServiceModel
{
Name = arguments.Name,
Database = arguments.Database,
Host = arguments.Service.Split(':')[0],
Port = int.Parse(arguments.Service.Split(':')[1]),
Tags = arguments.Tags.ToList(),
Pragma = new SqlDPragmaModel()
{
CountChanges = arguments.PragmaCountChanges,
JournalMode = arguments.PragmaJournalMode,
LockingMode = arguments.PragmaLockingMode,
Synchronous = arguments.PragmaSynchronous,
TempStore = arguments.PragmaTempStore,
PageSize = arguments.PragmaPageSize,
CacheSize = arguments.PragmaCacheSize,
QueryOnly = arguments.PragmaQueryOnly
}
});
}
if (arguments.Forwards.Any())
{
foreach (var forward in arguments.Forwards)
{
config.Services.ForEach(x => x.ForwardingTo.Add(new SqlDForwardingModel()
{
Host = forward.Split(':')[0],
Port = int.Parse(forward.Split(':')[1])
}));
}
}
entryAssembly.SqlDGo(config);
if (arguments.Wait)
{
Console.WriteLine("Press enter to quit...");
Console.ReadLine();
}
}
catch (Exception err)
{
Console.WriteLine(err);
Console.ReadLine();
}
finally
{
SqlDStart.SqlDStop(config);
}
}
