public CallerChain MakeChainFor(string entity)
{
ConnectionImpl conn = (ConnectionImpl)GetCurrentConnection();
if (conn == null)
{
Logger.Error("Não há conexão para executar a chamada MakeChainFor.");
throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No);
}
LoginInfo?myLogin = conn.Login;
if (!myLogin.HasValue)
{
Logger.Error("Não há login para executar a chamada MakeChainFor.");
throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No);
}
try {
AccessControl acs = conn.Acs;
SignedData signedChain = acs.signChainFor(entity);
CallChain callChain = CallerChainImpl.UnmarshalCallChain(signedChain);
if (conn.Legacy)
{
SignedCallChain legacySigned = conn.LegacyConverter.signChainFor(entity);
return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target,
callChain.originators, signedChain, legacySigned));
}
return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target,
callChain.originators, signedChain));
}
catch (GenericUserException e) {
Logger.Error("Falha inesperada ao criar uma nova cadeia.", e);
throw;
}
}
public CallerChain ImportChain(byte[] token, string domain)
{
ConnectionImpl conn = (ConnectionImpl)GetCurrentConnection();
if (conn == null)
{
throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No);
}
AccessControl acs = conn.Acs;
AsymmetricKeyParameter busKey = conn.BusKey;
if (busKey == null)
{
throw new NO_PERMISSION(NoLoginCode.ConstVal, CompletionStatus.Completed_No);
}
byte[] encryptedToken = Crypto.Encrypt(busKey, token);
SignedData signedChain = acs.signChainByToken(encryptedToken, domain);
try {
CallChain callChain = CallerChainImpl.UnmarshalCallChain(signedChain);
return(new CallerChainImpl(callChain.bus, callChain.caller, callChain.target,
callChain.originators, signedChain));
}
catch (GenericUserException e) {
const string message = "Falha inesperada ao importar uma nova cadeia.";
Logger.Error(message, e);
throw new OpenBusInternalException(message, e);
}
}
/// <summary>
/// Inicializa uma instância de renovação de <i>lease</i>.
/// </summary>
/// <param name="connection">A conexão que deve ser renovada.</param>
/// <param name="lease">O tempo de <i>lease</i>.</param>
public RenewerTask(Connection connection, int lease)
{
Lease = lease;
ConnectionImpl conn = connection as ConnectionImpl;
_conn = new WeakReference(conn);
}
/// <summary>
/// Inicia a renovação de lease.
/// </summary>
public void Run()
{
try {
while (!_autoEvent.WaitOne(Lease * 1000))
{
try {
ConnectionImpl conn = _conn.Target as ConnectionImpl;
if (conn == null)
{
break;
}
conn.Context.SetCurrentConnection(conn);
AccessControl ac = conn.Acs;
Lease = ac.renew();
Logger.Debug(
String.Format(
"{0} - Lease renovado. Próxima renovação em {1} segundos.",
DateTime.Now, Lease));
}
catch (NO_PERMISSION) {
Logger.Error(
"Impossível renovar a credencial pois a conexão não está logada no barramento.");
}
catch (AbstractCORBASystemException e) {
Logger.Error("Erro ao tentar renovar o lease", e);
}
}
Logger.Debug("Thread de renovação de login finalizada.");
}
catch (ThreadInterruptedException) {
Logger.Warn("Lease Interrompido");
}
}
public LoginCache(ConnectionImpl conn,
int maxSize =
LRUConcurrentDictionaryCache <string, LoginEntry> .
DefaultSize)
{
_conn = conn;
_logins = new LRUConcurrentDictionaryCache <string, LoginEntry>(maxSize);
}
public void Bind(ConnectionImpl connection)
{
if (!_purgeExistingMessages)
return;
_logger.InfoFormat("purging queues for {0}", _address);
Purge().Wait();
}
public void Bind(ConnectionImpl connection)
{
if (!_purgeExistingMessages)
{
return;
}
_logger.InfoFormat("purging queues for {0}", _address);
Purge().Wait();
}
// [packet length]000 [target length]0 [target]a- [sender length]0 [sender]a- [channel]000 000 [callback packet uid]000
public static Packet NewCallbackPacket(ConnectionImpl target, int callbackPacketUID)
{
Packet p = new Packet();
p.packetUID = 0;
string data = target.m_target.Length.ToString("00") + target.m_target + m_localIDLength + m_localID + target.m_channel.ToString("000") + "000" + callbackPacketUID.ToString("000");
p.packetData = string.Concat(data.Length.ToString("000"), data);
p.OnTransmissionFailure = target.OnCallbackPacketSent;
return(p);
}
/// <summary>
/// Gets an existing connection with the specified signature.
/// </summary>
/// <param name="targetID">endpoint target id</param>
/// <param name="channel">connection channel</param>
/// <returns>Existing connection object</returns>
public static IConnection GetExistingConnection(string targetID, byte channel)
{
for (int i = 1, l = m_connections.Count; i < l; i++) // iterate over connections, skipping static (first)
{
ConnectionImpl c = m_connections[i] as ConnectionImpl;
if (c.m_channel == channel && c.m_target == targetID)
{
return(c);
}
}
return(null);
}
public void UpdateTest()
{
// Arrange
var connection = new ConnectionImpl();
var sql = "SELECT Id, Name, UpdateDate FROM Hoge WHERE Id = /* id */10";
// Act
int updCount = connection.Update(sql, SetParameter);
// Assert
Assert.Greater(updCount, 0);
}
// [packet length]000 [target length]0 [target]a- [sender length]0 [sender]a- [channel]000 [packet uuid]000 msg_data [msg]a-
public static Packet NewDataPacket(ConnectionImpl target, string msg, int packetUID, Action <Packet> onTransmissionFailure)
{
Packet p = new Packet();
p.packetUID = packetUID;
p.m_sendsLeft = m_sendLimit;
string data = target.m_target.Length.ToString("00") + target.m_target + m_localIDLength + m_localID + target.m_channel.ToString("000") + packetUID.ToString("000") + msg_data + msg;
p.packetData = string.Concat(data.Length.ToString("000"), data);
p.OnTransmissionFailure = onTransmissionFailure;
return(p);
}
/// <inheritdoc />
public void receive_request_service_contexts(ServerRequestInfo ri)
{
string interceptedOperation = ri.operation;
Logger.Info(String.Format(
"A operação '{0}' foi interceptada no servidor.", interceptedOperation));
bool legacyContext;
ServiceContext serviceContext = GetContextFromRequestInfo(ri, true,
out legacyContext);
AnyCredential anyCredential = new AnyCredential(serviceContext,
legacyContext);
Logger.Debug(
String.Format("A operação '{0}' possui credencial. É legada? {1}.",
interceptedOperation, anyCredential.Legacy));
ConnectionImpl conn = null;
try {
conn = GetDispatcherForRequest(ri, anyCredential) as ConnectionImpl;
if (conn == null)
{
Logger.Error(
"Sem conexão ao barramento, impossível receber a chamada remota.");
throw new NO_PERMISSION(UnknownBusCode.ConstVal,
CompletionStatus.Completed_No);
}
if ((!conn.Legacy) && (anyCredential.Legacy))
{
Logger.Error(
String.Format(
"Chamada negada devido a suporte legado inativo: login {0} operação {1} requestId {2}",
anyCredential.Login, interceptedOperation,
ri.request_id));
throw new NO_PERMISSION(NoCredentialCode.ConstVal, CompletionStatus.Completed_No);
}
Context.SetCurrentConnection(conn, ri);
conn.ReceiveRequest(ri, anyCredential);
}
catch (InvalidSlot e) {
Logger.Fatal("Falha ao inserir a credencial em seu slot.", e);
throw;
}
finally {
if (conn != null)
{
ri.set_slot(ReceivingConnectionSlotId, conn);
}
}
}
/// <inheritdoc />
public void receive_exception(ClientRequestInfo ri)
{
if (!Context.IsCurrentThreadIgnored(ri))
{
ConnectionImpl conn = GetCurrentConnection() as ConnectionImpl;
if (conn != null)
{
conn.ReceiveException(ri);
return;
}
Logger.Warn("Sem conexão ao barramento para receber uma exceção.");
}
Logger.Debug("O login está sendo ignorado para receber uma exceção.");
}
/// <inheritdoc />
public void send_exception(ServerRequestInfo ri)
{
// esse tratamento precisa ser feito aqui (não é possível na receive_request) por causa de bugs do IIOP.net, descritos em OPENBUS-1677.
String interceptedOperation = ri.operation;
Logger.Info(String.Format(
"O lançamento de uma exceção para a operação '{0}' foi interceptado no servidor.",
interceptedOperation), (Exception)ri.sending_exception);
NO_PERMISSION ex = ri.sending_exception as NO_PERMISSION;
if (ex == null)
{
return;
}
if (ex.Minor == InvalidCredentialCode.ConstVal)
{
try {
// pela implementação do IIOP.Net, o ServerRequestInfo da send_exception é
// diferente do existente na receive_request. Assim, não podemos passar a
// credencial por um slot e então precisamos fazer o unmarshal novamente.
ConnectionImpl conn =
ri.get_slot(ReceivingConnectionSlotId) as ConnectionImpl;
if (conn == null)
{
Logger.Error(
"Sem conexão ao barramento, impossível enviar exceção à chamada remota.");
throw new NO_PERMISSION(UnverifiedLoginCode.ConstVal,
CompletionStatus.Completed_No);
}
bool legacyContext;
ServiceContext serviceContext =
GetContextFromRequestInfo(ri, conn.Legacy, out legacyContext);
// credencial é inválida
AnyCredential anyCredential = new AnyCredential(serviceContext,
legacyContext);
Logger.Debug(String.Format(
"A operação '{0}' para a qual será lançada a exceção possui credencial. Legada? {1}.",
interceptedOperation, anyCredential.Legacy));
conn.SendException(ri, anyCredential);
}
catch (InvalidSlot e) {
Logger.Fatal(
"Falha ao acessar o slot da conexão de recebimento para enviar uma exceção.",
e);
throw;
}
}
}
/// <summary>
/// Attempts to open a new connection witht the given id and channel. If there is already an existing connection witht the same signature, null is returned.
/// </summary>
/// <param name="targetID">endpoint target id, must be between 1 and 99 characters</param>
/// <param name="channel">connection channel</param>
/// <returns>New connection object</returns>
public static IConnection OpenConnection(string targetID, byte channel)
{
if (targetID == null || targetID.Length <= 0 || targetID.Length > 99)
{
return(null);
} // validate target id
if (GetExistingConnection(targetID, channel) == null) // check if there is existing connection with the provided signature
{
ConnectionImpl c = new ConnectionImpl(); // init new connection
c.m_target = targetID;
c.m_channel = channel;
m_connections.Add(c);
c.m_dataPackets.AddLast(Packet.NewSysPacket(targetID, channel, Packet.msg_sys_RequestOpen, 1, c.OnFailedDataPacket));// send out connection request
return(c);
}
return(null);
}
/// <summary>
/// Intercepta o request para inserção de informação de contexto.
/// </summary>
/// <remarks>Informação do cliente</remarks>
public void send_request(ClientRequestInfo ri)
{
if (!Context.IsCurrentThreadIgnored(ri))
{
ConnectionImpl conn = GetCurrentConnection() as ConnectionImpl;
if (conn != null)
{
conn.SendRequest(ri);
return;
}
Logger.Error(
"Sem conexão ao barramento, impossível realizar a chamada remota.");
throw new NO_PERMISSION(NoLoginCode.ConstVal,
CompletionStatus.Completed_No);
}
Logger.Debug("O login está sendo ignorado para esta chamada.");
}
public static Connection <T> ToConnection <T>(
this IEnumerable <T> enumerable,
int?first = null,
Cursor?after = null,
int?last = null,
Cursor?before = null,
int?totalCount = null)
{
ValidateParameters(first, after, last, before);
var connection = new ConnectionImpl <T>(enumerable, first, after, last, before);
return(new Connection <T>
{
Edges = connection.Edges,
PageInfo = connection.PageInfo,
TotalCount = totalCount,
});
}
public void CreateCommandTest()
{
// Arrange
var method = typeof(SqlUtils).GetMethod("CreateCommand", BindingFlags.NonPublic | BindingFlags.Static);
var connection = new ConnectionImpl();
var sql = "SELECT Id, Name, UpdateDate FROM Hoge WHERE Id = /* id */10";
Func <string, string> replaceToParamMark = ReplacetoParameterMark;
Action <int, string, IDataParameter> setParameter = SetParameter;
// Act
IDbCommand actual = (IDbCommand)method.Invoke(null, new object[] { connection, sql, replaceToParamMark, setParameter });
// Assert
Assert.IsNotNull(actual);
Assert.AreEqual("SELECT Id, Name, UpdateDate FROM Hoge WHERE Id = @id", actual.CommandText);
Assert.AreEqual(1, actual.Parameters.Count);
IDataParameter actualParam = (IDataParameter)actual.Parameters[0];
Assert.AreEqual("@id", actualParam.ParameterName);
Assert.AreEqual(256, actualParam.Value);
}
public void SelectTest()
{
// Arrange
var connection = new ConnectionImpl();
var sql = "SELECT Id, Name, UpdateDate FROM Hoge WHERE Id = /* id */10";
var parameters = new Dictionary <string, object>();
parameters["Id"] = "2";
// Act
var actuals = connection.Select <SqlUtisTestEntity>(sql, parameters);
// Assert
var datas = DataReaderImpl.DATAS;
var maxCount = datas.Length / DataReaderImpl.COLUMN_NAMES.Length;
for (int i = 0; i < maxCount; i++)
{
var actual = actuals[i];
Assert.AreEqual(datas[i, DataReaderImpl.COL_ID], actual.Id, "Id(int)");
Assert.AreEqual(datas[i, DataReaderImpl.COL_NAME], actual.Name, "Name(String)");
Assert.AreEqual(datas[i, DataReaderImpl.COL_UPD], actual.ModifyTime, "UpdateTime-ColumnAttribute(DateTime)");
}
}
public void Unbind(ConnectionImpl connection)
{
}
public ChannelManager(ConnectionImpl impl) : this(new ChannelContext(impl))
{
}
public ChannelContext(ConnectionImpl impl)
{
m_Impl = impl;
}
/// <summary>
/// Processes the packet
/// </summary>
/// <param name="msg">bulk message</param>
/// <param name="dataStart">packet start (without packet length)</param>
/// <param name="length">packet length relative to the msg</param>
/// <returns>True if packet was parsable, false if corrupted</returns>
public static bool ProcessPacketData(string msg, int dataStart, int length)
{
int tmpInt;
string tmpString;
if (dataStart + 2 < length && int.TryParse(msg.Substring(dataStart, 2).ToString(), out tmpInt)) // target length
{
dataStart += 2;
if (dataStart + tmpInt < length)
{
tmpString = msg.Substring(dataStart, tmpInt);
if (tmpString == m_localID) // target
{
dataStart += tmpInt;
if (dataStart + 2 < length && int.TryParse(msg.Substring(dataStart, 2).ToString(), out tmpInt)) // sender length
{
dataStart += 2;
if (dataStart + tmpInt < length)
{
tmpString = msg.Substring(dataStart, tmpInt);// sender
dataStart += tmpInt;
byte channel;
if (dataStart + 3 < length && byte.TryParse(msg.Substring(dataStart, 3), out channel)) // channel
{
dataStart += 3;
if (dataStart + 3 < length && int.TryParse(msg.Substring(dataStart, 3), out tmpInt)) // packet uid
{
dataStart += 3;
if (tmpInt == 0)
{
ConnectionImpl c = GetExistingConnection(tmpString, channel) as ConnectionImpl;
if (c != null)
{
if (dataStart + 3 <= length && int.TryParse(msg.Substring(dataStart, 3), out tmpInt)) // callback uid
{
LinkedListNode <Packet> node = c.m_dataPackets.First;
if (node.Value.packetUID == tmpInt)
{
c.m_dataPackets.RemoveFirst();
}
else
{
while ((node = node.Next) != c.m_dataPackets.First)
{
if (node.Value.packetUID == tmpInt)
{
c.m_dataPackets.Remove(node);
break;
}
}
}
}
else
{
return(false);
}
}
}
else if (dataStart < length)
{
char packetType = msg[dataStart++];
ConnectionImpl c = GetExistingConnection(tmpString, channel) as ConnectionImpl;
if (c == null)
{
if (packetType == msg_sys_RequestOpen)
{
if (m_connectionAcceptor != null && m_connectionAcceptor.Invoke(tmpString, channel))
{
c = new ConnectionImpl();
c.m_target = tmpString;
c.m_channel = channel;
c.m_dataPackets.AddLast(NewSysPacket(tmpString, channel, msg_sys_ConfirmOpen, 1, c.OnFailedDataPacket));
m_connections.Add(c);
if (m_connectionListener != null)
{
m_connectionListener.Invoke(c);
}
}
else
{
Packet p = NewSysPacket(tmpString, channel, msg_sys_ShutdownConnection, 1, m_connections[0].RemoveDataPacket);
p.m_sendsLeft = 1;
m_connections[0].m_dataPackets.AddLast(p);
}
}
}
else
{
if (packetType == msg_data)
{
if (c.state == ConnectionImpl.state_open)
{
if (tmpInt == 50 || c.nextExpectedPacketUID == tmpInt)
{
if (tmpInt != 50)
{
if (++c.nextExpectedPacketUID > 999)
{
c.nextExpectedPacketUID = 100;
}
}
int l = length - dataStart;
if (l < 0)
{
return(false);
}
if (l == 0)
{
if (c.OnData != null)
{
c.OnData.Invoke("");
}
}
else if (dataStart + l <= length)
{
if (c.OnData != null)
{
c.OnData.Invoke(msg.Substring(dataStart, l));
}
}
else
{
return(false);
}
}
if (tmpInt >= 100)
{
c.m_callbackPackets.Add(NewCallbackPacket(c, tmpInt));
}
}
}
else if (packetType == msg_sys_RequestOpen)
{
if (c.state == ConnectionImpl.state_pending)
{
c.m_dataPackets.Clear();
c.m_dataPackets.AddLast(NewSysPacket(tmpString, channel, msg_sys_ConfirmOpen, 1, c.OnFailedDataPacket));
}
}
else if (packetType == msg_sys_ConfirmOpen)
{
Packet p = NewSysPacket(tmpString, channel, msg_sys_OpenHandshake, 1, c.RemoveDataPacket);
p.m_sendsLeft = 1;
if (c.state == ConnectionImpl.state_pending)
{
c.m_dataPackets.Clear();
c.m_dataPackets.AddLast(p);
c.state = ConnectionImpl.state_open;
if (c.OnOpen != null)
{
c.OnOpen.Invoke();
}
}
else
{
c.m_dataPackets.AddFirst(p);
}
}
else if (packetType == msg_sys_OpenHandshake)
{
if (c.state == ConnectionImpl.state_pending)
{
c.m_dataPackets.Clear();
c.state = ConnectionImpl.state_open;
if (c.OnOpen != null)
{
c.OnOpen.Invoke();
}
}
}
else if (packetType == msg_sys_ShutdownConnection && tmpInt >= 100)
{
if ((c.state == ConnectionImpl.state_pending || c.nextExpectedPacketUID == tmpInt) && c.state != ConnectionImpl.state_closed)
{
c.InternalClose();
}
}
}
}
else
{
return(false);
}
return(true);// parse success
}
}
}
}
}
}
}
return(false);// parse failure, corrupted transmission
}
public void Unbind(ConnectionImpl connection)
{
}
