Example #1
0
        void IConnectedPeerStreamExtension.OnReceivedSignalingPacket(BinaryReader reader) // manager thread
        {
            var subtPacketType = (SubtPacketType)reader.ReadByte();

            switch (subtPacketType)
            {
            case SubtPacketType.RemoteStatus:
                var p = new SubtRemoteStatusPacket(reader);
                //   SubtLocalPeer.WriteToLog($"received from peer {SubtConnectedPeer.RemotePeerId}: SUBT status packet: {p}");
                LatestRemoteStatus = p;
                _stream.MarkAsActiveByExtension();

                if (_rxBwBeforeJB.OutputPerUnit > p.RecentTxBandwidth * 5)
                {
                    EmitPainToDeveloper($"_rxBwBeforeJB.OutputPerUnit={_rxBwBeforeJB.OutputPerUnit} > p.RecentTxBandwidth={p.RecentTxBandwidth}");
                }
                break;

            case SubtPacketType.AdjustmentRequest:
                var adj = new AdjustmentRequestPacket(reader);
                SubtLocalPeer.WriteToLog($"{this} received adjustment request: {adj}");
                if (adj.TxTargetBandwidth > this.TargetTxBandwidth)
                {     // increase
                    if (SubtLocalPeer.ImHealthyAndReadyFor100kbpsU2uSymbiosis)
                    {
                        // check requested BW
                        this.TargetTxBandwidth = Math.Min(adj.TxTargetBandwidth, MaxTxBandwidthToAcceptFromRemoteSide);
                        SubtLocalPeer.WriteToLog($"{this} bandwidth increased to {MiscProcedures.BandwidthToString(this.TargetTxBandwidth)}");
                    }
                    else
                    {
                        SubtLocalPeer.WriteToLog($"{this} is not healthy to increase bandwidth");
                    }
                }
                else     // decrease
                {
                    this.TargetTxBandwidth = adj.TxTargetBandwidth;
                    SubtLocalPeer.WriteToLog($"{this} bandwidth decreased to {MiscProcedures.BandwidthToString(this.TargetTxBandwidth)}");
                }

                // respond
                var resp     = new AdjustmentResponsePacket(this.TargetTxBandwidth);
                var respData = resp.Encode(this);
                _stream.SendPacket(respData, respData.Length);
                _lastTimeReceivedAdjustmentRequestUTC = SubtLocalPeer.LocalPeer.DateTimeNowUtc;
                break;

            case SubtPacketType.AdjustmentResponse:
                var adjResp = new AdjustmentResponsePacket(reader);
                if (PendingAdjustmentRequestPacket != null)
                {     // we got response from remote peer
                    SubtLocalPeer.WriteToLog($"{this} received adjustment response: {adjResp}");
                    //  adjust local tx BW, according to remote BW. check what is responded
                    this.TargetTxBandwidth             = Math.Min(adjResp.TxTargetBandwidth, PendingAdjustmentRequestPacket.TxTargetBandwidth);
                    PendingAdjustmentRequestPacket     = null;
                    PendingAdjustmentRequestPacketData = null;
                }
                break;
            }
        }
Example #2
0
        void IConnectedPeerStreamExtension.OnReceivedSignalingPacket(BinaryReader reader) // manager thread
        {
            // 1 request of adjustment
            // 2 confirmation of adjustment
            // 3 measurements report

            var subtPacketType = (SubtPacketType)reader.ReadByte();

            switch (subtPacketType)
            {
            case SubtPacketType.RemoteStatus:
                var p = new SubtRemoteStatusPacket(reader);
                //    SubtLocalPeer.WriteToLog($"received measurement: {rxm}");
                LatestRemoteStatus = p;
                _stream.MarkAsActiveByExtension();

                if (_rxBwBeforeJB.OutputPerUnit > p.RecentTxBandwidth * 5)
                {
                    EmitPainToDeveloper($"_rxBwBeforeJB.OutputPerUnit={_rxBwBeforeJB.OutputPerUnit} > p.RecentTxBandwidth={p.RecentTxBandwidth}");
                }

                break;
                //case SubtPacketType.AdjustmentSignal:
                //    var adj = new SubtPacketAdjustmentSignal(reader);
                // //   SubtLocalPeer.WriteToLog($"received adjustment packet: {adj}");
                //    SubtConnectedPeer.LatestReceivedAdjustmentSignal = adj;
                //    break;
            }
        }
Example #3
0
        void SendStatusIfNeeded(uint timestamp32)
        {
            if (_lastTimeSentStatus == null ||
                MiscProcedures.TimeStamp1IsLess(_lastTimeSentStatus.Value + SubtLogicConfiguration.RxMeasurementsTransmissionIntervalTicks, timestamp32)
                )
            {
                _lastTimeSentStatus = timestamp32;
                var remotePeerId = SubtConnectedPeer.RemotePeerId;
                if (remotePeerId != null)
                {
                    bool iwantToIncreaseBandwidthUntilHighPacketLoss = false;
                    if (SubtLocalPeer.LocalPeer.Configuration.RoleAsUser)
                    { // initially this signal comes from user
                        iwantToIncreaseBandwidthUntilHighPacketLoss = SubtLocalPeer.Configuration.BandwidthTargetMbps == null;
                    }
                    else if (SubtLocalPeer.LocalPeer.Configuration.RoleAsSharedPassive)
                    { // and then gets reflected from sharedPassive peers
                        iwantToIncreaseBandwidthUntilHighPacketLoss = LatestRemoteStatus?.IwantToIncreaseBandwidthUntilHighPacketLoss == true;
                    }

                    var data = new SubtRemoteStatusPacket(_rxMeasurement.RecentBandwidth, _rxMeasurement.RecentPacketLoss,
                                                          this.RecentTxBandwidth,
                                                          iwantToIncreaseBandwidthUntilHighPacketLoss,
                                                          SubtLocalPeer.LocalPeer.Configuration.RoleAsSharedPassive)
                               .Encode(this);
                    _stream.SendPacket(data, data.Length);
                }
            }
        }
Example #4
0
 void SendStatusIfNeeded(uint timestamp32) // sender thread
 {
     if (_lastTimeSentStatus == null ||
         MiscProcedures.TimeStamp1IsLess(_lastTimeSentStatus.Value + SubtLogicConfiguration.SubtRemoteStatusPacketTransmissionIntervalTicks, timestamp32)
         )
     {
         _lastTimeSentStatus = timestamp32;
         var remotePeerId = SubtConnectedPeer.RemotePeerId;
         if (remotePeerId != null)
         {
             var statusPacket = new SubtRemoteStatusPacket(_rxMeasurement.RecentBandwidth, _rxMeasurement.RecentPacketLoss,
                                                           this.RecentTxBandwidth,
                                                           SubtLocalPeer.LocalPeer.Configuration.RoleAsSharedPassive,
                                                           SubtLocalPeer.ImHealthyAndReadyFor100kbpsU2uSymbiosis
                                                           );
             var data = statusPacket.Encode(this);
             _stream.SendPacket(data, data.Length);
         }
     }
 }
        void SendStatusIfNeeded(uint timestamp32) // sender thread
        {
            if (_lastTimeSentStatus == null ||
                MiscProcedures.TimeStamp1IsLess(_lastTimeSentStatus.Value + SubtLogicConfiguration.SubtRemoteStatusPacketTransmissionIntervalTicks, timestamp32)
                )
            {
                _lastTimeSentStatus = timestamp32;
                var remotePeerId = SubtConnectedPeer.RemotePeerId;
                if (remotePeerId != null)
                {
                    bool samePacketAlreadySent = false;
                    if (_lastSentSubtStatusPacket != null)
                    {
                        if (_lastSentSubtStatusPacket.ImHealthyAndReadyFor100kbpsU2uSymbiosis == SubtLocalPeer.ImHealthyAndReadyFor100kbpsU2uSymbiosis &&
                            _lastSentSubtStatusPacket.RecentTxBandwidth == this.RecentTxBandwidth &&
                            _lastSentSubtStatusPacket.RecentRxBandwidth == _rxMeasurement.RecentBandwidth)
                        {
                            samePacketAlreadySent = true;
                        }
                    }

                    if (!samePacketAlreadySent)
                    {
                        var statusPacket = new SubtRemoteStatusPacket(_rxMeasurement.RecentBandwidth, _rxMeasurement.RecentPacketLoss,
                                                                      this.RecentTxBandwidth,
                                                                      SubtLocalPeer.LocalPeer.Configuration.RoleAsSharedPassive,
                                                                      SubtLocalPeer.ImHealthyAndReadyFor100kbpsU2uSymbiosis
                                                                      );
                        //  SubtLocalPeer.WriteToLog_deepDetail($"sending SUBT status packet: {statusPacket} to peer {SubtConnectedPeer.RemotePeerId}");
                        var data = statusPacket.Encode(this);
                        _stream.SendPacket(data, data.Length);
                        _lastSentSubtStatusPacket = statusPacket;
                    }
                }
            }
        }