void AppStartup()
{
var appsettings = ConfigurationManager.AppSettings;
var settings = appsettings.AllKeys
.ToDictionary(k => k, v => appsettings[v]);
settings["RootFolder"] = Server.MapPath(null);
GatewayManager.AddGateways(settings);
}
public void Create_WhereGatewaysAreSpecified_Succeeds()
{
var asyncGateways = new[] { new ExportFactory <IAsyncCloudGateway, CloudGatewayMetadata>(() => Fixture.GetAsyncCreator(), Fixture.GetAsyncGatewayMetadata()) };
var syncGateways = new[] { new ExportFactory <ICloudGateway, CloudGatewayMetadata>(() => Fixture.GetSyncCreator(), Fixture.GetSyncGatewayMetadata()) };
var sut = new GatewayManager(asyncGateways, syncGateways);
Assert.IsNotNull(sut, "GatewayManager creation failed");
}
public void Create_WhereGatewaysAreEmpty_Succeeds()
{
var asyncGateways = Enumerable.Empty <ExportFactory <IAsyncCloudGateway, CloudGatewayMetadata> >();
var syncGateways = Enumerable.Empty <ExportFactory <ICloudGateway, CloudGatewayMetadata> >();
var sut = new GatewayManager(asyncGateways, syncGateways);
Assert.IsNotNull(sut, "GatewayManager creation failed");
}
public void TryGetCloudGatewayForSchema_WhereNoGatewaysAreDefined_Fails()
{
var asyncGateways = Enumerable.Empty <ExportFactory <IAsyncCloudGateway, CloudGatewayMetadata> >();
var syncGateways = Enumerable.Empty <ExportFactory <ICloudGateway, CloudGatewayMetadata> >();
var sut = new GatewayManager(asyncGateways, syncGateways);
var result = sut.TryGetCloudGatewayForSchema("testSync", out ICloudGateway syncGateway);
Assert.IsFalse(result, "Unconfigured CloudGateway returned");
}
public void TryGetCloudGatewayForSchema_WhereGatewayIsUndefined_Fails()
{
var asyncGateways = Enumerable.Empty <ExportFactory <IAsyncCloudGateway, CloudGatewayMetadata> >();
var syncGateways = new[] { new ExportFactory <ICloudGateway, CloudGatewayMetadata>(() => Fixture.GetSyncCreator(), Fixture.GetSyncGatewayMetadata()) };
var sut = new GatewayManager(asyncGateways, syncGateways);
var result = sut.TryGetCloudGatewayForSchema("undefinedSync", out ICloudGateway syncGateway);
Assert.IsFalse(result, "Unconfigured CloudGateway returned");
}
public void TryGetAsyncCloudGatewayForSchema_WhereGatewayIsDefined_Succeeds()
{
var asyncGateways = new[] { new ExportFactory <IAsyncCloudGateway, CloudGatewayMetadata>(() => Fixture.GetAsyncCreator(), Fixture.GetAsyncGatewayMetadata()) };
var syncGateways = Enumerable.Empty <ExportFactory <ICloudGateway, CloudGatewayMetadata> >();
var sut = new GatewayManager(asyncGateways, syncGateways);
var result = sut.TryGetAsyncCloudGatewayForSchema("testAsync", out IAsyncCloudGateway asyncGateway);
Assert.IsTrue(result, "Configured AsyncCloudGateway not returned");
}
protected void Test_GatewaySelection(IGatewayListProvider listProvider)
{
IList <Uri> gatewayUris = listProvider.GetGateways().GetResult();
Assert.True(gatewayUris.Count > 0, $"Found some gateways. Data = {Utils.EnumerableToString(gatewayUris)}");
var gatewayEndpoints = gatewayUris.Select(uri =>
{
return(new IPEndPoint(IPAddress.Parse(uri.Host), uri.Port));
}).ToList();
var cfg = new ClientConfiguration
{
Gateways = gatewayEndpoints
};
var gatewayOptions = new GatewayOptions()
{
GatewayListRefreshPeriod = cfg.GatewayListRefreshPeriod,
PreferedGatewayIndex = cfg.PreferedGatewayIndex
};
var gatewayManager = new GatewayManager(gatewayOptions, listProvider, NullLoggerFactory.Instance);
var counts = new int[4];
for (int i = 0; i < 2300; i++)
{
var ip = gatewayManager.GetLiveGateway();
var addr = IPAddress.Parse(ip.Host);
Assert.Equal(IPAddress.Loopback, addr); // "Incorrect IP address returned for gateway"
Assert.True((0 < ip.Port) && (ip.Port < 5), "Incorrect IP port returned for gateway");
counts[ip.Port - 1]++;
}
// The following needed to be changed as the gateway manager now round-robins through the available gateways, rather than
// selecting randomly based on load numbers.
//Assert.True((500 < counts[0]) && (counts[0] < 1500), "Gateway selection is incorrectly skewed");
//Assert.True((500 < counts[1]) && (counts[1] < 1500), "Gateway selection is incorrectly skewed");
//Assert.True((125 < counts[2]) && (counts[2] < 375), "Gateway selection is incorrectly skewed");
//Assert.True((25 < counts[3]) && (counts[3] < 75), "Gateway selection is incorrectly skewed");
//Assert.True((287 < counts[0]) && (counts[0] < 1150), "Gateway selection is incorrectly skewed");
//Assert.True((287 < counts[1]) && (counts[1] < 1150), "Gateway selection is incorrectly skewed");
//Assert.True((287 < counts[2]) && (counts[2] < 1150), "Gateway selection is incorrectly skewed");
//Assert.True((287 < counts[3]) && (counts[3] < 1150), "Gateway selection is incorrectly skewed");
int low = 2300 / 4;
int up = 2300 / 4;
Assert.True((low <= counts[0]) && (counts[0] <= up), "Gateway selection is incorrectly skewed. " + counts[0]);
Assert.True((low <= counts[1]) && (counts[1] <= up), "Gateway selection is incorrectly skewed. " + counts[1]);
Assert.True((low <= counts[2]) && (counts[2] <= up), "Gateway selection is incorrectly skewed. " + counts[2]);
Assert.True((low <= counts[3]) && (counts[3] <= up), "Gateway selection is incorrectly skewed. " + counts[3]);
}
// Use this for initialization
void Start()
{
if (Instance != null && Instance != this)
{
Destroy(this.gameObject);
}
else
{
Instance = this;
}
DontDestroyOnLoad(this.gameObject);
SceneManager.sceneLoaded += SceneLoaded;
}
private void EnsureInitialized()
{
if (!isInitialized)
{
lock (this.initializationLock)
{
if (!isInitialized)
{
this.messageCenter = this.serviceProvider.GetRequiredService <ClientMessageCenter>();
this.gatewayManager = this.serviceProvider.GetRequiredService <GatewayManager>();
this.connectionManager = this.serviceProvider.GetRequiredService <ConnectionManager>();
this.isInitialized = true;
}
}
}
}
public ClientClusterManifestProvider(
IInternalGrainFactory grainFactory,
GatewayManager gatewayManager,
ILogger <ClientClusterManifestProvider> logger,
IOptions <TypeManagementOptions> options)
{
_grainFactory = grainFactory;
_logger = logger;
_gatewayManager = gatewayManager;
_options = options.Value;
_updates = new AsyncEnumerable <ClusterManifest>(
(previous, proposed) => previous is null || proposed.Version == MajorMinorVersion.Zero || proposed.Version > previous.Version,
_current)
{
OnPublished = update => Interlocked.Exchange(ref _current, update)
};
}
public ClientOutboundConnection(
ConnectionContext connection,
ConnectionDelegate middleware,
MessageFactory messageFactory,
IServiceProvider serviceProvider,
ClientMessageCenter messageCenter,
GatewayManager gatewayManager,
INetworkingTrace trace)
: base(connection, middleware, serviceProvider, trace)
{
this.messageFactory = messageFactory;
this.messageCenter = messageCenter;
this.gatewayManager = gatewayManager;
if (connection.RemoteEndPoint is IPEndPoint ipEndpoint)
{
this.TargetSilo = SiloAddress.New(ipEndpoint, 0);
}
}
protected override Connection CreateConnection(ConnectionContext context)
{
if (this.messageCenter is null)
{
this.messageCenter = this.serviceProvider.GetRequiredService <ClientMessageCenter>();
}
if (this.gatewayManager is null)
{
this.gatewayManager = this.serviceProvider.GetRequiredService <GatewayManager>();
}
return(new ClientOutboundConnection(
context,
this.ConnectionDelegate,
this.messageFactory,
this.serviceProvider,
this.messageCenter,
this.gatewayManager,
this.trace));
}
public ClientClusterManifestProvider(
IServiceProvider services,
GatewayManager gatewayManager,
ILogger <ClientClusterManifestProvider> logger,
ClientManifestProvider clientManifestProvider,
IOptions <TypeManagementOptions> typeManagementOptions)
{
_logger = logger;
_typeManagementOptions = typeManagementOptions.Value;
_services = services;
_gatewayManager = gatewayManager;
this.LocalGrainManifest = clientManifestProvider.ClientManifest;
_current = new ClusterManifest(MajorMinorVersion.Zero, ImmutableDictionary <SiloAddress, GrainManifest> .Empty, ImmutableArray.Create(this.LocalGrainManifest));
_updates = new AsyncEnumerable <ClusterManifest>(
(previous, proposed) => previous is null || proposed.Version == MajorMinorVersion.Zero || proposed.Version > previous.Version,
_current)
{
OnPublished = update => Interlocked.Exchange(ref _current, update)
};
}
public ClientOutboundConnection(
SiloAddress remoteSiloAddress,
ConnectionContext connection,
ConnectionDelegate middleware,
MessageFactory messageFactory,
IServiceProvider serviceProvider,
ClientMessageCenter messageCenter,
GatewayManager gatewayManager,
INetworkingTrace trace,
ConnectionManager connectionManager,
ConnectionOptions connectionOptions)
: base(connection, middleware, serviceProvider, trace)
{
this.messageFactory = messageFactory;
this.messageCenter = messageCenter;
this.gatewayManager = gatewayManager;
this.connectionManager = connectionManager;
this.connectionOptions = connectionOptions;
this.RemoteSiloAddress = remoteSiloAddress ?? throw new ArgumentNullException(nameof(remoteSiloAddress));
}
public ClientGatewayObserver(GatewayManager gatewayManager)
{
this.gatewayManager = gatewayManager;
}
private async Task InitAsync()
{
// Initialize a clean Couchbase bucket.
cluster = new Cluster();
clusterManager = cluster.CreateManager(CouchbaseUID, CouchbasePWD);
if (clusterManager.ListBuckets().Value.Count(b => b.Name == BucketName) > 0)
{
clusterManager.RemoveBucket(BucketName);
}
if (!clusterManager.CreateBucket(BucketName, 100).Success)
{
Assert.True(false, $"Could not create the [{BucketName}] Couchbase bucket.");
}
Bucket = cluster.OpenBucket(BucketName);
// Crank up the sync gateway.
syncGatewayProcess = Process.Start(SyncGatewayPath, $"-bucket \"{BucketName}\" -dbname \"{DatabaseName}\"");
if (syncGatewayProcess.WaitForExit(2000))
{
Assert.True(false, $"Could not start a Couchbase Sync Gateway. Verify that the service is not already running.");
}
// Initialize the sync gateway database.
gateway = new Gateway(
new GatewaySettings()
{
Host = "localhost"
});
gatewayManager = gateway.CreateManager();
var databasesDeleted = false;
foreach (var database in await gatewayManager.DatabaseListAsync())
{
if (database == DatabaseName)
{
await gatewayManager.DatabaseRemoveAsync(database);
databasesDeleted = true;
}
}
if (databasesDeleted)
{
// Looks like the sync gateway needs some time to stablize
// after deleting databases.
await Task.Delay(TimeSpan.FromSeconds(5));
}
await gatewayManager.DatabaseCreateAsync(
new DatabaseConfiguration()
{
Name = DatabaseName,
Bucket = BucketName,
Server = "http://127.0.0.1:8091",
Sync = "function (doc, oldDoc) { channel(doc.channels); }"
});
}
public MessageMessageGatewayHandler(GatewayManager connectionManager, ILogger <MessageMessageGatewayHandler> log)
{
this.connectionManager = connectionManager;
this.log = log;
}
public KeepAliveMessageGatewayHandler(ILogger <InfoMessageGatewayHandler> log, GatewayManager manager)
{
this.log = log;
this.manager = manager;
}
public GatewayService(GatewayManager manager)
{
this.manager = manager;
}
public ReqMessageGatewayHandler(GatewayManager manager)
{
this.manager = manager;
}
// Access the required database
public static GatewayBase GetGateway(string database)
{
return(GatewayManager.GetGateway(database));
}
public InfoMessageGatewayHandler(ILogger <InfoMessageGatewayHandler> log, GatewayManager manager, GatewayConnectionManager connections)
{
this.log = log;
this.manager = manager;
this.connections = connections;
}
public void OnActionExecuting(ActionExecutingContext context)
{
var api = context.ActionDescriptor.AttributeRouteInfo.Template;
var isEnableLog = IsEnableLog(context);
try
{
// 设置当前访问信息
string clientInfo = context.HttpContext.Connection?.RemoteIpAddress.ToString();
string requestId = context.HttpContext.Request.Headers["requestId"];
if (string.IsNullOrEmpty(requestId))
{
requestId = context.HttpContext.TraceIdentifier;
context.HttpContext.Request.Headers["requestId"] = requestId;
}
app.ActionArguments = context.ActionArguments;
AppManager.CurrentAppContext = app;
// 记录日志
if (isEnableLog)
{
string parm = JsonConvert.SerializeObject(app.ActionArguments);
app.LogRequest(requestId, context.ActionDescriptor.DisplayName, parm, clientInfo, context.ActionDescriptor.AttributeRouteInfo.Template);
}
// 读取或设置sessionId和language
if (IsEnableCookie(context))
{
InitCookies(api);
}
// 访问限制，登录等方法不受限制
if (AuthenticationProxy.IsCheckGateway(context))
{
var clientIp = context.HttpContext.Connection?.RemoteIpAddress.ToString();
if (!string.IsNullOrEmpty(clientIp))
{
GatewayManager.Check(clientIp);
}
}
var authentication = app.GetService <IAuthenticationProxy>();
// 鉴权-检查用户token，设置当前用户上下文
var token = (context.HttpContext.Request.Headers[ApiDocManager.TokenHeaderName]).ToString().Replace("Bearer ", "");
if (AuthenticationProxy.IsCheckToken(context) || !string.IsNullOrEmpty(token))
{
if (ConfigManager.Configuration["EnableApiDoc"] == "1" && string.IsNullOrEmpty(token))
{
token = ConfigManager.Configuration["DefaultToken"];
}
authentication.SetCurrentUser(token, context);
}
authentication.SetCurrentGuest(app.SessionID);
// 检查数据
VaildateModel(context);
// 异步
var asyncTask = AsyncTaskManager.GetTaskInfo(context, app.User?.UserID.ToString());
if (asyncTask != null)
{
var resultValue = ResultBuilder.AsSuccess(asyncTask);
context.Result = new JsonResult(resultValue);
return;
}
// 从缓存返回
var cacheResult = CacheManager.ReadCache(context, app);
if (cacheResult != null)
{
cacheResult.RequestId = context.HttpContext.TraceIdentifier;
var cacheTimeRate = CacheTimeSettings.GetCacheTimeRate();
var cacheSeconds = CacheManager.CalcCacheSeconds(context.ActionDescriptor as ControllerActionDescriptor, out var cacheTimeSetting);
var seconds = cacheTimeRate.HttpCacheTime * cacheSeconds;
if (seconds < 10)
{
seconds = 10;
}
if (seconds > 60)
{
seconds = 60;
}
context.HttpContext.Response.GetTypedHeaders().CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
Public = true,
MaxAge = TimeSpan.FromSeconds(seconds)
};
context.Result = new JsonResult(cacheResult);
return;
}
}
// 不捕获异常，由ExceptionFilter处理。
finally
{
if (context.Result != null)
{
CleanOnActionClose();
if (isEnableLog)
{
app.LogResponseResult(context.Result);
app.EndRequest();
}
}
}
}
