/// <summary>
/// Determines whether communication is running in headquarter branch or not.
/// </summary>
/// <returns>
/// <c>true</c> if this branch is headquarter; otherwise, <c>false</c>.
/// </returns>
public bool IsHeadquarter()
{
using (IConnectionWrapper wrapper = this.Database.SynchronizeConnection())
{
Makolab.Fractus.Kernel.Managers.SqlConnectionManager.Instance.SetConnection(wrapper.Connection, this.Transaction as SqlTransaction);
bool logOut = false;
if (KernelSessionManager.IsLogged == false)
{
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOn("xxx", "CD2EB0837C9B4C962C22D2FF8B5441B7B45805887F051D39BF133B583BAF6860", "pl", null);
KernelSessionManager.IsLogged = true;
logOut = true;
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.LocalTransactionId = Guid.NewGuid();
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.DeferredTransactionId = Guid.NewGuid();
}
var isHeadquarter = Makolab.Fractus.Kernel.Mappers.ConfigurationMapper.Instance.GetSingleConfigurationEntry("system.isHeadquarter");
if (logOut)
{
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOff();
KernelSessionManager.IsLogged = false;
}
return(Boolean.Parse(isHeadquarter.Value.Value));
}
}
public CommandGeneric(IQCollectionRetriever <T1> qcollectionRetriever, ICommand <T1, T2> oneInfo, IResultFormatter format, IConnectionWrapper api = null)
{
QCollectionRetriever = qcollectionRetriever;
OneElementLauncher = oneInfo;
FormatToString = format;
this.API = api ?? new ConnectionWrapper();
}
public CommandGenericOneElem(IQElementRetriever <T1> qelementRetriever, ICommand <T1, T2> getInfo, IResultFormatter formatter, IConnectionWrapper api = null)
{
this.QElementRetriever = qelementRetriever;
this.ElementLauncher = getInfo;
this.Formatter = formatter;
this.API = api ?? new ConnectionWrapper();
}
public bool VerifyPlayerLogin(string Username, NetConnection Sender, long creationTime, byte[] OriginalSHA, out IConnectionWrapper myData)
{
if (myWrapper.VerifyUser(Username, creationTime, OriginalSHA))
{
PlayerData PlayerDataFile;
if (File.Exists("./Users/" + Username + ".chr"))
{
PlayerDataFile = myFiles.OpenReadClass <PlayerData>("./Users/" + Username + ".chr");
}
else
{
PlayerDataFile = null;
}
var myWrapper = new IConnectionWrapper(PlayerDataFile, Sender, OriginalSHA);
myUsernameToConnectionWrapper.AddOrUpdate(Username, myWrapper, OnLoginDataUpdate);
myUserIDToUsernameString.AddOrUpdate(OriginalSHA, Username, updateUserIDFunction);
myData = myWrapper;
return(true);
}
else
{
myData = null;
return(false);
}
}
internal void Execute(string query)
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query.ToString());
comm.ExecuteNonQuery();
}
public async Task ExecuteNonQueryAsync(IConnectionWrapper connection, string query, SqlParameter[] parameters = null)
{
var mysqlConnection = (OracleConnectionWrapper)connection;
var command = GetCommand(mysqlConnection.GetConnection(), query, parameters);
await command.ExecuteNonQueryAsync().ConfigureAwait(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="ItemRepository"/> class.
/// </summary>
/// <param name="context">The unit of work.</param>
protected ItemRepository(IUnitOfWork context)
: base(context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
this.mapper = context.MapperFactory.CreateMapper <ItemMapper>(context.ConnectionManager);
if (this.mapper == null)
{
this.mapper = new ItemMapper(context.ConnectionManager);
}
this.mapper.Transaction = context.Transaction;
this.kernelItemMapper = context.MapperFactory.CreateMapper <Kernel.Mappers.ItemMapper>(context.ConnectionManager);
using (IConnectionWrapper conWrapper = context.ConnectionManager.SynchronizeConnection())
{
if (this.kernelItemMapper == null)
{
Makolab.Fractus.Kernel.Managers.SqlConnectionManager.Instance.SetConnection(conWrapper.Connection, context.Transaction as SqlTransaction);
this.kernelItemMapper = new Kernel.Mappers.ItemMapper();
}
}
}
public Listener(IConnectionWrapper connection, string name, DispatchType dispatchType, bool autoDelete, IDictionary <string, object> arguments = null, string topicFilter = "#") :
base(connection, dispatchType, name, autoDelete, arguments)
{
_topicFilter = topicFilter;
CreateConsumer();
BindQueueToExchange();
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="connectionWrapper">IConnectionWrapper</param>
/// <param name="logger">ILogger{ConsumerChannelFactory}</param>
/// <param name="channelRecovery">IChannelRecovery</param>
public ConsumerChannelFactory(IConnectionWrapper connectionWrapper,
ILogger <ConsumerChannelFactory> logger,
IChannelRecovery channelRecovery)
{
_connectionWrapper = connectionWrapper;
_logger = logger;
_channelRecovery = channelRecovery;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="connectionWrapper">IConnectionWrapper</param>
/// <param name="logger">ILogger{ConsumerChannelRecovery}</param>
/// <param name="timeLoop">ITimeLoop</param>
public ConsumerChannelRecovery(IConnectionWrapper connectionWrapper,
ILogger <ConsumerChannelRecovery> logger,
ITimeLoop timeLoop)
{
_connectionWrapper = connectionWrapper;
_logger = logger;
_timeLoop = timeLoop;
}
internal List <T> ExecuteAndReadEntity <T>(string query) where T : new()
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query);
var entities = comm.ExecuteReaderEntity <T>();
return(entities);
}
internal List <T> ExecuteAndReadOneColumn <T>(string query)
{
using IConnectionWrapper conn = dbWrapper.CreateConnection();
conn.Open();
using ICommandWrapper comm = dbWrapper.CreateCommand(query);
var entities = comm.ExecuteReaderOneColumn <T>(0);
return(entities);
}
/// <summary>
/// Cleans the execution engine. Runs when execution engine is stopping.
/// </summary>
/// <param name="connectionManager">The database connection manager.</param>
public void Clean(IDatabaseConnectionManager connectionManager)
{
using (IConnectionWrapper wrapper = connectionManager.SynchronizeConnection())
{
Makolab.Fractus.Kernel.Managers.SqlConnectionManager.Instance.SetConnection(wrapper.Connection, null);
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOff();
KernelSessionManager.IsLogged = false;
}
}
protected RabbitCore(IConnectionWrapper connection, DispatchType dispatchType, string name, bool autoDelete, IDictionary <string, object> arguments = null)
{
DispatchType = dispatchType;
Name = name;
Connection = connection;
AutoDelete = autoDelete;
Arguments = arguments;
ModelWrapper = Connection.CreateModel();
SetupQueue();
}
public void StartInitialization()
{
ILoggerFactory connectionLoggerFactory = LoggerFactory.Create("");
IRmqLogger connectionLogger = connectionLoggerFactory.CreateLogger(nameof(ConnectionWrapper));
connection = new ConnectionWrapper(config, connectionLogger);
IModel rpcCh = connection.CreateChannel();
rpcChannelPool = channelPoolFactory.CreateChannelPool(rpcCh);
IConsumerBinder rpcConsumerBinder = new RpcConsumerBinder();
IConsumerFactory rpcConsumerFactory = new ConsumerFactory(
rpcChannelPool.GetChannelWrapper(),
rpcConsumerBinder);
ILoggerFactory loggerFactory = LoggerFactory.Create(ConsumerType.Rpc.ToString());
IRmqLogger managerLogger = loggerFactory.CreateLogger(nameof(ConsumerManager));
IConsumerManager rpcConsumerManager = new ConsumerManager(
rpcConsumerFactory,
managerLogger);
rpcConsumerManager.InitConsumer();
IMainConsumerEventHandlerFactory rpcMainEventHandlerFactory
= ConsumerEventHandlersFactory.Create(rpcConsumerManager, loggerFactory);
IConsumerMainEventHandlers rpcConsumerMainEventHandler
= rpcMainEventHandlerFactory.CreateMainHandler();
IRmqLogger connectionHandlerLogger = loggerFactory.CreateLogger(nameof(ConnectionEventHandlers));
IConnectionEventsHandlerFactory connectionEventsHandlerFactory
= ConnectionEventsHandlerFactory.Create(connectionHandlerLogger, connection);
IConnectionEventHandlers connectionEventHandler = connectionEventsHandlerFactory.CreateHandler();
IRmqLogger channelGuardLogger = loggerFactory.CreateLogger(nameof(ChannelGuardService));
this.channelGuardService
= new ChannelGuardService(
rpcChannelPool, // <--- TODO только rpc?
channelGuardLogger,
connectionEventHandler,
rpcConsumerMainEventHandler);
// Подписка на ответы запросов rpc
responseMessageHandler = responseMessageHandlerFactory.GetHandler();
rpcConsumerMainEventHandler.AddReceiveHandler(responseMessageHandler.HandleMessage);
}
public void DisposeConnection(IConnectionWrapper connectionWrapper)
{
var connection = _busyWrappers.FirstOrDefault(x => x.Id == connectionWrapper.Id);
if (connection == null)
{
throw new ArgumentException("connectionWrapper");
}
_busyWrappers.Remove(connection);
_connectionFreeWrappers.Push(connection);
}
public RepositoryBase_TestBase()
{
unitOfWork = A.Fake <IUnitOfWork>();
transaction = A.Fake <IDbTransaction>();
connection = A.Fake <IConnectionWrapper>();
A.CallTo(() => unitOfWork.CurrentTransaction).Returns(transaction);
A.CallTo(() => unitOfWork.Connection).Returns(connection);
sampleRepository = new SampleRepository();
sampleRepository.SetUnitOfWork(unitOfWork);
}
/// <summary>
/// Initializes the execution engine. Runs before any package is executed.
/// </summary>
/// <param name="connectionManager">The database connection manager.</param>
public void Initialize(IDatabaseConnectionManager connectionManager)
{
using (IConnectionWrapper wrapper = connectionManager.SynchronizeConnection())
{
Makolab.Fractus.Kernel.Managers.SqlConnectionManager.Instance.SetConnection(wrapper.Connection, null);
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOn("xxx", "CD2EB0837C9B4C962C22D2FF8B5441B7B45805887F051D39BF133B583BAF6860", "pl", null);
KernelSessionManager.IsLogged = true;
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.LocalTransactionId = Guid.NewGuid();
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.DeferredTransactionId = Guid.NewGuid();
SetDatabaseId();
SetHeadquarterStatus(connectionManager);
}
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="connectionWrapper">IConnectionWrapper</param>
/// <param name="jsonConverter">IJsonConverter</param>
/// <param name="channelFactory">IChannelFactory</param>
/// <param name="eventingBasicConsumerImpl">IEventingBasicConsumerImpl</param>
/// <param name="consumerInvoker">IConsumerInvoker</param>
public RabbitMQMessageQueue(
IConnectionWrapper connectionWrapper,
IJsonConverter jsonConverter,
IChannelFactory channelFactory,
IEventingBasicConsumerImpl eventingBasicConsumerImpl,
IConsumerInvoker consumerInvoker)
{
_connectionWrapper = connectionWrapper;
_jsonConverter = jsonConverter;
_channelFactory = channelFactory;
_eventingBasicConsumerImpl = eventingBasicConsumerImpl;
_consumerInvoker = consumerInvoker;
}
private void CreateConnection(string hostName, string userName, string password, int port = 5672)
{
_connectionFactory = new ConnectionFactory
{
HostName = hostName,
Port = port,
UserName = userName,
Password = password,
AutomaticRecoveryEnabled = true
};
_connection = new ConnectionWrapper(_connectionFactory.CreateConnection());
}
public async Task <int> ExecuteScalarAsync(IConnectionWrapper connection, string query, SqlParameter[] parameters = null)
{
var connectionWrapper = (OracleConnectionWrapper)connection;
var command = GetCommand(connectionWrapper.GetConnection(), query, parameters);
var result = await command.ExecuteScalarAsync().ConfigureAwait(false);
if (result != DBNull.Value)
{
return(int.Parse(result.ToString()));
}
return(0);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="connectionWrapper">IConnectionWrapper</param>
/// <param name="jsonConverter">IJsonConverter</param>
/// <param name="channelFactory">IChannelFactory</param>
/// <param name="eventingBasicConsumerImpl">IEventingBasicConsumerImpl</param>
/// <param name="sendOptions">IOptions{SendOptions}</param>
/// <param name="logger">ILogger{RabbitMQMessageQueue}</param>
public RabbitMQMessageQueue(
IConnectionWrapper connectionWrapper,
IJsonConverter jsonConverter,
IChannelFactory channelFactory,
IEventingBasicConsumerImpl eventingBasicConsumerImpl,
IOptions <SendOptions> sendOptions,
ILogger <RabbitMQMessageQueue> logger)
{
_connectionWrapper = connectionWrapper;
_jsonConverter = jsonConverter;
_channelFactory = channelFactory;
_eventingBasicConsumerImpl = eventingBasicConsumerImpl;
_sendOptions = sendOptions;
_logger = logger;
}
/// <summary>
/// Gets the validation schemas used in comunication package validation.
/// </summary>
/// <returns>Collection of validation schemas.</returns>
public IDictionary <string, System.Xml.Schema.XmlSchemaSet> GetValidationSchemas()
{
Dictionary <string, XmlSchemaSet> schemasColl = new Dictionary <string, XmlSchemaSet>();
XmlSchemaSet schemaSet = new XmlSchemaSet();
XDocument schemas = null;
using (IConnectionWrapper wrapper = dbManager.SynchronizeConnection())
{
Makolab.Fractus.Kernel.Managers.SqlConnectionManager.Instance.SetConnection(wrapper.Connection, null);
bool logOut = false;
if (KernelSessionManager.IsLogged == false)
{
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOn("xxx", "CD2EB0837C9B4C962C22D2FF8B5441B7B45805887F051D39BF133B583BAF6860", "pl", null);
KernelSessionManager.IsLogged = true;
logOut = true;
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.LocalTransactionId = Guid.NewGuid();
Makolab.Fractus.Kernel.Managers.SessionManager.VolatileElements.DeferredTransactionId = Guid.NewGuid();
}
ConfigurationCoordinator confCoord = new ConfigurationCoordinator();
schemas = confCoord.GetConfiguration("communication.validation.schema");
if (logOut)
{
Makolab.Fractus.Kernel.Managers.SecurityManager.Instance.LogOff();
KernelSessionManager.IsLogged = false;
}
}
if (schemas == null)
{
throw new ConfigurationErrorsException("communication.validation.schema element is not defined in configuration.");
}
foreach (var schema in schemas.Root.Elements("validationSchama"))
{
XmlSchema contrSchema = XmlSchema.Read(new StringReader(schema.Value), null);
schemaSet.Add(contrSchema);
schemasColl.Add(schema.Attribute("xmlType").Value, schemaSet);
}
return(schemasColl);
}
public async Task <object[][]> ExecuteTableAsync(IConnectionWrapper connection, string query, SqlParameter[] parameters = null)
{
var connectionWrapper = (OracleConnectionWrapper)connection;
var command = GetCommand(connectionWrapper.GetConnection(), query, parameters);
var reader = await command.ExecuteReaderAsync().ConfigureAwait(false);
var schemaTable = reader.GetSchemaTable();
var result = new List <object[]>();
while (reader.Read())
{
var row = new List <object>();
for (var i = 0; i < schemaTable.Rows.Count; i++)
{
row.Add(reader.GetValue(i));
}
result.Add(row.ToArray());
}
return(result.ToArray());
}
public EchoConnection()
{
_connection = new ConnectionWrapper(this);
}
public EchoConnection(IConnectionWrapper connection)
{
_connection = connection;
}
public BaseRepository(IConnectionWrapper connectionWrapper)
{
_connectionWrapper = connectionWrapper;
}
public EchoConnection()
{
_connection = new ConnectionWrapper(this);
}
public EchoConnection(IConnectionWrapper connection)
{
_connection = connection;
}
public void LoadProcessors()
{
myServer.AssignProcessor(delegate(Packet P)
{
LoginPacket myPacket = (LoginPacket)P;
Console.WriteLine(myPacket.Username + " attempted to connect!");
IConnectionWrapper myData;
if (myLoginHandler.VerifyPlayerLogin(myPacket.Username, myPacket.Sender, myPacket.GetCreationTime(), myPacket.GetSHA(), out myData))
{
var PDataInfo = (PlayerData)myData.MyExternalData;
if (PDataInfo != null)
{
PlayerInfoPacket myInfo = new PlayerInfoPacket();
myInfo.NewChar = false;
myInfo.myMap = myMapHandler.GetPlayerMap(PDataInfo);
myInfo.Sender = myPacket.Sender;
myServer.Send(myInfo, NetDeliveryMethod.ReliableOrdered);
myMapHandler.Login(myData);
}
else
{
ThreadPool.QueueUserWorkItem(delegate(object State)
{
PlayerInfoPacket myInfo = new PlayerInfoPacket();
myInfo.Sender = myPacket.Sender;
PDataInfo = new PlayerData();
myInfo.NewChar = true;
myInfo.SetPlayerData(PDataInfo);
myInfo.myMap = myMapHandler.PlaceInFirstAvailable(myInfo.Sender, PDataInfo);
PDataInfo.CurrentMapID = PDataInfo.CurrentMapID;
myLoginHandler.UpdateInfo(myPacket.GetSHA(), PDataInfo);
myServer.Send(myInfo, NetDeliveryMethod.ReliableOrdered);
});
}
Console.WriteLine("User Authenticated Successfully!\n Awaiting Character Creation!");
}
else
{
LoginFailedPacket myAck = new LoginFailedPacket();
myAck.Sender = myPacket.Sender;
myServer.Send(myAck, NetDeliveryMethod.ReliableOrdered);
Console.WriteLine("User Authentication Failed!");
}
}, typeof(LoginPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
AnnounceToMapPacket myPacket = (AnnounceToMapPacket)P;
}
}, typeof(AnnounceToMapPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
IConnectionWrapper Recipient;
WhisperMessagePlayer myPacket = (WhisperMessagePlayer)P;
if ((Recipient = myLoginHandler.isLoggedIn(myPacket.RecipientUserID)) != null)
{
PlayerData Recip = (PlayerData)Recipient.MyExternalData;
PlayerData Sender = (PlayerData)mySender.MyExternalData;
if (Recip.CurrentMapID.CompareTo(Sender.CurrentMapID) == 0)
{
myPacket.Sender = Recipient.GetConnection();
myServer.Send(myPacket, NetDeliveryMethod.ReliableOrdered);
}
}
else
{
//TODO: send response packet.
}
}
}, typeof(WhisperMessagePlayer));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
SendMessageLocalAreaPacket myPacket = (SendMessageLocalAreaPacket)P;
}
}, typeof(SendMessageLocalAreaPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
SendMessageMapAreaPacket myPacket = (SendMessageMapAreaPacket)P;
//List<PlayerData> myData = myMapHandler.GetPlayersOnMap();
}
}, typeof(SendMessageMapAreaPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper mySender;
if ((mySender = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
AnnounceToAllMapsPacket myPacket = (AnnounceToAllMapsPacket)P;
}
}, typeof(AnnounceToAllMapsPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper Wrapper;
if ((Wrapper = myLoginHandler.isLoggedIn(P.UserID)) != null)
{
myLoginHandler.Logout(P.UserID);
myMapHandler.Logout(Wrapper);
}
}, typeof(DisconnectPacket));
myServer.AssignProcessor(delegate(Packet P)
{
IConnectionWrapper myValue = myLoginHandler.isLoggedIn(P.UserID);
if (myValue != null)
{
Map myMap = myMapHandler.GetPlayerMap((PlayerData)myValue.MyExternalData);
foreach (NetConnection A in myMap.GetPlayerIPs())
{
PlayerMapConnectionPacket myNewPlayer = new PlayerMapConnectionPacket();
myNewPlayer.SetNewPlayerData((PlayerData)myValue.MyExternalData);
myNewPlayer.Sender = A;
myServer.Send(myNewPlayer, NetDeliveryMethod.ReliableOrdered);
}
}
}, typeof(MapLoadedPacket));
myServer.AssignProcessor(delegate(Packet P)
{
CharacterCreationPacket Packet = ((CharacterCreationPacket)P);
IConnectionWrapper myValue = myLoginHandler.isLoggedIn(Packet.UserID);
if (myValue != null)
{
((PlayerData)myValue.MyExternalData).SetAnimation(Packet.GetAnimationInfo());
((PlayerData)myValue.MyExternalData).SetName(Packet.GetName());
Map myMap = myMapHandler.GetPlayerMap(((PlayerData)myValue.MyExternalData));
foreach (NetConnection A in myMap.GetPlayerIPs())
{
PlayerMapConnectionPacket myNewPlayer = new PlayerMapConnectionPacket();
myNewPlayer.SetNewPlayerData(((PlayerData)myValue.MyExternalData));
myNewPlayer.Sender = A;
myServer.Send(myNewPlayer, NetDeliveryMethod.ReliableOrdered);
}
}
}, typeof(CharacterCreationPacket));
}
public TestableEchoConnection(IConnectionWrapper connWrapper)
: base(connWrapper)
{
}
public Dispatcher(IConnectionWrapper connection, string name, DispatchType dispatchType, bool autoDelete, IDictionary <string, object> arguments = null) :
base(connection, dispatchType, name, autoDelete, arguments)
{
}
