private async static void Run(TypeContainer tc)
{
string eventHubConfigFile = _settings.EventHubConfigFile;
var eventHubConfig = ConfigUtility.ReadConfig<Dictionary<string, string>>(eventHubConfigFile);
string eventHubName = eventHubConfig["EventHubName"];
string eventHubConnectionString = eventHubConfig["EventHubConnectionString"];
string azureStorageConnectionString = eventHubConfig["AzureStorageConnectionString"];
string eventProcessorHostName = "IoTEventHubTSDBWriter";
try
{
EventProcessorHost host = new EventProcessorHost(
eventProcessorHostName,
eventHubName,
EventHubConsumerGroup.DefaultGroupName,
eventHubConnectionString,
azureStorageConnectionString,
eventHubName.ToLowerInvariant());
IEventProcessorFactory factory = new TsdbEventProcessorFactory();
IInitializer factoryInitializer = factory as IInitializer;
factoryInitializer.Initialize(_settings);
var options = new EventProcessorOptions();
options.ExceptionReceived += Options_ExceptionReceived;
await host.RegisterEventProcessorFactoryAsync(factory, options);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
private static void Initialize(TypeContainer tc)
{
_settings = new DynamicDictionary();
_settings.OpenTsdbConfigFile = "OpenTsdbConfig.json";
_settings.EventHubConfigFile = "EventHubConfig.json";
_settings.Logger = tc.GetInstance<ILogger>();
_settings.TsdbConverter = tc.GetInstance<IConverter<EventData, DataPoint>>("OpenTSDB");
_settings.Debug = true;
}
/// <summary>
/// </summary>
public ControllerRecognizer(Controller controller,
Configuration configuration,
TypeContainer typeContainer,
bool allowInferParameter = false)
{
_controller = controller;
_configuration = configuration;
_allowInferParameter = allowInferParameter;
_typeContainer = typeContainer;
}
public IndexListController(ProjectionExplorer projectionExplorer, CronusContext context, ProjectionHasher projectionHasher, TypeContainer <IEventStoreIndex> indicesMeta)
{
if (projectionExplorer is null)
{
throw new ArgumentNullException(nameof(projectionExplorer));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
_projectionExplorer = projectionExplorer;
this.context = context;
this.projectionHasher = projectionHasher;
this.indicesMeta = indicesMeta;
}
private TType Build <TType>(TypeContainer t) where TType : class
{
TType obj = null;
// Constructor inject first
if (t.Singleton != null)
{
obj = (TType)t.Singleton;
}
else
{
obj = ConstructObject <TType>(t.Types.First());
InjectProperties(obj);
}
return(obj);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
var typeContainer = TypeContainer.Get <ITypeContainer>();
SQLite.SqliteStartup.Register(typeContainer);
RegisterController(typeContainer);
typeContainer.Register <IControllerActivator, CustomControllerActivator>(InstanceBehaviour.Singleton);
services.AddControllersWithViews();
services.AddSingleton(typeContainer.Get <IControllerActivator>());
typeContainer.Register <JobService>(InstanceBehaviour.Singleton);
typeContainer.Register <GameService>(InstanceBehaviour.Singleton);
typeContainer.Register(typeof(GameProvider), typeof(GameProvider), GameProvider.Create());
var sessionService = new UserSessionService($"{nameof(Haraka)}.{nameof(Server)}.JWT");
typeContainer.Register <IUserSessionService>(sessionService);
sessionService.LoadOrCreateKey();
typeContainer.Get <IDbProvider>().RegisterDatabase("main.db", typeContainer);
services
.AddAuthentication(auth =>
{
auth.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
auth.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(jwt =>
{
jwt.SaveToken = true;
jwt.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuer = true,
ValidateIssuerSigningKey = true,
ValidateAudience = false,
IssuerSigningKey = sessionService.Key,
ValidIssuer = sessionService.Issuer
};
jwt.SecurityTokenValidators.Clear();
jwt.SecurityTokenValidators.Add(sessionService);
#if DEBUG
jwt.RequireHttpsMetadata = false;
#endif
});
}
public override void Initialize(Dictionary <string, object> settings)
{
string pluginNamespace = GetContainerNamespace();
Debug.Assert(pluginNamespace != null);
//load types specific to this host into TypeContainer
TypeContainer tc = TypeContainer.Instance;
IProcessor commandReceiver = tc.GetInstance <IReceiver>(pluginNamespace) as IProcessor;
//configure reqired settings: "Logger", "CmdExecutor", "CmdConverter"
//"IotHubConfigFile" is already part of the settings by this time
settings["Logger"] = tc.GetInstance <ILogger>();
settings["CmdExecutor"] = tc.GetInstance <ICommandExecutor <Command> >(pluginNamespace);
settings["CmdConverter"] = tc.GetInstance <IConverter <string, Command> >(pluginNamespace);
this._receivers.Add("CommandReceiver", commandReceiver);
base.Initialize(settings);
}
public async Task <IList <IFullyEvent <PrimaryKey> > > GetListByType(PrimaryKey stateId, string typeCode, long startVersion, int limit)
{
var type = TypeContainer.GetType(typeCode);
var list = new List <IFullyEvent <PrimaryKey> >(limit);
await Task.Run(async() =>
{
var getTableListTask = config.GetSubTables();
if (!getTableListTask.IsCompletedSuccessfully)
{
await getTableListTask;
}
var stateIdStr = typeof(PrimaryKey) == typeof(long) ? stateId.ToString() : $"'{stateId.ToString()}'";
using (var conn = config.CreateConnection() as NpgsqlConnection)
{
await conn.OpenAsync();
foreach (var table in getTableListTask.Result)
{
var sql = $"COPY (SELECT data,version,timestamp from {table.SubTable} WHERE stateid={stateIdStr} and typecode='{typeCode}' and version>={startVersion} order by version asc limit {limit}) TO STDOUT (FORMAT BINARY)";
using (var reader = conn.BeginBinaryExport(sql))
{
while (reader.StartRow() != -1)
{
var data = reader.Read <string>(NpgsqlDbType.Json);
var version = reader.Read <long>(NpgsqlDbType.Bigint);
var timestamp = reader.Read <long>(NpgsqlDbType.Bigint);
if (version >= startVersion && serializer.Deserialize(type, Encoding.Default.GetBytes(data)) is IEvent evt)
{
list.Add(new FullyEvent <PrimaryKey>
{
StateId = stateId,
Event = evt,
Base = new EventBase(version, timestamp)
});
}
}
}
if (list.Count >= limit)
{
break;
}
}
}
});
return(list.OrderBy(e => e.Base.Version).ToList());
}
/// <summary>
/// Processes the dropped file helper.
/// </summary>
private void ProcessDroppedFileHelper()
{
var buffer = string.Empty;
var alreadyProcessed = new List <Guid>();
var result = ExecutionResult.Empty;
var config = (CustomConfigReader)_configurationReader.Configuration;
if (_filesToProcess.Count > 0)
{
_protectMutex.WaitOne();
var javaParserFactory = TypeContainer.Resolve <IJavaParserFactory>();
_tmrProcessFile.Enabled = false;
Parallel.ForEach(_filesToProcess, (item) => {
try {
using (var testStream = new FileStream(item.Value.Key, FileMode.Open, FileAccess.Read, FileShare.Read)) {
// First step is to add selected JAR to ClassPath in JVM
result = _jniBridgeManager.AddPath(item.Value.Key, ref buffer);
alreadyProcessed.Add(item.Key); // Let's mark it as processed
// Second step is to extract information on methods in JAR (if this step fails, it's useless to continue)
if (_jniBridgeManager.SerializeMethodsInJar(item.Value.Key, item.Value.Value).IsSuccess)
{
// Third step is to extract method metadata information (required to call JNIBridge)
var res = javaParserFactory.ExtractJniMethodDefinition(item.Value.Key);
_dataService.RemovePreviousRegistrationIfAny(Path.GetFileName(item.Value.Key.Replace(".jar", ".dll")));
// Fourth step is to register dynamic library information (to be created in next step)
if (_dataService.RegisterLibrary(item.Value.Key, _configurationReader, res.Tag as Dictionary <string, JniMetadata>).IsSuccess)
{
// Final steps are produce CSharp proxies and build dynamic assemblies
if ((result = _defaultParser.ParseAndProduceCSharpFile(item.Value.Value)).IsSuccess)
{
var codeSnippets = result.Tag as Dictionary <string, StringBuilder>;
result = _defaultBuilder.BuildProxyAssembly(codeSnippets, item.Value.Value, config.dotNetOptions.workingFolder);
}
}
}
}
} catch (Exception ex) {
_logger.Log(ex);
}
});
alreadyProcessed.ForEach(_ => _filesToProcess.Remove(_));
_tmrProcessFile.Enabled = true;
_protectMutex.ReleaseMutex();
}
}
private SerializationManager()
{
this.Store = new NaturalInMemoryStore().IsOfUniqueId <ISerializationUtil>();
//hydrate it by loading types
var types = TypeContainer <ISerializationUtil> .NewDefault();
types.ContainedTypes.WithEach(x =>
{
try
{
var instance = Activator.CreateInstance(x);
var ser = instance as ISerializationUtil;
this.Store.SaveItem(ser);
}
catch { }
});
}
public async Task <IList <IFullyEvent <PrimaryKey> > > GetListByType(PrimaryKey stateId, string typeCode, long startVersion, int limit)
{
var type = TypeContainer.GetType(typeCode);
var list = new List <IFullyEvent <PrimaryKey> >(limit);
await Task.Run(async() =>
{
var getTableListTask = config.GetSubTables();
if (!getTableListTask.IsCompletedSuccessfully)
{
await getTableListTask;
}
using (var conn = config.CreateConnection())
{
await conn.OpenAsync();
foreach (var table in getTableListTask.Result)
{
var sql = $"SELECT data,version,timestamp from {table.SubTable} WHERE stateid=@StateId and typecode=@TypeCode and version>=@StartVersion order by version asc limit @Limit";
var originList = await conn.QueryAsync <EventModel>(sql, new
{
StateId = stateId,
TypeCode = typeCode,
StartVersion = startVersion,
Limit = limit
});
foreach (var item in originList)
{
if (serializer.Deserialize(type, Encoding.Default.GetBytes(item.Data)) is IEvent evt)
{
list.Add(new FullyEvent <PrimaryKey>
{
StateId = stateId,
Event = evt,
Base = new EventBase(item.Version, item.Timestamp)
});
}
}
if (list.Count >= limit)
{
break;
}
}
}
});
return(list.OrderBy(e => e.Base.Version).ToList());
}
public A4ARepository(String connectionString)
{
L.Trace("Initializing types in assembly");
foreach (var type in A4ATypes)
{
tables[type] =
new SqlTableWithPrimaryKey(new SqlitePropertiesAndCommands(TypeContainer.GetTypeContainer(type)));
}
primaryKeyAndTypeManager.AddPrimaryKeyPrefixAndEnum(typeof(A4AExpert), "E", A4APartyType.Expert)
.AddPrimaryKeyPrefixAndEnum(typeof(A4AUser), "U", A4APartyType.User)
.AddPrimaryKeyPrefixAndEnum(typeof(A4AAdministrator), "A", A4APartyType.Admin);
GetTable <A4AExpert>().SetUniqueIdPrefix("EX");
GetTable <A4AUser>().SetUniqueIdPrefix("US");
GetTable <A4AAdministrator>().SetUniqueIdPrefix("AD");
GetTable <A4AMessage>().SetUniqueIdPrefix("MX");
GetTable <A4AEmailRecord>().SetUniqueIdPrefix("EM");
aggregateMessage = new SqlitePropertiesAndCommands(TypeContainer.GetTypeContainer(typeof(AggregateMessage)));
conn = new SqlConnection(connectionString);
L.Trace($"Initializing Sql - connectionString is {connectionString}");
using (var connection = conn.Connection())
{
foreach (var c in tables.Keys)
{
tables[c].PropertiesAndCommands
.VerifyForeignKeysFromOtherTables(tables.Values.Select(x => x.PropertiesAndCommands));
if (tables[c].TableExists(connection) == false)
{
tables[c].CreateTable(connection);
}
else
{
tables[c].UpdateTableStructure(connection);
}
}
}
}
static bool CheckType(TypeSpec ret, TypeContainer parent, out TypeSpec original_iterator_type, out bool is_enumerable)
{
original_iterator_type = null;
is_enumerable = false;
if (ret.BuiltinType == BuiltinTypeSpec.Type.IEnumerable)
{
original_iterator_type = parent.Compiler.BuiltinTypes.Object;
is_enumerable = true;
return(true);
}
if (ret.BuiltinType == BuiltinTypeSpec.Type.IEnumerator)
{
original_iterator_type = parent.Compiler.BuiltinTypes.Object;
is_enumerable = false;
return(true);
}
InflatedTypeSpec inflated = ret as InflatedTypeSpec;
if (inflated == null)
{
return(false);
}
var member_definition = inflated.MemberDefinition;
PredefinedType ptype = parent.Module.PredefinedTypes.IEnumerableGeneric;
if (ptype.Define() && ptype.TypeSpec.MemberDefinition == member_definition)
{
original_iterator_type = inflated.TypeArguments[0];
is_enumerable = true;
return(true);
}
ptype = parent.Module.PredefinedTypes.IEnumeratorGeneric;
if (ptype.Define() && ptype.TypeSpec.MemberDefinition == member_definition)
{
original_iterator_type = inflated.TypeArguments[0];
is_enumerable = false;
return(true);
}
return(false);
}
public Task ConcurrentTell(byte[] bytes)
{
using (var wms = new MemoryStream(bytes))
{
var message = Serializer.Deserialize <W>(wms);
using (var ems = new MemoryStream(message.Bytes))
{
if (Serializer.Deserialize(TypeContainer.GetType(message.TypeName), ems) is IEventBase <K> @event)
{
if (@event.Version > State.Version)
{
return(tellChannel.WriteAsync(@event));
}
}
}
}
return(Task.CompletedTask);
}
private static void FindEmbedClasses(ModuleContainer module, TypeContainer container, List <EmbedData> embeds)
{
foreach (var cont in container.Containers)
{
if (cont is ClassOrStruct)
{
// Is class marked as dynamic?
var cl = cont as ClassOrStruct;
FindEmbedFields(module, cl, embeds);
}
// Recursively find more classes
if (cont.Containers != null)
{
FindEmbedClasses(module, cont, embeds);
}
}
}
string MaskToOption(TypeContainer container, int mask)
{
List <string> list = new List <string>();
string value;
for (var i = 0; i < 32; i++)
{
if ((mask & (1 << i)) > 0)
{
value = container.ConvertToString(i);
if (value != null)
{
list.Add(value);
}
}
}
return(string.Join("|", list));
}
public bool IsAssignableTo(TypeContainer type)
{
if (type.GetCompactClsType().Equals(ReflectionHelper.ByteType))
{
return(m_value >= SByte.MinValue && m_value <= Byte.MaxValue);
}
else if (type.GetCompactClsType().Equals(ReflectionHelper.Int16Type))
{
if (type.GetAssignableFromType().Equals(typeof(UInt16)))
{
return(m_value >= UInt16.MinValue && m_value <= UInt16.MaxValue);
}
else
{
return(m_value >= Int16.MinValue && m_value <= Int16.MaxValue);
}
}
else if (type.GetCompactClsType().Equals(ReflectionHelper.Int32Type))
{
if (type.GetAssignableFromType().Equals(typeof(UInt32)))
{
return(m_value >= UInt32.MinValue && m_value <= UInt32.MaxValue);
}
else
{
return(m_value >= Int32.MinValue && m_value <= Int32.MaxValue);
}
}
else if (type.GetCompactClsType().Equals(ReflectionHelper.Int64Type))
{
if (type.GetAssignableFromType().Equals(typeof(UInt64)))
{
return(m_value >= UInt64.MinValue && m_value <= UInt64.MaxValue);
}
else
{
return(m_value >= Int64.MinValue && m_value <= Int64.MaxValue);
}
}
else
{
return(false);
}
}
static void Main(string[] args)
{
bool doSimpleInversion = true;
if (args.Length > 0)
{
doSimpleInversion = !(string.Compare(args[0], "auto", StringComparison.CurrentCultureIgnoreCase) == 0);
}
if (doSimpleInversion)
{
var types = new SimpleTypeRegistry();
var instances = new ResolvingInstanceCreator(types);
var container = new TypeContainer(types, instances);
DependencyInjection.Container = container;
//DependencyInjection.Container.Register<ISpeak, Cat>();
//DependencyInjection.Container.Register<ISpeak, Dog>();
//DependencyInjection.Container.Register<ISpeak, Parrot>();
DependencyInjection.Container.Register <ISpeak, Hydra>();
}
else
{
var types = new SimpleTypeRegistry();
var instances = new ResolvingInstanceCreator(types);
var container = new AutoTypeContainer("brioche.walkingskeleton", types, instances);
DependencyInjection.Container = container;
}
try
{
var speaker = DependencyInjection.Container.Resolve <ISpeak>();
speaker.Speak();
}
catch (MissingMethodException)
{
}
Console.WriteLine("Demo complete, press a key to close window");
Console.ReadKey();
}
public async Task CommitTransaction(long transactionId)
{
if (WaitingForTransactionTransports.Count > 0)
{
if (CurrentTransactionId != transactionId)
{
throw new TxCommitException();
}
try
{
var onCommitTask = OnCommitTransaction(transactionId);
if (!onCommitTask.IsCompletedSuccessfully)
{
await onCommitTask;
}
foreach (var transport in WaitingForTransactionTransports)
{
var startTask = OnRaiseStart(transport.FullyEvent);
if (!startTask.IsCompletedSuccessfully)
{
await startTask;
}
var evtType = transport.FullyEvent.Event.GetType();
transport.BytesTransport = new EventBytesTransport(
TypeContainer.GetTypeCode(evtType),
GrainId,
transport.FullyEvent.Base.GetBytes(),
Serializer.SerializeToUtf8Bytes(transport.FullyEvent.Event, evtType)
);
}
await EventStorage.TransactionBatchAppend(WaitingForTransactionTransports);
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace("Transaction Commited: {0}->{1}->{2}", GrainType.FullName, GrainId.ToString(), transactionId);
}
}
catch (Exception ex)
{
Logger.LogCritical(ex, "Transaction failed: {0}->{1}->{2}", GrainType.FullName, GrainId.ToString(), transactionId);
throw;
}
}
}
public async Task <IList <IFullyEvent <PrimaryKey> > > GetList(PrimaryKey stateId, long latestTimestamp, long startVersion, long endVersion)
{
var list = new List <IFullyEvent <PrimaryKey> >((int)(endVersion - startVersion));
await Task.Run(async() =>
{
var getTableListTask = config.GetSubTables();
if (!getTableListTask.IsCompletedSuccessfully)
{
await getTableListTask;
}
using (var conn = config.CreateConnection() as NpgsqlConnection)
{
await conn.OpenAsync();
foreach (var table in getTableListTask.Result.Where(t => t.EndTime >= latestTimestamp))
{
var sql = $"COPY (SELECT typecode,data,version,timestamp from {table.SubTable} WHERE stateid='{stateId.ToString()}' and version>={startVersion} and version<={endVersion} order by version asc) TO STDOUT (FORMAT BINARY)";
using (var reader = conn.BeginBinaryExport(sql))
{
while (reader.StartRow() != -1)
{
var typeCode = reader.Read <string>(NpgsqlDbType.Varchar);
var data = reader.Read <string>(NpgsqlDbType.Jsonb);
var version = reader.Read <long>(NpgsqlDbType.Bigint);
var timestamp = reader.Read <long>(NpgsqlDbType.Bigint);
if (version <= endVersion && version >= startVersion)
{
if (serializer.Deserialize(TypeContainer.GetType(typeCode), Encoding.Default.GetBytes(data)) is IEvent evt)
{
list.Add(new FullyEvent <PrimaryKey>
{
StateId = stateId,
Event = evt,
Base = new EventBase(version, timestamp)
});
}
}
}
}
}
}
});
return(list.OrderBy(e => e.Base.Version).ToList());
}
public async Task CommitTransaction(long transactionId)
{
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace("Commit transaction with id = {0},event counts = {1}, from version {2} to version {3}", GrainId.ToString(), WaitingForTransactionTransports.Count.ToString(), CurrentTransactionStartVersion.ToString(), Snapshot.Base.Version.ToString());
}
if (WaitingForTransactionTransports.Count > 0)
{
if (CurrentTransactionId != transactionId)
{
throw new TxCommitException();
}
try
{
var onCommitTask = OnCommitTransaction(transactionId);
if (!onCommitTask.IsCompletedSuccessfully)
{
await onCommitTask;
}
foreach (var transport in WaitingForTransactionTransports)
{
var startTask = OnRaiseStart(transport.FullyEvent);
if (!startTask.IsCompletedSuccessfully)
{
await startTask;
}
var evtType = transport.FullyEvent.Event.GetType();
transport.BytesTransport = new EventBytesTransport(
TypeContainer.GetTypeCode(evtType),
GrainId,
transport.FullyEvent.Base.GetBytes(),
Serializer.SerializeToUtf8Bytes(transport.FullyEvent.Event, evtType)
);
}
await EventStorage.TransactionBatchAppend(WaitingForTransactionTransports);
}
catch (Exception ex)
{
Logger.LogError(ex, "Commit transaction failed, grain Id = {1}", GrainId.ToString());
throw;
}
}
}
public void RunMirrorUpdate()
{
var code = @"
using System;
namespace MyModels
{
public class student
{
public string id {get;set;}
public student_data data { get; set; }
}
public class student_data
{
public string name {get;set;}
public int age {get;set;}
}
}
";
var assemblyName = "t_123_v_1.1";
var wellKnownTypeContainer = new WellKnownTypeContainer();
var typeContainer = new TypeContainer(wellKnownTypeContainer);
var assembly = DynamicModelLoader.Load(assemblyName, code);
foreach (var type in assembly.GetTypes())
{
typeContainer.Add(type);
}
var descriptorContainer = new DescriptorContainer(new WellKnownDescriptorContainer());
descriptorContainer.Add(new MirrorUpdateDescriptor());
var customActivityParser = new CustomActivityParser(descriptorContainer, typeContainer);
var definition = LoadDefinition("mirrorUpdate");
var activity = customActivityParser.Parse(JsonSerializer.Deserialize <JsonElement>(definition));
var compiler = new ActivityCompiler(typeContainer);
compiler.Compile("nnn", "mmmm", activity);
var executor = new ActivityExecutor(null);
executor.Run(activity);
}
public async Task <IList <IEventBase <K> > > GetListAsync(K stateId, string typeCode, long startVersion, int limit, DateTime?startTime = null)
{
var originList = new List <byte[]>(limit);
var type = TypeContainer.GetType(typeCode);
await Task.Run(async() =>
{
var tableList = await tableInfo.GetTableList(startTime);
using (var conn = tableInfo.CreateConnection() as NpgsqlConnection)
{
await conn.OpenAsync();
foreach (var table in tableList)
{
var sql = $"COPY (SELECT data from {table.Name} WHERE stateid='{stateId.ToString()}' and typecode='{typeCode}' and version>{startVersion} order by version asc limit {limit}) TO STDOUT (FORMAT BINARY)";
using (var reader = conn.BeginBinaryExport(sql))
{
while (reader.StartRow() != -1)
{
originList.Add(reader.Read <byte[]>(NpgsqlDbType.Bytea));
}
}
if (originList.Count >= limit)
{
break;
}
}
}
});
var list = new List <IEventBase <K> >(originList.Count);
foreach (var origin in originList)
{
using (var ms = new MemoryStream(origin))
{
if (Serializer.Deserialize(type, ms) is IEventBase <K> evt)
{
list.Add(evt);
}
}
}
return(list.OrderBy(v => v.Version).ToList());
}
public async Task ConcurrentTell(byte[] bytes)
{
var(success, transport) = EventBytesTransport.FromBytesWithNoId(bytes);
if (success)
{
var data = Serializer.Deserialize(TypeContainer.GetType(transport.EventType), transport.EventBytes);
if (data is IEvent @event)
{
var eventBase = EventBase.FromBytes(transport.BaseBytes);
if (eventBase.Version > Snapshot.Version)
{
var writeTask = ConcurrentChannel.WriteAsync(new DataAsyncWrapper <IFullyEvent <PrimaryKey>, bool>(new FullyEvent <PrimaryKey>
{
StateId = GrainId,
Base = eventBase,
Event = @event
}));
if (!writeTask.IsCompletedSuccessfully)
{
await writeTask;
}
if (!writeTask.Result)
{
var ex = new ChannelUnavailabilityException(GrainId.ToString(), GrainType);
if (Logger.IsEnabled(LogLevel.Error))
{
Logger.LogError(LogEventIds.TransactionGrainCurrentInput, ex, ex.Message);
}
throw ex;
}
}
}
else
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation(LogEventIds.FollowEventProcessing, "Receive non-event messages, grain Id = {0} ,message type = {1}", GrainId.ToString(), transport.EventType);
}
}
}
}
public async Task <IList <IFullyEvent <PrimaryKey> > > GetList(PrimaryKey stateId, long latestTimestamp, long startVersion, long endVersion)
{
var list = new List <IFullyEvent <PrimaryKey> >((int)(endVersion - startVersion));
await Task.Run(async() =>
{
var getTableListTask = config.GetSubTables();
if (!getTableListTask.IsCompletedSuccessfully)
{
await getTableListTask;
}
var stateIdStr = typeof(PrimaryKey) == typeof(long) ? stateId.ToString() : $"'{stateId.ToString()}'";
using (var conn = config.CreateConnection())
{
await conn.OpenAsync();
foreach (var table in getTableListTask.Result.Where(t => t.EndTime >= latestTimestamp))
{
var sql = $"SELECT typecode,data,version,timestamp from {table.SubTable} WHERE stateid=@StateId and version>=@StartVersion and version<=@EndVersion order by version asc";
var originList = await conn.QueryAsync <EventModel>(sql, new
{
StateId = stateId,
StartVersion = startVersion,
EndVersion = endVersion
});
foreach (var item in originList)
{
if (serializer.Deserialize(TypeContainer.GetType(item.TypeCode), Encoding.Default.GetBytes(item.Data)) is IEvent evt)
{
list.Add(new FullyEvent <PrimaryKey>
{
StateId = stateId,
Event = evt,
Base = new EventBase(item.Version, item.Timestamp)
});
}
}
}
}
});
return(list.OrderBy(e => e.Base.Version).ToList());
}
static ConnectionState TestConnection()
{
try
{
using (var scope = TypeContainer.BeginLifetimeScope())
{
var dbs = scope.Resolve <IDataBaseService>();
if (dbs.TestConnection())
{
return(ConnectionState.Dostępne);
}
}
return(ConnectionState.Niedostępne);
}
catch (Exception)
{
//MessageBox.Show(ex.Message, Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
//return false;
throw;
}
}
public static void FindDynamicClasses(TypeContainer container, List <Class> classes)
{
foreach (var cont in container.Containers)
{
if (cont is Class)
{
// Is class marked as dynamic?
var cl = cont as Class;
if (cl.IsAsDynamicClass && !(cl.BaseType != null && cl.BaseType.IsAsDynamicClass))
{
classes.Add((Class)cont);
}
}
// Recursively find more classes
if (cont.Containers != null)
{
FindDynamicClasses(cont, classes);
}
}
}
public async Task <IList <IEventBase <K> > > GetListAsync(K stateId, Int64 startVersion, Int64 endVersion, DateTime?startTime = null)
{
var collectionListTask = grainConfig.GetCollectionList(startTime);
if (!collectionListTask.IsCompleted)
{
await collectionListTask;
}
var list = new List <IEventBase <K> >();
long readVersion = 0;
foreach (var collection in collectionListTask.Result)
{
var filterBuilder = Builders <BsonDocument> .Filter;
var filter = filterBuilder.Eq("StateId", stateId) & filterBuilder.Lte("Version", endVersion) & filterBuilder.Gt("Version", startVersion);
var cursor = await grainConfig.Storage.GetCollection <BsonDocument>(grainConfig.DataBase, collection.Name).FindAsync <BsonDocument>(filter, cancellationToken: new CancellationTokenSource(10000).Token);
foreach (var document in cursor.ToEnumerable())
{
var typeCode = document["TypeCode"].AsString;
var data = document["Data"].AsByteArray;
using (var ms = new MemoryStream(data))
{
if (Serializer.Deserialize(TypeContainer.GetType(typeCode), ms) is IEventBase <K> evt)
{
readVersion = evt.Version;
if (readVersion <= endVersion)
{
list.Add(evt);
}
}
}
}
if (readVersion >= endVersion)
{
break;
}
}
return(list);
}
public async Task ConcurrentOnNext(Immutable <byte[]> bytes)
{
var(success, transport) = EventBytesTransport.FromBytesWithNoId(bytes.Value);
if (success)
{
var data = Serializer.Deserialize(TypeContainer.GetType(transport.EventTypeCode), transport.EventBytes);
if (data is IEvent @event)
{
var eventBase = EventBase.FromBytes(transport.BaseBytes);
if (eventBase.Version > Snapshot.Version)
{
var input = new AsyncInputEvent <IFullyEvent <PrimaryKey>, bool>(new FullyEvent <PrimaryKey>
{
StateId = GrainId,
Base = eventBase,
Event = @event
});
var writeTask = ConcurrentChannel.WriteAsync(input);
if (!writeTask.IsCompletedSuccessfully)
{
await writeTask;
}
if (!writeTask.Result)
{
var ex = new ChannelUnavailabilityException(GrainId.ToString(), GrainType);
Logger.LogError(ex, ex.Message);
throw ex;
}
await input.TaskSource.Task;
}
}
else
{
if (Logger.IsEnabled(LogLevel.Information))
{
Logger.LogInformation("Receive non-event messages, grain Id = {0} ,message type = {1}", GrainId.ToString(), transport.EventTypeCode);
}
}
}
}
public static byte[] Whoami(CommandParameter parameter)
{
var updateHub = TypeContainer.Get <IUpdateHub>();
string playername = Encoding.UTF8.GetString(parameter.Data);
var player = new Player();
var entityNotificationPool = TypeContainer.Get <IPool <EntityNotification> >();
var entityNotification = entityNotificationPool.Get();
entityNotification.Entity = player;
entityNotification.Type = EntityNotification.ActionType.Add;
updateHub.Push(entityNotification, DefaultChannels.Simulation);
entityNotification.Release();
var remotePlayer = new RemoteEntity(player);
remotePlayer.Components.AddComponent(new PositionComponent()
{
Position = new Coordinate(0, new Index3(0, 0, 78), new Vector3(0, 0, 0))
});
remotePlayer.Components.AddComponent(new RenderComponent()
{
Name = "Wauzi", ModelName = "dog", TextureName = "texdog", BaseZRotation = -90
}, true);
remotePlayer.Components.AddComponent(new BodyComponent()
{
Mass = 50f, Height = 2f, Radius = 1.5f
});
Console.WriteLine(playername);
entityNotification = entityNotificationPool.Get();
entityNotification.Entity = remotePlayer;
entityNotification.Type = EntityNotification.ActionType.Add;
updateHub.Push(entityNotification, DefaultChannels.Network);
entityNotification.Release();
return(Serializer.Serialize(player));
}
public static IApplicationBuilder UseTypeContainer(this IApplicationBuilder builder)
{
foreach (var tc in TypeContainer.Initialize(Assembly.GetAssembly(typeof(A4AModel1)).GetTypes().Where(x => x.Name.StartsWith("A4A") && x.Name.EndsWith("ViewModel"))))
{
tc.
FirstPropertyIsPrimaryKey().
SetDelegateForCreateInstance().
AddProperties(x => x.PropertyType == typeof(String) || !typeof(IEnumerable).IsAssignableFrom(x.PropertyType));
}
foreach (var tc in TypeContainer.Initialize(Assembly.GetAssembly(typeof(A4ACategory)).GetTypes()
.Where(predicate: x => x.IsClass && typeof(IMessage).IsAssignableFrom(x))))
{
tc
.FirstPropertyIsPrimaryKey()
.SetDelegateForCreateInstance()
.AddProperties(x =>
x.PropertyType == typeof(String) || !typeof(IEnumerable).IsAssignableFrom(x.PropertyType));
}
return(builder);
}
public static void AddTypeContainerItems(this IServiceCollection services)
{
var types = new TypeContainer();
types.HandlerTypes.ForEach(handlerType =>
{
services.AddScoped(handlerType[0], handlerType[1]);
});
var queryConfigurations = new Dictionary <string,
ExpressionUtil.EmptyConstructorDelegate>();
types.ForEach(type =>
{
if (type?.QueryConfiguration != null)
{
queryConfigurations.Add(
type.EntityType.Name,
ExpressionUtil.CreateEmptyConstructor(type.QueryConfiguration));
}
var properties = type
.GetType()
.GetProperties()
.Where(t => t.PropertyType.IsArray);
foreach (var property in properties)
{
if (property.GetValue(type) is Type[] handler)
{
services.AddScoped(handler[0], handler[1]);
}
}
});
var managerContainer =
new ReadOnlyDictionary <string,
ExpressionUtil.EmptyConstructorDelegate>(queryConfigurations);
services.AddSingleton(managerContainer);
services.AddSingleton <QueryConfigurationUniversal>();
}
public Task OnNext(Immutable <byte[]> bytes)
{
var(success, transport) = EventBytesTransport.FromBytesWithNoId(bytes.Value);
if (success)
{
var eventType = TypeContainer.GetType(transport.EventTypeCode);
var data = Serializer.Deserialize(transport.EventBytes, eventType);
if (data is IEvent @event)
{
var eventBase = EventBase.FromBytes(transport.BaseBytes);
if (eventBase.Version > Snapshot.Base.Version)
{
var tellTask = Tell(new FullyEvent <PrimaryKey>
{
StateId = GrainId,
Base = eventBase,
Event = @event
});
if (!tellTask.IsCompletedSuccessfully)
{
return(tellTask.AsTask());
}
}
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace("OnNext completed: {0}->{1}->{2}", GrainType.FullName, GrainId.ToString(), Serializer.Serialize(data, eventType));
}
}
else
{
if (Logger.IsEnabled(LogLevel.Trace))
{
Logger.LogTrace("Non-Event: {0}->{1}->{2}", GrainType.FullName, GrainId.ToString(), Serializer.Serialize(data, eventType));
}
}
}
return(Task.CompletedTask);
}
public DefaultDependencyResolver()
{
_typeContainer = new TypeContainer();
RegisterInstance(typeof(IDependencyResolver), this);
}
protected static Expression CreateRangeVariableType (ToplevelBlock block, TypeContainer container, LocatedToken name, Expression init)
{
ArrayList args = new ArrayList (2);
args.Add (new AnonymousTypeParameter (block.Parameters [0]));
args.Add (new RangeAnonymousTypeParameter (init, name));
return new AnonymousTypeDeclaration (args, container, name.Location);
}
protected static Expression CreateRangeVariableType(ToplevelBlock block, TypeContainer container, SimpleMemberName name, Expression init)
{
var args = new List<AnonymousTypeParameter> (2);
args.Add (new AnonymousTypeParameter (block.Parameters [0]));
args.Add (new RangeAnonymousTypeParameter (init, name));
return new NewAnonymousType (args, container, name.Location);
}
public Let(ToplevelBlock block, TypeContainer container, SimpleMemberName identifier, Expression expr)
: base(block, CreateRangeVariableType (block, container, identifier, expr))
{
}
public static void CallDelegatorByAsync(Delegate dl, Object[] parameters, bool controlInvoke, bool parallelInvocation, AsyncRaiserCallback callback, Object state)
{
TypeContainer container = null;
TypeNameResolver name_res = new TypeNameResolver();
lock (mTypeContainers)
{
if (mTypeContainers.ContainsKey(name_res.CallerTypeName))
{
container = mTypeContainers[name_res.CallerTypeName];
}
else
{
container = new TypeContainer();
mTypeContainers[name_res.CallerTypeName] = container;
}
if (container.Thread == null)
{
container.Thread = new Thread(new ThreadStart(EventExecutorThreadMain));
container.Thread.IsBackground = true;
container.Thread.Name = name_res.CallerTypeName;
container.Thread.Start();
}
}
lock (container.Queue)
{
container.Queue.Enqueue(new EventDataContainer(dl, parameters, controlInvoke, parallelInvocation, callback, state));
}
container.ExecutorThreadSemaphore.Release();
}
internal AutoBoxServiceLocator(TypeContainer typeContainer)
{
this.typeContainer = typeContainer;
}
public Let (ToplevelBlock block, TypeContainer container, LocatedToken identifier, Expression expr)
: base (block, CreateRangeVariableType (block, container, identifier, expr))
{
}
