ConnectionPoolProvider.cs

/*
 * Copyright 2017 Stanislav Muhametsin. All rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
 * implied.
 *
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */
using CBAM.Abstractions;
using CBAM.Abstractions.Implementation.NetworkStream;
using CBAM.SQL.Implementation;
using CBAM.SQL.PostgreSQL;
using CBAM.SQL.PostgreSQL.Implementation;
using IOUtils.Network.Configuration;
using ResourcePooling.Async.Abstractions;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using UtilPack;
namespace CBAM.SQL.PostgreSQL
{
 using TIntermediateState = ValueTuple<BackendABIHelper, ResizableArray<Byte>, CancellationToken, Stream>;
 /// <summary>
 /// This is the entrypoint-class for using PostgreSQL connections.
 /// Use <see cref="Factory"/> static property to acquire <see cref="AsyncResourceFactory{TResource, TParams}"/> for <see cref="PgSQLConnection"/>, and then use <see cref="AsyncResourceFactory{TResource, TParams}.BindCreationParameters"/> to obtain <see cref="AsyncResourceFactory{TResource}"/>.
 /// This <see cref="AsyncResourceFactory{TResource}"/> with one generic type parameter then has a number of extension methods which create various <see cref="AsyncResourcePool{TResource}"/>s, those pools then provide effective mechanism to actually use <see cref="PgSQLConnection"/>s.
 /// </summary>
 /// <remarks>
 /// This class also (explicitly) implements <see cref="AsyncResourceFactoryProvider"/> interface in order to provide dynamic creation of <see cref="AsyncResourcePool{TResource}"/>s, but this is used in generic scenarios (e.g. MSBuild task, where this class can be given as parameter, and the task dynamically loads this type).
 /// </remarks>
 public sealed class PgSQLConnectionPoolProvider : AbstractAsyncResourceFactoryProvider<PgSQLConnection, PgSQLConnectionCreationInfo>
 {

 /// <summary>
 /// Gets the <see cref="AsyncResourceFactory{TResource, TParams}"/> which can create pools that provide instances of <see cref="PgSQLConnection"/> to use.
 /// </summary>
 /// <value>The <see cref="AsyncResourceFactory{TResource, TParams}"/> which can create <see cref="PgSQLConnection"/> to use.</value>
 /// <remarks>
 /// By invoking <see cref="AsyncResourceFactory{TResource, TParams}.BindCreationParameters"/>, one gets the bound version <see cref="AsyncResourceFactory{TResource}"/>, with only one generic parameter.
 /// Instead of directly using <see cref="AsyncResourceFactory{TResource}.CreateAcquireResourceContext"/>, typical scenario would involve creating an instance <see cref="AsyncResourcePool{TResource}"/> by invoking one of various extension methods for <see cref="AsyncResourceFactory{TResource}"/>.
 /// </remarks>
 public static AsyncResourceFactory<PgSQLConnection, PgSQLConnectionCreationInfo> Factory { get; } = new DefaultAsyncResourceFactory<PgSQLConnection, PgSQLConnectionCreationInfo>( config =>
 config.NewFactoryParametrizer<PgSQLConnectionCreationInfo, PgSQLConnectionCreationInfoData, PgSQLConnectionConfiguration, PgSQLInitializationConfiguration, PgSQLProtocolConfiguration, PgSQLPoolingConfiguration>()
 .BindPublicConnectionType<PgSQLConnection>()
 .CreateStatefulDelegatingConnectionFactory(
 new UTF8EncodingInfo(),
 ( parameters, encodingInfo, stringPool, stringPoolIsDedicated, socketOrNull, stream, token ) => new TIntermediateState( new BackendABIHelper( encodingInfo, stringPool ), new ResizableArray<Byte>( initialSize: 8, exponentialResize: true ), token, stream ),
 async ( parameters, encodingInfo, stringPool, stringPoolIsDedicated, state ) =>
 {
 var sslMode = parameters.CreationData?.Connection?.ConnectionSSLMode ?? ConnectionSSLMode.NotRequired;
 var retVal = sslMode == ConnectionSSLMode.Required || sslMode == ConnectionSSLMode.Preferred;
 if ( retVal )
 {
 await SSLRequestMessage.INSTANCE.SendMessageAsync( (state.Item1, state.Item4, state.Item3, state.Item2) );

 await state.Item4.ReadSpecificAmountAsync( state.Item2.Array, 0, 1, state.Item3 );
 retVal = state.Item2.Array[0] == (Byte) 'S';
 }

 return retVal;
 },
 () => new PgSQLException( "Server accepted SSL request, but the creation parameters did not have callback to create SSL stream" ),
 () => new PgSQLException( "Server does not support SSL." ),
 () => new PgSQLException( "SSL stream creation callback returned null." ),
 () => new PgSQLException( "Authentication callback given by SSL stream creation callback was null." ),
 inner => new PgSQLException( "Unable to start SSL client.", inner ),
 async ( parameters, encodingInfo, stringPool, stringPoolIsDedicated, stream, socketOrNull, token, state ) =>
 {
 (var proto, var warnings) = await PostgreSQLProtocol.PerformStartup(
 new PgSQLConnectionVendorFunctionalityImpl(),
 parameters,
 token,
 stream,
 state.Item1,
 state.Item2
#if !NETSTANDARD1_0
 , (System.Net.Sockets.Socket) socketOrNull
#endif
 );

 return proto;
 },
 protocol => new ValueTask<PgSQLConnectionImpl>( new PgSQLConnectionImpl( protocol, new PgSQLDatabaseMetaData( protocol ) ) ),
 ( protocol, connection ) => new PgSQLConnectionAcquireInfo( connection, protocol ),
 ( functionality, connection, token, error ) => functionality?.Stream
 ) );

 //new PgSQLConnectionFactory( config, new UTF8EncodingInfo() ) );

 /// <summary>
 /// Creates a new instance of <see cref="PgSQLConnectionPoolProvider"/>.
 /// </summary>
 /// <remarks>
 /// This constructor is not intended to be used directly, but a generic scenarios like MSBuild task dynamically loading this type.
 /// </remarks>
 public PgSQLConnectionPoolProvider()
 : base( typeof( PgSQLConnectionCreationInfoData ) )
 {
 }

 /// <summary>
 /// This method implements <see cref="AbstractAsyncResourceFactoryProvider{TFactoryResource, TCreationParameters}.TransformFactoryParameters"/> method, by checking that given object is <see cref="PgSQLConnectionCreationInfo"/> or <see cref="PgSQLConnectionCreationInfoData"/>.
 /// </summary>
 /// <param name="creationParameters">The untyped creation parameters.</param>
 /// <returns>The <see cref="PgSQLConnectionCreationInfo"/>.</returns>
 /// <exception cref="ArgumentNullException">If <paramref name="creationParameters"/> is <c>null</c>.</exception>
 /// <exception cref="ArgumentException">If <paramref name="creationParameters"/> is not <see cref="PgSQLConnectionCreationInfo"/> or <see cref="PgSQLConnectionCreationInfoData"/>.</exception>
 protected override PgSQLConnectionCreationInfo TransformFactoryParameters( Object creationParameters )
 {
 ArgumentValidator.ValidateNotNull( nameof( creationParameters ), creationParameters );

 PgSQLConnectionCreationInfo retVal;
 if ( creationParameters is PgSQLConnectionCreationInfoData creationData )
 {
 retVal = new PgSQLConnectionCreationInfo( creationData );

 }
 else if ( creationParameters is PgSQLConnectionCreationInfo creationInfo )
 {
 retVal = creationInfo;
 }
 else
 {
 throw new ArgumentException( $"The {nameof( creationParameters )} must be instance of {typeof( PgSQLConnectionCreationInfoData ).FullName}." );
 }

 return retVal;
 }

 /// <summary>
 /// This method implements <see cref="AbstractAsyncResourceFactoryProvider{TFactoryResource, TCreationParameters}.CreateFactory"/> by returning static property <see cref="Factory"/>.
 /// </summary>
 /// <returns>The value of <see cref="Factory"/> static property.</returns>
 protected override AsyncResourceFactory<PgSQLConnection, PgSQLConnectionCreationInfo> CreateFactory()
 => Factory;
 }
}