internal static IMobileUpdateProcessor CreateUpdateProcessor(Configuration configuration,
User user,
IFlagCacheManager flagCacheManager,
StreamManager.EventSourceCreator source = null)
{
if (configuration.MobileUpdateProcessor != null)
{
return(configuration.MobileUpdateProcessor);
}
if (configuration.Offline)
{
Log.InfoFormat("Starting LaunchDarkly client in offline mode");
return(new NullUpdateProcessor());
}
if (configuration.IsStreamingEnabled)
{
return(new MobileStreamingProcessor(configuration,
flagCacheManager,
user, source));
}
else
{
var featureFlagRequestor = new FeatureFlagRequestor(configuration, user);
return(new MobilePollingProcessor(featureFlagRequestor,
flagCacheManager,
user,
configuration.PollingInterval));
}
}
LdClient(Configuration configuration, User user)
{
Config = configuration;
connectionLock = new SemaphoreSlim(1, 1);
persister = Factory.CreatePersister(configuration);
deviceInfo = Factory.CreateDeviceInfo(configuration);
flagListenerManager = Factory.CreateFeatureFlagListenerManager(configuration);
// If you pass in a null user or user with a null key, one will be assigned to them.
if (user == null || user.Key == null)
{
User = UserWithUniqueKey(user);
}
else
{
User = user;
}
flagCacheManager = Factory.CreateFlagCacheManager(configuration, persister, flagListenerManager, User);
connectionManager = Factory.CreateConnectionManager(configuration);
updateProcessor = Factory.CreateUpdateProcessor(configuration, User, flagCacheManager);
eventProcessor = Factory.CreateEventProcessor(configuration);
SetupConnectionManager();
}
internal MobileStreamingProcessor(IMobileConfiguration configuration,
IFlagCacheManager cacheManager,
User user,
StreamManager.EventSourceCreator eventSourceCreator)
{
this._configuration = configuration;
this._cacheManager = cacheManager;
this._user = user;
StreamProperties streamProperties;
if (_configuration.UseReport)
{
streamProperties = MakeStreamPropertiesForREPORT();
}
else
{
streamProperties = MakeStreamPropertiesForGET();
}
_streamManager = new StreamManager(this,
streamProperties,
_configuration,
MobileClientEnvironment.Instance,
eventSourceCreator);
}
internal static IMobileUpdateProcessor CreateUpdateProcessor(Configuration configuration,
User user,
IFlagCacheManager flagCacheManager,
StreamManager.EventSourceCreator source = null)
{
if (configuration.MobileUpdateProcessor != null)
{
return(configuration.MobileUpdateProcessor);
}
IMobileUpdateProcessor updateProcessor = null;
if (configuration.Offline)
{
Log.InfoFormat("Was configured to be offline, starting service with NullUpdateProcessor");
return(new NullUpdateProcessor());
}
if (configuration.IsStreamingEnabled)
{
updateProcessor = new MobileStreamingProcessor(configuration,
flagCacheManager,
user, source);
}
else
{
var featureFlagRequestor = new FeatureFlagRequestor(configuration, user);
updateProcessor = new MobilePollingProcessor(featureFlagRequestor,
flagCacheManager,
user,
configuration.PollingInterval);
}
return(updateProcessor);
}
internal static Func <IMobileUpdateProcessor> CreateUpdateProcessorFactory(Configuration configuration, User user,
IFlagCacheManager flagCacheManager, bool inBackground)
{
return(() =>
{
if (configuration._updateProcessorFactory != null)
{
return configuration._updateProcessorFactory(configuration, flagCacheManager, user);
}
if (configuration.IsStreamingEnabled && !inBackground)
{
return new MobileStreamingProcessor(configuration, flagCacheManager, user, null);
}
else
{
var featureFlagRequestor = new FeatureFlagRequestor(configuration, user);
return new MobilePollingProcessor(featureFlagRequestor,
flagCacheManager,
user,
inBackground ? configuration.BackgroundPollingInterval : configuration.PollingInterval,
inBackground ? configuration.BackgroundPollingInterval : TimeSpan.Zero);
}
});
}
public Func <Configuration, IFlagCacheManager, User, IMobileUpdateProcessor> AsFactory()
{
return((config, manager, user) =>
{
_cacheManager = manager;
_user = user;
return this;
});
}
IMobileUpdateProcessor Processor()
{
var mockFeatureFlagRequestor = new MockFeatureFlagRequestor(flagsJson);
var stubbedFlagCache = new UserFlagInMemoryCache();
mockFlagCacheManager = new MockFlagCacheManager(stubbedFlagCache);
user = User.WithKey("user1Key");
return(new MobilePollingProcessor(mockFeatureFlagRequestor, mockFlagCacheManager, user, TimeSpan.FromSeconds(30), TimeSpan.Zero));
}
public MobileStreamingProcessorTests()
{
mockEventSource = new EventSourceMock();
eventSourceFactory = new TestEventSourceFactory(mockEventSource);
mockFlagCacheMgr = new MockFlagCacheManager(new UserFlagInMemoryCache());
configBuilder = Configuration.BuilderInternal("someKey")
.ConnectivityStateManager(new MockConnectivityStateManager(true))
.FlagCacheManager(mockFlagCacheMgr)
.IsStreamingEnabled(true);
}
internal MobilePollingProcessor(IFeatureFlagRequestor featureFlagRequestor,
IFlagCacheManager cacheManager,
User user,
TimeSpan pollingInterval)
{
this._featureFlagRequestor = featureFlagRequestor;
this._flagCacheManager = cacheManager;
this.user = user;
this.pollingInterval = pollingInterval;
_startTask = new TaskCompletionSource <bool>();
_stopTask = new TaskCompletionSource <bool>();
}
LdClient(Configuration configuration, User user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
_config = configuration ?? throw new ArgumentNullException(nameof(configuration));
persister = Factory.CreatePersistentStorage(configuration);
deviceInfo = Factory.CreateDeviceInfo(configuration);
flagChangedEventManager = Factory.CreateFlagChangedEventManager(configuration);
_user = DecorateUser(user);
flagCacheManager = Factory.CreateFlagCacheManager(configuration, persister, flagChangedEventManager, User);
_connectionManager = new ConnectionManager();
_connectionManager.SetForceOffline(configuration.Offline);
if (configuration.Offline)
{
Log.InfoFormat("Starting LaunchDarkly client in offline mode");
}
_connectionManager.SetUpdateProcessorFactory(
Factory.CreateUpdateProcessorFactory(configuration, User, flagCacheManager, _inBackground),
true
);
_connectivityStateManager = Factory.CreateConnectivityStateManager(configuration);
_connectivityStateManager.ConnectionChanged += networkAvailable =>
{
Log.DebugFormat("Setting online to {0} due to a connectivity change event", networkAvailable);
_ = _connectionManager.SetNetworkEnabled(networkAvailable); // do not await the result
eventProcessor.SetOffline(!networkAvailable || _connectionManager.ForceOffline);
};
var isConnected = _connectivityStateManager.IsConnected;
_connectionManager.SetNetworkEnabled(isConnected);
eventProcessor = Factory.CreateEventProcessor(configuration);
eventProcessor.SetOffline(configuration.Offline || !isConnected);
// Send an initial identify event, but only if we weren't explicitly set to be offline
if (!configuration.Offline)
{
eventProcessor.SendEvent(_eventFactoryDefault.NewIdentifyEvent(User));
}
_backgroundModeManager = _config._backgroundModeManager ?? new DefaultBackgroundModeManager();
_backgroundModeManager.BackgroundModeChanged += OnBackgroundModeChanged;
}
private IMobileUpdateProcessor MobileStreamingProcessorStarted()
{
mockEventSource = new EventSourceMock();
eventSourceFactory = new TestEventSourceFactory(mockEventSource);
// stub with an empty InMemoryCache, so Stream updates can be tested
mockFlagCacheMgr = new MockFlagCacheManager(new UserFlagInMemoryCache());
var config = Configuration.Default("someKey")
.WithConnectionManager(new MockConnectionManager(true))
.WithIsStreamingEnabled(true)
.WithFlagCacheManager(mockFlagCacheMgr);
var processor = Factory.CreateUpdateProcessor(config, user, mockFlagCacheMgr, eventSourceFactory.Create());
processor.Start();
return(processor);
}
internal MobileStreamingProcessor(Configuration configuration,
IFlagCacheManager cacheManager,
User user,
StreamManager.EventSourceCreator eventSourceCreator)
{
this._configuration = configuration;
this._cacheManager = cacheManager;
this._user = user;
var streamProperties = _configuration.UseReport ? MakeStreamPropertiesForReport() : MakeStreamPropertiesForGet();
_streamManager = new StreamManager(this,
streamProperties,
_configuration.StreamManagerConfiguration,
MobileClientEnvironment.Instance,
eventSourceCreator);
}
LdClient(Configuration configuration, User user)
{
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (user == null)
{
throw new ArgumentNullException("user");
}
Config = configuration;
connectionLock = new SemaphoreSlim(1, 1);
persister = Factory.CreatePersister(configuration);
deviceInfo = Factory.CreateDeviceInfo(configuration);
flagListenerManager = Factory.CreateFeatureFlagListenerManager(configuration);
platformAdapter = Factory.CreatePlatformAdapter(configuration);
// If you pass in a user with a null or blank key, one will be assigned to them.
if (String.IsNullOrEmpty(user.Key))
{
User = UserWithUniqueKey(user);
}
else
{
User = user;
}
flagCacheManager = Factory.CreateFlagCacheManager(configuration, persister, flagListenerManager, User);
connectionManager = Factory.CreateConnectionManager(configuration);
updateProcessor = Factory.CreateUpdateProcessor(configuration, User, flagCacheManager);
eventProcessor = Factory.CreateEventProcessor(configuration);
eventProcessor.SendEvent(eventFactory.NewIdentifyEvent(User));
SetupConnectionManager();
}
internal Configuration(ConfigurationBuilder builder)
{
_allAttributesPrivate = builder._allAttributesPrivate;
_backgroundPollingInterval = builder._backgroundPollingInterval;
_baseUri = builder._baseUri;
_connectionTimeout = builder._connectionTimeout;
_enableBackgroundUpdating = builder._enableBackgroundUpdating;
_evaluationReasons = builder._evaluationReasons;
_eventFlushInterval = builder._eventFlushInterval;
_eventCapacity = builder._eventCapacity;
_eventsUri = builder._eventsUri;
_httpMessageHandler = object.ReferenceEquals(builder._httpMessageHandler, ConfigurationBuilder.DefaultHttpMessageHandlerInstance) ?
PlatformSpecific.Http.CreateHttpMessageHandler(builder._connectionTimeout, builder._readTimeout) :
builder._httpMessageHandler;
_inlineUsersInEvents = builder._inlineUsersInEvents;
_isStreamingEnabled = builder._isStreamingEnabled;
_mobileKey = builder._mobileKey;
_offline = builder._offline;
_persistFlagValues = builder._persistFlagValues;
_pollingInterval = builder._pollingInterval;
_privateAttributeNames = builder._privateAttributeNames is null ? null :
builder._privateAttributeNames.ToImmutableHashSet();
_readTimeout = builder._readTimeout;
_reconnectTime = builder._reconnectTime;
_streamUri = builder._streamUri;
_useReport = builder._useReport;
_userKeysCapacity = builder._userKeysCapacity;
_userKeysFlushInterval = builder._userKeysFlushInterval;
_backgroundModeManager = builder._backgroundModeManager;
_connectivityStateManager = builder._connectivityStateManager;
_deviceInfo = builder._deviceInfo;
_eventProcessor = builder._eventProcessor;
_flagCacheManager = builder._flagCacheManager;
_flagChangedEventManager = builder._flagChangedEventManager;
_persistentStorage = builder._persistentStorage;
_updateProcessorFactory = builder._updateProcessorFactory;
}
/// <summary>
/// Sets the IFlagCacheManager instance, used internally for stubbing mock instances.
/// </summary>
/// <param name="configuration">Configuration.</param>
/// <param name="flagCacheManager">FlagCacheManager.</param>
/// <returns>the same <c>Configuration</c> instance</returns>
internal static Configuration WithFlagCacheManager(this Configuration configuration, IFlagCacheManager flagCacheManager)
{
configuration.FlagCacheManager = flagCacheManager;
return(configuration);
}
private MockPollingProcessor(IFlagCacheManager cacheManager, User user, string flagsJson)
{
_cacheManager = cacheManager;
_user = user;
_flagsJson = flagsJson;
}
internal ConfigurationBuilder FlagCacheManager(IFlagCacheManager flagCacheManager)
{
_flagCacheManager = flagCacheManager;
return(this);
}
