public void CreateClientInstanceUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
(var tlsCert, var pvtKey) = DtlsUtils.CreateSelfSignedTlsCert();
DtlsSrtpTransport dtlsTransport = new DtlsSrtpTransport(new DtlsSrtpClient(tlsCert, pvtKey));
Assert.NotNull(dtlsTransport);
}
public void GenerateLocalOfferUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
RTCPeerConnection pc = new RTCPeerConnection(null);
pc.IceSession.StartGathering();
var offer = pc.createOffer(new RTCOfferOptions());
Assert.NotNull(offer);
logger.LogDebug(offer.ToString());
}
public unsafe void DecodeKeyFrame()
{
string hexKeyFrame = "5043009d012a8002e00102c7088585889984880f0201d807f007f4040d6d4a7c9ee0d02c93ed7b7364e70f64e70f64e70c84f70681649f6bdb9b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387b27387900fefc1bddffff15ac3ace2ffc56fffffc56b0eb38bff153dd80";
byte[] keyFrame = HexStr.ParseHexStr(hexKeyFrame);
Assert.Equal(573, keyFrame.Length);
vpx_codec_ctx_t decoder = new vpx_codec_ctx_t();
vpx_codec_iface_t algo = vp8_dx.vpx_codec_vp8_dx();
vpx_codec_dec_cfg_t cfg = new vpx_codec_dec_cfg_t {
threads = 4
};
vpx_codec_err_t res = vpx_decoder.vpx_codec_dec_init(decoder, algo, cfg, 0);
Assert.Equal(vpx_codec_err_t.VPX_CODEC_OK, res);
Assert.NotNull(decoder);
fixed(byte *pKeyFrame = keyFrame)
{
var result = vpx_decoder.vpx_codec_decode(decoder, pKeyFrame, (uint)keyFrame.Length, IntPtr.Zero, 0);
Assert.Equal(vpx_codec_err_t.VPX_CODEC_OK, result);
}
IntPtr iter = IntPtr.Zero;
var img = vpx_decoder.vpx_codec_get_frame(decoder, iter);
Assert.NotNull(img);
Assert.Equal(640U, img.d_w);
Assert.Equal(480U, img.d_h);
byte[] yPlane = new byte[img.stride[0]];
byte[] uPlane = new byte[img.stride[1]];
byte[] vPlane = new byte[img.stride[2]];
Marshal.Copy((IntPtr)img.planes[0], yPlane, 0, yPlane.Length);
Marshal.Copy((IntPtr)img.planes[1], uPlane, 0, uPlane.Length);
Marshal.Copy((IntPtr)img.planes[2], vPlane, 0, vPlane.Length);
logger.LogDebug(HexStr.ToHexStr(yPlane));
logger.LogDebug(HexStr.ToHexStr(uPlane));
logger.LogDebug(HexStr.ToHexStr(vPlane));
string expectedYPlaneHexStr = "0101010101010101010101010101010100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000101010101010101010101010101010101010101010101010101010101010101";
string expectedUPlaneHexStr = "02020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202";
string expectedVPlaneHexStr = "02020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202020202";
Assert.Equal(704, yPlane.Length);
Assert.Equal(352, uPlane.Length);
Assert.Equal(352, vPlane.Length);
Assert.Equal(expectedYPlaneHexStr, HexStr.ToHexStr(yPlane));
Assert.Equal(expectedUPlaneHexStr, HexStr.ToHexStr(uPlane));
Assert.Equal(expectedVPlaneHexStr, HexStr.ToHexStr(vPlane));
}
private static Task <RTCPeerConnection> CreatePeerConnection()
{
RTCConfiguration config = new RTCConfiguration
{
iceServers = new List <RTCIceServer> {
new RTCIceServer {
urls = STUN_URL
}
}
};
var pc = new RTCPeerConnection(config);
//AudioExtrasSource audioSource = new AudioExtrasSource(new AudioEncoder(), new AudioSourceOptions { AudioSource = AudioSourcesEnum.SineWave });
//audioSource.OnAudioSourceEncodedSample += pc.SendAudio;
WindowsAudioEndPoint audioSource = new WindowsAudioEndPoint(new AudioEncoder());
audioSource.OnAudioSourceEncodedSample += pc.SendAudio;
MediaStreamTrack audioTrack = new MediaStreamTrack(audioSource.GetAudioSourceFormats(), MediaStreamStatusEnum.SendOnly);
pc.addTrack(audioTrack);
pc.OnAudioFormatsNegotiated += (audioFormats) => audioSource.SetAudioSourceFormat(audioFormats.First());
pc.onconnectionstatechange += async(state) =>
{
logger.LogDebug($"Peer connection state change to {state}.");
if (state == RTCPeerConnectionState.connected)
{
await audioSource.StartAudio();
}
else if (state == RTCPeerConnectionState.failed)
{
pc.Close("ice disconnection");
}
else if (state == RTCPeerConnectionState.closed)
{
await audioSource.CloseAudio();
}
};
// Diagnostics.
pc.OnReceiveReport += (re, media, rr) => logger.LogDebug($"RTCP Receive for {media} from {re}\n{rr.GetDebugSummary()}");
pc.OnSendReport += (media, sr) => logger.LogDebug($"RTCP Send for {media}\n{sr.GetDebugSummary()}");
pc.GetRtpChannel().OnStunMessageReceived += (msg, ep, isRelay) => logger.LogDebug($"STUN {msg.Header.MessageType} received from {ep}.");
pc.oniceconnectionstatechange += (state) => logger.LogDebug($"ICE connection state change to {state}.");
return(Task.FromResult(pc));
}
private Task <RTCPeerConnection> CreatePeerConnection()
{
var pc = new RTCPeerConnection();
// Set up sources and hook up send events to peer connection.
//AudioExtrasSource audioSrc = new AudioExtrasSource(new AudioEncoder(), new AudioSourceOptions { AudioSource = AudioSourcesEnum.None });
//audioSrc.OnAudioSourceEncodedSample += pc.SendAudio;
//var testPatternSource = new VideoTestPatternSource();
//testPatternSource.SetMaxFrameRate(true);
//testPatternSource.OnVideoSourceRawSample += VideoEncoderEndPoint.ExternalVideoSourceRawSample;
//VideoEncoderEndPoint.OnVideoSourceEncodedSample += pc.SendVideo;
// Add tracks.
//var audioTrack = new SIPSorcery.Net.MediaStreamTrack(audioSrc.GetAudioSourceFormats(), SIPSorcery.Net.MediaStreamStatusEnum.SendOnly);
//pc.addTrack(audioTrack);
var videoTrack = new MediaStreamTrack(VideoEncoderEndPoint.GetVideoSourceFormats(), MediaStreamStatusEnum.RecvOnly);
pc.addTrack(videoTrack);
// Handlers to set the codecs to use on the sources once the SDP negotiation is complete.
pc.OnVideoFormatsNegotiated += (sdpFormat) => VideoEncoderEndPoint.SetVideoSourceFormat(sdpFormat.First());
//pc.OnAudioFormatsNegotiated += (sdpFormat) => audioSrc.SetAudioSourceFormat(sdpFormat.First());
pc.OnVideoFrameReceived += VideoEncoderEndPoint.GotVideoFrame;
pc.OnTimeout += (mediaType) => logger.LogDebug($"Timeout on media {mediaType}.");
pc.oniceconnectionstatechange += (state) => logger.LogDebug($"ICE connection state changed to {state}.");
pc.onconnectionstatechange += (state) =>
{
logger.LogDebug($"Peer connection connected changed to {state}.");
if (state == RTCPeerConnectionState.connected)
{
//await audioSrc.StartAudio();
//await testPatternSource.StartVideo();
}
else if (state == RTCPeerConnectionState.closed || state == SIPSorcery.Net.RTCPeerConnectionState.failed)
{
//await audioSrc.CloseAudio();
//await testPatternSource.CloseVideo();
}
};
//pc.GetRtpChannel().OnStunMessageReceived += (msg, ep, isRelay) =>
//{
// bool hasUseCandidate = msg.Attributes.Any(x => x.AttributeType == SIPSorcery.Net.STUNAttributeTypesEnum.UseCandidate);
// logger.LogDebug($"STUN {msg.Header.MessageType} received from {ep}, use candidate {hasUseCandidate}.");
//};
return(Task.FromResult(pc));
}
public void HasStringUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
byte[] sample = Encoding.ASCII.GetBytes("The quick brown fox jumped over...");
bool hasFox = BufferUtils.HasString(sample, 0, Int32.MaxValue, "fox", null);
Assert.True(hasFox, "The string was not found in the buffer.");
}
private static async Task <RTCPeerConnection> SendOffer(WebSocketContext context)
{
logger.LogDebug($"Web socket client connection from {context.UserEndPoint}, sending offer.");
var pc = Createpc(context, _ffmpegVideoFormat);
var offerInit = pc.createOffer(null);
await pc.setLocalDescription(offerInit);
logger.LogDebug($"Sending SDP offer to client {context.UserEndPoint}.");
context.WebSocket.Send(offerInit.sdp);
return(pc);
}
public void RoundTripDataChannelOpenPacketUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
//var dataChanOpen = new DataChannelOpen("label");
//byte[] pkt = dataChanOpen.getBytes();
//logger.LogDebug(pkt.HexStr());
//var rndTripPkt = new DataChannelOpen(new ByteBuffer(pkt));
//Assert.NotNull(rndTripPkt);
//Assert.Equal(dataChanOpen.getLabel(), rndTripPkt.getLabel());
}
public void RoundtripRTCPByeUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
uint ssrc = 23;
RTCPBye bye = new RTCPBye(ssrc, null);
byte[] buffer = bye.GetBytes();
RTCPBye parsedBye = new RTCPBye(buffer);
Assert.Equal(ssrc, parsedBye.SSRC);
Assert.Null(parsedBye.Reason);
}
public void RoundtripRTCPReceiverResportUnitTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
uint ssrc = 1;
uint rrSsrc = 5;
byte fractionLost = 6;
int packetsLost = 7;
uint highestSeqNum = 8;
uint jitter = 9;
uint lastSRTimestamp = 10;
uint delaySinceLastSR = 11;
var rr = new ReceptionReportSample(rrSsrc, fractionLost, packetsLost, highestSeqNum, jitter, lastSRTimestamp, delaySinceLastSR);
var receiverReport = new RTCPReceiverReport(ssrc, new List <ReceptionReportSample> {
rr
});
byte[] buffer = receiverReport.GetBytes();
RTCPReceiverReport parsedRR = new RTCPReceiverReport(buffer);
Assert.Equal(ssrc, parsedRR.SSRC);
Assert.Equal(rrSsrc, parsedRR.ReceptionReports.First().SSRC);
Assert.Equal(fractionLost, parsedRR.ReceptionReports.First().FractionLost);
Assert.Equal(packetsLost, parsedRR.ReceptionReports.First().PacketsLost);
Assert.Equal(highestSeqNum, parsedRR.ReceptionReports.First().ExtendedHighestSequenceNumber);
Assert.Equal(jitter, parsedRR.ReceptionReports.First().Jitter);
Assert.Equal(lastSRTimestamp, parsedRR.ReceptionReports.First().LastSenderReportTimestamp);
Assert.Equal(delaySinceLastSR, parsedRR.ReceptionReports.First().DelaySinceLastSenderReport);
}
private async Task sendEventHubData()
{
_logger.LogDebug($"Begin Sending Data to Event Hub");
List <EventData> eventData = MessageEntity.GetBatch(_config.Value.BatchSize);
// Create a batch of events
using EventDataBatch eventBatch = await ehProducerClient.CreateBatchAsync();
foreach (var item in eventData)
{
eventBatch.TryAdd(item);
}
// Use the producer client to send the batch of events to the event hub
await ehProducerClient.SendAsync(eventBatch);
//this code has to be reviewed as it seems not calculating properly the kpi :)
if ((double)MessageEntity.CurrentGen % 1000.0 == 0)
{
var now = DateTime.UtcNow;
TimeSpan elapsedTime = now - lastMetric;
lastMetric = now;
var totals = elapsedTime.TotalSeconds;
var messSec = 1000.0 / totals;
//toreview this calculation
_logger.LogInformation($"{Guid.Empty},Sending {messSec} message / seconds");
}
}
public IJournalSubscription Subscribe(long from, Action <JournalRecord> handler)
{
long?checkPoint = null;
if (from > 0)
{
checkPoint = from - 1;
}
var ready = false;
var sub = _connection.SubscribeToStreamFrom(
stream: _streamName,
lastCheckpoint: checkPoint,
settings: new CatchUpSubscriptionSettings(10000, 4096, false, false),
eventAppeared: (s, re) =>
{
_logger.LogDebug("eventAppeared, recordNumber {0}", re.OriginalEventNumber);
handler.Invoke(re.Event.ToJournalRecord(_serializer));
},
liveProcessingStarted: s =>
{
ready = true;
_logger.LogInformation("liveProcessingStarted");
});
return(new EventStoreSubscriptionAdapter(_memstateSettings, sub, () => ready));
}
public void SeverityTest()
{
var testSink = new TestSink();
LoggerConfiguration TestSinkMap(LoggerSinkConfiguration loggerSinkConfiguration)
=> loggerSinkConfiguration.Sink(testSink);
ILogger logger = Logger.GetLoggerFactory(LogEventLevel.Debug, TestSinkMap).CreateLogger("test");
Assert.NotNull(logger);
logger.LogInformation("Test message");
List <LogEvent> emittedEvents = testSink.GetEmittedEvents();
Assert.Equal("6", emittedEvents[0].Properties["Severity"].ToString());
testSink.Reset();
logger.LogDebug("Test message");
emittedEvents = testSink.GetEmittedEvents();
Assert.Equal("7", emittedEvents[0].Properties["Severity"].ToString());
testSink.Reset();
logger.LogWarning("Test message");
emittedEvents = testSink.GetEmittedEvents();
Assert.Equal("4", emittedEvents[0].Properties["Severity"].ToString());
testSink.Reset();
logger.LogError("Test message");
emittedEvents = testSink.GetEmittedEvents();
Assert.Equal("3", emittedEvents[0].Properties["Severity"].ToString());
}
public void Log(MessageLevel level, [CanBeNull] string message, [NotNull, ItemNotNull] params object[] args)
{
if (string.IsNullOrWhiteSpace(message))
{
return;
}
// ReSharper disable once SwitchStatementMissingSomeCases
switch (level)
{
case MessageLevel.Debug:
_logger.LogTrace(message, args);
break;
case MessageLevel.Info:
_logger.LogDebug(message, args);
break;
case MessageLevel.Warning:
_logger.LogWarning(message, args);
break;
case MessageLevel.Error:
_logger.LogError(message, args);
break;
}
}
public static async Task Orchestrator([OrchestrationTrigger] DurableOrchestrationContext context, ILogger log)
{
var fileName = context.GetInput <string>();
var wineCountries = await context.CallActivityAsync <Countries[]>("A_ExtractWineCountries", fileName);
var tasks = new List <Task <Wine[]> >();
foreach (Countries wineCountry in wineCountries)
{
tasks.Add(context.CallActivityAsync <Wine[]>("A_ExtractWines", wineCountry));
}
var wineTasks = await Task.WhenAll(tasks);
List <Task> uploadWineTasks = new List <Task>();
foreach (Wine wineTask in wineTasks.SelectMany(x => x))
{
uploadWineTasks.Add(context.CallActivityAsync("A_UploadWine", wineTask));
}
await Task.WhenAll(uploadWineTasks);
if (!context.IsReplaying)
{
log.LogDebug($"Finished file: {fileName}");
}
}
/// <summary>
/// Gets the grant.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public async Task <PersistedGrant> GetAsync(string key)
{
using (ISession session = _context.GetDriver().Session())
{
Node n = new Node(type: typeof(PersistedGrant));
PersistedGrant result = await session.AsAsync(s =>
s.ExecuteQuery <PersistedGrant>($"MATCH (n{n.Labels} {{{nameof(PersistedGrant.Key)}:${nameof(key)}}}) " +
$"RETURN n"
, new { key }).FirstOrDefault());
_logger.LogDebug("{persistedGrantKey} found in database: {persistedGrantKeyFound}", key, result != null);
return(result);
}
}
public static Microsoft.Extensions.Logging.ILogger CreateILoggerFromNLog(bool debug = false)
{
// NLog build Example for microsoft ILogger find on :
// https://stackoverflow.com/questions/56534730/nlog-works-in-asp-net-core-app-but-not-in-net-core-xunit-test-project
var configuration = new NLog.Config.LoggingConfiguration();
configuration.AddRuleForAllLevels(new NLog.Targets.ConsoleTarget());
NLog.Web.NLogBuilder.ConfigureNLog(configuration);
// Create provider to bridge Microsoft.Extensions.Logging
var provider = new NLog.Extensions.Logging.NLogLoggerProvider();
// Create logger
Microsoft.Extensions.Logging.ILogger logger = provider.CreateLogger(typeof(DnsSrvToolsIntergrationTest).FullName);
if (debug)
{
logger.LogDebug("This is a test of the log system : LogDebug.");
logger.LogTrace("This is a test of the log system : LogTrace.");
logger.LogInformation("This is a test of the log system : LogInformation.");
logger.LogWarning("This is a test of the log system : LogWarning.");
logger.LogError("This is a test of the log system : LogError.");
logger.LogCritical("This is a test of the log system : LogCritical.");
}
return(logger);
}
public static void Run(ILogger logger)
{
OnlineClient client = Bootstrap.Client(logger);
logger.LogInformation("Executing create test object function to API");
TestObjectCreate create = new TestObjectCreate()
{
Name = "hello world",
};
Task <OnlineResponse> createTask = client.Execute(create);
createTask.Wait();
OnlineResponse createResponse = createTask.Result;
Result createResult = createResponse.Results[0];
try
{
int recordNo = int.Parse(createResult.Data[0].Element("id").Value);
Console.WriteLine("Created record ID " + recordNo.ToString());
}
catch (NullReferenceException e)
{
logger.LogDebug("No response in Data. {0}", e);
}
finally
{
LogManager.Flush();
}
}
public async Task PollForChanges()
{
while (!_server.Manager.CancellationToken.IsCancellationRequested)
{
if (_server.IsInitialized)
{
try
{
await UpdateLogEvents();
}
catch (Exception e)
{
using (LogContext.PushProperty("Server", _server.ToString()))
{
_logger.LogError(e, "Failed to update log event for {endpoint}", _server.EndPoint);
}
}
}
await Task.Delay(_reader.UpdateInterval, _server.Manager.CancellationToken);
}
_logger.LogDebug("Stopped polling for changes");
}
public UtilityBase(Option option)
{
this.Options = option;
serilogLogger = new SetupSerilog().Configure(ConfigureLogging).Create();
var env = EnvironmentSetting.DOTNET_ENVIRONMENT;
IHostBuilder hostBuilder = Host.CreateDefaultBuilder().UseSerilog();
var configBuilder = new ConfigurationBuilder()
.SetBasePath(CurrentDirectory)
.AddJsonFile("appsettings.json", false, true);
if (!string.IsNullOrEmpty(env.Value))
{
configBuilder.AddJsonFile($"appsettings.{env.Value}.json", true, true);
}
var configuration = configBuilder.AddEnvironmentVariables().Build();
host = hostBuilder.ConfigureAppConfiguration(builder => {
builder.Sources.Clear();
builder.AddConfiguration(configuration);
}).ConfigureServices((ctx, svc) => RegisterServices(ctx.Configuration, env, svc)).Build();
logger = host.Services.GetRequiredService <Microsoft.Extensions.Logging.ILogger>();
logger.LogDebug("Logging initialized for {type} instance", this.GetType().Name);
Init(host.Services.GetRequiredService <IConfiguration>(), host.Services);
}
public IEnumerable <JournalRecord> GetRecords(long fromRecord = 0)
{
var nextRecord = fromRecord;
_logger.LogInformation("GetRecords from {0}", nextRecord);
while (true)
{
var slice = _connection.ReadStreamEventsForwardAsync(_streamName, nextRecord, _eventsPerSlice, false).Result;
_logger.LogDebug("{0} events in slice from {0}", slice.Events.Length, slice.FromEventNumber);
foreach (var @event in slice.Events.Select(e => e.Event))
{
yield return(@event.ToJournalRecord(_serializer));
}
if (slice.IsEndOfStream)
{
break;
}
nextRecord = slice.NextEventNumber;
}
_logger.LogInformation("GetRecords completed");
}
public void RTSPRequestWIthStandardHeadersParseTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
int cseq = 23;
string session = Guid.NewGuid().ToString();
string body = "v=0" + m_CRLF +
"o=- 2890844526 2890842807 IN IP4 192.16.24.202" + m_CRLF +
"s=RTSP Session" + m_CRLF +
"m=audio 3456 RTP/AVP 0" + m_CRLF +
"a=control:rtsp://live.example.com/concert/audio" + m_CRLF +
"c=IN IP4 224.2.0.1/16";
RTSPResponse describeResponse = new RTSPResponse(RTSPResponseStatusCodesEnum.OK, null);
describeResponse.Header = new RTSPHeader(cseq, session);
describeResponse.Body = body;
byte[] buffer = Encoding.UTF8.GetBytes(describeResponse.ToString());
RTSPMessage rtspMessage = RTSPMessage.ParseRTSPMessage(buffer, null, null);
Assert.Equal(RTSPMessageTypesEnum.Response, rtspMessage.RTSPMessageType);
Assert.Equal(body, rtspMessage.Body);
}
public void JsonRoundtripUnitTest()
{
RTCPeerConnection pcSrc = new RTCPeerConnection(null);
var videoTrackSrc = new MediaStreamTrack(SDPMediaTypesEnum.video, false, new List <SDPAudioVideoMediaFormat> {
new SDPAudioVideoMediaFormat(SDPMediaTypesEnum.video, 96, "VP8", 90000)
});
pcSrc.addTrack(videoTrackSrc);
var offer = pcSrc.createOffer(new RTCOfferOptions());
Assert.NotNull(offer.toJSON());
logger.LogDebug($"offer: {offer.toJSON()}");
var parseResult = RTCSessionDescriptionInit.TryParse(offer.toJSON(), out var init);
Assert.True(parseResult);
Assert.Equal(RTCSdpType.offer, init.type);
Assert.NotNull(init.sdp);
SDP sdp = SDP.ParseSDPDescription(init.sdp);
Assert.Equal(0, sdp.Version);
}
public ScaniiClientTests()
{
var serilogLogger = new LoggerConfiguration()
.WriteTo.Console()
.MinimumLevel.Is(LogEventLevel.Debug)
.CreateLogger();
var provider = new SerilogLoggerProvider(serilogLogger);
_logger = provider.CreateLogger("ScaniiClientTests");
_logger.LogDebug("ctor");
if (Environment.GetEnvironmentVariable("SCANII_CREDS") != null)
{
// ReSharper disable once PossibleNullReferenceException
var credentials = Environment.GetEnvironmentVariable("SCANII_CREDS").Split(':');
_key = credentials[0];
_secret = credentials[1];
}
Debug.Assert(_secret != null, nameof(_secret) + " != null");
Debug.Assert(_key != null, nameof(_key) + " != null");
_client = ScaniiClients.CreateDefault(_key, _secret, _logger, new HttpClient());
}
/// <summary>
/// This method posts debug messages onto CloudWatchLogs.
/// </summary>
/// <param name="count">The number of messages that would be posted onto CloudWatchLogs</param>
public void ILoggerThread(int count)
{
for (int i = 0; i < count; i++)
{
logger.LogDebug(string.Format("Test logging message {0} Ilogger, Thread Id:{1}", i, Thread.CurrentThread.ManagedThreadId));
}
}
public void RTSPTransportHeaderParseTest()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
string header = "RTP/AVP;unicast;destination=192.168.33.170;source=192.168.33.103;client_port=61132-61133;server_port=6970-6971";
var transportHeader = RTSPTransportHeader.Parse(header);
Assert.Equal("RTP/AVP", transportHeader.TransportSpecifier);
Assert.Equal("unicast", transportHeader.BroadcastType);
Assert.Equal("192.168.33.170", transportHeader.Destination);
Assert.Equal("192.168.33.103", transportHeader.Source);
Assert.Equal("61132-61133", transportHeader.ClientRTPPortRange);
Assert.Equal("6970-6971", transportHeader.ServerRTPPortRange);
}
public void KeySaltBase64Test()
{
logger.LogDebug("--> " + System.Reflection.MethodBase.GetCurrentMethod().Name);
logger.BeginScope(System.Reflection.MethodBase.GetCurrentMethod().Name);
SDPSecurityDescription.KeyParameter keyParameter = KeyParameterFactory.Create("ĀĀ\0\0\0\0\0\0\0\0\0\0\0\0\0\0", "ĀĀĀ\0\0\0\0\0\0\0\0\0\0\0");
Assert.NotNull((object)keyParameter);
Assert.Equal(Encoding.ASCII.GetBytes("ĀĀ\0\0\0\0\0\0\0\0\0\0\0\0\0\0"), keyParameter.Key);
Assert.Equal(Encoding.ASCII.GetBytes("ĀĀĀ\0\0\0\0\0\0\0\0\0\0\0"), keyParameter.Salt);
Assert.Equal(0uL, keyParameter.LifeTime);
Assert.Equal((string)null, keyParameter.LifeTimeString);
Assert.Equal(0u, keyParameter.MkiValue);
Assert.Equal(0u, keyParameter.MkiLength);
Assert.Equal(40, keyParameter.KeySaltBase64.Length);
}
public MockTurnServer(IPAddress listenAddress, int port)
{
_listenAddress = listenAddress;
_listenPort = port;
NetServices.CreateRtpSocket(false, _listenAddress, 0, out _clientSocket, out _);
ListeningEndPoint = _clientSocket.LocalEndPoint as IPEndPoint;
logger.LogDebug($"MockTurnServer listening on {ListeningEndPoint}.");
_listener = new UdpReceiver(_clientSocket);
_listener.OnPacketReceived += OnPacketReceived;
_listener.OnClosed += (reason) => logger.LogDebug($"MockTurnServer on {ListeningEndPoint} closed.");
_listener.BeginReceiveFrom();
}
public Task <List <string> > GetAsync()
{
_logger.LogDebug("Recieved Value Request.");
var valueSequence = _busClient.ExecuteSequence(s => s
.PublishAsync(new ValuesRequested
{
NumberOfValues = _random.Next(1, 10)
})
.When <ValueCreationFailed>(
(failed, context) =>
{
_logger.LogWarning("Unable to create Values. Exception: {0}", failed.Exception);
return(Task.CompletedTask);
}, it => it.AbortsExecution())
.Complete <ValuesCalculated>()
);
return(valueSequence.Task.ContinueWith(tResponse =>
{
if (tResponse.IsFaulted)
{
throw new Exception("No response recieved. Is the Console App started?");
}
_logger.LogInformation("Successfully created {valueCount} values", tResponse.Result.Values.Count);
return valueSequence.Aborted
? new List <string>()
: tResponse.Result.Values;
}));
}
static void Main()
{
Console.WriteLine("SIPSorcery Getting Started Demo");
Log = AddConsoleLogger();
_waveFile = new WaveFileWriter("output.mp3", _waveFormat);
_sipTransport = new SIPTransport();
_sipTransport.AddSIPChannel(new SIPUDPChannel(new IPEndPoint(IPAddress.Any, SIP_LISTEN_PORT)));
var userAgent = new SIPUserAgent(_sipTransport, null, true);
userAgent.ServerCallCancelled += (uas) => Log.LogDebug("Incoming call cancelled by remote party.");
userAgent.OnCallHungup += (dialog) => _waveFile?.Close();
userAgent.OnIncomingCall += async(ua, req) =>
{
WindowsAudioEndPoint winAudioEP = new WindowsAudioEndPoint(new AudioEncoder());
VoIPMediaSession voipMediaSession = new VoIPMediaSession(winAudioEP.ToMediaEndPoints());
voipMediaSession.AcceptRtpFromAny = true;
voipMediaSession.OnRtpPacketReceived += OnRtpPacketReceived;
var uas = userAgent.AcceptCall(req);
await userAgent.Answer(uas, voipMediaSession);
};
Console.WriteLine("press any key to exit...");
Console.Read();
// Clean up.
_sipTransport.Shutdown();
}
