public void OnProviderClose(Zeze.Net.AsyncSocket provider)
{
ProviderSession providerSession = provider.UserState as ProviderSession;
if (null == providerSession)
{
return;
}
// unbind module
UnBindModules(provider, providerSession.StaticBinds.Keys, true);
providerSession.StaticBinds.Clear();
// unbind LinkSession
lock (providerSession.LinkSessionIds)
{
foreach (var e in providerSession.LinkSessionIds)
{
foreach (var linkSid in e.Value)
{
var link = App.Instance.LinkdService.GetSocket(linkSid);
if (null != link)
{
var linkSession = link.UserState as LinkSession;
linkSession?.UnBind(link, e.Key, provider, true);
}
}
}
providerSession.LinkSessionIds.Clear();
}
}
public async Task Can_add_async()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderSessionMongoRepository(database);
ProviderSession session = BuildDummySession();
await repo.AddAsync(session);
}
public void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_serverHost;
sessionOptions.ServerPort = d_serverPort;
sessionOptions.AuthenticationOptions = d_authOptions;
System.Console.WriteLine("Connecting to " + d_serverHost + ":" + d_serverPort);
ProviderSession session = new ProviderSession(sessionOptions, ProcessEvent);
if (!session.Start())
{
Console.Error.WriteLine("Failed to start session");
return;
}
Identity identity = null;
if (d_authOptions.Length != 0)
{
if (!Authorize(out identity, session))
{
return;
}
}
TopicList topicList = new TopicList();
topicList.Add(
d_serviceName + "/220/660/1",
new CorrelationID(new MyStream("220/660/1")));
session.CreateTopics(
topicList,
ResolveMode.AUTO_REGISTER_SERVICES,
identity);
List <MyStream> myStreams = new List <MyStream>();
for (int i = 0; i < topicList.Size; ++i)
{
if (topicList.StatusAt(i) == TopicList.TopicStatus.CREATED)
{
Topic topic = session.GetTopic(topicList.MessageAt(i));
MyStream stream = (MyStream)topicList.CorrelationIdAt(i).Object;
stream.SetTopic(topic);
myStreams.Add(stream);
}
}
PublishEvents(session, myStreams);
session.Stop();
}
public void SetSession(ProviderSession session, INdmProviderPeer peer)
{
if (_logger.IsInfo)
{
_logger.Info($"Setting an active session: '{session.Id}' for node: '{peer.NodeId}', address: '{peer.ConsumerAddress}', deposit: '{session.DepositId}'.");
}
var node = GetConsumerNode(peer);
if (node is null)
{
if (_logger.IsInfo)
{
_logger.Info($"Couldn't set an active session: '{session.Id}' for node: '{peer.NodeId}', deposit: '{session.DepositId}' - consumer node was not found.");
}
return;
}
node.AddSession(session);
var depositNodes = DepositNodes.AddOrUpdate(session.DepositId,
_ => new ConcurrentDictionary <PublicKey, ConsumerNode>(),
(_, nodes) => nodes);
depositNodes.TryRemove(peer.NodeId, out _);
depositNodes.TryAdd(peer.NodeId, node);
if (_logger.IsInfo)
{
_logger.Info($"Set an active session: '{session.Id}' for node: '{peer.NodeId}', deposit: '{session.DepositId}'.");
}
}
private void ProcessRequestEvent(Event eventObj, ProviderSession session)
{
foreach (Message msg in eventObj)
{
Console.WriteLine(msg);
if (msg.MessageType == PERMISSION_REQUEST)
{
Service pubService = session.GetService(d_service);
if (pubService == null)
{
Console.Error.WriteLine("service unavailable");
return;
}
Event response = pubService.CreateResponseEvent(msg.CorrelationID);
EventFormatter ef = new EventFormatter(response);
ef.AppendResponse("PermissionResponse");
ef.PushElement("topicPermissions"); // TopicPermissions
Element topicElement = msg.GetElement(Name.GetName("topics"));
for (int i = 0; i < topicElement.NumValues; ++i)
{
ef.AppendElement();
ef.SetElement("topic", topicElement.GetValueAsString(i));
ef.SetElement("result", 0); // ALLOWED: 0, DENIED: 1
ef.PopElement();
}
session.SendResponse(response);
}
}
}
private void ProcessResponseEvent(Event eventObj, ProviderSession session)
{
foreach (Message msg in eventObj)
{
if (msg.CorrelationID != null && d_verbose > 1)
{
Console.Out.WriteLine("cid = " + msg.CorrelationID);
}
Console.Out.WriteLine("Message = " + msg);
if (msg.CorrelationID == null)
{
continue;
}
lock (d_authorizationStatus)
{
if (d_authorizationStatus.ContainsKey(msg.CorrelationID))
{
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.AUTHORIZED;
}
else
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.FAILED;
}
Monitor.Pulse(d_authorizationStatus);
}
}
}
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
switch (eventObj.Type)
{
case Event.EventType.TOPIC_STATUS:
ProcessTopicStatusEvent(eventObj, session);
break;
case Event.EventType.REQUEST:
ProcessRequestEvent(eventObj, session);
break;
case Event.EventType.RESPONSE:
case Event.EventType.PARTIAL_RESPONSE:
case Event.EventType.REQUEST_STATUS:
ProcessResponseEvent(eventObj, session);
break;
case Event.EventType.SESSION_STATUS:
foreach (Message msg in eventObj)
{
Console.WriteLine(msg);
if (msg.MessageType == SESSION_TERMINATED)
{
d_running = false;
}
}
break;
default:
PrintMessage(eventObj);
break;
}
}
private bool Authorize(out Identity identity, ProviderSession session)
{
identity = null;
EventQueue tokenEventQueue = new EventQueue();
session.GenerateToken(new CorrelationID(tokenEventQueue), tokenEventQueue);
String token = null;
const int timeoutMilliSeonds = 10000;
Event eventObj = tokenEventQueue.NextEvent(timeoutMilliSeonds);
if (eventObj.Type == Event.EventType.TOKEN_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == TOKEN_SUCCESS)
{
token = msg.GetElementAsString("token");
}
}
}
if (token == null)
{
System.Console.WriteLine("Failed to get token");
return(false);
}
const string authServiceName = "//blp/apiauth";
if (session.OpenService(authServiceName))
{
Service authService = session.GetService(authServiceName);
Request authRequest = authService.CreateAuthorizationRequest();
authRequest.Set("token", token);
EventQueue authEventQueue = new EventQueue();
identity = session.CreateIdentity();
session.SendAuthorizationRequest(authRequest, identity, authEventQueue, new CorrelationID(identity));
eventObj = authEventQueue.NextEvent();
if (eventObj.Type == Event.EventType.RESPONSE ||
eventObj.Type == Event.EventType.PARTIAL_RESPONSE ||
eventObj.Type == Event.EventType.REQUEST_STATUS)
{
foreach (Message msg in eventObj)
{
System.Console.WriteLine(msg.ToString());
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
return(true);
}
else
{
return(false);
}
}
}
}
return(false);
}
private void PublishEvents(ProviderSession session)
{
Service service = session.GetService(d_service);
while (g_running)
{
Event eventObj = null;
lock (d_topicSet)
{
if (d_topicSet.Count == 0)
{
Monitor.Wait(d_topicSet, 100);
}
if (d_topicSet.Count == 0)
{
continue;
}
Console.WriteLine("Publishing");
eventObj = service.CreatePublishEvent();
EventFormatter eventFormatter = new EventFormatter(eventObj);
foreach (Topic topic in d_topicSet.Keys)
{
String os = new DateTime().ToString();
int numRows = 5;
int numCols = 3;
for (int i = 0; i < numRows; ++i)
{
eventFormatter.AppendMessage("RowUpdate", topic);
eventFormatter.SetElement("rowNum", i);
eventFormatter.PushElement("spanUpdate");
for (int j = 0; j < numCols; ++j)
{
eventFormatter.AppendElement();
eventFormatter.SetElement("startCol", j);
eventFormatter.SetElement("length", os.Length);
eventFormatter.SetElement("text", os);
eventFormatter.PopElement();
}
eventFormatter.PopElement();
}
}
}
if (d_verbose > 1)
{
if (eventObj != null)
{
foreach (Message msg in eventObj)
{
Console.WriteLine(msg);
}
}
}
session.Publish(eventObj);
Thread.Sleep(10 * 1000);
}
}
private Task AddOrUpdateAsync(ProviderSession session)
{
var rlp = RlpObjectDecoder.Encode(session);
_database.Set(session.Id, rlp.Bytes);
return(Task.CompletedTask);
}
private IReadOnlyList <ProviderSession> Filter(Keccak?depositId = null, Keccak?dataAssetId = null,
PublicKey?consumerNodeId = null, Address?consumerAddress = null, PublicKey?providerNodeId = null,
Address?providerAddress = null)
{
var sessionsBytes = _database.GetAllValues().ToArray();
if (sessionsBytes.Length == 0)
{
return(Array.Empty <ProviderSession>());
}
var sessions = new ProviderSession[sessionsBytes.Length];
for (var i = 0; i < sessionsBytes.Length; i++)
{
sessions[i] = Decode(sessionsBytes[i]);
}
if (depositId is null && dataAssetId is null && consumerNodeId is null && consumerAddress is null &&
providerNodeId is null && providerAddress is null)
{
return(sessions);
}
var filteredSessions = sessions.AsEnumerable();
if (!(depositId is null))
{
filteredSessions = filteredSessions.Where(s => s.DepositId == depositId);
}
if (!(dataAssetId is null))
{
filteredSessions = filteredSessions.Where(s => s.DataAssetId == dataAssetId);
}
if (!(consumerNodeId is null))
{
filteredSessions = filteredSessions.Where(s => s.ConsumerNodeId == consumerNodeId);
}
if (!(consumerAddress is null))
{
filteredSessions = filteredSessions.Where(s => s.ConsumerAddress == consumerAddress);
}
if (!(providerNodeId is null))
{
filteredSessions = filteredSessions.Where(s => s.ProviderNodeId == providerNodeId);
}
if (!(providerAddress is null))
{
filteredSessions = filteredSessions.Where(s => s.ProviderAddress == providerAddress);
}
return(filteredSessions.OrderByDescending(s => s.StartTimestamp).ToArray());
}
public async Task Can_get_previous_returns_null_if_only_same()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderSessionMongoRepository(database);
ProviderSession session = BuildDummySession();
await repo.AddAsync(session);
var result = await repo.GetPreviousAsync(session);
result.Should().BeNull();
}
public async Task Can_get_by_id()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderSessionMongoRepository(database);
ProviderSession session = BuildDummySession();
await repo.AddAsync(session);
var result = await repo.GetAsync(session.Id);
result.Should().BeEquivalentTo(session);
}
public async Task Can_get_previous()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderSessionMongoRepository(database);
ProviderSession session = BuildDummySession();
await repo.AddAsync(session);
ProviderSession session2 = BuildDummySession(Keccak.Zero);
var result = await repo.GetPreviousAsync(session2);
result.Should().BeEquivalentTo(session);
}
private string GetSenderID(ProviderSession sessionInfo)
{
var targetID = sessionInfo.SessionName;
return(!string.IsNullOrEmpty(sessionInfo.SenderCompId)
? sessionInfo.SenderCompId
: senderIdByTargetId.ContainsKey(targetID)
? senderIdByTargetId[targetID]
: senderIdByTargetId.ContainsKey("")
? senderIdByTargetId[""]
: string.Empty);
}
public void SetUp()
{
_sessionRepository = Substitute.For <IProviderSessionRepository>();
_encoder = Substitute.For <IAbiEncoder>();
_signer = Substitute.For <IEcdsa>();
_peer = Substitute.For <INdmProviderPeer>();
_publicKey = new PublicKey(new byte[64]);
_session = new ProviderSession(Keccak.Zero, Keccak.Zero, Keccak.Zero, _publicKey.Address,
_publicKey, TestItem.AddressB, TestItem.PublicKeyB, 0, 0);
_session.SetDataAvailability(DataAvailability.Available);
_session.Start(0);
_processor = new ReceiptProcessor(_sessionRepository, _encoder, _signer, LimboLogs.Instance);
}
public void Run(String[] args) //throws Exception
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerHost = d_host;
sessionOptions.ServerPort = d_port;
sessionOptions.AuthenticationOptions = d_authOptions;
System.Console.WriteLine("Connecting to " + d_host + ":" + d_port);
ProviderSession session = new ProviderSession(sessionOptions, ProcessEvent);
if (!session.Start())
{
System.Console.WriteLine("Failed to start session");
return;
}
Identity identity = null;
if (d_authOptions.Length != 0)
{
if (!Authorize(out identity, session))
{
return;
}
}
TopicList topicList = new TopicList();
topicList.Add(
d_service + "/1245/4/5",
new CorrelationID(new MyStream("1245/4/5")));
topicList.Add(
d_service + "/330/1/1",
new CorrelationID(new MyStream("330/1/1")));
session.CreateTopics(
topicList,
ResolveMode.AUTO_REGISTER_SERVICES,
identity);
// createTopics() is synchronous, topicList will be updated
// with the results of topic creation (resolution will happen
// under the covers)
Publish(topicList, session);
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
if (eventObj == null)
{
Console.WriteLine("Received null event ");
return;
}
Console.WriteLine("Received event " + eventObj.Type.ToString());
foreach (Message msg in eventObj)
{
Console.WriteLine("Message = " + msg);
}
//TO DO Process event if needed.
}
private void Deactivate(ProviderSession session)
{
if (d_useSsc)
{
Console.WriteLine(
String.Format(
"DeActivating sub service code range [{0}, {1}] "
+ "@ priority: {2}",
d_sscBegin,
d_sscEnd,
d_sscPriority));
session.DeactivateSubServiceCodeRange(d_service,
d_sscBegin,
d_sscEnd);
}
}
private void ProcessTopicStatusEvent(Event eventObj, ProviderSession session)
{
foreach (Message msg in eventObj)
{
Console.WriteLine(msg);
if (msg.MessageType == TOPIC_RECAP || msg.MessageType == TOPIC_SUBSCRIBED)
{
Topic topic = session.GetTopic(msg);
if (topic != null)
{
// send initial paint, this should come from my own cache
Service service = session.GetService(d_service);
if (service == null)
{
Console.Error.WriteLine("service unavailable");
return;
}
Event recapEvent = service.CreatePublishEvent();
EventFormatter eventFormatter = new EventFormatter(recapEvent);
CorrelationID recapCid = msg.MessageType == TOPIC_RECAP ?
msg.CorrelationID //solicited recap
: null; //unsolicited recap
eventFormatter.AppendRecapMessage(
topic,
recapCid);
eventFormatter.SetElement("numRows", 25);
eventFormatter.SetElement("numCols", 80);
eventFormatter.PushElement("rowUpdate");
for (int i = 1; i <= 5; ++i)
{
eventFormatter.AppendElement();
eventFormatter.SetElement("rowNum", i);
eventFormatter.PushElement("spanUpdate");
eventFormatter.AppendElement();
eventFormatter.SetElement("startCol", 1);
eventFormatter.SetElement("length", 10);
eventFormatter.SetElement("text", "RECAP");
eventFormatter.PopElement();
eventFormatter.PopElement();
eventFormatter.PopElement();
}
eventFormatter.PopElement();
session.Publish(recapEvent);
}
}
}
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
PrintMessage(eventObj);
switch (eventObj.Type)
{
case Event.EventType.TOPIC_STATUS:
ProcessTopicStatusEvent(eventObj, session);
break;
case Event.EventType.REQUEST:
ProcessRequestEvent(eventObj, session);
break;
default:
break;
}
return;
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
if (d_verbose > 0)
{
if (d_verbose > 1)
{
Console.WriteLine("Received event " + eventObj.Type);
}
foreach (Message msg in eventObj)
{
if (msg.CorrelationID != null && d_verbose > 1)
{
Console.WriteLine("cid = " + msg.CorrelationID);
}
Console.WriteLine("Message = " + msg);
}
}
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
if (d_verbose > 0)
{
Console.Out.WriteLine("Received event " + eventObj.Type);
}
foreach (Message msg in eventObj)
{
if (msg.CorrelationID != null && d_verbose > 1)
{
Console.Out.WriteLine("cid = " + msg.CorrelationID);
}
Console.Out.WriteLine("Message = " + msg);
if (eventObj.Type == Event.EventType.SESSION_STATUS)
{
if (msg.MessageType == SESSION_TERMINATED)
{
d_running = false;
}
continue;
}
if (msg.CorrelationID == null)
{
continue;
}
lock (d_authorizationStatus)
{
if (d_authorizationStatus.ContainsKey(msg.CorrelationID))
{
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.AUTHORIZED;
}
else
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.FAILED;
}
Monitor.Pulse(d_authorizationStatus);
}
}
}
}
public async Task <ProviderSession?> GetPreviousAsync(ProviderSession session)
{
var previousSessions = await Filter(session.DepositId).Take(2).ToListAsync();
switch (previousSessions.Count)
{
case 0:
return(null);
case 1:
return(GetUniqueSession(session, previousSessions[0]));
default:
{
return(GetUniqueSession(session, previousSessions[1]) ??
GetUniqueSession(session, previousSessions[0]));
}
}
}
public async Task Can_browse_with_query_and_pagination()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new ProviderSessionMongoRepository(database);
ProviderSession session = BuildDummySession();
await repo.AddAsync(session);
var query = new GetProviderSessions();
query.ConsumerAddress = session.ConsumerAddress;
query.DepositId = session.DepositId;
query.ProviderAddress = session.ProviderAddress;
query.ConsumerNodeId = session.ConsumerNodeId;
query.DataAssetId = session.DataAssetId;
query.ProviderNodeId = session.ProviderNodeId;
query.Page = 0;
query.Results = 10;
await repo.BrowseAsync(query);
}
private void ProcessEvent(Event eventObj, ProviderSession session)
{
if (eventObj == null)
{
Console.WriteLine("Received null event ");
return;
}
Console.WriteLine("Received event " + eventObj.Type.ToString());
foreach (Message msg in eventObj)
{
Console.WriteLine("Message = " + msg);
if (eventObj.Type == Event.EventType.SESSION_STATUS)
{
if (msg.MessageType == SESSION_TERMINATED)
{
d_running = false;
}
continue;
}
if (msg.CorrelationID == null)
{
continue;
}
lock (d_authorizationStatus)
{
if (d_authorizationStatus.ContainsKey(msg.CorrelationID))
{
if (msg.MessageType == AUTHORIZATION_SUCCESS)
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.AUTHORIZED;
}
else
{
d_authorizationStatus[msg.CorrelationID] = AuthorizationStatus.FAILED;
}
Monitor.Pulse(d_authorizationStatus);
}
}
}
//TO DO Process event if needed.
}
private void ProcessTokenStatusMsg(ProviderSession session, Event eventObj)
{
foreach (Message msg in eventObj)
{
Object tokenResponseMonitor = msg.CorrelationID.Object;
lock (tokenResponseMonitor)
{
if (msg.MessageType == TOKEN_SUCCESS)
{
d_tokenGenerationResponse = true;
d_token = msg.GetElementAsString("token");
}
else if (msg.MessageType == TOKEN_FAILURE)
{
d_tokenGenerationResponse = false;
}
Monitor.PulseAll(tokenResponseMonitor);
}
}
}
public Task <ProviderSession?> GetPreviousAsync(ProviderSession session)
{
var sessions = Filter(session.DepositId);
switch (sessions.Count)
{
case 0:
return(Task.FromResult <ProviderSession?>(null));
case 1:
return(Task.FromResult <ProviderSession?>(GetUniqueSession(session, sessions[0])));
default:
{
var previousSessions = sessions.Take(2).ToArray();
return(Task.FromResult <ProviderSession?>(GetUniqueSession(session, previousSessions[1]) ??
GetUniqueSession(session, previousSessions[0])));
}
}
}
public void Run(String[] args)
{
if (!ParseCommandLine(args))
{
return;
}
SessionOptions.ServerAddress[] servers = new SessionOptions.ServerAddress[d_hosts.Count];
for (int i = 0; i < d_hosts.Count; ++i)
{
servers[i] = new SessionOptions.ServerAddress(d_hosts[i], d_port);
}
SessionOptions sessionOptions = new SessionOptions();
sessionOptions.ServerAddresses = servers;
sessionOptions.AuthenticationOptions = d_authOptions;
sessionOptions.AutoRestartOnDisconnection = true;
sessionOptions.NumStartAttempts = d_numRetry;
Console.Write("Connecting to");
foreach (SessionOptions.ServerAddress server in sessionOptions.ServerAddresses)
{
Console.Write(" " + server);
}
Console.WriteLine();
if (d_role == Role.SERVER || d_role == Role.BOTH)
{
ProviderSession session = new ProviderSession(sessionOptions, ProcessServerEvent);
ServerRun(session);
}
if (d_role == Role.CLIENT || d_role == Role.BOTH)
{
Session session = new Session(sessionOptions, ProcessClientEvent);
ClientRun(session);
}
}
private void ProcessRequestEvent(Event eventObj, ProviderSession session)
{
foreach (Message msg in eventObj)
{
if (msg.MessageType == PERMISSION_REQUEST)
{
Service pubService = session.GetService(d_service);
Event response = pubService.CreateResponseEvent(msg.CorrelationID);
EventFormatter ef = new EventFormatter(response);
ef.AppendResponse("PermissionResponse");
ef.PushElement("topicPermissions"); // TopicPermissions
Element topicElement = msg.GetElement(Name.GetName("topics"));
for (int i = 0; i < topicElement.NumValues; ++i)
{
ef.AppendElement();
ef.SetElement("topic", topicElement.GetValueAsString(i));
int permission = 0;
ef.SetElement("result", permission); // ALLOWED: 0, DENIED: 1
if (permission == 1)
{ // DENIED
ef.PushElement("reason");
ef.SetElement("source", "My Publisher Name");
ef.SetElement("category", "NOT_AUTHORIZED"); // or BAD_TOPIC, or custom
ef.SetElement("subcategory", "Publisher Controlled");
ef.SetElement("description", "Permission denied by My Publisher Name");
ef.PopElement();
}
}
session.SendResponse(response);
}
else
{
System.Console.WriteLine("Received unknown request: " + msg);
}
}
}
