private HttpRequestMessage GetRequestMessage()
{
var path = StandardEndpoints.PollingRequestGetRequestPath(
Base64.UrlSafeEncode(DataModelSerialization.SerializeUser(_currentUser)));
return(new HttpRequestMessage(HttpMethod.Get, MakeRequestUriWithPath(path)));
}
public Task <bool> Start()
{
if (_useReport)
{
_eventSource = CreateEventSource(
_httpProperties,
ReportMethod,
MakeRequestUriWithPath(StandardEndpoints.StreamingReportRequestPath),
DataModelSerialization.SerializeUser(_user)
);
}
else
{
_eventSource = CreateEventSource(
_httpProperties,
HttpMethod.Get,
MakeRequestUriWithPath(StandardEndpoints.StreamingGetRequestPath(
Base64.UrlSafeEncode(DataModelSerialization.SerializeUser(_user)))),
null
);
}
_eventSource.MessageReceived += OnMessage;
_eventSource.Error += OnError;
_eventSource.Opened += OnOpen;
_esStarted = DateTime.Now;
_ = Task.Run(() => _eventSource.StartAsync());
return(_initTask.Task);
}
/// <inheritdoc/>
public LdValue DescribeConfiguration(LdClientContext context) =>
LdValue.BuildObject()
.WithPollingProperties(
StandardEndpoints.IsCustomUri(context.ServiceEndpoints, e => e.PollingBaseUri),
_pollInterval
)
.Add("backgroundPollingIntervalMillis", _backgroundPollInterval.TotalMilliseconds)
.Build();
/// <inheritdoc/>
public LdValue DescribeConfiguration(BasicConfiguration basic) =>
LdValue.BuildObject()
.WithPollingProperties(
StandardEndpoints.IsCustomUri(basic.ServiceEndpoints, _baseUri, e => e.StreamingBaseUri),
_pollInterval
)
.Add("usingRelayDaemon", false) // this property is specific to the server-side SDK
.Build();
/// <inheritdoc/>
public LdValue DescribeConfiguration(BasicConfiguration basic) =>
LdValue.BuildObject()
.WithEventProperties(
MakeEventsConfiguration(basic, false),
StandardEndpoints.IsCustomUri(basic.ServiceEndpoints, _baseUri, e => e.EventsBaseUri)
)
.Add("userKeysCapacity", _userKeysCapacity) // these two properties are specific to the server-side SDK
.Add("userKeysFlushIntervalMillis", _userKeysFlushInterval.TotalMilliseconds)
.Build();
/// <inheritdoc/>
public LdValue DescribeConfiguration(BasicConfiguration basic) =>
LdValue.BuildObject()
.WithStreamingProperties(
StandardEndpoints.IsCustomUri(basic.ServiceEndpoints, _baseUri, e => e.StreamingBaseUri),
false,
_initialReconnectDelay
)
.Set("usingRelayDaemon", false)
.Build();
/// <inheritdoc/>
public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates)
{
var configuredBaseUri = _baseUri ??
StandardEndpoints.SelectBaseUri(context.Basic.ServiceEndpoints, e => e.StreamingBaseUri, "Streaming", context.Basic.Logger);
return(new StreamProcessor(
context,
dataSourceUpdates,
configuredBaseUri,
_initialReconnectDelay,
_eventSourceCreator
));
}
/// <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
));
}
/// <inheritdoc/>
public IDataSource CreateDataSource(LdClientContext context, IDataSourceUpdates dataSourceUpdates)
{
var configuredBaseUri = _baseUri ??
StandardEndpoints.SelectBaseUri(context.Basic.ServiceEndpoints, e => e.PollingBaseUri, "Polling",
context.Basic.Logger);
context.Basic.Logger.Warn("You should only disable the streaming API if instructed to do so by LaunchDarkly support");
FeatureRequestor requestor = new FeatureRequestor(context, configuredBaseUri);
return(new PollingProcessor(
context,
requestor,
dataSourceUpdates,
_pollInterval
));
}
private EventsConfiguration MakeEventsConfiguration(BasicConfiguration basic, bool logConfigErrors)
{
var configuredBaseUri = _baseUri ??
StandardEndpoints.SelectBaseUri(basic.ServiceEndpoints, e => e.EventsBaseUri, "Events",
logConfigErrors ? basic.Logger : Logs.None.Logger(""));
return(new EventsConfiguration
{
AllAttributesPrivate = _allAttributesPrivate,
DiagnosticRecordingInterval = _diagnosticRecordingInterval,
EventCapacity = _capacity,
EventFlushInterval = _flushInterval,
EventsUri = configuredBaseUri.AddPath("bulk"),
DiagnosticUri = configuredBaseUri.AddPath("diagnostic"),
InlineUsersInEvents = _inlineUsersInEvents,
PrivateAttributeNames = _privateAttributes.ToImmutableHashSet(),
UserKeysCapacity = _userKeysCapacity,
UserKeysFlushInterval = _userKeysFlushInterval
});
}
/// <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
));
}
