/// <summary>
/// Initializes a new instance of the <see cref="GroupCI"/> class
/// </summary>
/// <param name="exportable">A <see cref="ExportableGroupCI"/> containing group information</param>
internal GroupCI(ExportableGroupCI exportable)
{
if (exportable == null)
{
throw new ArgumentNullException(nameof(exportable));
}
Id = exportable.Id;
Name = exportable.Name;
try
{
CompetitorsIds = exportable.Competitors?.Select(URN.Parse);
if (!exportable.CompetitorsReferences.IsNullOrEmpty())
{
CompetitorsReferences = new Dictionary <URN, ReferenceIdCI>();
foreach (var competitorsReference in exportable.CompetitorsReferences)
{
var referenceIds = new Dictionary <string, string>();
var refs = competitorsReference.Value.Split(',');
foreach (var r in refs)
{
var refKeyValue = r.Split('=');
referenceIds.Add(refKeyValue[0], refKeyValue[1]);
}
CompetitorsReferences.Add(URN.Parse(competitorsReference.Key), new ReferenceIdCI(referenceIds));
}
}
}
catch (Exception e)
{
SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).Error("Importing GroupCI", e);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SimpleMessageProcessor" /> class.
/// </summary>
/// <param name="dispatcher">
/// A <see cref="IEntityDispatcher{ISportEvent}" /> whose dispatched entities will be processed by the current instance.
/// </param>
/// <param name="name">The name of the session/processor</param>
/// <param name="log">A <see cref="ILogger" /> instance used for logging</param>
public SimpleMessageProcessor(IEntityDispatcher <ISportEvent> dispatcher, string name = null, ILog log = null)
{
_dispatcher = dispatcher;
_log = log ?? SdkLoggerFactory.GetLogger(typeof(SimpleMessageProcessor));
FeedMessages = new ConcurrentBag <FMessage>();
Name = name ?? ((IOddsFeedSession)dispatcher).Name;
}
/// <summary>
/// Initializes a new instance of the <see cref="Feed"/> class
/// </summary>
/// <param name="config">A <see cref="IOddsFeedConfiguration"/> instance representing feed configuration</param>
/// <param name="isReplay">Value indicating whether the constructed instance will be used to connect to replay server</param>
/// <param name="loggerFactory">A <see cref="ILoggerFactory"/> used to create <see cref="ILogger"/> used within sdk</param>
/// <param name="metricsRoot">A <see cref="IMetricsRoot"/> used to provide metrics within sdk</param>
protected Feed(IOddsFeedConfiguration config, bool isReplay, ILoggerFactory loggerFactory = null, IMetricsRoot metricsRoot = null)
{
Guard.Argument(config, nameof(config)).NotNull();
FeedInitialized = false;
UnityContainer = new UnityContainer();
//UnityContainer = new UnityContainer().EnableDiagnostic();
UnityContainer.RegisterBaseTypes(config, loggerFactory, metricsRoot);
InternalConfig = UnityContainer.Resolve <IOddsFeedConfigurationInternal>();
if (isReplay || InternalConfig.Environment == SdkEnvironment.Replay)
{
InternalConfig.EnableReplayServer();
}
_log = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
LogInit();
_metricsRoot = UnityContainer.Resolve <IMetricsRoot>();
_metricsLogger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed));
_metricsTaskScheduler = new AppMetricsTaskScheduler(
TimeSpan.FromSeconds(InternalConfig.StatisticsTimeout),
async() => { await LogMetricsAsync(); });
}
public void CloseConnection()
{
lock (_syncLock)
{
if (_connectionSingleton != null)
{
try
{
_connectionSingleton.ConnectionBlocked -= OnConnectionBlocked;
_connectionSingleton.ConnectionUnblocked -= OnConnectionUnblocked;
_connectionSingleton.CallbackException -= OnCallbackException;
_connectionSingleton.ConnectionShutdown -= OnConnectionShutdown;
_connectionSingleton.Close();
}
catch (Exception e)
{
SdkLoggerFactory.GetLoggerForExecution(typeof(ConfiguredConnectionFactory)).Warn("Error closing connection", e);
}
finally
{
_connectionSingleton.Dispose();
_connectionSingleton = null;
ConnectionCreated = DateTime.MinValue;
}
}
}
}
/// <summary>
/// Asynchronous export item's properties
/// </summary>
/// <returns>An <see cref="ExportableCI"/> instance containing all relevant properties</returns>
public Task <ExportableGroupCI> ExportAsync()
{
var cr = new Dictionary <string, string>();
if (!CompetitorsReferences.IsNullOrEmpty())
{
foreach (var competitorsReference in CompetitorsReferences)
{
try
{
if (!competitorsReference.Value.ReferenceIds.IsNullOrEmpty())
{
var refs = string.Join(",", competitorsReference.Value.ReferenceIds.Select(s => $"{s.Key}={s.Value}"));
cr.Add(competitorsReference.Key.ToString(), refs);
}
}
catch (Exception e)
{
SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).Error("Exporting GroupCI", e);
}
}
}
return(Task.FromResult(new ExportableGroupCI
{
Id = Id,
Name = Name,
Competitors = CompetitorsIds?.Select(s => s.ToString()).ToList(),
CompetitorsReferences = cr.IsNullOrEmpty() ? null : cr
}));
}
/// <summary>
/// Asynchronous export item's properties
/// </summary>
/// <returns>An <see cref="ExportableCI"/> instance containing all relevant properties</returns>
public Task <ExportableGroupCI> ExportAsync()
{
var cr = new Dictionary <string, Dictionary <string, string> >();
if (!CompetitorsReferences.IsNullOrEmpty())
{
foreach (var competitorsReference in CompetitorsReferences)
{
try
{
var refs = competitorsReference.Value.ReferenceIds?.ToDictionary(r => r.Key, r => r.Value);
cr.Add(competitorsReference.Key.ToString(), refs);
}
catch (Exception e)
{
SdkLoggerFactory.GetLoggerForExecution(typeof(GroupCI)).LogError(e, "Exporting GroupCI");
}
}
}
return(Task.FromResult(new ExportableGroupCI
{
Id = Id,
Name = Name,
Competitors = CompetitorsIds?.Select(s => s.ToString()),
CompetitorsReferences = cr.IsNullOrEmpty() ? null : cr
}));
}
public void Init()
{
var services = new ServiceCollection();
services.AddLogging(configure => configure.AddLog4Net("log4net.sdk.config"));
var servicesProvider = services.BuildServiceProvider();
var loggerFactory = servicesProvider.GetService <ILoggerFactory>();
var _ = new SdkLoggerFactory(loggerFactory);
}
public void Init()
{
SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config"));
_sef = new TestSportEntityFactoryBuilder();
_sef.InitializeSportEntities();
_sef.LoadTournamentMissingValues();
_sef.LoadSeasonMissingValues();
}
/// <summary>
/// Constructs a new instance of the <see cref="MtsSdk"/> class
/// </summary>
/// <param name="config">A <see cref="ISdkConfiguration"/> instance representing feed configuration</param>
/// <param name="loggerFactory">A <see cref="ILoggerFactory"/> used to create <see cref="ILogger"/> used within sdk</param>
/// <param name="metricsRoot">A <see cref="IMetricsRoot"/> used to provide metrics within sdk</param>
public MtsSdk(ISdkConfiguration config, ILoggerFactory loggerFactory = null, IMetricsRoot metricsRoot = null)
{
Guard.Argument(config, nameof(config)).NotNull();
LogInit();
_isDisposed = false;
_isOpened = 0;
_unityContainer = new UnityContainer();
_unityContainer.RegisterTypes(config, loggerFactory, metricsRoot);
_config = _unityContainer.Resolve <ISdkConfigurationInternal>();
_executionLog = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk));
_interactionLog = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk));
LogInit();
_metricsRoot = _unityContainer.Resolve <IMetricsRoot>();
_metricsLogger = SdkLoggerFactory.GetLoggerForStats(typeof(MtsSdk));
_metricsTaskScheduler = new AppMetricsTaskScheduler(
TimeSpan.FromSeconds(_config.StatisticsTimeout),
async() => { await LogMetricsAsync(); });
_connectionValidator = _unityContainer.Resolve <ConnectionValidator>();
BuilderFactory = _unityContainer.Resolve <IBuilderFactory>();
_ticketPublisherFactory = _unityContainer.Resolve <ITicketSenderFactory>();
_entitiesMapper = _unityContainer.Resolve <EntitiesMapper>();
_rabbitMqMessageReceiverForTickets = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketResponseMessageReceiver");
_rabbitMqMessageReceiverForTicketCancels = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketCancelResponseMessageReceiver");
_rabbitMqMessageReceiverForTicketCashouts = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketCashoutResponseMessageReceiver");
_rabbitMqMessageReceiverForTicketNonSrSettle = _unityContainer.Resolve <IRabbitMqMessageReceiver>("TicketNonSrSettleResponseMessageReceiver");
ClientApi = _unityContainer.Resolve <IMtsClientApi>();
CustomBetManager = _unityContainer.Resolve <ICustomBetManager>();
ConnectionStatus = _unityContainer.Resolve <IConnectionStatus>();
ReportManager = _unityContainer.Resolve <IReportManager>();
_autoResetEventsForBlockingRequests = new ConcurrentDictionary <string, AutoResetEvent>();
_responsesFromBlockingRequests = new ConcurrentDictionary <string, ISdkTicket>();
_ticketsForNonBlockingRequests = new MemoryCache("TicketsForNonBlockingRequests");
_lockForTicketsForNonBlockingRequestsCache = new object();
foreach (var t in Enum.GetValues(typeof(SdkTicketType)))
{
var publisher = _ticketPublisherFactory.GetTicketSender((SdkTicketType)t);
if (publisher != null)
{
publisher.TicketSendFailed += PublisherOnTicketSendFailed;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SpecificEntityProcessor{T}"/> class
/// </summary>
/// <param name="dispatcher">A <see cref="ISpecificEntityDispatcher{T}"/> used to obtain SDK messages</param>
/// <param name="sportEntityWriter">A <see cref="SportEntityWriter"/> used to write the sport entities data</param>
/// <param name="marketWriter">A <see cref="MarketWriter"/> used to write market and outcome data</param>
/// <param name="log">A <see cref="ILogger"/> instance used for logging</param>
public SpecificEntityProcessor(ISpecificEntityDispatcher <T> dispatcher, SportEntityWriter sportEntityWriter = null, MarketWriter marketWriter = null, ILogger log = null)
{
Guard.Argument(dispatcher, nameof(dispatcher)).NotNull();
Guard.Argument(log, nameof(log)).NotNull();
_log = log ?? SdkLoggerFactory.GetLogger(typeof(SpecificEntityProcessor <T>)); // new NullLogger<SpecificEntityProcessor<T>>();
_dispatcher = dispatcher;
_sportEntityWriter = sportEntityWriter;
_marketWriter = marketWriter;
}
/// <summary>
/// Sets the last timestamp before disconnect
/// </summary>
/// <param name="timestamp">The timestamp</param>
internal void SetLastTimestampBeforeDisconnect(DateTime timestamp)
{
if (timestamp >= LastTimestampBeforeDisconnect)
{
LastTimestampBeforeDisconnect = timestamp;
}
else if (timestamp < LastTimestampBeforeDisconnect.AddSeconds(-MaxInactivitySeconds))
{
var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Producer));
logger.Warn($"Suspicious feed message timestamp arrived for producer {Id}. Current={LastTimestampBeforeDisconnect}. Arrived={timestamp}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SdkCache"/> class
/// </summary>
protected SdkCache(ICacheManager cacheManager)
{
Guard.Argument(cacheManager, nameof(cacheManager)).NotNull();
_cacheManager = cacheManager;
CacheName = GetType().Name;
// ReSharper disable once VirtualMemberCallInConstructor
RegisterCache();
ExecutionLog = SdkLoggerFactory.GetLoggerForExecution(GetType());
}
/// <summary>
/// Initializes a new instance of the <see cref="SdkCache" /> class
/// </summary>
protected SdkCache(ICacheManager cacheManager)
{
Contract.Requires(cacheManager != null);
_cacheManager = cacheManager;
CacheName = GetType().Name;
// ReSharper disable once VirtualMemberCallInConstructor
RegisterCache();
ExecutionLog = SdkLoggerFactory.GetLoggerForExecution(GetType());
}
/// <summary>
/// Converts the provided int <code>value</code> to the member of the specified enum, or returns <code>defaultValue</code>
/// </summary>
/// <typeparam name="T">The type of enum to which to convert the <code>value</code></typeparam>
/// <param name="value">The value in the feed message</param>
/// <param name="defaultValue">A <see cref="T"/> member to be returned if unknown <code>value</code></param>
/// <returns>The <code>value</code> converted to enum <see cref="T"/> member</returns>
public static T GetEnumValue <T>(int value, T defaultValue) where T : struct, IConvertible
{
try
{
return(GetEnumValue <T>(value));
}
catch
{
var log = SdkLoggerFactory.GetLogger(typeof(MessageMapperHelper));
log.LogError($"Enum value [{value}] not available for enum {typeof(T)}.");
// ignored
}
return(defaultValue);
}
public static void RegisterTypes(this IUnityContainer container, ISdkConfiguration userConfig, ILoggerFactory loggerFactory, IMetricsRoot metricsRoot)
{
Guard.Argument(container, nameof(container)).NotNull();
Guard.Argument(userConfig, nameof(userConfig)).NotNull();
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12;
if (loggerFactory != null)
{
var _ = new SdkLoggerFactory(loggerFactory);
}
_log = SdkLoggerFactory.GetLogger(typeof(SdkUnityBootstrapper));
if (metricsRoot == null)
{
_metricsRoot = new MetricsBuilder()
.Configuration.Configure(
options =>
{
options.DefaultContextLabel = "UF SDK .NET Core";
options.Enabled = true;
options.ReportingEnabled = true;
})
.OutputMetrics.AsPlainText()
.Build();
}
else
{
_metricsRoot = metricsRoot;
}
container.RegisterInstance(_metricsRoot, new ContainerControlledLifetimeManager());
RegisterBaseClasses(container, userConfig);
RegisterRabbitMqTypes(container, userConfig, _environment);
RegisterTicketSenders(container);
RegisterMarketDescriptionCache(container, userConfig);
RegisterSdkStatisticsWriter(container);
RegisterMtsAuthService(container, userConfig);
RegisterClientApi(container, userConfig);
RegisterReportManager(container, userConfig);
RegisterCustomBet(container);
}
/// <summary>
/// Runs the report of <see cref="MetricsData"/>
/// </summary>
/// <param name="metricsData">The metrics data</param>
/// <param name="healthStatus">The health status</param>
/// <param name="token">The token</param>
public void RunReport(MetricsData metricsData, Func <HealthStatus> healthStatus, CancellationToken token)
{
if (_log == null)
{
_log = SdkLoggerFactory.GetLoggerForStats(typeof(MetricsReporter));
}
var mdr = new MetricDataReport(metricsData?.Context, _log, _printMode, _decimals);
mdr.Report(metricsData);
if (_runHealthStatus)
{
RunHealthStatus(metricsData?.Context);
}
}
private static void LogInit()
{
var msg = "MtsSdk initialization. Version: " + SdkInfo.GetVersion();
var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(MtsSdk));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForCache(typeof(MtsSdk));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(MtsSdk));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(MtsSdk));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForStats(typeof(MtsSdk));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForExecution(typeof(MtsSdk));
logger.LogInformation(msg);
}
private void LogInit()
{
var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion();
var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed));
logger.Info($"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
}
/// <summary>
/// Initializes a new instance of the <see cref="SportEvent"/> class
/// </summary>
/// <param name="id">A <see cref="URN"/> uniquely identifying the sport event</param>
/// <param name="sportId">A <see cref="URN"/> identifying the sport current instance belong to</param>
/// <param name="executionLog">The <see cref="ILog"/> instance used for execution logging</param>
/// <param name="sportEventCache">A <see cref="ISportEventCache"/> instance containing <see cref="SportEventCI"/></param>
/// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying languages the current instance supports</param>
/// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the instance will handle potential exceptions</param>
public SportEvent(URN id,
URN sportId,
ILog executionLog,
ISportEventCache sportEventCache,
IEnumerable <CultureInfo> cultures,
ExceptionHandlingStrategy exceptionStrategy)
{
Contract.Requires(id != null);
Contract.Requires(sportEventCache != null);
Contract.Requires(cultures != null && cultures.Any());
Id = id;
SportId = sportId;
ExecutionLog = executionLog ?? SdkLoggerFactory.GetLoggerForExecution(typeof(SportEvent));
ExceptionStrategy = exceptionStrategy;
Cultures = cultures;
SportEventCache = sportEventCache;
}
/// <summary>
/// Initializes a new instance of the <see cref="SportEvent"/> class
/// </summary>
/// <param name="id">A <see cref="URN"/> uniquely identifying the sport event</param>
/// <param name="sportId">A <see cref="URN"/> identifying the sport current instance belong to</param>
/// <param name="executionLog">The <see cref="ILog"/> instance used for execution logging</param>
/// <param name="sportEventCache">A <see cref="ISportEventCache"/> instance containing <see cref="SportEventCI"/></param>
/// <param name="cultures">A <see cref="IEnumerable{CultureInfo}"/> specifying languages the current instance supports</param>
/// <param name="exceptionStrategy">A <see cref="ExceptionHandlingStrategy"/> enum member specifying how the instance will handle potential exceptions</param>
public SportEvent(URN id,
URN sportId,
ILog executionLog,
ISportEventCache sportEventCache,
IEnumerable <CultureInfo> cultures,
ExceptionHandlingStrategy exceptionStrategy)
{
Guard.Argument(id, nameof(id)).NotNull();
Guard.Argument(sportEventCache, nameof(sportEventCache)).NotNull();
Guard.Argument(cultures, nameof(cultures)).NotNull().NotEmpty();
Id = id;
SportId = sportId;
ExecutionLog = executionLog ?? SdkLoggerFactory.GetLoggerForExecution(typeof(SportEvent));
ExceptionStrategy = exceptionStrategy;
Cultures = cultures;
SportEventCache = sportEventCache;
}
/// <summary>
/// Initializes a new instance of the <see cref="Feed"/> class
/// </summary>
/// <param name="config">A <see cref="IOddsFeedConfiguration"/> instance representing feed configuration</param>
/// <param name="isReplay">Value indicating whether the constructed instance will be used to connect to replay server</param>
protected Feed(IOddsFeedConfiguration config, bool isReplay)
{
Guard.Argument(config, nameof(config)).NotNull();
FeedInitialized = false;
UnityContainer = new UnityContainer();
UnityContainer.RegisterBaseTypes(config);
InternalConfig = UnityContainer.Resolve <IOddsFeedConfigurationInternal>();
if (isReplay || InternalConfig.Environment == SdkEnvironment.Replay)
{
InternalConfig.EnableReplayServer();
}
_log = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
LogInit();
}
private void LogInit()
{
var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion();
var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed));
Contract.Assume(logger != null);
logger.Info(msg);
logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed));
logger.Info(msg);
logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed));
logger.Info(msg);
logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed));
logger.Info(msg);
logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
logger.Info(msg);
logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed));
logger.Info(msg);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompetitorCI"/> class
/// </summary>
/// <param name="exportable">A <see cref="ExportableCompetitorCI"/> containing information about the sport entity</param>
internal void Import(ExportableCompetitorCI exportable)
{
try
{
Names = exportable.Name.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.Name);
_countryNames = exportable.CountryNames.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.CountryNames);
_abbreviations = exportable.Abbreviations.IsNullOrEmpty() ? new Dictionary <CultureInfo, string>() : new Dictionary <CultureInfo, string>(exportable.Abbreviations);
_associatedPlayerIds = exportable.AssociatedPlayerIds.IsNullOrEmpty() ? new List <URN>() : new List <URN>(exportable.AssociatedPlayerIds.Select(URN.Parse));
_isVirtual = exportable.IsVirtual;
_referenceId = exportable.ReferenceIds.IsNullOrEmpty() ? null : new ReferenceIdCI(exportable.ReferenceIds);
_jerseys = exportable.Jerseys.IsNullOrEmpty() ? new List <JerseyCI>() : new List <JerseyCI>(exportable.Jerseys.Select(j => new JerseyCI(j)));
_countryCode = exportable.CountryCode;
_state = exportable.State;
_manager = exportable.Manager == null ? null : new ManagerCI(exportable.Manager);
_venue = exportable.Venue == null ? null : new VenueCI(exportable.Venue);
_gender = exportable.Gender;
_ageGroup = exportable.AgeGroup;
_fetchedCultures = exportable.FetchedCultures.IsNullOrEmpty() ? new List <CultureInfo>() : new List <CultureInfo>(exportable.FetchedCultures);
_primaryCulture = exportable.PrimaryCulture;
_raceDriverProfile = exportable.RaceDriverProfile == null ? null : new RaceDriverProfileCI(exportable.RaceDriverProfile);
_referenceId = exportable.ReferenceIds.IsNullOrEmpty() ? null : new ReferenceIdCI(exportable.ReferenceIds);
_lastTimeCompetitorProfileFetched = DateTime.MinValue;
if (exportable.LastTimeCompetitorProfileIsFetched.HasValue)
{
_lastTimeCompetitorProfileFetched = exportable.LastTimeCompetitorProfileIsFetched.Value;
}
_cultureCompetitorProfileFetched = new List <CultureInfo>();
if (exportable.CultureCompetitorProfileFetched != null)
{
_cultureCompetitorProfileFetched = exportable.CultureCompetitorProfileFetched.ToList();
}
_sportId = exportable.SportId != null?URN.Parse(exportable.SportId) : null;
_categoryId = exportable.CategoryId != null?URN.Parse(exportable.CategoryId) : null;
_shortName = exportable.ShortName;
}
catch (Exception e)
{
SdkLoggerFactory.GetLoggerForExecution(typeof(CompetitorCI)).Error("Importing CompetitorCI", e);
}
}
private void LogInit()
{
var msg = "UF SDK .NET Core initialization. Version: " + SdkInfo.GetVersion();
var logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
if (logger == null)
{
return;
}
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed));
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed));
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed));
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed));
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed));
logger.Log(SdkLoggerFactory.GetWriteLogLevel(logger, LogLevel.Information), $"{msg}. LogLevel: {SdkLoggerFactory.GetLoggerLogLevel(logger)}");
}
private void LogInit()
{
var msg = "UF SDK .NET initialization. Version: " + SdkInfo.GetVersion();
var logger = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(Feed));
if (logger == null)
{
return;
}
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForCache(typeof(Feed));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(Feed));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(Feed));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForExecution(typeof(Feed));
logger.LogInformation(msg);
logger = SdkLoggerFactory.GetLoggerForStats(typeof(Feed));
logger.LogInformation(msg);
}
private static void Main()
{
log4net.Config.XmlConfigurator.Configure(new FileInfo("log4net.config"));
SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config"));
_log = LogManager.GetLogger(typeof(Start));
if (!SdkLoggerFactory.CheckAllLoggersExists())
{
_log.Warn("Loggers are not set correctly!");
}
var key = 'y';
while (key.Equals('y'))
{
DoExampleSelection();
Console.WriteLine(string.Empty);
Console.Write("Want to run another example? (y|n): ");
key = Console.ReadKey().KeyChar;
Console.WriteLine(string.Empty);
}
}
private static void PrintLogManagerStatus()
{
Console.WriteLine($"Number of loggers: {LogManager.GetCurrentLoggers().Length}");
foreach (var l in LogManager.GetCurrentLoggers())
{
Console.WriteLine($"\tLogger: {l.Logger.Name}");
foreach (var a in l.Logger.Repository.GetAppenders())
{
Console.WriteLine($"\t\t Appender: {a.Name}");
}
}
Console.WriteLine($"Number of repositories: {LogManager.GetAllRepositories().Length}");
foreach (var l in LogManager.GetAllRepositories())
{
Console.WriteLine($"\tRepository: {l.Name}");
}
Console.WriteLine(Environment.NewLine);
var logDefault = SdkLoggerFactory.GetLogger(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
var logCache = SdkLoggerFactory.GetLoggerForCache(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
var logClientIteration = SdkLoggerFactory.GetLoggerForClientInteraction(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
var logFeedTraffic = SdkLoggerFactory.GetLoggerForFeedTraffic(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
var logRestTraffic = SdkLoggerFactory.GetLoggerForRestTraffic(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
var logStatsTraffic = SdkLoggerFactory.GetLoggerForStats(typeof(SdkLogTest), SdkCommon.TestData.SdkTestLogRepositoryName);
LogPrint(logDefault);
LogPrint(logCache);
LogPrint(logClientIteration);
LogPrint(logFeedTraffic);
LogPrint(logRestTraffic);
LogPrint(logStatsTraffic);
//for (int i = 0; i < 10000; i++)
//{
// LogPrint(logRestTraffic);
//}
}
public void Init()
{
SdkLoggerFactory.Configure(new FileInfo("log4net.sdk.config"), SdkCommon.TestData.SdkTestLogRepositoryName);
}
/// <summary>When overridden in a derived class, invokes the method that is specified in the provided <see cref="T:System.Runtime.Remoting.Messaging.IMessage" /> on the remote object that is represented by the current instance.</summary>
/// <returns>The message returned by the invoked method, containing the return value and any out or ref parameters.</returns>
/// <param name="msg">A <see cref="T:System.Runtime.Remoting.Messaging.IMessage" /> that contains a <see cref="T:System.Collections.IDictionary" /> of information about the method call. </param>
public override IMessage Invoke(IMessage msg)
{
var logEnabled = false;
var methodCall = msg as IMethodCallMessage;
if (methodCall == null)
{
throw new ArgumentException("Input parameter 'msg' not valid IMethodCallMessage.");
}
var methodInfo = methodCall.MethodBase as MethodInfo;
if (methodInfo == null)
{
throw new ArgumentException("Input parameter 'msg' does not have MethodBase as MethodInfo.");
}
var logger = SdkLoggerFactory.GetLogger(methodCall.MethodBase.ReflectedType, SdkLoggerFactory.SdkLogRepositoryName, _defaultLoggerType);
if (_filter != null && _filter(methodInfo))
{
logEnabled = true;
}
if (!logEnabled || _canOverrideLoggerType)
{
var attributes = methodInfo.GetCustomAttributes(true).ToList();
if (methodInfo.DeclaringType != null)
{
attributes.AddRange(methodInfo.DeclaringType.GetCustomAttributes(true));
}
if (attributes.Count > 0)
{
foreach (var t in attributes)
{
if (!(t is LogAttribute))
{
continue;
}
logEnabled = true;
if (_canOverrideLoggerType)
{
logger = SdkLoggerFactory.GetLogger(methodCall.MethodBase.ReflectedType, SdkLoggerFactory.SdkLogRepositoryName, ((LogAttribute)t).LoggerType);
}
break;
}
}
}
var watch = new Stopwatch();
watch.Start();
try
{
if (methodCall.MethodName == "GetType")
{
logEnabled = false;
}
if (logEnabled)
{
logger.Info($"Starting executing '{methodCall.MethodName}' ...");
}
if (logEnabled && methodCall.InArgCount > 0)
{
logger.Debug($"{methodCall.MethodName} arguments:");
for (var i = 0; i < methodCall.InArgCount; i++)
{
logger.Debug($"\t{((Type[]) methodCall.MethodSignature)[i].Name}={methodCall.InArgs[i]}");
}
}
var result = methodInfo.Invoke(_decorated, methodCall.InArgs); // MAIN EXECUTION
var task = result as Task;
if (task != null)
{
var perm = new LogProxyPerm
{
LogEnabled = logEnabled,
Logger = logger,
MethodCall = methodCall,
MethodInfo = methodInfo,
Result = result,
Watch = watch
};
_proxyPerms.Add(task.Id, perm);
if (logEnabled)
{
logger.Debug($"TaskId:{task.Id} is executing and we wait to finish ...");
}
task.ContinueWith(TaskExecutionFinished);
return(new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall));
}
FinishExecution(logEnabled, methodCall, methodInfo, result?.GetType().Name, result, logger, watch);
return(new ReturnMessage(result, null, 0, methodCall.LogicalCallContext, methodCall));
}
catch (Exception e)
{
watch.Stop();
if (logEnabled)
{
logger.Error($"Exception during executing '{methodCall.MethodName}': {Environment.NewLine}", e);
}
return(new ReturnMessage(e, methodCall));
}
}
public void Init()
{
_log = SdkLoggerFactory.GetLogger(typeof(EntityPrinterTest));
}
