internal BrokerWrapper(IConnectionBuilder connectionBuilder,
IModel model,
EnvironmentConfiguration configuration)
: base(configuration, connectionBuilder)
{
_model = model;
}
public static FrontEndConnection CreateFrontEndConnection(
string identifier,
ConnectionBuilderSettings settings,
params object[] parameters)
{
Type t = GenericClassIdentifierFactory.FindTypeForIdentifier <FrontEndConnection>(identifier);
if (t == null)
{
return(null);
}
FrontEndConnectionAttribute attr = (FrontEndConnectionAttribute)t.GetCustomAttributes(typeof(FrontEndConnectionAttribute), false)[0];
if (attr.ConnectionBuilder != null)
{
IConnectionBuilder connectionBuilder = (IConnectionBuilder)
GenericClassIdentifierFactory.CreateInstance(attr.ConnectionBuilder, parameters);
connectionBuilder.Settings = settings;
return(connectionBuilder.SetupConnection());
}
else
{
return(GenericClassIdentifierFactory.CreateFromClassIdentifierOrType <FrontEndConnection>(identifier, parameters));
}
}
public void Invoke(IConnectionBuilder builder)
{
foreach (var configureDelegate in this.configurationDelegates)
{
configureDelegate(builder);
}
}
public Server(IConnectionBuilder listener, IFormatter formatter, Func <IConnection <TMessage> > connectionFactory, IHeartBeatFactory <TMessage> heartbeatFactory)
{
this.listener = listener;
this.formatter = formatter;
this.connectionFactory = connectionFactory;
this.heartbeatFactory = heartbeatFactory;
}
public static IConnectionBuilder UseConnectionHandler <TConnectionHandler>(this IConnectionBuilder connectionBuilder) where TConnectionHandler : ConnectionHandler
{
var handler = ActivatorUtilities.GetServiceOrCreateInstance <TConnectionHandler>(connectionBuilder.ApplicationServices);
// This is a terminal middleware, so there's no need to use the 'next' parameter
return(connectionBuilder.Run(connection => handler.OnConnectedAsync(connection)));
}
protected internal Broker(EnvironmentConfiguration configuration, IConnectionBuilder connectionBuilder)
{
_configuration = configuration;
_connectionBuilder = connectionBuilder;
_retryPolicy = _connectionBuilder.RetryPolicy;
_circuitBreakerPolicy = _connectionBuilder.CircuitBreakerPolicy;
}
internal BrokerWrapper(IConnectionBuilder connectionBuilder,
IModel model,
EnvironmentConfiguration configuration)
: base(configuration, connectionBuilder)
{
_model = model;
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
internal Connection(Server server, IConnectionBuilder builder)
{
_connectionType = builder.ConnectionType;
_bufferSize = builder.BufferSize;
Created = DateTime.UtcNow;
Server = server;
var socket = new TSocket(server.Host, server.Port, server.Timeout * 1000);
switch (_connectionType)
{
case ConnectionType.Simple:
_transport = socket;
break;
case ConnectionType.Buffered:
_transport = new TBufferedTransport(socket, _bufferSize);
break;
case ConnectionType.Framed:
_transport = new TFramedTransport(socket);
break;
}
_protocol = new TBinaryProtocol(_transport);
_client = new Cassandra.Client(_protocol);
}
public static IConnectionBuilder UseServer(this IConnectionBuilder builder, IList <IConnectionAdapter> adapters)
{
return(builder.Use(next =>
{
return context => Task.WhenAll(adapters.Select(a => a.OnConnectionAsync(new ConnectionAdapterContext(context, new RawStream(context.Transport.Input, context.Transport.Output)))));
}));
}
protected override void ConfigureConnectionBuilder(IConnectionBuilder connectionBuilder)
{
var configureDelegate = (SiloConnectionOptions.ISiloConnectionBuilderOptions) this.siloConnectionOptions;
configureDelegate.ConfigureSiloOutboundBuilder(connectionBuilder);
base.ConfigureConnectionBuilder(connectionBuilder);
}
private static IConnectionProvider CreateProvider(IConnectionBuilder builder)
{
if (builder.Pooling)
return new PooledConnectionProvider(builder);
else
return new NormalConnectionProvider(builder);
}
public static IConnectionBuilder UseEndPoint <TEndPoint>(this IConnectionBuilder connectionBuilder) where TEndPoint : EndPoint
{
var endpoint = connectionBuilder.ApplicationServices.GetRequiredService <TEndPoint>();
// This is a terminal middleware, so there's no need to use the 'next' parameter
return(connectionBuilder.Run(connection => endpoint.OnConnectedAsync(connection)));
}
private static IServerManager CreateManager(IConnectionBuilder builder)
{
if (builder.Servers.Count == 1) {
return new SingleServerManager(builder);
} else {
return new RoundRobinServerManager(builder);
}
}
public static IConnectionBuilder UseHttpServer(this IConnectionBuilder builder, IHttpApplication application)
{
return(builder.Run(connection =>
{
var httpConnection = HttpServerProtocol.CreateFromConnection(connection);
return application.ProcessRequests(httpConnection.ReadAllRequestsAsync());
}));
}
protected SQLiteServerConnection CreateConnectionNewSource(IConnectionBuilder connectionBuilder = null
, int?defaultTimeout = null)
{
var source = GetTempFileName();
_sources.Add(source);
return(CreateConnection(connectionBuilder, defaultTimeout, source));
}
public RoundRobinServerManager(IConnectionBuilder builder)
{
_servers = new List <Server>(builder.Servers);
_serverQueue = new Queue <Server>(_servers);
_blackListed = new HashSet <Server>();
_recoveryTimerInterval = (long)builder.ServerPollingInterval.TotalMilliseconds;
_recoveryTimer = new Timer(o => ServerRecover(), null, _recoveryTimerInterval, Timeout.Infinite);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public NormalConnectionProvider(IConnectionBuilder builder)
: base(builder)
{
if (builder.Servers.Count > 1 && builder.ConnectionTimeout == TimeSpan.Zero)
throw new CassandraException("You must specify a timeout when using multiple servers.");
ConnectionTimeout = builder.ConnectionTimeout;
}
public RoundRobinServerManager(IConnectionBuilder builder)
{
_servers = new List<Server>(builder.Servers);
_serverQueue = new Queue<Server>(_servers);
_blackListed = new HashSet<Server>();
_recoveryTimerInterval = (long)builder.ServerPollingInterval.TotalMilliseconds;
_recoveryTimer = new Timer(o => ServerRecover(), null, _recoveryTimerInterval, Timeout.Infinite);
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public PooledConnectionProvider(IConnectionBuilder builder)
: base(builder)
{
MinPoolSize = builder.MinPoolSize;
MaxPoolSize = builder.MaxPoolSize;
ConnectionLifetime = builder.ConnectionLifetime;
_maintenanceTimer = new Timer(o => Cleanup(), null, 30000L, 30000L);
}
protected SQLiteServerConnection CreateConnection(
IConnectionBuilder connectionBuilder,
SQLiteServerConnection parent)
{
var connection = new SQLiteServerConnection(parent.ConnectionString, connectionBuilder);
_connections.Add(connection);
return(connection);
}
/// <summary>
///
/// </summary>
/// <param name="connectionBuilder"></param>
public CassandraContext(IConnectionBuilder connectionBuilder)
{
ThrowErrors = true;
_trackers = new List <IFluentMutationTracker>();
ConnectionBuilder = connectionBuilder;
Keyspace = new CassandraKeyspace(ConnectionBuilder.Keyspace, this);
}
public static IConnectionBuilder UseHttpServer <TContext>(this IConnectionBuilder builder, ServiceContext serviceContext, IHttpApplication <TContext> application, HttpProtocols protocols) where TContext : notnull
{
var middleware = new HttpConnectionMiddleware <TContext>(serviceContext, application, protocols);
return(builder.Use(next =>
{
return middleware.OnConnectionAsync;
}));
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public PooledConnectionProvider(IConnectionBuilder builder)
: base(builder)
{
MinPoolSize = builder.MinPoolSize;
MaxPoolSize = builder.MaxPoolSize;
ConnectionLifetime = builder.ConnectionLifetime;
_maintenanceTimer = new Timer(o => Cleanup(), null, 30000L, 30000L);
}
public static IConnectionBuilder UseHttpServer <TContext>(this IConnectionBuilder builder, IList <IConnectionAdapter> adapters, ServiceContext serviceContext, IHttpApplication <TContext> application, HttpProtocols protocols)
{
var middleware = new HttpConnectionMiddleware <TContext>(adapters, serviceContext, application, protocols);
return(builder.Use(next =>
{
return middleware.OnConnectionAsync;
}));
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
public NormalConnectionProvider(IConnectionBuilder builder)
: base(builder)
{
if (builder.Servers.Count > 1 && builder.ConnectionTimeout == TimeSpan.Zero)
{
throw new CassandraException("You must specify a timeout when using multiple servers.");
}
ConnectionTimeout = builder.ConnectionTimeout;
}
private void AcceptClientsAsync(IConnectionBuilder listenerObject)
{
Task.Run(() =>
{
while (true)
{
AcceptAsync(listenerObject.AcceptClient());
}
});
}
/// <summary>
/// Add the given <paramref name="middleware"/> to the connection.
/// </summary>
/// <param name="connectionBuilder">The <see cref="IConnectionBuilder"/>.</param>
/// <param name="middleware">The middleware to add to the <see cref="IConnectionBuilder"/>.</param>
/// <returns>The <see cref="IConnectionBuilder"/>.</returns>
public static IConnectionBuilder Run(this IConnectionBuilder connectionBuilder, Func <ConnectionContext, Task> middleware)
{
return(connectionBuilder.Use(next =>
{
return context =>
{
return middleware(context);
};
}));
}
public BaseScriptExecutor(ConnectionProperties connectionProperties, JobExecutionContext context, IConnectionBuilder connectionBuilder)
{
ConnectionProperties = connectionProperties;
Context = context;
ConnectionBuilder = connectionBuilder;
if (!string.IsNullOrEmpty(context.Database))
{
ConnectionProperties.WithDatabaseName(context.Database); // todo it will change conProp object, be careful
}
}
public static IConnectionBuilder UseTlsFilter(
this IConnectionBuilder builder)
{
return(builder.Use((connection, next) =>
{
/// Write code here to use the connection to filter the connection before the handshake
return next();
}));
}
private static IConnectionProvider CreateProvider(IConnectionBuilder builder)
{
if (builder.Pooling)
{
return(new PooledConnectionProvider(builder));
}
else
{
return(new NormalConnectionProvider(builder));
}
}
/// <summary>
/// Add the given <paramref name="middleware"/> to the connection.
/// </summary>
/// <param name="connectionBuilder">The <see cref="IConnectionBuilder"/>.</param>
/// <param name="middleware">The middleware to add to the <see cref="IConnectionBuilder"/>.</param>
/// <returns>The <see cref="IConnectionBuilder"/>.</returns>
public static IConnectionBuilder Use(this IConnectionBuilder connectionBuilder, Func <ConnectionContext, Func <Task>, Task> middleware)
{
return(connectionBuilder.Use(next =>
{
return context =>
{
Func <Task> simpleNext = () => next(context);
return middleware(context, simpleNext);
};
}));
}
private static IServerManager CreateManager(IConnectionBuilder builder)
{
if (builder.Servers.Count == 1)
{
return(new SingleServerManager(builder));
}
else
{
return(new RoundRobinServerManager(builder));
}
}
public static IConnectionBuilder UseEndPoint <TEndPoint>(this IConnectionBuilder connectionBuilder) where TEndPoint : EndPoint
{
var endpoint = (TEndPoint)connectionBuilder.ApplicationServices.GetService(typeof(TEndPoint));
if (endpoint == null)
{
throw new InvalidOperationException($"{nameof(EndPoint)} type {typeof(TEndPoint)} is not registered.");
}
// This is a terminal middleware, so there's no need to use the 'next' parameter
return(connectionBuilder.Run(connection => endpoint.OnConnectedAsync(connection)));
}
public static IConnectionBuilder UseMqttFilter(this IConnectionBuilder builder)
{
return(builder.Use((connection, next) =>
{
/// Write code here to use the connection to filter the connection before the handshake
Console.WriteLine(connection.ConnectionId);
return next();
}));
}
public TcpServer(IPEndPoint endpoint, IConnectionBuilder connectionBuilder,
IInternalServiceManager <IServer> services = null)
{
Connections = new ConcurrentDictionary <long, IConnection>();
Endpoint = endpoint;
ConnectionBuilder = connectionBuilder.UseDispatcher(Con_DispatchPayload);
_timer = new Timer(Timer_Tick, null, 0, System.Threading.Timeout.Infinite);
_services = services ?? ServicesManager <IServer> .Empty;
DispatchPayload = new List <Connection.InternalPayloadDispatchHandler>(0);
}
public static IConnectionBuilder UseHttpServer <TContext>(this IConnectionBuilder builder,
ServerContext serverContext,
IHttpApplication <TContext> application,
HttpVersion protocolVersion)
{
var middleware = new HttpMiddleware <TContext>(serverContext, application, protocolVersion);
return(builder.Use(next =>
{
return middleware.OnConnectionAsync;
}));
}
public static IConnectionBuilder UseHub <THub>(this IConnectionBuilder connectionBuilder) where THub : Hub
{
var marker = connectionBuilder.ApplicationServices.GetService(typeof(SignalRMarkerService));
if (marker == null)
{
throw new InvalidOperationException("Unable to find the required services. Please add all the required services by calling " +
"'IServiceCollection.AddSignalR' inside the call to 'ConfigureServices(...)' in the application startup code.");
}
return(connectionBuilder.UseConnectionHandler <HubConnectionHandler <THub> >());
}
public static IBroker New(Action<EnvironmentConfiguration> configure, IConnectionBuilder connectionBuilder)
{
if (configure == null)
throw new ArgumentNullException(nameof(configure));
if (connectionBuilder == null)
throw new ArgumentNullException(nameof(connectionBuilder));
var configuration = new EnvironmentConfiguration();
configure(configuration);
return new Broker(configuration, connectionBuilder);
}
public static IConnectionProvider Get(IConnectionBuilder connectionBuilder)
{
lock (Lock) {
IConnectionProvider provider;
if (!Providers.TryGetValue(connectionBuilder.Uuid, out provider)) {
provider = CreateProvider(connectionBuilder);
Providers.Add(connectionBuilder.Uuid, provider);
}
return provider;
}
}
public static IServerManager Get(IConnectionBuilder connectionBuilder)
{
lock (Lock) {
IServerManager manager;
if (!Managers.TryGetValue(connectionBuilder.Uuid, out manager)) {
manager = CreateManager(connectionBuilder);
Managers.Add(connectionBuilder.Uuid, manager);
}
return manager;
}
}
protected override void ConfigureConnectionBuilder(IConnectionBuilder connectionBuilder)
{
connectionBuilder.Use(next =>
{
return(async context =>
{
context.Features.Set <IConnectionDirectionFeature>(this);
await next(context);
});
});
this.clientConnectionOptions.ConfigureConnectionBuilder(connectionBuilder);
base.ConfigureConnectionBuilder(connectionBuilder);
}
private static IServerManager CreateManager(IConnectionBuilder builder)
{
if(_alternateManagerCreator != null)
{
var manager = _alternateManagerCreator(builder);
if(manager != null)
return manager;
}
return builder.Servers.Count == 1
? (IServerManager)new SingleServerManager(builder)
: new RoundRobinServerManager(builder);
}
public SqlItem(
string name,
string sql,
string readServer,
string writeServer,
string rawConnectionString,
IConnectionBuilder builder,
ICache<string, object> cache)
{
this.Name = name;
this.Sql = sql;
this.Cache = cache;
this.readServer = readServer;
this.writeServer = writeServer;
this.builder = builder;
this.rawConnectionString = rawConnectionString;
}
/// <summary>
///
/// </summary>
/// <param name="server"></param>
/// <param name="builder"></param>
public Connection(Server server, IConnectionBuilder builder)
: this(server, builder.ConnectionType, builder.BufferSize) { }
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected ConnectionProvider(IConnectionBuilder builder)
{
ConnectionBuilder = builder;
Servers = ServerManagerFactory.Get(builder);
}
public void SetUp()
{
_file = TestData.UsersXlsx;
_connectionString = MockRepository.GenerateMock<IConnectionString>();
_connectionBuilder = new ConnectionBuilder(_connectionString);
}
public BioSkyNetDataModel( IConnectionBuilder connectionBuilder)
: base(connectionBuilder.create())
{
}
protected internal Broker(EnvironmentConfiguration configuration, IConnectionBuilder connectionBuilder)
{
_configuration = configuration;
_connectionBuilder = connectionBuilder;
}
public SingleServerManager(IConnectionBuilder builder)
{
_server = builder.Servers[0];
}
/// <summary>
///
/// </summary>
/// <param name="builder"></param>
protected ConnectionProvider(IConnectionBuilder builder)
{
ConnectionBuilder = builder;
Servers = new RoundRobinServerManager(builder);
}
public SingleServerManager(IConnectionBuilder builder)
{
_server = builder.Servers[0];
_recoveryTimerInterval = (long)builder.ServerPollingInterval.TotalMilliseconds;
_recoveryTimer = new Timer(ServerRecover);
}
public RoundRobinServerManager(IConnectionBuilder builder)
{
_servers = new List<Server>(builder.Servers);
_serverQueue = new Queue<Server>(_servers);
_blackListed = new HashSet<Server>();
}
protected ConnectionProviderBase(IClusterManager clusterManager, IConnectionBuilder connectionBuilder, ConnectionProviderType providerType)
{
ClusterManager = clusterManager;
ConnectionBuilder = connectionBuilder;
Type = providerType;
}
