/// <summary>
/// Initializes a new instance of the <see cref="IdxClient"/> class using the specified <see cref="HttpClient"/>.
/// </summary>
/// <param name="apiClientConfiguration">
/// The client configuration. If <c>null</c>, the library will attempt to load
/// configuration from an <c>okta.yaml</c> file or environment variables.
/// </param>
/// <param name="httpClient">The HTTP client to use for requests to the Okta API.</param>
/// <param name="logger">The logging interface to use, if any.</param>
public IdxClient(
IdxConfiguration configuration = null,
HttpClient httpClient = null,
ILogger logger = null)
{
Configuration = GetConfigurationOrDefault(configuration);
IdxConfigurationValidator.Validate(Configuration);
GenerateStateCodeVerifierAndChallenge();
_logger = logger ?? NullLogger.Instance;
var userAgentBuilder = new UserAgentBuilder("okta-idx-dotnet", typeof(IdxClient).GetTypeInfo().Assembly.GetName().Version);
// TODO: Allow proxy configuration
httpClient = httpClient ?? DefaultHttpClient.Create(
connectionTimeout: null,
proxyConfiguration: null,
logger: _logger);
var oktaBaseConfiguration = OktaConfigurationConverter.Convert(Configuration);
var resourceTypeResolverFactory = new AbstractResourceTypeResolverFactory(ResourceTypeHelper.GetAllDefinedTypes(typeof(Resource)));
var requestExecutor = new DefaultRequestExecutor(oktaBaseConfiguration, httpClient, _logger);
var resourceFactory = new ResourceFactory(this, _logger, resourceTypeResolverFactory);
_dataStore = new DefaultDataStore(
requestExecutor,
new DefaultSerializer(),
resourceFactory,
_logger,
userAgentBuilder);
}
/// <summary>
/// Initializes a new instance of the <see cref="OktaClient"/> class.
/// </summary>
/// <param name="apiClientConfiguration">
/// The client configuration. If <c>null</c>, the library will attempt to load
/// configuration from an <c>okta.yaml</c> file or environment variables.
/// </param>
/// <param name="logger">The logging interface to use, if any.</param>
/// <param name="serializer">The JSON serializer to use, if any. Using the <c>DefaultSerializer</c> is still strongly recommended since it has all the behavior this SDK needs to work properly.
/// If a custom serializer is used, the developer is responsible to add the required logic for this SDK to continue working properly. See <see cref="DefaultSerializer"/> to check out what can be configured.
/// </param>
public OktaClient(OktaClientConfiguration apiClientConfiguration = null, ILogger logger = null, ISerializer serializer = null)
{
Configuration = GetConfigurationOrDefault(apiClientConfiguration);
OktaClientConfigurationValidator.Validate(Configuration);
logger = logger ?? NullLogger.Instance;
serializer = serializer ?? new DefaultSerializer();
var defaultClient = DefaultHttpClient.Create(
Configuration.ConnectionTimeout,
Configuration.Proxy,
logger);
var resourceFactory = new ResourceFactory(this, logger);
IOAuthTokenProvider oAuthTokenProvider = (Configuration.AuthorizationMode == AuthorizationMode.PrivateKey) ? new DefaultOAuthTokenProvider(Configuration, resourceFactory, logger: logger) : NullOAuthTokenProvider.Instance;
var requestExecutor = new DefaultRequestExecutor(Configuration, defaultClient, logger, oAuthTokenProvider: oAuthTokenProvider);
_dataStore = new DefaultDataStore(
requestExecutor,
serializer,
resourceFactory,
logger);
PayloadHandler.TryRegister <PkixCertPayloadHandler>();
PayloadHandler.TryRegister <PemFilePayloadHandler>();
PayloadHandler.TryRegister <X509CaCertPayloadHandler>();
}
private static IDataStore PrepareIDataStore(OktaClientConfiguration apiClientConfiguration)
{
OktaClientConfiguration oktaClientConfiguration = PrepareOktaClientConfiguration(apiClientConfiguration);
Microsoft.Extensions.Logging.ILogger logger = Microsoft.Extensions.Logging.Abstractions.NullLogger.Instance;
HttpClient httpClient = DefaultHttpClient.Create(
oktaClientConfiguration.ConnectionTimeout,
oktaClientConfiguration.Proxy,
logger);
AbstractResourceTypeResolverFactory resourceTypeResolverFactory = null;
BaseOktaClient baseOktaClient = new BaseOktaClient();
dynamic resourceFactory = new ResourceFactory(baseOktaClient, logger, resourceTypeResolverFactory);
var requestExecutor = new DefaultRequestExecutor(oktaClientConfiguration, httpClient, logger);
UserAgentBuilder userAgentBuilder = new UserAgentBuilder(
"custom", typeof(CustomAuthnClient).GetTypeInfo().Assembly.GetName().Version);
IDataStore dataStore = new DefaultDataStore(
requestExecutor,
new DefaultSerializer(),
resourceFactory,
logger,
userAgentBuilder);
return(dataStore);
}
internal static OktaConnectionContext GetConnectionContext(KeyedCollection <string, ConfigParameter> configParameters)
{
ProxyConfiguration proxyConfig = null;
if (!string.IsNullOrWhiteSpace(OktaMAConfigSection.Configuration.ProxyUrl))
{
proxyConfig = new ProxyConfiguration()
{
Host = OktaMAConfigSection.Configuration.ProxyUrl
};
logger.Info($"Using proxy host {proxyConfig.Host}");
}
logger.Info($"Setting up connection to {configParameters[ConfigParameterNames.TenantUrl].Value}");
System.Net.ServicePointManager.DefaultConnectionLimit = OktaMAConfigSection.Configuration.ConnectionLimit;
GlobalSettings.ExportThreadCount = OktaMAConfigSection.Configuration.ExportThreads;
NLog.Extensions.Logging.NLogLoggerProvider f = new NLog.Extensions.Logging.NLogLoggerProvider();
ILogger nlogger = f.CreateLogger("ext-logger");
OktaClientConfiguration oktaConfig = new OktaClientConfiguration
{
OktaDomain = configParameters[ConfigParameterNames.TenantUrl].Value,
Token = configParameters[ConfigParameterNames.ApiKey].SecureValue.ConvertToUnsecureString(),
Proxy = proxyConfig,
ConnectionTimeout = OktaMAConfigSection.Configuration.HttpClientTimeout,
MaxRetries = 8,
};
HttpClient httpClient;
if (OktaMAConfigSection.Configuration.HttpDebugEnabled)
{
logger.Warn("WARNING: HTTPS Debugging enabled. Service certificate validation is disabled");
httpClient = OktaConnectionContext.CreateDebugHttpClient(nlogger, oktaConfig);
}
else
{
httpClient = DefaultHttpClient.Create(oktaConfig.ConnectionTimeout, proxyConfig, nlogger);
}
return(new OktaConnectionContext()
{
Client = new OktaClient(oktaConfig, httpClient, nlogger, new DefaultRetryStrategy(oktaConfig.MaxRetries ?? 8, 0, 1))
});
}
/// <summary>
/// Initializes a new instance of the <see cref="OktaClient"/> class.
/// </summary>
/// <param name="apiClientConfiguration">
/// The client configuration. If <c>null</c>, the library will attempt to load
/// configuration from an <c>okta.yaml</c> file or environment variables.
/// </param>
/// <param name="logger">The logging interface to use, if any.</param>
public OktaClient(OktaClientConfiguration apiClientConfiguration = null, ILogger logger = null)
{
Configuration = GetConfigurationOrDefault(apiClientConfiguration);
ThrowIfInvalidConfiguration(Configuration);
logger = logger ?? NullLogger.Instance;
var defaultClient = DefaultHttpClient.Create(
Configuration.ConnectionTimeout,
Configuration.Proxy,
logger);
var requestExecutor = new DefaultRequestExecutor(Configuration, defaultClient, logger);
var resourceFactory = new ResourceFactory(this, logger);
_dataStore = new DefaultDataStore(
requestExecutor,
new DefaultSerializer(),
resourceFactory,
logger);
}
public async Task NotSendCloseConnectionHeaderWhenUsingTheDefaultClient()
{
var testOktaClient = TestClient.Create();
var configuration = testOktaClient.Configuration;
var httpClient = DefaultHttpClient.Create(configuration.ConnectionTimeout, configuration.Proxy, NullLogger.Instance);
var requestExecutor = new DefaultRequestExecutor(configuration, httpClient, NullLogger.Instance);
var resourceFactory = new ResourceFactory(testOktaClient, NullLogger.Instance);
var dataStore = new DefaultDataStore(requestExecutor, new DefaultSerializer(), resourceFactory, NullLogger.Instance);
var response = await dataStore.GetAsync <Resource>(
new HttpRequest
{
// Endpoint that returns a chunked response
Uri = $"/api/v1/meta/schemas/user/default",
},
null,
default(CancellationToken));
var connectionHeader = response.Headers.FirstOrDefault(x => x.Key.Equals("connection", StringComparison.OrdinalIgnoreCase));
connectionHeader.Value?.Any(s => s.Equals("close", StringComparison.OrdinalIgnoreCase)).Should().BeFalse();
}
public void NotHaveCloseConnectionAsDefaultHeader()
{
var client = DefaultHttpClient.Create(30, null, NullLogger.Instance);
client.DefaultRequestHeaders?.Connection?.Should().BeNullOrEmpty();
}
