public void Sqlite_JournalSettings_default_should_contain_default_config()
{
var config = SqlitePersistence.Get(Sys).DefaultJournalConfig;
var settings = new JournalSettings(config);
// values should be correct
settings.ConnectionString.Should().Be(string.Empty);
settings.ConnectionStringName.Should().Be(string.Empty);
settings.ConnectionTimeout.Should().Equals(TimeSpan.FromSeconds(30));
settings.JournalTableName.Should().Equals("event_journal");
settings.SchemaName.Should().BeNull();
settings.MetaTableName.Should().Equals("journal_metadata");
settings.TimestampProvider.Should().Be("Akka.Persistence.Sql.Common.Journal.DefaultTimestampProvider, Akka.Persistence.Sql.Common");
settings.AutoInitialize.Should().BeFalse();
// values should reflect configuration
settings.ConnectionString.Should().Equals(config.GetString("connection-string"));
settings.ConnectionStringName.Should().Equals(config.GetString("connection-string-name"));
settings.ConnectionTimeout.Should().Equals(config.GetTimeSpan("connection-timeout"));
settings.JournalTableName.Should().Equals(config.GetString("table-name"));
settings.SchemaName.Should().Equals(config.GetString("schema-name", null));
settings.MetaTableName.Should().Equals(config.GetString("metadata-table-name"));
settings.TimestampProvider.Should().Be(config.GetString("timestamp-provider"));
settings.AutoInitialize.Should().Equals(config.GetBoolean("auto-initialize"));
}
public PersistenceSettings(ActorSystem system, Config config)
: base(system, config)
{
Journal = new JournalSettings(config);
View = new ViewSettings(config);
GuaranteedDelivery = new GuaranteedDeliverySettings(config);
Internal = new InternalSettings(config);
}
public PersistenceSettings(ActorSystem system, Config config)
: base(system, config)
{
Journal = new JournalSettings(config);
View = new ViewSettings(config);
AtLeastOnceDelivery = new AtLeastOnceDeliverySettings(config);
Internal = new InternalSettings(config);
}
protected JournalDbEngine(JournalSettings settings, Akka.Serialization.Serialization serialization)
{
Settings = settings;
_serialization = serialization;
QueryMapper = new DefaultJournalQueryMapper(serialization);
PendingOperations = new LinkedList<CancellationTokenSource>();
}
protected JournalDbEngine(JournalSettings settings, Akka.Serialization.Serialization serialization)
{
Settings = settings;
_serialization = serialization;
QueryMapper = new DefaultJournalQueryMapper(serialization);
PendingOperations = new LinkedList <CancellationTokenSource>();
}
protected JournalDbEngine(ActorSystem system)
{
_system = system;
Settings = new JournalSettings(system.Settings.Config.GetConfig(JournalConfigPath));
QueryMapper = new DefaultJournalQueryMapper(_system.Serialization);
TimestampProvider = CreateTimestampProvider();
_pendingRequestsCancellation = new CancellationTokenSource();
}
protected JournalDbEngine(ActorSystem system)
{
_system = system;
Settings = new JournalSettings(system.Settings.Config.GetConfig(JournalConfigPath));
QueryMapper = new DefaultJournalQueryMapper(_system.Serialization);
TimestampProvider = CreateTimestampProvider();
_pendingRequestsCancellation = new CancellationTokenSource();
}
internal JournalCore(IJournalMetadata metadata, IPartitionManager partitionManager)
{
_settings = metadata.Settings;
_partitionManager = partitionManager;
Metadata = metadata;
var unsafePartitionManager = (IUnsafePartitionManager)partitionManager;
QueryStatistics = new JournalStatistics(Metadata, unsafePartitionManager);
Diagnostics = new JournalDiagnostics(unsafePartitionManager);
Initialize(partitionManager.Access);
}
public PartitionManager(IJournalMetadata metadata, EFileAccess access,
ICompositeFileFactory fileFactory, IJournalServer server, ITxLog txLog = null)
{
Access = access;
_metadata = metadata;
_settings = metadata.Settings;
_fileFactory = fileFactory;
_server = server;
Server = server;
if (txLog == null)
{
var txFileName = Path.Combine(metadata.Settings.DefaultPath, MetadataConstants.TX_FILE_NAME);
_txLogFile = new CompositeRawFile(txFileName,
MetadataConstants.PIPE_BIT_HINT, _fileFactory, access, SYMBOL_PARTITION_ID,
MetadataConstants.TX_LOG_FILE_ID, MetadataConstants.TX_LOG_FILE_ID, EDataType.Data);
txLog = new TxLog(_txLogFile);
}
_txLog = txLog;
}
public PostgreSqlJournalEngine(JournalSettings journalSettings, Akka.Serialization.Serialization serialization)
: base(journalSettings, serialization)
{
QueryBuilder = new PostgreSqlJournalQueryBuilder(journalSettings.TableName, journalSettings.SchemaName);
QueryMapper = new PostgreSqlJournalQueryMapper(serialization);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="journalConfig">TBD</param>
protected SqlJournal(Config journalConfig)
{
_settings = new JournalSettings(journalConfig);
_pendingRequestsCancellation = new CancellationTokenSource();
}
protected SqlJournal(Config journalConfig)
{
_settings = new JournalSettings(journalConfig);
_pendingRequestsCancellation = new CancellationTokenSource();
}
public SqlJournalEngine(JournalSettings journalSettings, Akka.Serialization.Serialization serialization)
: base(journalSettings, serialization)
{
QueryBuilder = new DefaultJournalQueryBuilder(journalSettings.TableName, journalSettings.SchemaName);
}
public JournalMutation(
JournalSettings journalSettings,
OrchestratorSettings orchestratorSettings,
HttpClient httpClient)
{
Field <JournalType>()
.Name("createJournalEC")
.Argument <NonNullGraphType <JournalInputType> >("journal", "Add a journal")
.ResolveAsync(async ctx =>
{
var dto = ctx.GetArgument <JournalDTO>("journal");
var requestUrl = $"{journalSettings.BaseUrl}/{journalSettings.Endpoints.AddJournal}";
var content = new StringContent(JsonConvert.SerializeObject(dto), Encoding.Default, "application/json");
using (var responseMessage = await httpClient.PostAsync(requestUrl, content))
{
if (!responseMessage.IsSuccessStatusCode)
{
var errorContent = await responseMessage.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(errorContent))
{
ctx.Errors.Add(new GraphQL.ExecutionError(errorContent));
}
else
{
responseMessage.EnsureSuccessStatusCode();
}
return(null);
}
var serializedResponse = await responseMessage.Content.ReadAsStringAsync();
var response = JsonConvert.DeserializeObject <JournalDTO>(serializedResponse);
return(response);
}
});
Field <JournalType>()
.Name("createJournalSaga")
.Argument <NonNullGraphType <JournalInputType> >("journal", "Add a journal")
.ResolveAsync(async ctx =>
{
var dto = ctx.GetArgument <JournalDTO>("journal");
var requestUrl = $"{orchestratorSettings.BaseUrl}/{orchestratorSettings.FunctionName}";
var content = new StringContent(JsonConvert.SerializeObject(dto), Encoding.Default, "application/json");
HttpManagementPayload httpManagementPayload;
using (var responseMessage = await httpClient.PostAsync(requestUrl, content))
{
if (!responseMessage.IsSuccessStatusCode)
{
var errorContent = await responseMessage.Content.ReadAsStringAsync();
if (!string.IsNullOrEmpty(errorContent))
{
ctx.Errors.Add(new GraphQL.ExecutionError(errorContent));
}
else
{
responseMessage.EnsureSuccessStatusCode();
}
return(null);
}
var serializedResponse = await responseMessage.Content.ReadAsStringAsync();
httpManagementPayload = JsonConvert.DeserializeObject <HttpManagementPayload>(serializedResponse);
}
JToken status = null;
do
{
await Task.Delay(2000);
status = await GetStatus(httpManagementPayload.StatusQueryGetUri, ctx);
if (status == null)
{
return(status);
}
} while(status.Value <string>("runtimeStatus") == "Pending" ||
status.Value <string>("runtimeStatus") == "Running");
if (status.Value <string>("runtimeStatus") != "Completed")
{
ctx.Errors.Add(new GraphQL.ExecutionError("Saga failed"));
return(null);
}
var journalResult = status["output"].ToObject <Result <JournalDTO> >();
if (journalResult.IsFailure)
{
ctx.Errors.Add(new GraphQL.ExecutionError(journalResult.ErrorMessage));
return(null);
}
return(journalResult.Value);
});
this.httpClient = httpClient;
}
