/// <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); }