private void mk_rtp_server_detach(IntPtr userdata)
{
if (OnTimeout != null)
{
OnTimeout.Invoke();
}
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
try {
Assert.AssertEquals(3, interest.getLink().getDelegations().size());
} catch (EncodingException ex) {
Assert.Fail("Error in getLink: " + ex);
}
if (interest.matchesName(contentData_.getName()))
{
contentCount_[0] = 1;
onData.onData(interest, contentData_);
}
else if (interest.matchesName(cKeyData_.getName()))
{
cKeyCount_[0] = 1;
onData.onData(interest, cKeyData_);
}
else if (interest.matchesName(dKeyData_.getName()))
{
dKeyCount_[0] = 1;
onData.onData(interest, dKeyData_);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
private void Timeout_Elapsed(object state)
{
// This is for very large caches, ideally we want to process all data in the cache in a single tick
// if we are unable too, slowly start raising the interval until we can.
if (_overload)
{
_period++;
_timeout.Change(0, _period * 1000);
return;
}
_overload = true;
foreach (var entry in _timing)
{
var time = DateTime.FromBinary(entry.Value.Timestamp);
if ((DateTime.UtcNow - time).TotalSeconds < entry.Value.Timeout)
{
continue;
}
var removed = base.Delete <dynamic>(entry.Key);
_timing.TryRemove(entry.Key, out _);
OnTimeout?.Invoke(this, entry.Key, removed, entry.Value.Timeout);
}
_overload = false;
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details.
/// </summary>
///
public override long expressInterest(Interest interest_0, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat_1)
{
long pendingInterestId_2 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_3 = onData;
OnData onDataSubmit_4 = new ThreadPoolFace.Anonymous_C14 (this, finalOnData_3);
OnTimeout finalOnTimeout_5 = onTimeout;
OnTimeout onTimeoutSubmit_6 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C13 (this, finalOnTimeout_5);
OnNetworkNack finalOnNetworkNack_7 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_8 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C12 (this, finalOnNetworkNack_7);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_9 = new Interest(interest_0);
threadPool_.submit(new ThreadPoolFace.Anonymous_C11 (this, onNetworkNackSubmit_8, onDataSubmit_4,
interestCopy_9, onTimeoutSubmit_6, pendingInterestId_2, wireFormat_1));
return pendingInterestId_2;
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details.
/// </summary>
///
public override long expressInterest(Interest interest_0, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat_1)
{
long pendingInterestId_2 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_3 = onData;
OnData onDataSubmit_4 = new ThreadPoolFace.Anonymous_C14(this, finalOnData_3);
OnTimeout finalOnTimeout_5 = onTimeout;
OnTimeout onTimeoutSubmit_6 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C13(this, finalOnTimeout_5);
OnNetworkNack finalOnNetworkNack_7 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_8 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C12(this, finalOnNetworkNack_7);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_9 = new Interest(interest_0);
threadPool_.submit(new ThreadPoolFace.Anonymous_C11(this, onNetworkNackSubmit_8, interestCopy_9,
onDataSubmit_4, pendingInterestId_2, wireFormat_1, onTimeoutSubmit_6));
return(pendingInterestId_2);
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details. We make a separate
/// expressInterest overload for supplying a Name vs. Interest to avoid making
/// multiple copies of the Interest.
/// </summary>
///
public override long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat_0)
{
long pendingInterestId_1 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_2 = onData;
OnData onDataSubmit_3 = new ThreadPoolFace.Anonymous_C10(this, finalOnData_2);
OnTimeout finalOnTimeout_4 = onTimeout;
OnTimeout onTimeoutSubmit_5 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C9(this, finalOnTimeout_4);
OnNetworkNack finalOnNetworkNack_6 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_7 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C8(this, finalOnNetworkNack_6);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_8 = net.named_data.jndn.Face.getInterestCopy(name, interestTemplate);
threadPool_.submit(new ThreadPoolFace.Anonymous_C7(this, onTimeoutSubmit_5, onDataSubmit_3, interestCopy_8,
wireFormat_0, pendingInterestId_1, onNetworkNackSubmit_7));
return(pendingInterestId_1);
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
if (interest.matchesName(contentData_.getName()))
{
contentCount_[0] = 1;
onData.onData(interest, contentData_);
}
else if (interest.matchesName(cKeyData_.getName()))
{
cKeyCount_[0] = 1;
onData.onData(interest, cKeyData_);
}
else if (interest.matchesName(dKeyData_.getName()))
{
dKeyCount_[0] = 1;
onData.onData(interest, dKeyData_);
}
else
{
onTimeout.onTimeout(interest);
}
return(0);
}
private void CheckForTimeout(int id)
{
lock (registers[id]) {
if (messageReceived[id])
{
timeoutTimers[id].Reset();
return;
}
}
if (timeoutTimers[id].ElapsedMilliseconds >= MessageTimemout)
{
int n;
lock (this) {
//BytesSent -= updateSize[id];
n = ++numTimeouts;
if (numTimeouts >= TimeoutAttempts)
{
StopAsync();
Console.Error.WriteLine("Robot Timeout!!");
}
BytesSent -= updateSize[id];
}
if (SendMessage(id, registers[id].ResendUpdate))
{
timeoutTimers[id].Restart();
}
ThreadPool.QueueUserWorkItem(new WaitCallback((object callback) => { OnTimeout?.Invoke(); }));
Console.Error.WriteLine("Message timeout! #{0}", n);
}
}
/// <summary>
/// Create a new ExponentialReExpress where onTimeout expresses the interest
/// again with double the interestLifetime. If the interesLifetime goes over
/// maxInterestLifetime, then call the given onTimeout. If this internally
/// gets onData, just call the given onData.
/// </summary>
///
private ExponentialReExpress(Face face, OnData onData, OnTimeout onTimeout,
double maxInterestLifetime)
{
face_ = face;
callerOnData_ = onData;
callerOnTimeout_ = onTimeout;
maxInterestLifetime_ = maxInterestLifetime;
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
NetworkNack networkNack = new NetworkNack();
networkNack.setReason(net.named_data.jndn.NetworkNack.Reason.NO_ROUTE);
onNetworkNack.onNetworkNack(interest, networkNack);
}
/// <summary>
/// Create a new Entry with the given fields. Note: You should not call this
/// directly but call PendingInterestTable.add.
/// </summary>
///
public Entry(long pendingInterestId, Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
this.isRemoved_ = false;
pendingInterestId_ = pendingInterestId;
interest_ = interest;
onData_ = onData;
onTimeout_ = onTimeout;
onNetworkNack_ = onNetworkNack;
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
Assert.AssertEquals(expectedInterest_, interest.getName());
++timeoutCount_[0];
onTimeout.onTimeout(interest);
return(0);
}
public void Update()
{
try
{
var polled = false;
// poll loop to retrieve more than one data per frame
while (!polled)
{
if (_host.CheckEvents(out var netEvent) <= 0)
{
if (_host.Service(0, out netEvent) <= 0)
{
break;
}
polled = true;
}
var data = new ServerEventData(netEvent.ChannelID, netEvent.Peer.ID, netEvent.Peer.IP);
switch (netEvent.Type)
{
case EventType.Connect:
AddPeer(netEvent.Peer);
OnConnect?.Invoke(data);
NetworkRouter.PeerConnection(data.PeerId);
break;
case EventType.Disconnect:
RemovePeer(netEvent.Peer);
OnDisconnect?.Invoke(data);
NetworkRouter.PeerDisconnection(data.PeerId);
break;
case EventType.Timeout:
RemovePeer(netEvent.Peer);
OnTimeout?.Invoke(data);
NetworkRouter.PeerTimeout(data.PeerId);
break;
case EventType.Receive:
var buffer = new byte[netEvent.Packet.Length];
netEvent.Packet.CopyTo(buffer);
netEvent.Packet.Dispose();
data.Content = buffer;
OnReceive?.Invoke(data);
NetworkRouter.PeerReceive(data.PeerId, data.ChannelId, data.Content);
break;
}
}
}
catch (Exception e)
{
UnityEngine.Debug.Log("ERROR Update : " + e);
}
}
/// <summary>
/// Callback function for the RTCP report timer.
/// </summary>
/// <param name="stateInfo">Not used.</param>
private void SendReportTimerCallback(Object stateInfo)
{
try
{
if (!IsClosed)
{
lock (m_rtcpReportTimer)
{
if ((LastActivityAt != DateTime.MinValue &&
DateTime.Now.Subtract(LastActivityAt).TotalMilliseconds >
NO_ACTIVITY_TIMEOUT_MILLISECONDS) ||
(LastActivityAt == DateTime.MinValue && DateTime.Now.Subtract(CreatedAt).TotalMilliseconds >
NO_ACTIVITY_TIMEOUT_MILLISECONDS))
{
if (!IsTimedOut)
{
logger.LogWarning(
$"RTCP session for local ssrc {Ssrc} has not had any activity for over {NO_ACTIVITY_TIMEOUT_MILLISECONDS / 1000} seconds.");
IsTimedOut = true;
OnTimeout?.Invoke(MediaType);
}
}
//logger.LogDebug($"SendRtcpSenderReport ssrc {Ssrc}, last seqnum {LastSeqNum}, pkts {PacketsSentCount}, bytes {OctetsSentCount} ");
var report = GetRtcpReport();
OnReportReadyToSend?.Invoke(MediaType, report);
m_previousPacketsSentCount = PacketsSentCount;
var interval = GetNextRtcpInterval(RTCP_MINIMUM_REPORT_PERIOD_MILLISECONDS);
if (m_rtcpReportTimer == null)
{
m_rtcpReportTimer = new Timer(SendReportTimerCallback, null, interval, Timeout.Infinite);
}
else
{
m_rtcpReportTimer?.Change(interval, Timeout.Infinite);
}
}
}
}
catch (ObjectDisposedException) // The RTP socket can disappear between the null check and the report send.
{
m_rtcpReportTimer?.Dispose();
}
catch (Exception excp)
{
// RTCP reports are not critical enough to bubble the exception up to the application.
logger.LogError($"Exception SendReportTimerCallback. {excp.Message}");
m_rtcpReportTimer?.Dispose();
}
}
/// <summary>
/// Start a timeout timer for this player.
/// </summary>
/// <param name="msTimeout">Timeout interval in milliseconds.</param>
public void InitTimeout(int msTimeout)
{
timeoutTimer = new Timer(msTimeout);
timeoutTimer.Start();
timeoutTimer.Elapsed += ((_, __) =>
{
player.Drop("Loading timeout.");
OnTimeout?.Invoke();
});
}
public void IsTimeout()
{
TimeoutEventArgs e = new TimeoutEventArgs
{
Server = Server,
MaxTime =,
UtcTime = DateTime.UtcNow
};
OnTimeout?.BeginInvoke(this, e, null, null);
}
public void Update()
{
if (!_host.IsSet)
{
return;
}
var polled = false;
// poll loop to retrieve more than one data per frame
while (!polled)
{
if (_host.CheckEvents(out var netEvent) <= 0)
{
if (_host.Service(0, out netEvent) <= 0)
{
break;
}
polled = true;
}
var data = new ClientEventData(netEvent.ChannelID, netEvent.Peer.ID);
switch (netEvent.Type)
{
case EventType.Connect:
OnConnect?.Invoke(data);
NetworkRouter.PeerConnection(data.PeerId);
break;
case EventType.Disconnect:
OnDisconnect?.Invoke(data);
NetworkRouter.PeerDisconnection(data.PeerId);
break;
case EventType.Timeout:
OnTimeout?.Invoke(data);
NetworkRouter.PeerTimeout(data.PeerId);
break;
case EventType.Receive:
// Get the byte[] from the netEvent.Packet
var buffer = new byte[netEvent.Packet.Length];
netEvent.Packet.CopyTo(buffer);
netEvent.Packet.Dispose();
data.Content = buffer;
OnReceive?.Invoke(data);
NetworkRouter.PeerReceive(data.PeerId, data.ChannelId, data.Content);
break;
}
}
}
/// <summary>
/// Handles the MediaEnded event of the IntroduceMedia control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
private void ThankYouMedia_MediaEnded(object sender, RoutedEventArgs e)
{
ThankYouMedia.Stop();
ThankYouMedia.Visibility = Visibility.Hidden;
ResetMedia();
//
// Invoke the code to navigate back to the main animation screen
// This assumes the thank-you sequence is long enough. If not, then
// we'll use the timer elapsed method instead
//
OnTimeout.Invoke(sender, e);
}
private void Update()
{
instantElapsed = EditorApplication.timeSinceStartup - previousTime;
TimeElapsed += (float)instantElapsed;
//Debug.Log(TimeElapsed);
if (Passed(TotalTime))
{
Stop();
OnTimeout?.Invoke();
}
previousTime = EditorApplication.timeSinceStartup;
}
public Anonymous_C7(ThreadPoolFace paramouter_ThreadPoolFace,
OnTimeout onTimeoutSubmit_0, OnData onDataSubmit_1,
Interest interestCopy_2, WireFormat wireFormat_3,
long pendingInterestId_4, OnNetworkNack onNetworkNackSubmit_5)
{
this.onTimeoutSubmit = onTimeoutSubmit_0;
this.onDataSubmit = onDataSubmit_1;
this.interestCopy = interestCopy_2;
this.wireFormat = wireFormat_3;
this.pendingInterestId = pendingInterestId_4;
this.onNetworkNackSubmit = onNetworkNackSubmit_5;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
public void StartTimer()
{
if (Timeout <= 0.0)
{
throw new Exception(string.Format("Timeout {0} is invalid", Timeout));
}
Device.StartTimer(TimeSpan.FromSeconds(Timeout), () =>
{
OnTimeout?.Invoke(this, new EventArgs());
return(false);
});
}
public Anonymous_C3(Node paramouter_Node, Interest interestCopy_0,
OnData onData_1, WireFormat wireFormat_2, OnTimeout onTimeout_3,
long pendingInterestId_4, Face face_5, OnNetworkNack onNetworkNack_6)
{
this.interestCopy = interestCopy_0;
this.onData = onData_1;
this.wireFormat = wireFormat_2;
this.onTimeout = onTimeout_3;
this.pendingInterestId = pendingInterestId_4;
this.face = face_5;
this.onNetworkNack = onNetworkNack_6;
this.outer_Node = paramouter_Node;
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
if (interest.getName().isPrefixOf(expiredCertificate.getName()))
{
onData.onData(interest, expiredCertificate);
}
else
{
originalProcessInterest.processInterest(interest, onData,
onTimeout, onNetworkNack);
}
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
++expressInterestCallCount_[0];
Name interestName = new Name(interest.getName());
interestName.append(timeMarker_);
Assert.AssertEquals(true, outer_TestProducer.encryptionKeys.Contains(interestName));
onData.onData(interest, (Data)ILOG.J2CsMapping.Collections.Collections.Get(outer_TestProducer.encryptionKeys, interestName));
return(0);
}
private void TimerElapsed(object sender, ElapsedEventArgs e)
{
RemainingTimeInSeconds--;
ShowRemainingTime();
if (RemainingTimeInSeconds > 0)
{
return;
}
timer.Stop();
timer.Dispose();
_ = OnTimeout.InvokeAsync(OnTimeout);
}
public void processInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
CertificateV2 certificate = outer_ValidatorFixture.cache_.find(interest);
if (certificate != null)
{
onData.onData(interest, certificate);
}
else
{
onTimeout.onTimeout(interest);
}
}
public void Tick(float delta)
{
if (TTL > 0f)
{
TTL -= delta;
if (IsDone)
{
OnTimeout?.Invoke();
if (AutoRestart)
{
Start();
}
}
}
}
public override long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
Assert.AssertEquals(expectedInterest_, interest.getName());
try {
Assert.AssertEquals(3, interest.getLink().getDelegations().size());
} catch (EncodingException ex) {
Assert.Fail("Error in getLink: " + ex);
}
++timeoutCount_[0];
onTimeout.onTimeout(interest);
return(0);
}
public SyncWorld(World world, Client client, string targetId, Connection connection, int retries = 0)
{
if (connection == null || !connection.Connected)
{
connection = client.Multiplayer.CreateJoinRoom(targetId, "", true, null, null);
}
connection.OnMessage += (s, e) => {
switch (e.Type)
{
case "init":
Task.Delay(1000).Wait();
connection.Send("save");
break;
case "saved":
var status = Upload(world, client, connection, targetId);
switch (status)
{
case Status.Incomplete:
retries++;
if (retries < 16)
{
connection.Send("save");
}
else
{
connection.Disconnect();
OnTimeout.Invoke();
}
break;
case Status.Completed:
OnCompleted.Invoke();
break;
}
break;
}
};
connection.OnDisconnect += (s, e) => {
var sync = new SyncWorld(world, client, targetId, connection, retries);
};
connection.Send("init");
}
internal bool FireTimeout()
{
if (OnTimeout != null)
{
if (CalledTimeout)
{
return(false);
}
OnTimeout?.Invoke();
}
else
{
IOHandler.EnqueueTerminate(this);
}
return(false);
}
public void SetTimeout(uint msg_id, int timeout, OnTimeout timeout_callback)
{
System.Timers.Timer timer = new System.Timers.Timer();
timer.Interval = timeout * 1000;
timer.AutoReset = false;
timer.Elapsed += delegate {
timeout_callback();
};
timer.Start();
if (false == timers.ContainsKey(msg_id))
{
timers.Add(msg_id, new List <System.Timers.Timer>());
}
timers[msg_id].Add(timer);
}
public PendingInterestTable.Entry add(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack)
{
int removeRequestIndex = removeRequests_.indexOf(pendingInterestId);
if (removeRequestIndex >= 0) {
// removePendingInterest was called with the pendingInterestId returned by
// expressInterest before we got here, so don't add a PIT entry.
ILOG.J2CsMapping.Collections.Collections.RemoveAt(removeRequests_,removeRequestIndex);
return null;
}
PendingInterestTable.Entry entry = new PendingInterestTable.Entry (pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack);
ILOG.J2CsMapping.Collections.Collections.Add(table_,entry);
return entry;
}
public long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat) throws IOException {
public Anonymous_C13(ThreadPoolFace paramouter_ThreadPoolFace,
OnTimeout finalOnTimeout_0)
{
this.finalOnTimeout = finalOnTimeout_0;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData, OnTimeout onTimeout)
{
return expressInterest(name, null, onData, onTimeout,
net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, WireFormat wireFormat)
{
return expressInterest(name, interestTemplate, onData, onTimeout, null,
wireFormat);
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// This uses the default WireFormat.getDefaultWireFormat().
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
return expressInterest(name, interestTemplate, onData, onTimeout,
onNetworkNack, net.named_data.jndn.encoding.WireFormat.getDefaultWireFormat());
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy">to use.</param>
/// <param name="onData">expressInterest and data is the received Data object.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public void expressInterest(long pendingInterestId,
Interest interestCopy, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat, Face face)
{
// Set the nonce in our copy of the Interest so it is saved in the PIT.
interestCopy.setNonce(nonceTemplate_);
interestCopy.refreshNonce();
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE) {
// We are connected. Simply send the interest without synchronizing.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
return;
}
lock (onConnectedCallbacks_) {
// TODO: Properly check if we are already connected to the expected host.
if (!transport_.isAsync()) {
// The simple case: Just do a blocking connect and express.
transport_.connect(connectionInfo_, this, null);
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
// Make future calls to expressInterest send directly to the Transport.
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE;
return;
}
// Handle the async case.
if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.UNCONNECTED) {
connectStatus_ = net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED;
// expressInterestHelper will be called by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_,new Node.Anonymous_C3 (this, interestCopy, onNetworkNack, face,
onTimeout, pendingInterestId, wireFormat, onData));
IRunnable onConnected = new Node.Anonymous_C2 (this);
transport_.connect(connectionInfo_, this, onConnected);
} else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_REQUESTED) {
// Still connecting. add to the interests to express by onConnected.
ILOG.J2CsMapping.Collections.Collections.Add(onConnectedCallbacks_,new Node.Anonymous_C1 (this, interestCopy, onData, onTimeout,
onNetworkNack, wireFormat, face, pendingInterestId));
} else if (connectStatus_ == net.named_data.jndn.Node.ConnectStatus.CONNECT_COMPLETE)
// We have to repeat this check for CONNECT_COMPLETE in case the
// onConnected callback was called while we were waiting to enter this
// synchronized block.
expressInterestHelper(pendingInterestId, interestCopy, onData,
onTimeout, onNetworkNack, wireFormat, face);
else
// Don't expect this to happen.
throw new Exception("Node: Unrecognized _connectStatus "
+ connectStatus_);
}
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, WireFormat wireFormat)
{
return expressInterest(interest, onData, onTimeout, null, wireFormat);
}
/// <summary>
/// Do the work of expressInterest once we know we are connected. Add the entry
/// to the PIT, encode and send the interest.
/// </summary>
///
/// <param name="pendingInterestId"></param>
/// <param name="interestCopy"></param>
/// <param name="onData"></param>
/// <param name="onTimeout"></param>
/// <param name="onNetworkNack"></param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <param name="face"></param>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
internal void expressInterestHelper(long pendingInterestId,
Interest interestCopy, OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat, Face face)
{
PendingInterestTable.Entry pendingInterest = pendingInterestTable_
.add(pendingInterestId, interestCopy, onData, onTimeout,
onNetworkNack);
if (pendingInterest == null)
// removePendingInterest was already called with the pendingInterestId.
return;
if (onTimeout != null
|| interestCopy.getInterestLifetimeMilliseconds() >= 0.0d) {
// Set up the timeout.
double delayMilliseconds = interestCopy
.getInterestLifetimeMilliseconds();
if (delayMilliseconds < 0.0d)
// Use a default timeout delay.
delayMilliseconds = 4000.0d;
face.callLater(delayMilliseconds, new Node.Anonymous_C0 (this, pendingInterest));
}
// Special case: For timeoutPrefix_ we don't actually send the interest.
if (!timeoutPrefix_.match(interestCopy.getName())) {
Blob encoding = interestCopy.wireEncode(wireFormat);
if (encoding.size() > getMaxNdnPacketSize())
throw new Exception(
"The encoded interest size exceeds the maximum limit getMaxNdnPacketSize()");
transport_.send(encoding.buf());
}
}
public Anonymous_C11(ThreadPoolFace paramouter_ThreadPoolFace,
OnNetworkNack onNetworkNackSubmit_0, OnData onDataSubmit_1,
Interest interestCopy_2, OnTimeout onTimeoutSubmit_3,
long pendingInterestId_4, WireFormat wireFormat_5)
{
this.onNetworkNackSubmit = onNetworkNackSubmit_0;
this.onDataSubmit = onDataSubmit_1;
this.interestCopy = interestCopy_2;
this.onTimeoutSubmit = onTimeoutSubmit_3;
this.pendingInterestId = pendingInterestId_4;
this.wireFormat = wireFormat_5;
this.outer_ThreadPoolFace = paramouter_ThreadPoolFace;
}
/// <summary>
/// Encode name as an Interest. If interestTemplate is not null, use its
/// interest selectors.
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="interestTemplate"></param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the name object as required by Node.expressInterest.
node_.expressInterest(pendingInterestId,
getInterestCopy(name, interestTemplate), onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
/// <summary>
/// Encode name as an Interest, using a default interest lifetime.
/// Send the Interest through the transport, read the entire response and call
/// onData or onTimeout as described below.
/// </summary>
///
/// <param name="name">A Name for the interest. This copies the Name.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public long expressInterest(Name name, OnData onData, OnTimeout onTimeout,
WireFormat wireFormat)
{
return expressInterest(name, null, onData, onTimeout, wireFormat);
}
/// <summary>
/// Override to submit a task to use the thread pool given to the constructor.
/// Also wrap the supplied onData, onTimeout and onNetworkNack callbacks in an
/// outer callback which submits a task to the thread pool to call the supplied
/// callback. See Face.expressInterest for calling details. We make a separate
/// expressInterest overload for supplying a Name vs. Interest to avoid making
/// multiple copies of the Interest.
/// </summary>
///
public override long expressInterest(Name name, Interest interestTemplate,
OnData onData, OnTimeout onTimeout,
OnNetworkNack onNetworkNack, WireFormat wireFormat_0)
{
long pendingInterestId_1 = node_.getNextEntryId();
// Wrap callbacks to submit to the thread pool.
OnData finalOnData_2 = onData;
OnData onDataSubmit_3 = new ThreadPoolFace.Anonymous_C10 (this, finalOnData_2);
OnTimeout finalOnTimeout_4 = onTimeout;
OnTimeout onTimeoutSubmit_5 = (onTimeout == null) ? null
: new ThreadPoolFace.Anonymous_C9 (this, finalOnTimeout_4);
OnNetworkNack finalOnNetworkNack_6 = onNetworkNack;
OnNetworkNack onNetworkNackSubmit_7 = (onNetworkNack == null) ? null
: new ThreadPoolFace.Anonymous_C8 (this, finalOnNetworkNack_6);
// Make an interest copy as required by Node.expressInterest.
Interest interestCopy_8 = net.named_data.jndn.Face.getInterestCopy(name, interestTemplate);
threadPool_.submit(new ThreadPoolFace.Anonymous_C7 (this, onDataSubmit_3, onTimeoutSubmit_5, interestCopy_8,
onNetworkNackSubmit_7, wireFormat_0, pendingInterestId_1));
return pendingInterestId_1;
}
/// <summary>
/// Create a new Entry with the given fields. Note: You should not call this
/// directly but call PendingInterestTable.add.
/// </summary>
///
public Entry(long pendingInterestId, Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack)
{
this.isRemoved_ = false;
pendingInterestId_ = pendingInterestId;
interest_ = interest;
onData_ = onData;
onTimeout_ = onTimeout;
onNetworkNack_ = onNetworkNack;
}
/// <summary>
/// Send the Interest through the transport, read the entire response and call
/// onData, onTimeout or onNetworkNack as described below.
/// </summary>
///
/// <param name="interest">The Interest to send. This copies the Interest.</param>
/// <param name="onData">expressInterest and data is the received Data object. NOTE: You must not change the interest object - if you need to change it then make a copy. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onTimeout">interest given to expressInterest. If onTimeout is null, this does not use it. NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="onNetworkNack">onNetworkNack.onNetworkNack(interest, networkNack) and does not call onTimeout. However, if a network Nack is received and onNetworkNack is null, do nothing and wait for the interest to time out. (Therefore, an application which does not yet process a network Nack reason treats a Nack the same as a timeout.) NOTE: The library will log any exceptions thrown by this callback, but for better error handling the callback should catch and properly handle any exceptions.</param>
/// <param name="wireFormat">A WireFormat object used to encode the message.</param>
/// <returns>The pending interest ID which can be used with
/// removePendingInterest.</returns>
/// <exception cref="IOException">For I/O error in sending the interest.</exception>
/// <exception cref="System.Exception">If the encoded interest size exceeds getMaxNdnPacketSize().</exception>
public virtual long expressInterest(Interest interest, OnData onData,
OnTimeout onTimeout, OnNetworkNack onNetworkNack,
WireFormat wireFormat)
{
long pendingInterestId = node_.getNextEntryId();
// This copies the interest as required by Node.expressInterest.
node_.expressInterest(pendingInterestId, interest, onData, onTimeout,
onNetworkNack, wireFormat, this);
return pendingInterestId;
}
public Anonymous_C3(Node paramouter_Node, Interest interestCopy_0,
OnNetworkNack onNetworkNack_1, Face face_2, OnTimeout onTimeout_3,
long pendingInterestId_4, WireFormat wireFormat_5, OnData onData_6)
{
this.interestCopy = interestCopy_0;
this.onNetworkNack = onNetworkNack_1;
this.face = face_2;
this.onTimeout = onTimeout_3;
this.pendingInterestId = pendingInterestId_4;
this.wireFormat = wireFormat_5;
this.onData = onData_6;
this.outer_Node = paramouter_Node;
}
