Example #1
0
        /// <inheritdoc/>
        public IDataSource CreateDataSource(
            LdClientContext context,
            IDataSourceUpdateSink updateSink,
            User currentUser,
            bool inBackground
            )
        {
            var baseUri = StandardEndpoints.SelectBaseUri(
                context.ServiceEndpoints,
                e => e.StreamingBaseUri,
                "Streaming",
                context.BaseLogger
                );
            var pollingBaseUri = StandardEndpoints.SelectBaseUri(
                context.ServiceEndpoints,
                e => e.PollingBaseUri,
                "Polling",
                context.BaseLogger
                );

            if (inBackground)
            {
                // When in the background, always use polling instead of streaming
                return(new PollingDataSourceBuilder()
                       .BackgroundPollInterval(_backgroundPollInterval)
                       .CreateDataSource(context, updateSink, currentUser, true));
            }

            var logger    = context.BaseLogger.SubLogger(LogNames.DataSourceSubLog);
            var requestor = new FeatureFlagRequestor(
                pollingBaseUri,
                currentUser,
                context.EvaluationReasons,
                context.Http,
                logger
                );

            return(new StreamingDataSource(
                       updateSink,
                       currentUser,
                       baseUri,
                       context.EvaluationReasons,
                       _initialReconnectDelay,
                       requestor,
                       context.Http,
                       logger,
                       context.DiagnosticStore
                       ));
        }
Example #2
0
        /// <inheritdoc/>
        public IDataSource CreateDataSource(
            LdClientContext context,
            IDataSourceUpdateSink updateSink,
            User currentUser,
            bool inBackground
            )
        {
            if (!inBackground)
            {
                context.BaseLogger.Warn("You should only disable the streaming API if instructed to do so by LaunchDarkly support");
            }
            var baseUri = StandardEndpoints.SelectBaseUri(
                context.ServiceEndpoints,
                e => e.PollingBaseUri,
                "Polling",
                context.BaseLogger
                );

            var logger    = context.BaseLogger.SubLogger(LogNames.DataSourceSubLog);
            var requestor = new FeatureFlagRequestor(
                baseUri,
                currentUser,
                context.EvaluationReasons,
                context.Http,
                logger
                );

            return(new PollingDataSource(
                       updateSink,
                       currentUser,
                       requestor,
                       _pollInterval,
                       TimeSpan.Zero,
                       context.TaskExecutor,
                       logger
                       ));
        }
        public async Task GetFlagsUsesCorrectUriAndMethodInGetModeWithReasonsAsync()
        {
            await WithServerAsync(async server =>
            {
                server.ForAllRequests(r => r.WithJsonBody(_allDataJson));

                var config = Configuration.Builder(_mobileKey).BaseUri(new Uri(server.GetUrl()))
                             .EvaluationReasons(true).Build();

                using (var requestor = new FeatureFlagRequestor(config, _user))
                {
                    var resp = await requestor.FeatureFlagsAsync();
                    Assert.Equal(200, resp.statusCode);
                    Assert.Equal(_allDataJson, resp.jsonResponse);

                    var req = server.GetLastRequest();
                    Assert.Equal("GET", req.Method);
                    Assert.Equal($"/msdk/evalx/users/{_encodedUser}", req.Path);
                    Assert.Equal("?withReasons=true", req.RawQuery);
                    Assert.Equal(_mobileKey, req.Headers["Authorization"][0]);
                    Assert.Null(req.Body);
                }
            });
        }