private async Task StopAsync()
{
try
{
if (_processor != null)
{
await _processor.StopAsync(_application);
}
}
catch (Exception ex)
{
_logger?.LogError(ex, "Error while shutting down");
}
finally
{
if (DashboardWebApplication != null)
{
// Stop the host after everything else has been shutdown
try
{
await DashboardWebApplication.StopAsync();
}
catch (OperationCanceledException)
{
// ignore cancellation failures from stop async
}
}
}
_processor = null;
}
/// <summary>
/// Starts the subscription
/// </summary>
/// <summary>
/// Starts the subscription
/// </summary>
public async Task Start()
{
if (_disposed)
{
throw new ObjectDisposedException($"{typeof(JsonRpcSubscription).FullName}@{this.GetHashCode()}");
}
if (!_client.IsConnected)
{
_client.Connect();
}
if (_subscription != null)
{
await _client.UnsubAsync(_subscription);
_subscription = null;
}
_subscription = await _client.SubAsync(_sInfo, stream => stream.Subscribe(msg =>
{
try
{
byte[] resp = OnMessage(msg.Payload);
_client.Pub(msg.ReplyTo, resp);
}
catch (Exception ex)
{
_logger?.LogError(ex, "Error publishing NATS message");
}
}, error => {
_logger?.LogError(error, "Fatal error in NATS subscription handler");
}));
}
public static QueryBoostingContext Load(string fileName, ILoader loader, FrameworkLogger logger)
{
try
{
using (var reader = loader.GetReader(fileName))
{
var serializer = new JsonSerializer();
var value = serializer.Deserialize<QueryBoostingContext>(reader);
return value;
}
}
catch (Exception ex)
{
if (IndexingUtils.IsFatal(ex))
{
throw;
}
logger.LogError($"Unable to load {fileName}.", ex);
}
return Default;
}
public NugetPackage(ILogger logger)
{
_logger = logger;
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException ex)
{
// create default settings using a non-existent config file
settings = new Settings(nameof(Script.ScriptRunner));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings);
_packageSources = SettingsUtility.GetEnabledSources(settings);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance,
nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
}
catch (Exception e)
{
_logger?.LogError(e.Message + e.StackTrace);
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public async Task WriteResponseAsync(IOwinContext context, Exception e, FrameworkLogger logger)
{
logger.LogError("Internal server error", e);
await WriteResponseAsync(context, HttpStatusCode.InternalServerError, JObject.FromObject(new
{
error = "Internal server error",
httpRequestId = context.Get<string>(CorrelationIdMiddleware.CorrelationIdHeaderKey)
}));
}
public static void Load(string name, ILoader loader, FrameworkLogger logger, IDictionary<string, HashSet<string>> targetDictionary)
{
try
{
using (var jsonReader = loader.GetReader(name))
{
UpdateDictionary(jsonReader, targetDictionary);
}
}
catch (Exception e)
{
if (IsFatal(e))
{
throw;
}
logger.LogError($"Unable to load {name}.", e);
}
}
public NugetPackage(ILogger logger, NugetManager manager)
{
_manager = manager;
_logger = logger;
try
{
ISettings settings;
try
{
settings = Settings.LoadDefaultSettings(
root: null,
configFileName: null,
machineWideSettings: new XPlatMachineWideSetting());
}
catch (NuGetConfigurationException)
{
// create default settings using a non-existent config file
settings = new Settings(nameof(NugetPackage));
}
GlobalPackageFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
_configFilePaths = new List <string>(); //SettingsUtility.GetConfigFilePaths(settings);
var sources = SettingsUtility.GetEnabledSources(settings);
_packageSources = _manager.AdditionalSources.Select(p => new PackageSource(p.source, p.name)).Concat(sources).ToList();
DefaultCredentialServiceUtility.SetupDefaultCredentialService(NullLogger.Instance,
nonInteractive: false);
var sourceProvider = new PackageSourceProvider(settings);
var providers = new List <Lazy <INuGetResourceProvider> >();
providers.AddRange(Repository.Provider.GetCoreV3());
_sourceRepositories = _packageSources.Select(s => new SourceRepository(s, providers)).ToList();
}
catch (Exception e)
{
_logger?.LogError(e.Message + e.StackTrace);
_initializationException = ExceptionDispatchInfo.Capture(e);
}
}
public static async Task OnCreateLeagueCommandHandlerOrchestrator
([OrchestrationTrigger] DurableOrchestrationContext context,
Microsoft.Extensions.Logging.ILogger log)
{
CommandRequest <Create_New_League_Definition> cmdRequest = context.GetInput <CommandRequest <Create_New_League_Definition> >();
if (null != cmdRequest)
{
ActivityResponse resp = await context.CallActivityWithRetryAsync <ActivityResponse>("CreateLeagueCommandLogParametersActivity",
DomainSettings.CommandRetryOptions(),
cmdRequest);
Create_New_League_Definition parameters = cmdRequest.GetParameters();
IEnumerable <CommandNotificationImpactedEntity> impactedEntities = null;
if (null != parameters)
{
Tuple <string, string>[] entitiesImpacted = new Tuple <string, string>[] { new Tuple <string, string>(@"League", parameters.LeagueName) };
impactedEntities = CommandNotificationImpactedEntity.CreateImpactedEntityList(entitiesImpacted);
}
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
if (!resp.FatalError)
{
// validate the command
bool valid = await context.CallActivityWithRetryAsync <bool>("CreateLeagueCommandValidationActivity",
DomainSettings.CommandRetryOptions(),
cmdRequest);
if (!valid)
{
resp.Message = $"Validation failed for command {cmdRequest.CommandName} id: {cmdRequest.CommandUniqueIdentifier }";
resp.FatalError = true;
}
}
if (!resp.FatalError)
{
CommandStepResponse stepResponse = new CommandStepResponse()
{
CommandName = cmdRequest.CommandName,
CommandUniqueIdentifier = cmdRequest.CommandUniqueIdentifier,
StepName = resp.FunctionName,
Message = resp.Message,
ImpactedEntities = impactedEntities
};
resp = await context.CallActivityAsync <ActivityResponse>("CommandStepCompleteActivity", stepResponse);
}
if (!resp.FatalError)
{
// execute the command
resp = await context.CallActivityWithRetryAsync <ActivityResponse>("CreateLeagueCommandHandlerAction",
DomainSettings.CommandRetryOptions(),
cmdRequest);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
}
if (!resp.FatalError)
{
// 3) Mark the step as complete
CommandStepResponse stepResponse = new CommandStepResponse()
{
CommandName = cmdRequest.CommandName,
CommandUniqueIdentifier = cmdRequest.CommandUniqueIdentifier,
StepName = resp.FunctionName,
Message = resp.Message,
ImpactedEntities = impactedEntities
};
resp = await context.CallActivityAsync <ActivityResponse>("CommandStepCompleteActivity", stepResponse);
}
if (!resp.FatalError)
{
resp = await context.CallActivityAsync <ActivityResponse>("CommandCompleteActivity", cmdRequest);
}
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
// Fire the orchestration to do the actual work of sending notifications
Command_Get_Notifications_Request payload = new Command_Get_Notifications_Request()
{
CommandName = cmdRequest.CommandName,
CommandUniqueIdentifier = cmdRequest.CommandUniqueIdentifier.ToString()
};
// call the orchestrator...
resp = await context.CallSubOrchestratorAsync <ActivityResponse>("CommandNotificationOrchestrator", payload);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
}
else
{
#region Logging
if (null != log)
{
// Unable to get the request details from the orchestration
log.LogError("OnCreateLeagueCommandHandlerOrchestrator : Unable to get the command request from the context");
string contextAsString = context.GetInput <string>();
if (!string.IsNullOrWhiteSpace(contextAsString))
{
log.LogError($"Context was {contextAsString} ");
}
else
{
log.LogError($"Context was blank ");
}
}
#endregion
return;
}
}
public static async Task <ActivityResponse> QueryProjectionProcessorOrchestrator(
[OrchestrationTrigger] DurableOrchestrationContext context,
Microsoft.Extensions.Logging.ILogger log)
{
ActivityResponse response = new ActivityResponse()
{
FunctionName = "QueryProjectionProcessorOrchestrator"
};
Query_Projections_Projection_Request request = context.GetInput <Query_Projections_Projection_Request>();
if (null != request)
{
Guid UniqueIdentifierGuid;
if (!Guid.TryParse(request.UniqueIdentifier, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(request.CallbackOrchestrationIdentifier, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(context.ParentInstanceId, out UniqueIdentifierGuid))
{
if (!Guid.TryParse(context.InstanceId, out UniqueIdentifierGuid))
{
UniqueIdentifierGuid = Guid.NewGuid();
}
}
}
}
// get all the projection requests for the query
List <Query_Projections_Projection_Return> allProjections = await context
.CallActivityWithRetryAsync <List <Query_Projections_Projection_Return> >("GetQueryProjectionsStatusProjectionActivity",
DomainSettings.QueryRetryOptions(),
request);
if (null != allProjections)
{
#region Logging
if (null != log)
{
log.LogInformation($"Query {request.QueryName}.{request.UniqueIdentifier} has {allProjections.Count} projections total ");
}
#endregion
// Run them - This should be done by fan-out/fan-in
List <Task <ProjectionResultsRecord <object> > > allProjectionTasks = new List <Task <ProjectionResultsRecord <object> > >();
// run all the outstanding projections in parallel
foreach (Query_Projections_Projection_Return projectionRequest in allProjections)
{
if (projectionRequest.ProjectionState == Query_Projections_Projection_Return.QueryProjectionState.Queued)
{
ProjectionRequest projRequest = new ProjectionRequest()
{
ParentRequestName = request.QueryName,
CorrelationIdentifier = UniqueIdentifierGuid,
DomainName = projectionRequest.Projection.DomainName,
AggregateTypeName = projectionRequest.Projection.AggregateTypeName,
AggregateInstanceUniqueIdentifier = projectionRequest.Projection.InstanceKey,
AsOfDate = request.AsOfDate,
ProjectionName = projectionRequest.Projection.ProjectionTypeName
};
if (null != projRequest)
{
context.SetCustomStatus(projRequest);
}
// mark it as in-flight
response = await context.CallActivityWithRetryAsync <ActivityResponse>("LogQueryProjectionInFlightActivity",
DomainSettings.QueryRetryOptions(),
projRequest);
if (null != response)
{
context.SetCustomStatus(response);
}
}
}
// Now start them running using a fan-out/fan in pattern
foreach (Query_Projections_Projection_Return projectionRequested in allProjections)
{
if (projectionRequested.ProjectionState == Query_Projections_Projection_Return.QueryProjectionState.Queued)
{
ProjectionRequest projectionRequest = new ProjectionRequest()
{
ParentRequestName = request.QueryName,
CorrelationIdentifier = UniqueIdentifierGuid,
DomainName = projectionRequested.Projection.DomainName,
AggregateTypeName = projectionRequested.Projection.AggregateTypeName,
AggregateInstanceUniqueIdentifier = projectionRequested.Projection.InstanceKey,
AsOfDate = request.AsOfDate,
ProjectionName = projectionRequested.Projection.ProjectionTypeName
};
// and start running it...
allProjectionTasks.Add(context.CallActivityWithRetryAsync <ProjectionResultsRecord <object> >("RunProjectionActivity",
DomainSettings.QueryRetryOptions(),
projectionRequest));
}
}
// Run the projections in parallel...
await Task.WhenAll(allProjectionTasks);
// and save their results to the query
foreach (var returnValue in allProjectionTasks)
{
ProjectionResultsRecord <object> result = returnValue.Result;
if (null != result)
{
if (!result.Error)
{
response = await context.CallActivityWithRetryAsync <ActivityResponse>("LogQueryProjectionResultActivity",
DomainSettings.QueryRetryOptions(),
result);
}
else
{
#region Logging
if (null != log)
{
log.LogError($"Error running projection {result.ProjectionName} - {result.StatusMessage} ");
}
#endregion
response.Message = $"Error running projection {result.ProjectionName} - {result.StatusMessage} ";
}
if (null != response)
{
context.SetCustomStatus(response);
}
}
else
{
#region Logging
if (null != log)
{
log.LogError($"Projection {returnValue.Id} did not return any values : {returnValue.Exception}");
}
#endregion
}
}
}
// when all done - trigger the calling orchestration to come out of hibernation
if (!string.IsNullOrWhiteSpace(request.CallbackOrchestrationIdentifier))
{
}
}
else
{
response.Message = $"Unable to read projection request data from context {context.InstanceId}";
response.FatalError = true;
}
return(response);
}
public void LogError(Exception ex, string message)
{
_functionLogger.LogError(ex, message, _source);
_redisLogger.Error(ex, message);
}
public void Error(string message)
{
_logger.LogError(message);
}
/// <summary>
/// Process user key presses.
/// </summary>
/// <param name="exit">The cancellation token to set if the user requests to quit the application.</param>
private static void OnKeyPress(CancellationTokenSource exitCts)
{
try
{
while (!exitCts.IsCancellationRequested)
{
var keyProps = Console.ReadKey();
if (keyProps.KeyChar == 'c')
{
// Set up a default SIP transport.
var sipTransport = new SIPTransport();
//EnableTraceLogs(sipTransport);
var targetUri = SIPURI.ParseSIPURI(TARGET_DST);
int requestedDtmfCode = Crypto.GetRandomInt(4);
targetUri.User = requestedDtmfCode.ToString();
SIPUserAgent ua = new SIPUserAgent(sipTransport, null, true);
CallRecord cr = new CallRecord {
UA = ua, RequestedDtmfCode = requestedDtmfCode, ReceivedDtmfCode = ""
};
// Place an outgoing call.
ua.ClientCallTrying += (uac, resp) => Log.LogInformation($"{uac.CallDescriptor.To} Trying: {resp.StatusCode} {resp.ReasonPhrase}.");
ua.ClientCallRinging += (uac, resp) => Log.LogInformation($"{uac.CallDescriptor.To} Ringing: {resp.StatusCode} {resp.ReasonPhrase}.");
ua.ClientCallFailed += (uac, err, resp) => Log.LogWarning($"{uac.CallDescriptor.To} Failed: {err}, Status code: {resp?.StatusCode}");
ua.ClientCallAnswered += (uac, resp) => Log.LogInformation($"{uac.CallDescriptor.To} Answered: {resp.StatusCode} {resp.ReasonPhrase}.");
ua.OnDtmfTone += (key, duration) =>
{
cr.ReceivedDtmfCode = cr.ReceivedDtmfCode.Insert(0, key.ToString());
Log.LogInformation($"Received DTMF tone {key} {cr.ReceivedDtmfCode}.");
};
//ua.OnRtpEvent += (evt, hdr) => Log.LogDebug($"transferee rtp event {evt.EventID}, ssrc {hdr.SyncSource}, duration {evt.Duration}, end of event {evt.EndOfEvent}, timestamp {hdr.Timestamp}, marker {hdr.MarkerBit}.");
ua.OnCallHungup += (dialog) => Log.LogDebug("Call hungup by remote party.");
Task.Run(async() =>
{
var rtpSession = CreateRtpSession();
var callResult = await ua.Call(targetUri.ToString(), null, null, rtpSession);
if (!callResult)
{
Log.LogWarning($"Call to {targetUri} failed.");
}
else
{
Log.LogInformation($"Call to {targetUri} was successful.");
_calls.TryAdd(ua.Dialogue.CallId, cr);
}
});
}
else if (keyProps.KeyChar == 'h')
{
if (_calls.Count == 0)
{
Log.LogWarning("There are no active calls.");
}
else
{
var oldestCall = _calls.OrderBy(x => x.Value.UA.Dialogue.Inserted).First();
Log.LogInformation($"Hanging up call {oldestCall.Key}.");
oldestCall.Value.UA.OnCallHungup -= OnHangup;
oldestCall.Value.UA.Hangup();
_calls.TryRemove(oldestCall.Key, out _);
}
}
else if (keyProps.KeyChar == 'H')
{
if (_calls.Count == 0)
{
Log.LogWarning("There are no active calls.");
}
else
{
foreach (var call in _calls)
{
Log.LogInformation($"Hanging up call {call.Key}.");
call.Value.UA.OnCallHungup -= OnHangup;
call.Value.UA.Hangup();
}
_calls.Clear();
}
}
else if (keyProps.KeyChar == 'l')
{
if (_calls.Count == 0)
{
Log.LogInformation("There are no active calls.");
}
else
{
Log.LogInformation("Current call list:");
foreach (var call in _calls)
{
int duration = Convert.ToInt32(DateTimeOffset.Now.Subtract(call.Value.UA.Dialogue.Inserted).TotalSeconds);
uint rtpSent = (call.Value.UA.MediaSession as RtpAudioSession).RtpPacketsSent;
uint rtpRecv = (call.Value.UA.MediaSession as RtpAudioSession).RtpPacketsReceived;
Log.LogInformation($"{call.Key}: {call.Value.UA.Dialogue.RemoteTarget}, req code {call.Value.RequestedDtmfCode}, recvd code {call.Value.ReceivedDtmfCode}, dur {duration}s, rtp sent/recvd {rtpSent}/{rtpRecv}");
}
}
}
else if (keyProps.KeyChar == 'q')
{
// Quit application.
Log.LogInformation("Quitting");
exitCts.Cancel();
break;
}
}
}
catch (Exception excp)
{
Log.LogError($"Exception OnKeyPress. {excp.Message}.");
}
}
public RabbitMqConnectionStatusMonitor(IRabbitMqConnection connection, ILoggerFactory?loggerFactory = null)
{
_rabbitMqConnection = connection;
_logger = loggerFactory?.CreateLogger(nameof(RabbitMqConnectionStatusMonitor));
_isConnected = new BehaviorSubject <bool>(false);
_rabbitMqConnection.Connect();
var blocked = Observable.FromEventPattern <ConnectionBlockedEventArgs>(h => connection.AutoRecoveringConnection.ConnectionBlocked += h, h => connection.AutoRecoveringConnection.ConnectionBlocked -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection blocked - {nameof(ShutdownEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
var unblocked = Observable.FromEventPattern <EventArgs>(h => connection.AutoRecoveringConnection.ConnectionUnblocked += h, h => connection.AutoRecoveringConnection.ConnectionUnblocked -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection unblocked - {nameof(EventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Connected);
});
var shutdowned = Observable.FromEventPattern <ShutdownEventArgs>(h => connection.AutoRecoveringConnection.ConnectionShutdown += h, h => connection.AutoRecoveringConnection.ConnectionShutdown -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection shutdown - {nameof(ShutdownEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
var closed = Observable.FromEventPattern <CallbackExceptionEventArgs>(h => connection.AutoRecoveringConnection.CallbackException += h, h => connection.AutoRecoveringConnection.CallbackException -= h).Select(e =>
{
_logger?.LogError(e.EventArgs.Exception, $"An exception occured in a callback process - {nameof(CallbackExceptionEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.ErrorOccurred);
});
var errorOccurred = Observable.FromEventPattern <EventArgs>(h => connection.AutoRecoveringConnection.RecoverySucceeded += h, h => connection.AutoRecoveringConnection.RecoverySucceeded -= h).Select(e =>
{
_logger?.LogInformation($"AMQP connection recovery success - {nameof(EventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Connected);
});
var connectionRecoveryError = Observable.FromEventPattern <ConnectionRecoveryErrorEventArgs>(h => connection.AutoRecoveringConnection.ConnectionRecoveryError += h, h => connection.AutoRecoveringConnection.ConnectionRecoveryError -= h).Select(e =>
{
_logger?.LogError(e.EventArgs.Exception, $"AMQP connection recovery error - {nameof(ConnectionRecoveryErrorEventArgs)} => {e.EventArgs?.ToJson()}");
return(ConnectionStatus.Disconnected);
});
_connectionInfoChanged = Observable.Merge(blocked, unblocked, shutdowned, closed, errorOccurred, connectionRecoveryError)
.Scan(ConnectionInfo.InitialConnected, UpdateConnectionInfo)
.StartWith(ConnectionInfo.InitialConnected)
.Do(connectionInfo =>
{
ConnectionInfo = connectionInfo;
_logger?.LogInformation($"{nameof(RabbitMqConnectionStatusMonitor)} => ConnectionInfo - {connectionInfo}");
_isConnected.OnNext(connectionInfo.Status == ConnectionStatus.Connected);
})
.Replay(1);
_cleanUp = _connectionInfoChanged.Connect();
}
public void OnPostLogError()
{
_logger.LogError("Какая-то ошибка произошла");
}
/// <summary>
/// Executes the command set by the program's command line arguments.
/// </summary>
/// <param name="options">The options that dictate the SIP command to execute.</param>
static async Task RunCommand(Options options)
{
try
{
logger.LogDebug($"RunCommand scenario {options.Scenario}, destination {options.Destination}");
Stopwatch sw = new Stopwatch();
sw.Start();
CancellationTokenSource cts = new CancellationTokenSource();
int taskCount = 0;
int successCount = 0;
List <Task> tasks = new List <Task>();
for (int i = 0; i < options.Concurrent; i++)
{
var task = Task.Run(async() =>
{
while (taskCount < options.Count && !cts.IsCancellationRequested)
{
int taskNum = Interlocked.Increment(ref taskCount);
bool success = await RunTask(options, taskNum);
if (success)
{
Interlocked.Increment(ref successCount);
}
else if (options.BreakOnFail)
{
cts.Cancel();
break;
}
else if (options.Period > 0)
{
await Task.Delay(options.Period * 1000);
}
}
}, cts.Token);
tasks.Add(task);
// Spread the concurrent tasks out a tiny bit.
await Task.Delay(Crypto.GetRandomInt(500, 2000));
}
// Wait for all the concurrent tasks to complete.
await Task.WhenAll(tasks.ToArray());
sw.Stop();
// Give the transport half a second to shutdown (puts the log messages in a better sequence).
await Task.Delay(500);
logger.LogInformation($"=> Command completed task count {taskCount} success count {successCount} duration {sw.Elapsed.TotalSeconds:0.##}s.");
}
catch (Exception excp)
{
logger.LogError($"Exception RunCommand. {excp.Message}");
}
}
public static async Task OnGetLeagueSummaryQueryHandler(
[EventGridTrigger] EventGridEvent eventGridEvent,
[OrchestrationClient] DurableOrchestrationClient getLeagueSummaryQueryHandlerOrchestrationClient,
Microsoft.Extensions.Logging.ILogger log
)
{
#region Logging
if (null != log)
{
log.LogDebug("Function triggered in OnGetLeagueSummaryQuery");
}
if (null == eventGridEvent)
{
// This function should not proceed if there is no event data
if (null != log)
{
log.LogError("Missing event grid trigger data in OnGetLeagueSummaryQuery");
}
return;
}
else
{
if (null != log)
{
log.LogDebug($"Event grid topic: {eventGridEvent.Topic}");
log.LogDebug($"Event grid subject: {eventGridEvent.Subject }");
log.LogDebug($"Event grid metadata version: {eventGridEvent.MetadataVersion }");
log.LogDebug($"Event grid event type: {eventGridEvent.EventType }");
log.LogDebug($"Event Grid Data : {eventGridEvent.Data }");
}
}
#endregion
try
{
#region Logging
if (null != log)
{
log.LogDebug($"Get the query parameters in OnGetLeagueSummaryQuery");
if (null == eventGridEvent.Data)
{
log.LogError($"The query parameter has no values in OnGetLeagueSummaryQuery");
return;
}
}
#endregion
// Get the query request details out of the event grid data request
var jsondata = JsonConvert.SerializeObject(eventGridEvent.Data);
QueryRequest <Get_League_Summary_Definition> queryRequest = null;
if (!string.IsNullOrWhiteSpace(jsondata))
{
queryRequest = JsonConvert.DeserializeObject <QueryRequest <Get_League_Summary_Definition> >(jsondata);
}
if (null != queryRequest)
{
log.LogInformation($"Running query handler with durable functions orchestration");
log.LogInformation($"{queryRequest.QueryName} with league {queryRequest.GetParameters().League_Name}");
// Using Azure Durable functions to do the query chaining
string instanceId = await getLeagueSummaryQueryHandlerOrchestrationClient.StartNewAsync("OnGetLeagueSummaryQueryHandlerOrchestrator", queryRequest);
log.LogInformation($"Started OnGetLeagueSummaryQueryHandlerOrchestrator orchestration with ID = '{instanceId}'.");
}
else
{
if (null != log)
{
log.LogError($"Unable to read query request from eventgrid data: {eventGridEvent.Data} Type: {eventGridEvent.Data.GetType()} ");
}
}
}
catch (Exception ex)
{
if (null != log)
{
log.LogError(ex.ToString(), ex);
}
throw;
}
}
public async Task ExecuteEvent(GameEvent newEvent)
{
ProcessingEvents.TryAdd(newEvent.Id, newEvent);
// the event has failed already
if (newEvent.Failed)
{
goto skip;
}
try
{
await newEvent.Owner.ExecuteEvent(newEvent);
// save the event info to the database
await _changeHistoryService.Add(newEvent);
}
catch (TaskCanceledException)
{
_logger.LogDebug("Received quit signal for event id {eventId}, so we are aborting early", newEvent.Id);
}
catch (OperationCanceledException)
{
_logger.LogDebug("Received quit signal for event id {eventId}, so we are aborting early", newEvent.Id);
}
// this happens if a plugin requires login
catch (AuthorizationException ex)
{
newEvent.FailReason = EventFailReason.Permission;
newEvent.Origin.Tell($"{Utilities.CurrentLocalization.LocalizationIndex["COMMAND_NOTAUTHORIZED"]} - {ex.Message}");
}
catch (NetworkException ex)
{
newEvent.FailReason = EventFailReason.Exception;
using (LogContext.PushProperty("Server", newEvent.Owner?.ToString()))
{
_logger.LogError(ex, ex.Message);
}
}
catch (ServerException ex)
{
newEvent.FailReason = EventFailReason.Exception;
using (LogContext.PushProperty("Server", newEvent.Owner?.ToString()))
{
_logger.LogError(ex, ex.Message);
}
}
catch (Exception ex)
{
newEvent.FailReason = EventFailReason.Exception;
Console.WriteLine(Utilities.CurrentLocalization.LocalizationIndex["SERVER_ERROR_EXCEPTION"].FormatExt(newEvent.Owner));
using (LogContext.PushProperty("Server", newEvent.Owner?.ToString()))
{
_logger.LogError(ex, "Unexpected exception");
}
}
skip:
if (newEvent.Type == EventType.Command && newEvent.ImpersonationOrigin == null)
{
var correlatedEvents =
ProcessingEvents.Values.Where(ev =>
ev.CorrelationId == newEvent.CorrelationId && ev.Id != newEvent.Id)
.ToList();
await Task.WhenAll(correlatedEvents.Select(ev =>
ev.WaitAsync(Utilities.DefaultCommandTimeout, CancellationToken)));
newEvent.Output.AddRange(correlatedEvents.SelectMany(ev => ev.Output));
foreach (var correlatedEvent in correlatedEvents)
{
ProcessingEvents.Remove(correlatedEvent.Id, out _);
}
}
// we don't want to remove events that are correlated to command
if (ProcessingEvents.Values.ToList()?.Count(gameEvent => gameEvent.CorrelationId == newEvent.CorrelationId) == 1)
{
ProcessingEvents.Remove(newEvent.Id, out _);
}
// tell anyone waiting for the output that we're done
newEvent.Complete();
OnGameEventExecuted?.Invoke(this, newEvent);
}
public static async Task <Get_League_Summary_Definition_Return> OnGetLeagueSummaryQueryHandlerOrchestrator
([OrchestrationTrigger] DurableOrchestrationContext context,
Microsoft.Extensions.Logging.ILogger log)
{
// Get the query definition form the context...
QueryRequest <Get_League_Summary_Definition> queryRequest = context.GetInput <QueryRequest <Get_League_Summary_Definition> >();
if (null != queryRequest)
{
queryRequest.QueryName = "get-league-summary";
// Log the query request in its own own query event stream
Guid queryId = await context.CallActivityAsync <Guid>("GetLeagueSummaryCreateQueryRequestActivity", queryRequest);
if (queryId.Equals(Guid.Empty))
{
#region Logging
if (null != log)
{
// Unable to get the request details from the orchestration
log.LogError("OnGetLeagueSummaryQueryHandlerOrchestrator : Unable to create the query event stream");
}
#endregion
return(null);
}
else
{
queryRequest.QueryUniqueIdentifier = queryId;
// Save the parameters to the event stream
ActivityResponse resp = await context.CallActivityAsync <ActivityResponse>("GetLeagueSummaryLogParametersActivity", queryRequest);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
// next validate the query
bool valid = await context.CallActivityAsync <bool>("GetLeagueSummaryValidateActivity", queryRequest);
if (!valid)
{
if (null != log)
{
// Could not run the query as the parameters don't make sense
log.LogError($"OnGetLeagueSummaryQueryHandlerOrchestrator : Query parameters are invalid {queryId}");
}
return(null);
}
else
{
// Request all the projections needed to answer this query
resp = await context.CallActivityAsync <ActivityResponse>("GetLeagueSummaryQueryProjectionRequestActivity", queryRequest);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
// Run all the outstanding projections for this query
resp = await context.CallActivityAsync <ActivityResponse>("GetLeagueSummaryQueryProjectionProcessActivity", queryRequest);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
// Output the results
resp = await context.CallActivityAsync <ActivityResponse>("GetLeagueSummaryOutputResultsActivity", queryRequest);
#region Logging
if (null != log)
{
if (null != resp)
{
log.LogInformation($"{resp.FunctionName} complete: {resp.Message } ");
}
}
#endregion
if (null != resp)
{
context.SetCustomStatus(resp);
}
// Get the results for ourselves to return...to do this the query must be complete...
return(await context.CallActivityAsync <Get_League_Summary_Definition_Return>("GetLeagueSummaryGetResultsActivity", queryRequest));
}
}
}
else
{
if (null != log)
{
// Unable to get the request details from the orchestration
log.LogError("OnGetLeagueSummaryQueryHandlerOrchestrator : Unable to get the query request from the context");
string contextAsString = context.GetInput <string>();
if (!string.IsNullOrWhiteSpace(contextAsString))
{
log.LogError($"Context was {contextAsString} ");
}
else
{
log.LogError($"Context was blank ");
}
}
return(null);
}
}
public void LogError(string message, params object[] args) => logger.LogError(message, args);
static void Main()
{
Console.WriteLine("SIPSorcery Call Hold and Blind Transfer example.");
Console.WriteLine("Press 'c' to initiate a call to the default destination.");
Console.WriteLine("Press 'h' to place an established call on and off hold.");
Console.WriteLine("Press 'H' to hangup an established call.");
Console.WriteLine("Press 't' to request a blind transfer on an established call.");
Console.WriteLine("Press 'q' or ctrl-c to exit.");
// Plumbing code to facilitate a graceful exit.
CancellationTokenSource exitCts = new CancellationTokenSource(); // Cancellation token to stop the SIP transport and RTP stream.
Log = AddConsoleLogger();
// Set up a default SIP transport.
var sipTransport = new SIPTransport();
sipTransport.AddSIPChannel(new SIPUDPChannel(new IPEndPoint(IPAddress.Any, SIP_LISTEN_PORT)));
Console.WriteLine($"Listening for incoming calls on: {sipTransport.GetSIPChannels().First().ListeningEndPoint}.");
EnableTraceLogs(sipTransport);
var winAudio = new WindowsAudioEndPoint(new AudioEncoder());
winAudio.RestrictFormats(formats => formats.Codec == AudioCodecsEnum.PCMU);
// Create a client/server user agent to place a call to a remote SIP server along with event handlers for the different stages of the call.
var userAgent = new SIPUserAgent(sipTransport, null, true);
userAgent.RemotePutOnHold += () => Log.LogInformation("Remote call party has placed us on hold.");
userAgent.RemoteTookOffHold += () => Log.LogInformation("Remote call party took us off hold.");
userAgent.OnIncomingCall += async(ua, req) =>
{
Log.LogInformation($"Incoming call from {req.Header.From.FriendlyDescription()} at {req.RemoteSIPEndPoint}.");
var uas = userAgent.AcceptCall(req);
if (userAgent?.IsCallActive == true)
{
// If we are already on a call return a busy response.
Log.LogWarning($"Busy response returned for incoming call request.");
uas.Reject(SIPResponseStatusCodesEnum.BusyHere, null);
}
else
{
var voipSession = new VoIPMediaSession(winAudio.ToMediaEndPoints());
voipSession.AcceptRtpFromAny = true;
var answerResult = await userAgent.Answer(uas, voipSession);
}
};
// At this point the call has been initiated and everything will be handled in an event handler.
Task.Run(async() =>
{
try
{
while (!exitCts.Token.WaitHandle.WaitOne(0))
{
var keyProps = Console.ReadKey();
if (keyProps.KeyChar == 'c')
{
if (!userAgent.IsCallActive)
{
var voipSession = new VoIPMediaSession(winAudio.ToMediaEndPoints());
voipSession.AcceptRtpFromAny = true;
bool callResult = await userAgent.Call(DEFAULT_DESTINATION_SIP_URI, SIP_USERNAME, SIP_PASSWORD, voipSession);
Log.LogInformation($"Call attempt {((callResult) ? "successfull" : "failed")}.");
}
else
{
Log.LogWarning("There is already an active call.");
}
}
else if (keyProps.KeyChar == 'h')
{
// Place call on/off hold.
if (userAgent.IsCallActive)
{
if (userAgent.IsOnLocalHold)
{
Log.LogInformation("Taking the remote call party off hold.");
(userAgent.MediaSession as VoIPMediaSession).TakeOffHold();
userAgent.TakeOffHold();
}
else
{
Log.LogInformation("Placing the remote call party on hold.");
await(userAgent.MediaSession as VoIPMediaSession).PutOnHold();
userAgent.PutOnHold();
}
}
else
{
Log.LogWarning("There is no active call to put on hold.");
}
}
else if (keyProps.KeyChar == 'H')
{
if (userAgent.IsCallActive)
{
Log.LogInformation("Hanging up call.");
userAgent.Hangup();
}
}
else if (keyProps.KeyChar == 't')
{
// Initiate a blind transfer to the remote call party.
if (userAgent.IsCallActive)
{
var transferURI = SIPURI.ParseSIPURI(TRANSFER_DESTINATION_SIP_URI);
bool result = await userAgent.BlindTransfer(transferURI, TimeSpan.FromSeconds(TRANSFER_TIMEOUT_SECONDS), exitCts.Token);
if (result)
{
// If the transfer was accepted the original call will already have been hungup.
// Wait a second for the transfer NOTIFY request to arrive.
await Task.Delay(1000);
exitCts.Cancel();
}
else
{
Log.LogWarning($"Transfer to {TRANSFER_DESTINATION_SIP_URI} failed.");
}
}
else
{
Log.LogWarning("There is no active call to transfer.");
}
}
else if (keyProps.KeyChar == 'q')
{
// Quit application.
exitCts.Cancel();
}
}
}
catch (Exception excp)
{
Log.LogError($"Exception Key Press listener. {excp.Message}.");
}
});
// Ctrl-c will gracefully exit the call at any point.
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
exitCts.Cancel();
};
// Wait for a signal saying the call failed, was cancelled with ctrl-c or completed.
exitCts.Token.WaitHandle.WaitOne();
#region Cleanup.
Log.LogInformation("Exiting...");
if (userAgent != null)
{
if (userAgent.IsCallActive)
{
Log.LogInformation($"Hanging up call to {userAgent?.CallDescriptor?.To}.");
userAgent.Hangup();
}
// Give the BYE or CANCEL request time to be transmitted.
Log.LogInformation("Waiting 1s for call to clean up...");
Task.Delay(1000).Wait();
}
if (sipTransport != null)
{
Log.LogInformation("Shutting down SIP transport...");
sipTransport.Shutdown();
}
#endregion
}
public async Task CacheContent()
{
try
{
var settings = await _lidarrSettings.GetSettingsAsync();
if (settings.Enabled)
{
try
{
var albums = await _lidarrApi.GetAllAlbums(settings.ApiKey, settings.FullUri);
if (albums != null && albums.Any())
{
// Let's remove the old cached data
using (var tran = await _ctx.Database.BeginTransactionAsync())
{
await _ctx.Database.ExecuteSqlCommandAsync("DELETE FROM LidarrAlbumCache");
tran.Commit();
}
var albumCache = new List <LidarrAlbumCache>();
foreach (var a in albums)
{
if (a.id > 0)
{
albumCache.Add(new LidarrAlbumCache
{
ArtistId = a.artistId,
ForeignAlbumId = a.foreignAlbumId,
ReleaseDate = a.releaseDate,
TrackCount = a.currentRelease?.trackCount ?? 0,
Monitored = a.monitored,
Title = a.title,
PercentOfTracks = a.statistics?.percentOfEpisodes ?? 0m,
AddedAt = DateTime.Now,
});
}
}
using (var tran = await _ctx.Database.BeginTransactionAsync())
{
await _ctx.LidarrAlbumCache.AddRangeAsync(albumCache);
await _ctx.SaveChangesAsync();
tran.Commit();
}
}
}
catch (System.Exception ex)
{
_logger.LogError(LoggingEvents.Cacher, ex, "Failed caching queued items from Lidarr Album");
}
await _availability.Start();
}
}
catch (Exception)
{
_logger.LogInformation(LoggingEvents.LidarrArtistCache, "Lidarr is not setup, cannot cache Album");
}
}
/// <inheritdoc /> public void Error(string format, params object[] args) => _logger.LogError(string.Format(format, args));
public async Task <ConversionStatus> ConvertPdf2Swf(string inPdfFilePath, ConversionOptions options, Func <ConversionState, ConversionStatus> checkResultAfterConversion = null)
{
var status = new ConversionStatus(ConversionState.ConversionFailed);
try
{
var inputPdf = new FileInfo(inPdfFilePath);
if (!inputPdf.Exists)
{
status.Message = "Input file doesn't exist. " + inPdfFilePath;
_logger.LogError(status.Message);
return(status);
}
//setting defaults
var workingDir = options.OutputDirectory ?? inputPdf.DirectoryName;
_logger.LogDebug($"Starting Conversion for file {inPdfFilePath}. Working dir {workingDir}");
var optimizedFilePath = Path.Combine(workingDir, options.OutputNamingConventions.BuildOptimizedPdfFileName(inputPdf.Name));
await OptimizePdfForConverter(inPdfFilePath, optimizedFilePath, status);
if (status.State == ConversionState.OptimizationFailed)
{
return(status);
}
int numberOfPages = await GetNumberOfPages(optimizedFilePath);
if (numberOfPages == 0)
{
var message = $"Critical failure. Can't detect number of pages for pdf: {optimizedFilePath}";
_logger.LogCritical(message);
return(new ConversionStatus(ConversionState.ConversionFailed, message));
}
var swfFile = Path.Combine(workingDir, options.OutputNamingConventions.BuildSwfFileName(inputPdf.Name));
var swfPagedFile = Path.Combine(workingDir, options.OutputNamingConventions.BuildPagedSwfFileName(inputPdf.Name));
if (options.OverwriteExistingSwfs)
{
CleanFilesBeforeConversion(options, swfFile, swfPagedFile, numberOfPages);
}
switch (options.HowToConvert)
{
case ConversionPath.OnePdf2OneSwf:
status = await PerformOnePdf2OneSwfConversion(options, optimizedFilePath, swfFile, checkResultAfterConversion);
break;
case ConversionPath.OnePdf2PerPageSwf:
status = await PerformOnePdf2ManyPagesConversion(options, inPdfFilePath, swfPagedFile, numberOfPages, checkResultAfterConversion);
break;
case ConversionPath.Both:
status = await PerformOnePdf2OneSwfConversion(options, optimizedFilePath, swfFile);
if (status.State == ConversionState.Converted || status.State == ConversionState.OutputExists)
{
status = await PerformOnePdf2ManyPagesConversion(options, inPdfFilePath, swfPagedFile, numberOfPages, checkResultAfterConversion, status);
}
break;
}
}
catch (Exception ex)
{
status.Message = $"Critical failure. Converting error {ex}";
status.State = ConversionState.ConversionFailed;
_logger.LogCritical(status.Message);
return(status);
}
_logger.LogDebug($"Finishing Conversion for file {inPdfFilePath}. Status: {status.State}");
return(status);
}
/// <summary>
/// Main background task.
/// </summary>
/// <param name="taskInstance"></param>
public void Run(IBackgroundTaskInstance taskInstance)
{
_deferral = taskInstance.GetDeferral();
taskInstance.Canceled += TaskInstanceCanceled;
try
{
// Copy the appsetting.json file if necessary.
if (CopyAppSettings().Result)
{
// Set the default culture.
CultureInfo.CurrentCulture = new CultureInfo("en-US");
// Read the application settings file containing the Serilog configuration.
var configuration = new ConfigurationBuilder()
.SetBasePath(ApplicationData.Current.LocalFolder.Path)
.AddJsonFile("appsettings.json", false, false)
.AddEnvironmentVariables()
.Build();
configuration.GetSection("AppSettings")?.Bind(_settings);
// Setting up the static Serilog logger.
//Log.Logger = new LoggerConfiguration()
// .ReadFrom.Configuration(configuration)
// .Enrich.FromLogContext()
// .CreateLogger();
StorageFolder folder = ApplicationData.Current.LocalFolder;
string fullPath = folder.Path + "\\Logs\\{Date}.log";
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.WriteTo.RollingFile(fullPath)
.CreateLogger();
// Setting up the application logger.
var services = new ServiceCollection()
.AddLogging(builder =>
{
builder.AddSerilog();
});
// Add services.
services.AddSingleton <ILoggerFactory>(logger => new SerilogLoggerFactory(null, true));
services.Configure <SettingsData>(configuration.GetSection("AppSettings"));
services.Configure <AppSettings>(configuration.GetSection("AppSettings"));
services.AddSingleton <ISettingsData, SettingsData>();
// Setting up the Zipato HTTP client.
services.AddHttpClient <IZipatoClient, ZipatoClient>(client =>
{
client.BaseAddress = new Uri(_settings.Servers.Zipato);
client.Timeout = TimeSpan.FromSeconds(_settings.Timeout);
})
.ConfigureHttpMessageHandlerBuilder(config => new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => { return(true); }
})
.AddPolicyHandler(HttpPolicyExtensions
.HandleTransientHttpError()
.OrResult(msg => msg.StatusCode == System.Net.HttpStatusCode.NotFound)
.WaitAndRetryAsync(_settings.Retries,
attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt))));
// Setup the data values.
services.AddSingleton <NetatmoValues>();
services.AddSingleton <ETAPU11Values>();
services.AddSingleton <EM300LRValues>();
services.AddSingleton <FroniusValues>();
services.AddSingleton <KWLEC200Values>();
services.AddSingleton <HomeDataValues>();
services.AddSingleton <WallboxValues>();
// Build the service provider and add the logger.
var serviceProvider = services.BuildServiceProvider();
_logger = serviceProvider.GetService <ILogger <StartupTask> >();
// Get the data values instances.
_netatmoValues = ActivatorUtilities.CreateInstance <NetatmoValues>(serviceProvider);
_etapu11Values = ActivatorUtilities.CreateInstance <ETAPU11Values>(serviceProvider);
_em300lrValues = ActivatorUtilities.CreateInstance <EM300LRValues>(serviceProvider);
_froniusValues = ActivatorUtilities.CreateInstance <FroniusValues>(serviceProvider);
_kwlec200Values = ActivatorUtilities.CreateInstance <KWLEC200Values>(serviceProvider);
_homeDataValues = ActivatorUtilities.CreateInstance <HomeDataValues>(serviceProvider);
_wallboxValues = ActivatorUtilities.CreateInstance <WallboxValues>(serviceProvider);
// Update immediately.
ThreadPoolTimer.CreateTimer(async(timer) => await SendValuesAsync(), TimeSpan.Zero);
// Setup periodic timer (updating every 60 seconds).
_timer = ThreadPoolTimer.CreatePeriodicTimer(async(timer) => await SendValuesAsync(), TimeSpan.FromMinutes(1));
}
else
{
throw new ApplicationException("StartupTask application settings not found.");
}
}
catch (Exception ex)
{
_logger?.LogError(ex, $"Exception StartupTask.");
_deferral.Complete();
}
_logger?.LogInformation($"StartupTask done.");
}
/// <summary>
/// Removes the override event from the site model.
/// </summary>
public async Task <OverrideEventResponse> ExecuteAsync(OverrideEventRequestArgument arg)
{
Log.LogInformation($"START Remove Override Event Executor: Project={arg.ProjectID}, Asset={arg.AssetID}, Date Range={arg.StartUTC}-{arg.EndUTC}");
var result = new OverrideEventResponse {
Success = false
};
var siteModel = DIContext.Obtain <ISiteModels>().GetSiteModel(arg.ProjectID);
if (siteModel == null)
{
result.Message = $"Failed to locate site model {arg.ProjectID}";
Log.LogError(result.Message);
return(result);
}
bool changed = false;
lock (siteModel)
{
if (arg.AssetID == Guid.Empty)
{
//If AssetID not provided, remove all override events for project
Log.LogDebug($"Removing override events for all assets in project {arg.ProjectID}");
foreach (var machine in siteModel.Machines)
{
if (RemoveOverrideEventsForMachine(siteModel, machine, arg))
{
changed = true;
}
}
}
else
{
var machine = siteModel.Machines.Locate(arg.AssetID);
if (machine == null)
{
result.Message = $"Failed to locate machine {arg.AssetID}";
Log.LogError(result.Message);
return(result);
}
Log.LogDebug($"Removing override events for asset {arg.AssetID}");
changed = RemoveOverrideEventsForMachine(siteModel, machine, arg);
}
if (changed)
{
Log.LogDebug($"Notifying grid of changes to project {arg.ProjectID}");
// Notify the immutable grid listeners that attributes of this site model have changed.
var sender = DIContext.Obtain <ISiteModelAttributesChangedEventSender>();
sender.ModelAttributesChanged(SiteModelNotificationEventGridMutability.NotifyImmutable,
siteModel.ID,
machineTargetValuesChanged: true);
}
}
if (!changed)
{
result.Message = "No override event(s) found to remove";
}
result.Success = changed;
Log.LogInformation($"END Remove Override Event Executor: Project={arg.ProjectID}, Asset={arg.AssetID}, Date Range={arg.StartUTC}-{arg.EndUTC}");
return(result);
}
public void Load(string name, ILoader loader, FrameworkLogger logger)
{
// The data in downloads.v1.json will be an array of Package records - which has Id, Array of Versions and download count.
// Sample.json : [["AutofacContrib.NSubstitute",["2.4.3.700",406],["2.5.0",137]],["Assman.Core",["2.0.7",138]]....
using (var jsonReader = loader.GetReader(name))
{
try
{
jsonReader.Read();
while (jsonReader.Read())
{
try
{
if (jsonReader.TokenType == JsonToken.StartArray)
{
JToken record = JToken.ReadFrom(jsonReader);
string id = String.Intern(record[0].ToString().ToLowerInvariant());
// The second entry in each record should be an array of versions, if not move on to next entry.
// This is a check to safe guard against invalid entries.
if (record.Count() == 2 && record[1].Type != JTokenType.Array)
{
continue;
}
if (!_downloads.ContainsKey(id))
{
_downloads.Add(id, new DownloadsByVersion());
}
var versions = _downloads[id];
foreach (JToken token in record)
{
if (token != null && token.Count() == 2)
{
string version = String.Intern(token[0].ToString().ToLowerInvariant());
versions[version] = token[1].ToObject<int>();
}
}
}
}
catch (JsonReaderException ex)
{
logger.LogInformation("Invalid entry found in downloads.v1.json. Exception Message : {0}", ex.Message);
}
}
}
catch (JsonReaderException ex)
{
logger.LogError("Data present in downloads.v1.json is invalid. Couldn't get download data.", ex);
}
}
}
public static async Task MainAsync(string[] args)
{
if (args.Length > 0 && string.Equals("dbg", args[0], StringComparison.OrdinalIgnoreCase))
{
args = args.Skip(1).ToArray();
Debugger.Launch();
}
NgJob job = null;
ApplicationInsightsConfiguration applicationInsightsConfiguration = null;
int exitCode = 0;
try
{
// Get arguments
var arguments = CommandHelpers.GetArguments(args, 1, out var secretInjector);
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Determine the job name
if (args.Length == 0)
{
throw new ArgumentException("Missing job name argument.");
}
var jobName = args[0];
var instanceName = arguments.GetOrDefault(Arguments.InstanceName, jobName);
var instrumentationKey = arguments.GetOrDefault <string>(Arguments.InstrumentationKey);
var heartbeatIntervalSeconds = arguments.GetOrDefault <int>(Arguments.HeartbeatIntervalSeconds);
applicationInsightsConfiguration = ConfigureApplicationInsights(
instrumentationKey,
heartbeatIntervalSeconds,
jobName,
instanceName,
out var telemetryClient,
out var telemetryGlobalDimensions);
var loggerFactory = ConfigureLoggerFactory(applicationInsightsConfiguration);
InitializeServiceProvider(
arguments,
secretInjector,
applicationInsightsConfiguration,
telemetryClient,
loggerFactory);
job = NgJobFactory.GetJob(jobName, loggerFactory, telemetryClient, telemetryGlobalDimensions);
job.SetSecretInjector(secretInjector);
// This tells Application Insights that, even though a heartbeat is reported,
// the state of the application is unhealthy when the exitcode is different from zero.
// The heartbeat metadata is enriched with the job loop exit code.
applicationInsightsConfiguration.DiagnosticsTelemetryModule?.AddOrSetHeartbeatProperty(
HeartbeatProperty_JobLoopExitCode,
exitCode.ToString(),
isHealthy: exitCode == 0);
var cancellationTokenSource = new CancellationTokenSource();
await job.RunAsync(arguments, cancellationTokenSource.Token);
exitCode = 0;
}
catch (ArgumentException ae)
{
exitCode = 1;
_logger?.LogError("A required argument was not found or was malformed/invalid: {Exception}", ae);
Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase());
}
catch (KeyNotFoundException knfe)
{
exitCode = 1;
_logger?.LogError("An expected key was not found. One possible cause of this is required argument has not been provided: {Exception}", knfe);
Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase());
}
catch (Exception e)
{
exitCode = 1;
_logger?.LogCritical("A critical exception occured in ng.exe! {Exception}", e);
}
applicationInsightsConfiguration.DiagnosticsTelemetryModule?.SetHeartbeatProperty(
HeartbeatProperty_JobLoopExitCode,
exitCode.ToString(),
isHealthy: exitCode == 0);
Trace.Close();
applicationInsightsConfiguration?.TelemetryConfiguration.TelemetryChannel.Flush();
}
static void Main()
{
Console.WriteLine("SIPSorcery client user agent example.");
Console.WriteLine("Press ctrl-c to exit.");
CancellationTokenSource exitCts = new CancellationTokenSource(); // Cancellation token to stop the SIP transport and RTP stream.
AddConsoleLogger();
// Set up a default SIP transport.
var sipTransport = new SIPTransport();
sipTransport.AddSIPChannel(new SIPUDPChannel(new IPEndPoint(IPAddress.Any, SIP_LISTEN_PORT)));
// Un/comment this line to see/hide each SIP message sent and received.
EnableTraceLogs(sipTransport);
// To keep things a bit simpler this example only supports a single call at a time and the SIP server user agent
// acts as a singleton
SIPUserAgent userAgent = new SIPUserAgent(sipTransport, null);
CancellationTokenSource rtpCts = null; // Cancellation token to stop the RTP stream.
Socket rtpSocket = null;
Socket controlSocket = null;
// Because this is a server user agent the SIP transport must start listening for client user agents.
sipTransport.SIPTransportRequestReceived += (SIPEndPoint localSIPEndPoint, SIPEndPoint remoteEndPoint, SIPRequest sipRequest) =>
{
try
{
if (sipRequest.Header.From != null &&
sipRequest.Header.From.FromTag != null &&
sipRequest.Header.To != null &&
sipRequest.Header.To.ToTag != null)
{
userAgent.InDialogRequestReceivedAsync(sipRequest).Wait();
}
if (sipRequest.Method == SIPMethodsEnum.INVITE)
{
SIPSorcery.Sys.Log.Logger.LogInformation($"Incoming call request: {localSIPEndPoint}<-{remoteEndPoint} {sipRequest.URI}.");
// Check there's a codec we support in the INVITE offer.
var offerSdp = SDP.ParseSDPDescription(sipRequest.Body);
IPEndPoint dstRtpEndPoint = SDP.GetSDPRTPEndPoint(sipRequest.Body);
RTPSession rtpSession = null;
string audioFile = null;
if (offerSdp.Media.Any(x => x.Media == SDPMediaTypesEnum.audio && x.HasMediaFormat((int)RTPPayloadTypesEnum.PCMU)))
{
Log.LogDebug($"Using PCMU RTP media type and audio file {AUDIO_FILE_PCMU}.");
rtpSession = new RTPSession((int)RTPPayloadTypesEnum.PCMU, null, null);
audioFile = AUDIO_FILE_PCMU;
}
if (rtpSession == null)
{
// Didn't get a match on the codecs we support.
SIPResponse noMatchingCodecResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.NotAcceptableHere, null);
sipTransport.SendResponse(noMatchingCodecResponse);
}
else
{
// If there's already a call in progress hang it up. Of course this is not ideal for a real softphone or server but it
// means this example can be kept simpler.
if (userAgent?.IsAnswered == true)
{
userAgent?.Hangup();
}
rtpCts?.Cancel();
UASInviteTransaction uasTransaction = sipTransport.CreateUASTransaction(sipRequest, null);
if (userAgent.AcceptCall(uasTransaction))
{
rtpCts = new CancellationTokenSource();
// The RTP socket is listening on IPAddress.Any but the IP address placed into the SDP needs to be one the caller can reach.
IPAddress rtpAddress = NetServices.GetLocalAddressForRemote(dstRtpEndPoint.Address);
// Initialise an RTP session to receive the RTP packets from the remote SIP server.
NetServices.CreateRtpSocket(rtpAddress, RTP_PORT_START, RTP_PORT_END, false, out rtpSocket, out controlSocket);
var rtpRecvSession = new RTPSession((int)RTPPayloadTypesEnum.PCMU, null, null);
var rtpSendSession = new RTPSession((int)RTPPayloadTypesEnum.PCMU, null, null);
rtpSendSession.DestinationEndPoint = dstRtpEndPoint;
rtpRecvSession.OnReceiveFromEndPointChanged += (oldEP, newEP) =>
{
Log.LogDebug($"RTP destination end point changed from {oldEP} to {newEP}.");
rtpSendSession.DestinationEndPoint = newEP;
};
Task.Run(() => RecvRtp(rtpSocket, rtpRecvSession, rtpCts));
Task.Run(() => SendRtp(rtpSocket, rtpSendSession, rtpCts));
userAgent.Answer(GetSDP(rtpSocket.LocalEndPoint as IPEndPoint));
}
}
}
else if (sipRequest.Method == SIPMethodsEnum.SUBSCRIBE)
{
SIPResponse notAllowededResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.MethodNotAllowed, null);
sipTransport.SendResponse(notAllowededResponse);
}
else if (sipRequest.Method == SIPMethodsEnum.OPTIONS || sipRequest.Method == SIPMethodsEnum.REGISTER)
{
SIPResponse optionsResponse = SIPTransport.GetResponse(sipRequest, SIPResponseStatusCodesEnum.Ok, null);
sipTransport.SendResponse(optionsResponse);
}
}
catch (Exception reqExcp)
{
SIPSorcery.Sys.Log.Logger.LogWarning($"Exception handling {sipRequest.Method}. {reqExcp.Message}");
}
};
// Ctrl-c will gracefully exit the call at any point.
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
exitCts.Cancel();
rtpCts?.Cancel();
};
// At this point the call has been initiated and everything will be handled in an event handler.
Task.Run(async() =>
{
try
{
while (!exitCts.Token.WaitHandle.WaitOne(0))
{
var keyProps = Console.ReadKey();
if (keyProps.KeyChar == 't')
{
// Initiate a transfer.
bool transferResult = await userAgent.Transfer(SIPURI.ParseSIPURI(TRANSFER_DESTINATION_SIP_URI), new TimeSpan(0, 0, TRANSFER_TIMEOUT_SECONDS), exitCts.Token);
if (transferResult)
{
// If the transfer was accepted the original call will already have been hungup.
userAgent = null;
exitCts.Cancel();
}
else
{
Log.LogWarning($"Transfer to {TRANSFER_DESTINATION_SIP_URI} failed.");
}
}
else if (keyProps.KeyChar == 'q')
{
// Quit application.
exitCts.Cancel();
}
}
}
catch (Exception excp)
{
Log.LogError($"Exception Key Press listener. {excp.Message}.");
}
});
// Wait for a signal saying the call failed, was cancelled with ctrl-c or completed.
exitCts.Token.WaitHandle.WaitOne();
Log.LogInformation("Exiting...");
rtpSocket?.Close();
controlSocket?.Close();
if (userAgent != null)
{
if (userAgent.IsAnswered)
{
Log.LogInformation($"Hanging up call to {userAgent?.CallDescriptor?.To}.");
userAgent.Hangup();
}
// Give the final request time to be transmitted.
Log.LogInformation("Waiting 1s for call to clean up...");
Task.Delay(1000).Wait();
}
SIPSorcery.Net.DNSManager.Stop();
if (sipTransport != null)
{
Log.LogInformation("Shutting down SIP transport...");
sipTransport.Shutdown();
}
}
/// <summary>
/// Executes the command set by the program's command line arguments.
/// </summary>
/// <param name="options">The options that dictate the SIP command to execute.</param>
static async Task RunCommand(Options options)
{
try
{
logger.LogDebug($"RunCommand {options.Destination}");
(var dstEp, var dstUri) = ParseDestination(options.Destination);
logger.LogDebug($"Destination IP end point {dstEp} and SIP URI {dstUri}");
int sendCount = 0;
bool success = true;
do
{
IPAddress localAddress = (dstEp.Address.AddressFamily == AddressFamily.InterNetworkV6) ? IPAddress.IPv6Any : IPAddress.Any;
SIPChannel sipChannel = null;
switch (dstEp.Protocol)
{
case SIPProtocolsEnum.tcp:
sipChannel = new SIPTCPChannel(new IPEndPoint(localAddress, DEFAULT_SIP_CLIENT_PORT));
(sipChannel as SIPTCPChannel).DisableLocalTCPSocketsCheck = true; // Allow sends to listeners on this host.
break;
case SIPProtocolsEnum.tls:
var certificate = new X509Certificate2(@"localhost.pfx", "");
sipChannel = new SIPTLSChannel(certificate, new IPEndPoint(localAddress, DEFAULT_SIPS_CLIENT_PORT));
break;
case SIPProtocolsEnum.udp:
sipChannel = new SIPUDPChannel(new IPEndPoint(localAddress, DEFAULT_SIP_CLIENT_PORT));
break;
case SIPProtocolsEnum.ws:
sipChannel = new SIPClientWebSocketChannel();
break;
case SIPProtocolsEnum.wss:
sipChannel = new SIPClientWebSocketChannel();
break;
default:
throw new ApplicationException($"Don't know how to create SIP channel for transport {dstEp.Protocol}.");
}
SIPTransport sipTransport = new SIPTransport();
sipTransport.AddSIPChannel(sipChannel);
if (sendCount > 0 && options.Period > 0)
{
await Task.Delay(options.Period * 1000);
}
sendCount++;
DateTime sendTime = DateTime.Now;
var sendTask = SendOptionsTaskAsync(sipTransport, dstUri);
var result = await Task.WhenAny(sendTask, Task.Delay(options.Timeout * 1000));
TimeSpan duration = DateTime.Now.Subtract(sendTime);
if (!sendTask.IsCompleted)
{
logger.LogWarning($"=> Request to {dstEp} did not get a response on send {sendCount} of {options.Count} after {duration.TotalMilliseconds.ToString("0")}ms.");
success = false;
}
else if (!sendTask.Result)
{
logger.LogWarning($"=> Request to {dstEp} did not get the expected response on request {sendCount} of {options.Count} after {duration.TotalMilliseconds.ToString("0")}ms.");
success = false;
}
else
{
logger.LogInformation($"=> Got correct response on send {sendCount} of {options.Count} in {duration.TotalMilliseconds.ToString("0")}ms.");
}
logger.LogDebug("Shutting down the SIP transport...");
sipTransport.Shutdown();
if (success == false)
{
break;
}
}while (sendCount < options.Count);
DNSManager.Stop();
// Give the transport half a second to shutdown (puts the log messages in a better sequence).
await Task.Delay(500);
logger.LogInformation($"=> Command completed {((success) ? "successfully" : "with failure")}.");
}
catch (Exception excp)
{
logger.LogError($"Exception RunCommand. {excp.Message}");
}
}
public async Task <bool> VerifyAsync(string file, StringBuilder buffer)
{
if (file == null)
{
throw new ArgumentNullException(nameof(file));
}
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
var trustProviders = new ISignatureVerificationProvider[]
{
new IntegrityVerificationProvider(),
new SignatureTrustAndValidityVerificationProvider()
};
var verifier = new PackageSignatureVerifier(trustProviders);
var allPackagesVerified = true;
try
{
var result = 0;
var packagesToVerify = LocalFolderUtility.ResolvePackageFromPath(file);
foreach (var packageFile in packagesToVerify)
{
using var package = new PackageArchiveReader(packageFile);
var verificationResult = await verifier.VerifySignaturesAsync(package, SignedPackageVerifierSettings.GetVerifyCommandDefaultPolicy(), CancellationToken.None);
if (verificationResult.IsValid)
{
allPackagesVerified = true;
}
else
{
var logMessages = verificationResult.Results.SelectMany(p => p.Issues).Select(p => p.AsRestoreLogMessage()).ToList();
foreach (var msg in logMessages)
{
buffer.AppendLine(msg.Message);
}
if (logMessages.Any(m => m.Level >= NuGet.Common.LogLevel.Warning))
{
var errors = logMessages.Where(m => m.Level == NuGet.Common.LogLevel.Error).Count();
var warnings = logMessages.Where(m => m.Level == NuGet.Common.LogLevel.Warning).Count();
buffer.AppendLine($"Finished with {errors} errors and {warnings} warnings.");
result = errors;
}
allPackagesVerified = false;
}
}
}
catch (Exception e)
{
logger.LogError(e, e.Message);
return(false);
}
return(allPackagesVerified);
}
public static async Task <(bool, AddonData)> ProccessAddonData(HttpClient httpClient, AddonData addonData)
{
if (!string.IsNullOrEmpty(addonData.FolderName))
{
return(true, addonData);
}
bool found = false;
string zipFile = string.Empty;
try
{
zipFile = await Update.DLWithHttpProgress(httpClient, addonData.Downloads[0]);
}
catch (Exception e)
{
logger.LogError(e, "Something went wrong in " + nameof(ProccessAddonData) + " for " + addonData.ProjectName);
return(found, addonData);
}
if (string.IsNullOrEmpty(zipFile) || !File.Exists(zipFile))
{
logger.LogError("No zipFile found for " + addonData.ProjectName);
return(found, addonData);
}
FileInfo fileInfo = new FileInfo(zipFile);
addonData.Size = fileInfo.Length;
try
{
(int entries, List <string> folders) = Update.UpdateAddon2(zipFile);
addonData.Files = entries;
if (folders.Count == 1)
{
addonData.FolderName = folders[0];
found = true;
}
else
{
foreach (string folder in folders)
{
string lowered = folder.ToLower();
if (PROJECT_URLS.TryGetValue(lowered, out string mapped))
{
if (mapped.Equals(addonData.ProjectName))
{
found = true;
addonData.FolderName = folder;
break;
}
}
}
if (!found)
{
HashSet <string> urlNames = new HashSet <string>()
{
addonData.ProjectName,
addonData.ProjectName.Replace("-", ""),
addonData.ProjectName.Replace("_", ""),
addonData.ProjectName.Replace("_", "-"),
addonData.ProjectName.Replace("-", "_")
};
foreach (string folder in folders)
{
string lowered = folder.ToLower();
HashSet <string> folderNames = new HashSet <string>()
{
lowered,
lowered.Replace(" ", "-"),
lowered.Replace("_", "-")
};
if (folderNames.Contains(addonData.ProjectName))
{
found = true;
addonData.FolderName = folder;
break;
}
if (urlNames.Contains(lowered))
{
found = true;
addonData.FolderName = folder;
break;
}
}
}
}
addonData.SubFolders = folders.Where(f => !f.Equals(addonData.FolderName)).ToHashSet();
if (found)
{
File.Delete(zipFile);
Directory.Delete(zipFile.Replace(".zip", ""), true);
}
return(found, addonData);
}
catch (Exception e)
{
logger.LogError(e, "Someting went wrong for " + addonData.ProjectName);
return(found, addonData);
}
}
private static async Task WebSocketMessageReceived(WebSocketContext context, RTCPeerConnection pc, string message)
{
try
{
if (pc.localDescription == null)
{
//logger.LogDebug("Offer SDP: " + message);
logger.LogDebug("Offer SDP received.");
// Add local media tracks depending on what was offered. Also add local tracks with the same media ID as
// the remote tracks so that the media announcement in the SDP answer are in the same order.
SDP remoteSdp = SDP.ParseSDPDescription(message);
foreach (var ann in remoteSdp.Media)
{
var capbilities = FilterCodecs(ann.Media, ann.MediaFormats);
MediaStreamTrack track = new MediaStreamTrack(ann.Media, false, capbilities, MediaStreamStatusEnum.RecvOnly);
pc.addTrack(track);
}
pc.setRemoteDescription(new RTCSessionDescriptionInit {
sdp = message, type = RTCSdpType.offer
});
var answer = pc.createAnswer(null);
await pc.setLocalDescription(answer);
Console.WriteLine(answer.sdp);
context.WebSocket.Send(answer.sdp);
}
else if (pc.remoteDescription == null)
{
logger.LogDebug("Answer SDP: " + message);
var result = pc.setRemoteDescription(new RTCSessionDescriptionInit {
sdp = message, type = RTCSdpType.answer
});
if (result != SetDescriptionResultEnum.OK)
{
logger.LogWarning($"Failed to set remote description {result}.");
}
}
else
{
logger.LogDebug("ICE Candidate: " + message);
if (string.IsNullOrWhiteSpace(message) || message.Trim().ToLower() == SDP.END_ICE_CANDIDATES_ATTRIBUTE)
{
logger.LogDebug("End of candidates message received.");
}
else
{
var candInit = Newtonsoft.Json.JsonConvert.DeserializeObject <RTCIceCandidateInit>(message);
pc.addIceCandidate(candInit);
}
}
}
catch (Exception excp)
{
logger.LogError("Exception WebSocketMessageReceived. " + excp.Message);
}
}
public static async Task MainAsync(string[] args)
{
if (args.Length > 0 && string.Equals("dbg", args[0], StringComparison.OrdinalIgnoreCase))
{
args = args.Skip(1).ToArray();
Debugger.Launch();
}
NgJob job = null;
try
{
// Get arguments
var arguments = CommandHelpers.GetArguments(args, 1);
// Ensure that SSLv3 is disabled and that Tls v1.2 is enabled.
ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3;
ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12;
// Determine the job name
if (args.Length == 0)
{
throw new ArgumentException("Missing job name argument.");
}
var jobName = args[0];
TelemetryConfiguration.Active.TelemetryInitializers.Add(new JobNameTelemetryInitializer(jobName));
// Configure ApplicationInsights
ApplicationInsights.Initialize(arguments.GetOrDefault <string>(Arguments.InstrumentationKey));
// Create an ILoggerFactory
var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(withConsoleLogger: true);
loggerConfiguration.WriteTo.File("Log.txt", retainedFileCountLimit: 3, fileSizeLimitBytes: 1000000, rollOnFileSizeLimit: true);
var loggerFactory = LoggingSetup.CreateLoggerFactory(loggerConfiguration, LogEventLevel.Debug);
// Create a logger that is scoped to this class (only)
_logger = loggerFactory.CreateLogger <Program>();
var cancellationTokenSource = new CancellationTokenSource();
// Create an ITelemetryService
var telemetryService = new TelemetryService(new TelemetryClient());
// Allow jobs to set global custom dimensions
TelemetryConfiguration.Active.TelemetryInitializers.Add(new JobPropertiesTelemetryInitializer(telemetryService));
job = NgJobFactory.GetJob(jobName, telemetryService, loggerFactory);
await job.RunAsync(arguments, cancellationTokenSource.Token);
}
catch (ArgumentException ae)
{
_logger?.LogError("A required argument was not found or was malformed/invalid: {Exception}", ae);
Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase());
}
catch (Exception e)
{
_logger?.LogCritical("A critical exception occured in ng.exe! {Exception}", e);
}
Trace.Close();
TelemetryConfiguration.Active.TelemetryChannel.Flush();
}
private static async Task WebSocketMessageReceived(WebSocketContext context, RTCPeerConnection pc, string message)
{
try
{
if (pc.localDescription == null)
{
//logger.LogDebug("Offer SDP: " + message);
logger.LogDebug("Offer SDP received.");
// Add local media tracks depending on what was offered. Also add local tracks with the same media ID as
// the remote tracks so that the media announcement in the SDP answer are in the same order.
var offerInit = JsonConvert.DeserializeObject <RTCSessionDescriptionInit>(message, new Newtonsoft.Json.Converters.StringEnumConverter());
logger.LogDebug(SDP.ParseSDPDescription(offerInit.sdp).ToString());
var res = pc.setRemoteDescription(offerInit);
if (res != SetDescriptionResultEnum.OK)
{
// No point continuing. Something will need to change and then try again.
pc.Close("failed to set remote sdp");
}
else
{
var answer = pc.createAnswer(_answerOptions);
await pc.setLocalDescription(answer);
context.WebSocket.Send(JsonConvert.SerializeObject(answer, new Newtonsoft.Json.Converters.StringEnumConverter()));
}
}
else if (pc.remoteDescription == null)
{
logger.LogDebug("Answer SDP received:");
var answerInit = JsonConvert.DeserializeObject <RTCSessionDescriptionInit>(message, new Newtonsoft.Json.Converters.StringEnumConverter());
logger.LogDebug(SDP.ParseSDPDescription(answerInit.sdp).ToString());
var res = pc.setRemoteDescription(answerInit);
if (res != SetDescriptionResultEnum.OK)
{
// No point continuing. Something will need to change and then try again.
pc.Close("failed to set remote sdp");
}
}
else
{
logger.LogDebug("ICE Candidate: " + message);
if (string.IsNullOrWhiteSpace(message) || message.Trim().ToLower() == SDP.END_ICE_CANDIDATES_ATTRIBUTE)
{
logger.LogDebug("End of candidates message received.");
}
else
{
var candInit = Newtonsoft.Json.JsonConvert.DeserializeObject <RTCIceCandidateInit>(message);
if (_acceptIceTypes.Count > 0 && !_acceptIceTypes.Any(x => x == RTCIceCandidate.Parse(candInit.candidate).type))
{
logger.LogDebug($"Ignoring remote ICE candidate as type not in accept list.");
}
else
{
pc.addIceCandidate(candInit);
}
}
}
}
catch (Exception excp)
{
logger.LogError("Exception WebSocketMessageReceived. " + excp.Message);
}
}
