/// <summary>
/// Constructor.
/// </summary>
/// <param name="logger">nstance implementing the <see cref="ILogger"/> interface for writing some useful debug messages.</param>
/// <param name="beaconCache">The beacon cache to evict if necessary.</param>
/// <param name="configuration"></param>
internal SpaceEvictionStrategy(ILogger logger, IBeaconCache beaconCache, BeaconCacheConfiguration configuration, Func <bool> isShutdownFunc)
{
this.logger = logger;
this.beaconCache = beaconCache;
this.configuration = configuration;
this.isShutdownFunc = isShutdownFunc;
}
public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockBeaconCache = Substitute.For <IBeaconCache>();
mockTimingProvider = Substitute.For <ITimingProvider>();
isShutdownFunc = () => false;
}
public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockOpenKitConfiguration = Substitute.For <IOpenKitConfiguration>();
mockOpenKitConfiguration.ApplicationId.Returns(string.Empty);
mockOpenKitConfiguration.ApplicationName.Returns(string.Empty);
mockOpenKitConfiguration.ApplicationVersion.Returns(string.Empty);
mockOpenKitConfiguration.DeviceId.Returns(DeviceId);
mockPrivacyConfiguration = Substitute.For <IPrivacyConfiguration>();
mockBeaconCache = Substitute.For <IBeaconCache>();
mockSessionIdProvider = Substitute.For <ISessionIdProvider>();
mockThreadIdProvider = Substitute.For <IThreadIdProvider>();
mockTimingProvider = Substitute.For <ITimingProvider>();
mockParent = Substitute.For <IOpenKitComposite>();
mockInput = Substitute.For <ISessionCreatorInput>();
mockInput.Logger.Returns(mockLogger);
mockInput.OpenKitConfiguration.Returns(mockOpenKitConfiguration);
mockInput.PrivacyConfiguration.Returns(mockPrivacyConfiguration);
mockInput.BeaconCache.Returns(mockBeaconCache);
mockInput.SessionIdProvider.Returns(mockSessionIdProvider);
mockInput.ThreadIdProvider.Returns(mockThreadIdProvider);
mockInput.TimingProvider.Returns(mockTimingProvider);
mockInput.CurrentServerId.Returns(ServerId);
}
public OpenKitInitializer(IOpenKitBuilder builder)
{
logger = builder.Logger;
privacyConfiguration = PrivacyConfiguration.From(builder);
openKitConfiguration = OpenKitConfiguration.From(builder);
timingProvider = new DefaultTimingProvider();
threadIdProvider = new DefaultThreadIdProvider();
sessionIdProvider = new DefaultSessionIdProvider();
beaconCache = new BeaconCache(logger);
beaconCacheEvictor = new BeaconCacheEvictor(logger, beaconCache, BeaconCacheConfiguration.From(builder),
timingProvider);
var httpClientConfig = HttpClientConfiguration.From(openKitConfiguration);
// shared thread suspender between BeaconSender and HttpClient. HttpClient will be woken up when
// BeaconSender shuts down
var beaconSenderThreadSuspender = new InterruptibleThreadSuspender();
beaconSender = new BeaconSender(
logger,
httpClientConfig,
new DefaultHttpClientProvider(logger, beaconSenderThreadSuspender),
timingProvider,
beaconSenderThreadSuspender);
var watchdogThreadSuspender = new InterruptibleThreadSuspender();
sessionWatchdog = new SessionWatchdog(
logger,
new SessionWatchdogContext(timingProvider, watchdogThreadSuspender));
}
public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockLogger.IsInfoEnabled.Returns(true);
mockLogger.IsDebugEnabled.Returns(true);
mockPrivacyConfig = Substitute.For <IPrivacyConfiguration>();
mockPrivacyConfig.DataCollectionLevel.Returns(ConfigurationDefaults.DefaultDataCollectionLevel);
mockPrivacyConfig.CrashReportingLevel.Returns(ConfigurationDefaults.DefaultCrashReportingLevel);
mockOpenKitConfig = Substitute.For <IOpenKitConfiguration>();
mockOpenKitConfig.ApplicationId.Returns(AppId);
mockOpenKitConfig.DeviceId.Returns(DeviceId);
mockOpenKitConfig.ApplicationName.Returns(AppName);
mockOpenKitConfig.OperatingSystem.Returns(string.Empty);
mockOpenKitConfig.Manufacturer.Returns(string.Empty);
mockOpenKitConfig.ModelId.Returns(string.Empty);
mockTimingProvider = Substitute.For <ITimingProvider>();
mockThreadIdProvider = Substitute.For <IThreadIdProvider>();
mockSessionIdProvider = Substitute.For <ISessionIdProvider>();
mockBeaconCache = Substitute.For <IBeaconCache>();
mockBeaconSender = Substitute.For <IBeaconSender>();
mockBeaconCacheEvictor = Substitute.For <IBeaconCacheEvictor>();
mockSessionWatchdog = Substitute.For <ISessionWatchdog>();
}
/// <summary>
/// Internal testing constructor.
/// </summary>
/// <param name="logger">Logger to write some debug output</param>
/// <param name="beaconCache">The Beacon cache to check if entries need to be evicted</param>
/// <param name="strategies">Strategies executed in the thread</param>
internal BeaconCacheEvictor(ILogger logger, IBeaconCache beaconCache, params IBeaconCacheEvictionStrategy[] strategies)
{
this.logger = logger;
this.beaconCache = beaconCache;
this.strategies = strategies;
evictionThread = new Thread(RunEvictionThread);
evictionThread.Name = this.GetType().Name;
}
/// <summary>
/// Public constructor, initializing the eviction thread with the default <see cref="TimeEvictionStrategy"/>
/// and <see cref="SpaceEvictionStrategy"/> strategies.
/// </summary>
/// <param name="logger">Logger to write some debug output</param>
/// <param name="beaconCache">The Beacon cache to check if entries need to be evicted</param>
/// <param name="configuration">Beacon cache configuration</param>
/// <param name="timingProvider">Timing provider required for time retrieval</param>
public BeaconCacheEvictor(ILogger logger, IBeaconCache beaconCache, BeaconCacheConfiguration configuration, ITimingProvider timingProvider) :
this(logger, beaconCache)
{
strategies = new IBeaconCacheEvictionStrategy[]
{
new TimeEvictionStrategy(logger, beaconCache, configuration, timingProvider, () => IsShutdownRequested),
new SpaceEvictionStrategy(logger, beaconCache, configuration, () => IsShutdownRequested)
};
}
internal TimeEvictionStrategy(ILogger logger, IBeaconCache beaconCache, IBeaconCacheConfiguration configuration, ITimingProvider timingProvider, Func <bool> isShutdownFunc)
{
this.logger = logger;
this.beaconCache = beaconCache;
this.configuration = configuration;
this.timingProvider = timingProvider;
this.isShutdownFunc = isShutdownFunc;
LastRunTimestamp = -1;
}
internal TestBeaconBuilder()
{
logger = Substitute.For <ILogger>();
beaconCache = Substitute.For <IBeaconCache>();
clientIpAddress = "127.0.0.1";
sessionIdProvider = Substitute.For <ISessionIdProvider>();
threadIdProvider = Substitute.For <IThreadIdProvider>();
timingProvider = Substitute.For <ITimingProvider>();
randomGenerator = Substitute.For <IPrnGenerator>();
}
public TestOpenKitBuilder()
{
logger = Substitute.For <ILogger>();
privacyConfig = Substitute.For <IPrivacyConfiguration>();
openKitConfig = Substitute.For <IOpenKitConfiguration>();
threadIdProvider = Substitute.For <IThreadIdProvider>();
timingProvider = Substitute.For <ITimingProvider>();
sessionIdProvider = Substitute.For <ISessionIdProvider>();
beaconCache = Substitute.For <IBeaconCache>();
beaconSender = Substitute.For <IBeaconSender>();
beaconCacheEvictor = Substitute.For <IBeaconCacheEvictor>();
sessionWatchdog = Substitute.For <ISessionWatchdog>();
}
public void SetUp()
{
mockLogger = Substitute.For <ILogger>();
mockLogger.IsDebugEnabled.Returns(true);
mockLogger.IsInfoEnabled.Returns(true);
mockLogger.IsWarnEnabled.Returns(true);
mockLogger.IsErrorEnabled.Returns(true);
mockBeaconCache = Substitute.For <IBeaconCache>();
mockStrategyOne = Substitute.For <IBeaconCacheEvictionStrategy>();
mockStrategyTwo = Substitute.For <IBeaconCacheEvictionStrategy>();
evictor = null;
}
/// <summary>
/// Internal testing constructor.
/// </summary>
/// <param name="logger">Logger to write some debug output</param>
/// <param name="beaconCache">The Beacon cache to check if entries need to be evicted</param>
/// <param name="strategies">Strategies executed in the thread</param>
internal BeaconCacheEvictor(ILogger logger, IBeaconCache beaconCache, params IBeaconCacheEvictionStrategy[] strategies)
{
this.logger = logger;
this.beaconCache = beaconCache;
this.strategies = strategies;
#if WINDOWS_UWP || NETSTANDARD1_1
evictionThread = new System.Threading.Tasks.Task(RunEvictionThread);
#else
evictionThread = new Thread(RunEvictionThread)
{
Name = GetType().Name,
IsBackground = true
};
#endif
}
/// <summary>
/// Constructor for creating an OpenKit instance.
/// </summary>
/// <param name="initializer">provider to get all OpenKit related configuration parameters.</param>
internal OpenKit(IOpenKitInitializer initializer)
{
logger = initializer.Logger;
privacyConfiguration = initializer.PrivacyConfiguration;
openKitConfiguration = initializer.OpenKitConfiguration;
timingProvider = initializer.TimingProvider;
threadIdProvider = initializer.ThreadIdProvider;
sessionIdProvider = initializer.SessionIdProvider;
beaconCache = initializer.BeaconCache;
beaconCacheEvictor = initializer.BeaconCacheEvictor;
beaconSender = initializer.BeaconSender;
sessionWatchdog = initializer.SessionWatchdog;
LogOpenKitInstanceCreation(logger, openKitConfiguration);
}
/// <summary>
/// Creates a new instance of type Beacon
/// </summary>
/// <param name="initializer">provider of relevant parameters to initialize / create the beacon</param>
/// <param name="configuration">OpenKit related configuration</param>
internal Beacon(IBeaconInitializer initializer, IBeaconConfiguration configuration)
{
beaconCache = initializer.BeaconCache;
var beaconId = initializer.SessionIdProvider.GetNextSessionId();
SessionSequenceNumber = initializer.SessionSequenceNumber;
beaconKey = new BeaconKey(beaconId, SessionSequenceNumber);
SessionNumber = DetermineSessionNumber(configuration, beaconId);
this.configuration = configuration;
threadIdProvider = initializer.ThreadIdProvider;
timingProvider = initializer.TimingProvider;
SessionStartTime = timingProvider.ProvideTimestampInMilliseconds();
DeviceId = CreateDeviceId(configuration, initializer.RandomNumberGenerator);
TrafficControlValue = initializer.RandomNumberGenerator.NextPercentageValue();
logger = initializer.Logger;
var ipAddress = initializer.ClientIpAddress;
if (ipAddress == null)
{
// A client IP address, which is a null, is valid.
// The real IP address is determined on the server side.
clientIpAddress = null;
}
else if (InetAddressValidator.IsValidIP(ipAddress))
{
clientIpAddress = ipAddress;
}
else
{
if (logger.IsWarnEnabled)
{
logger.Warn($"Beacon: Client IP address validation failed: {ipAddress}");
}
clientIpAddress = null; // determined on server side, based on remote IP address
}
basicBeaconData = CreateBasicBeaconData();
}
internal TestOpenKitBuilder With(IBeaconCache cache)
{
this.beaconCache = cache;
return(this);
}
internal TestBeaconBuilder With(IBeaconCache cache)
{
beaconCache = cache;
return(this);
}
