void GetPropertyValues(ServiceProtocol serviceProtocol, Int64 requestID, ref ArrayList propertyList) { // Return modified ArrayList with tag details included. }
bool ModifyThingPath(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, String path) { if (true) // Decide whether to modify an item. { // We're going to do it. // Modify the item. // Raise event(s). serviceProtocol.DoThingPathModified(requestID, guid, path); return true; } else { // We're not going to do it. return false; } }
/// <summary> 获取服务 </summary> /// <typeparam name="T"></typeparam> /// <param name="provider"></param> /// <param name="protocol"></param> /// <returns></returns> public static T GetService <T>(this IServiceProvider provider, ServiceProtocol protocol) { var list = provider.GetServices <T>(); return(list.First(t => t.GetType().GetCustomAttribute <ProtocolAttribute>()?.Protocol == protocol)); }
public ProtocolAttribute(ServiceProtocol protocol) { Protocol = protocol; }
public async Task RegisterRpcRoutes(double processorTime, ServiceProtocol serviceProtocol) { await _serviceRouteManager.RegisterRpcRoutes(processorTime, serviceProtocol); }
public async Task ClientConnectionContextAbortCanSendOutCloseMessage() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Trace, expectedErrors: c => true, logChecker: logs => { return(true); })) { var ccm = new TestClientConnectionManager(); var ccf = new ClientConnectionFactory(); var protocol = new ServiceProtocol(); TestConnection transportConnection = null; var connectionFactory = new TestConnectionFactory(conn => { transportConnection = conn; return(Task.CompletedTask); }); var services = new ServiceCollection(); var lastWill = "This is the last will"; var connectionHandler = new LastWillConnectionHandler(lastWill); services.AddSingleton(connectionHandler); var builder = new ConnectionBuilder(services.BuildServiceProvider()); builder.UseConnectionHandler <LastWillConnectionHandler>(); ConnectionDelegate handler = builder.Build(); var connection = new ServiceConnection(protocol, ccm, connectionFactory, loggerFactory, handler, ccf, "serverId", Guid.NewGuid().ToString("N"), null, null, closeTimeOutMilliseconds: 500); var connectionTask = connection.StartAsync(); // completed handshake await connection.ConnectionInitializedTask.OrTimeout(); Assert.Equal(ServiceConnectionStatus.Connected, connection.Status); var clientConnectionId = Guid.NewGuid().ToString(); await transportConnection.Application.Output.WriteAsync( protocol.GetMessageBytes(new OpenConnectionMessage(clientConnectionId, new Claim[] { }))); var clientConnection = await ccm.WaitForClientConnectionAsync(clientConnectionId).OrTimeout(); await clientConnection.LifetimeTask.OrTimeout(); transportConnection.Transport.Output.Complete(); var input = await transportConnection.Application.Input.ReadAsync(); var buffer = input.Buffer; var canParse = protocol.TryParseMessage(ref buffer, out var msg); Assert.True(canParse); var message = msg as ConnectionDataMessage; Assert.NotNull(message); Assert.Equal(clientConnectionId, message.ConnectionId); Assert.Equal(lastWill, Encoding.UTF8.GetString(message.Payload.First.ToArray())); // complete reading to end the connection transportConnection.Application.Output.Complete(); // 1s for application task to timeout await connectionTask.OrTimeout(1000); Assert.Equal(ServiceConnectionStatus.Disconnected, connection.Status); Assert.Empty(ccm.ClientConnections); } }
void Sync(ServiceProtocol serviceProtocol, Int64 requestID) { serviceProtocol.Sync(requestID); }
ArrayList PropertyListCheck(ServiceProtocol serviceProtocol, Guid guid, String tag, String path) { //char* dest = new char[tag.Length+1]; //strcpy(dest, static_cast<LPCTSTR>(const_cast<void*>(static_cast<const void*>(System.Runtime.InteropServices.Marshal.StringToHGlobalAnsi(tag))))); //ScdMainWnd().PostMessage(WMU_TAGACTION, SUB_TAGACTION_FINDANDACCESS, (LPARAM)dest); ArrayList list = new ArrayList(); // Generate list of properties at this level in properties tree. return list; }
void GetSubTags(ServiceProtocol serviceProtocol, Int64 requestID, String propertyPath, out ArrayList propertyList) { propertyList = new ArrayList(); Random random = new Random(); // Return ArrayList with tag details included. for (int i=0; i<10; i++) { StringBuilder builder = new StringBuilder(); System.Char ch; int n = random.Next(5, 10); for (int j = 0; j < n; j++) { ch = Convert.ToChar(random.Next(33, 126)); builder.Append(ch); } switch (random.Next(0, 3)) { case 0: propertyList.Add(new ModelProperty(builder.ToString(), random.Next())); break; case 1: propertyList.Add(new ModelProperty(builder.ToString(), random.NextDouble())); break; case 2: propertyList.Add(new ModelProperty(builder.ToString(), builder.ToString())); break; case 3: propertyList.Add(new ModelProperty(builder.ToString(), Color.FromArgb(random.Next()))); break; } } }
bool ChangeState(ServiceProtocol serviceProtocol, Int64 requestID, BaseProtocol.RunStates runState) { if (true) // Decide whether to allow runstate change { // We're going to do it. // Change the runstate. // Raise event(s). serviceProtocol.DoStateChanged(requestID, runState); return true; } else { // We're not going to do it. return false; } }
public ServiceDomain(string domain, ServiceProtocol protocol) { _domain = domain; _protocol = protocol; }
bool DeleteThing(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid) { if (true) // Decide whether to delete an Thing. { // We're going to do it. // Delete the Thing. // Raise event(s). serviceProtocol.DoThingDeleted(requestID, guid); return true; } else { // We're not going to do it. return false; } }
bool CreateItem(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, String tag, String path, Model model, Shape stencil, RectangleF boundingRect, Single angle, System.Drawing.Color fillColor, System.Drawing.Drawing2D.FillMode fillMode, bool mirrorX, bool mirrorY) { // Need to check for runstate here, and decide if we'll fire DoItemCreated. // This is required in case a rogue client tries to create an item even when not supposed to. // This applies to all three create*, and all three delete* events. if (true) // Decide whether to create an item. { // We're going to do it. // Create the item. // Raise event(s). serviceProtocol.DoItemCreated(requestID, guid, tag, path, model, stencil, boundingRect, angle, fillColor, fillMode, mirrorX, mirrorY); return true; } else { // We're not going to do it. return false; } }
PortStatus PortCheck(ServiceProtocol serviceProtocol, Guid guid, Anchor anchor) { // CNSGuidItem * pGuid = new CNSGuidItem(); // pGuid.m_Guid = guid; // m_pUnmanaged.m_Guids.AddTail(null); // CNSGuidItem * pGuid = m_pUnmanaged.m_Guids.Find(guid); // CNSMdlLink * pLink = dynamic_cast<CNSMdlLink *>(guid); return PortStatus.Available; }
bool ModifyItem(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, String tag, String path, Model model, Shape stencil, RectangleF boundingRect, Single angle, System.Drawing.Color fillColor, System.Drawing.Drawing2D.FillMode fillMode, bool mirrorX, bool mirrorY) { if (true) // Decide whether to modify an item. { // We're going to do it. // Modify the item. // Need to get hold of a valid pDoc pointer... ********* //Individual changes would go something like this: ********* //int length = tag.Length; //wchar_t * tagwc = (wchar_t*)(void*)Marshal.StringToHGlobalUni(tag); //char * tagc = (char *)malloc(length+1); //tagc[length] = 0; //for (int i=0; i<length; i++) // tagc[i] = (char)tagwc[i]; //pDoc.GCB.DoModify(tagc, // angle, // boundingRect, // fillColor, // fillMode, // mirrorX, // mirrorY); // Raise event(s). serviceProtocol.DoItemModified(requestID, guid, tag, path, model, stencil, boundingRect, angle, fillColor, fillMode, mirrorX, mirrorY); return true; } else { // We're not going to do it. return false; } }
public void MarshalServiceInterface(String filename) { ServiceProtocol.ChangeStateHandler changeState = new ServiceProtocol.ChangeStateHandler(ChangeState); ServiceProtocol.GetPropertyValuesHandler getPropertyValues = new ServiceProtocol.GetPropertyValuesHandler(GetPropertyValues); ServiceProtocol.GetSubTagsHandler getSubTags = new ServiceProtocol.GetSubTagsHandler(GetSubTags); ServiceProtocol.CreateItemHandler createItem = new ServiceProtocol.CreateItemHandler(CreateItem); ServiceProtocol.ModifyItemHandler modifyItem = new ServiceProtocol.ModifyItemHandler(ModifyItem); ServiceProtocol.ModifyItemPathHandler modifyItemPath = new ServiceProtocol.ModifyItemPathHandler(ModifyItemPath); ServiceProtocol.DeleteItemHandler deleteItem = new ServiceProtocol.DeleteItemHandler(DeleteItem); ServiceProtocol.CreateLinkHandler createLink = new ServiceProtocol.CreateLinkHandler(CreateLink); ServiceProtocol.ModifyLinkHandler modifyLink = new ServiceProtocol.ModifyLinkHandler(ModifyLink); ServiceProtocol.DeleteLinkHandler deleteLink = new ServiceProtocol.DeleteLinkHandler(DeleteLink); ServiceProtocol.CreateThingHandler createThing = new ServiceProtocol.CreateThingHandler(CreateThing); ServiceProtocol.ModifyThingHandler modifyThing = new ServiceProtocol.ModifyThingHandler(ModifyThing); ServiceProtocol.ModifyThingPathHandler modifyThingPath = new ServiceProtocol.ModifyThingPathHandler(ModifyThingPath); ServiceProtocol.DeleteThingHandler deleteThing = new ServiceProtocol.DeleteThingHandler(DeleteThing); ServiceProtocol.PortCheckHandler portCheck = new ServiceProtocol.PortCheckHandler(PortCheck); ServiceProtocol.PropertyListHandler propertyListCheck = new ServiceProtocol.PropertyListHandler(PropertyListCheck); serviceProtocol = new ServiceProtocol(changeState, getPropertyValues, getSubTags, createItem, modifyItem, modifyItemPath, deleteItem, createLink, modifyLink, deleteLink, createThing, modifyThing, modifyThingPath, deleteThing, portCheck, propertyListCheck); //String filename = PrjName(); //gs_pPrj. RemotingServices.Marshal(serviceProtocol, filename); m_Config.ProjectList.Add(filename); LogNote("Srvr", 0, "Added project %s to ProjectList.", filename); }
bool ModifyItemBoundingRect(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, RectangleF boundingRect) { if (true) // Decide whether to modify an item. { // We're going to do it. // Modify the item. // Raise event(s). serviceProtocol.DoItemBoundingRectModified(requestID, guid, boundingRect); return true; } else { // We're not going to do it. return false; } }
public async Task TestServiceConnectionWithErrorApplicationTask() { using (StartVerifiableLog(out var loggerFactory, LogLevel.Warning, expectedErrors: c => true, logChecker: logs => { Assert.Equal(2, logs.Count); Assert.Equal("SendLoopStopped", logs[0].Write.EventId.Name); Assert.Equal("ApplicationTaskFailed", logs[1].Write.EventId.Name); return(true); })) { var ccm = new TestClientConnectionManager(); var ccf = new ClientConnectionFactory(); var protocol = new ServiceProtocol(); TestConnection transportConnection = null; var connectionFactory = new TestConnectionFactory(conn => { transportConnection = conn; return(Task.CompletedTask); }); var services = new ServiceCollection(); var errorTcs = new TaskCompletionSource <Exception>(); var connectionHandler = new ErrorConnectionHandler(errorTcs); services.AddSingleton(connectionHandler); var builder = new ConnectionBuilder(services.BuildServiceProvider()); builder.UseConnectionHandler <ErrorConnectionHandler>(); ConnectionDelegate handler = builder.Build(); var connection = new ServiceConnection(protocol, ccm, connectionFactory, loggerFactory, handler, ccf, "serverId", Guid.NewGuid().ToString("N"), null, null); var connectionTask = connection.StartAsync(); // completed handshake await connection.ConnectionInitializedTask.OrTimeout(); Assert.Equal(ServiceConnectionStatus.Connected, connection.Status); var clientConnectionId = Guid.NewGuid().ToString(); await transportConnection.Application.Output.WriteAsync( protocol.GetMessageBytes(new OpenConnectionMessage(clientConnectionId, new Claim[] { }))); var clientConnection = await ccm.WaitForClientConnectionAsync(clientConnectionId).OrTimeout(); errorTcs.SetException(new InvalidOperationException("error operation")); await clientConnection.LifetimeTask.OrTimeout(); // Should complete the connection when application throws await ccm.WaitForClientConnectionRemovalAsync(clientConnectionId).OrTimeout(); // Application task should not affect the underlying service connection Assert.Equal(ServiceConnectionStatus.Connected, connection.Status); // complete reading to end the connection transportConnection.Application.Output.Complete(); await connectionTask.OrTimeout(); Assert.Equal(ServiceConnectionStatus.Disconnected, connection.Status); Assert.Empty(ccm.ClientConnections); } }
bool ModifyLink(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, String tag, String classID, Guid origin, Guid destination, String originPort, String destinationPort, List<PointF> controlPoints) { if (true) // Decide whether to modify an link. { // We're going to do it. // Modify the item. // Raise event(s). serviceProtocol.DoLinkModified(requestID, guid, tag, classID, origin, destination, originPort, destinationPort, controlPoints); return true; } else { // We're not going to do it. return false; } }
public async Task <IServiceHubContext> CreateHubContextAsync(string hubName, ILoggerFactory loggerFactory = null, CancellationToken cancellationToken = default) { loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; switch (_serviceManagerOptions.ServiceTransportType) { case ServiceTransportType.Persistent: { var connectionFactory = new ManagementConnectionFactory(_productInfo, new ConnectionFactory(_serverNameProvider, loggerFactory)); var serviceProtocol = new ServiceProtocol(); var clientConnectionManager = new ClientConnectionManager(); var clientConnectionFactory = new ClientConnectionFactory(); ConnectionDelegate connectionDelegate = connectionContext => Task.CompletedTask; var serviceConnectionFactory = new ServiceConnectionFactory( serviceProtocol, clientConnectionManager, connectionFactory, loggerFactory, connectionDelegate, clientConnectionFactory, new DefaultServerNameProvider() ); var weakConnectionContainer = new WeakServiceConnectionContainer( serviceConnectionFactory, _serviceManagerOptions.ConnectionCount, new HubServiceEndpoint(hubName, _endpointProvider, _endpoint), loggerFactory?.CreateLogger(nameof(WeakServiceConnectionContainer)) ?? NullLogger.Instance); var serviceCollection = new ServiceCollection(); serviceCollection.AddSignalRCore(); serviceCollection.AddSingleton <IConfigureOptions <HubOptions>, ManagementHubOptionsSetup>(); if (loggerFactory != null) { serviceCollection.AddSingleton(typeof(ILoggerFactory), loggerFactory); } serviceCollection .AddLogging() .AddSingleton(typeof(IConnectionFactory), sp => connectionFactory) .AddSingleton(typeof(HubLifetimeManager <>), typeof(WebSocketsHubLifetimeManager <>)) .AddSingleton(typeof(IServiceConnectionManager <>), typeof(ServiceConnectionManager <>)) .AddSingleton(typeof(IServiceConnectionContainer), sp => weakConnectionContainer); var success = false; ServiceProvider serviceProvider = null; try { serviceProvider = serviceCollection.BuildServiceProvider(); var serviceConnectionManager = serviceProvider.GetRequiredService <IServiceConnectionManager <Hub> >(); serviceConnectionManager.SetServiceConnection(weakConnectionContainer); _ = serviceConnectionManager.StartAsync(); // wait until service connection established await weakConnectionContainer.ConnectionInitializedTask.OrTimeout(cancellationToken); var webSocketsHubLifetimeManager = (WebSocketsHubLifetimeManager <Hub>)serviceProvider.GetRequiredService <HubLifetimeManager <Hub> >(); var hubContext = serviceProvider.GetRequiredService <IHubContext <Hub> >(); var serviceHubContext = new ServiceHubContext(hubContext, webSocketsHubLifetimeManager, serviceProvider); success = true; return(serviceHubContext); } finally { if (!success) { serviceProvider?.Dispose(); } } } case ServiceTransportType.Transient: { var serviceCollection = new ServiceCollection(); serviceCollection.AddSignalRCore(); // remove default hub lifetime manager var serviceDescriptor = serviceCollection.FirstOrDefault(descriptor => descriptor.ServiceType == typeof(HubLifetimeManager <>)); serviceCollection.Remove(serviceDescriptor); // add rest hub lifetime manager var restHubLifetimeManager = new RestHubLifetimeManager(_serviceManagerOptions, hubName, _productInfo); serviceCollection.AddSingleton(typeof(HubLifetimeManager <Hub>), sp => restHubLifetimeManager); var serviceProvider = serviceCollection.BuildServiceProvider(); var hubContext = serviceProvider.GetRequiredService <IHubContext <Hub> >(); return(new ServiceHubContext(hubContext, restHubLifetimeManager, serviceProvider)); } default: throw new ArgumentException("Not supported service transport type."); } }
bool ModifyLinkControlPoints(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, List<PointF> controlPoints) { if (true) // Decide whether to modify an item. { // We're going to do it. // Modify the item. // Raise event(s). serviceProtocol.DoLinkControlPointsModified(requestID, guid, controlPoints); return true; } else { // We're not going to do it. return false; } }
/// <summary> 获取服务 </summary> /// <param name="provider"></param> /// <param name="type"></param> /// <param name="protocol"></param> /// <returns></returns> public static object GetService(this IServiceProvider provider, Type type, ServiceProtocol protocol) { var list = provider.GetServices(type); return(list.First(t => t.GetType().GetCustomAttribute <ProtocolAttribute>()?.Protocol == protocol)); }
bool ModifyThing(ServiceProtocol serviceProtocol, Int64 requestID, Guid guid, String tag, String path, RectangleF boundingRect, String xaml, Single angle, bool mirrorX, bool mirrorY) { if (true) // Decide whether to modify an Thing. { // We're going to do it. // Modify the Thing. // Raise event(s). serviceProtocol.DoThingModified(requestID, guid, tag, path, boundingRect, xaml, angle, mirrorX, mirrorY); return true; } else { // We're not going to do it. return false; } }
internal static ServiceHubDispatcher PrepareAndGetDispatcher(IAppBuilder builder, HubConfiguration configuration, ServiceOptions options, string applicationName, ILoggerFactory loggerFactory) { // Ensure we have the conversions for MS.Owin so that // the app builder respects the OwinMiddleware base class SignatureConversions.AddConversions(builder); // ServiceEndpointManager needs the logger var hubs = GetAvailableHubNames(configuration); // Get the one from DI or new a default one var router = configuration.Resolver.Resolve <IEndpointRouter>() ?? new DefaultEndpointRouter(); var serverNameProvider = configuration.Resolver.Resolve <IServerNameProvider>(); if (serverNameProvider == null) { serverNameProvider = new DefaultServerNameProvider(); configuration.Resolver.Register(typeof(IServerNameProvider), () => serverNameProvider); } var synchronizer = configuration.Resolver.Resolve <IAccessKeySynchronizer>(); if (synchronizer == null) { synchronizer = new AccessKeySynchronizer(serverNameProvider, loggerFactory); configuration.Resolver.Register(typeof(IAccessKeySynchronizer), () => synchronizer); } var endpoint = new ServiceEndpointManager(synchronizer, options, loggerFactory); configuration.Resolver.Register(typeof(IServiceEndpointManager), () => endpoint); var requestIdProvider = configuration.Resolver.Resolve <IConnectionRequestIdProvider>(); if (requestIdProvider == null) { requestIdProvider = new DefaultConnectionRequestIdProvider(); configuration.Resolver.Register(typeof(IConnectionRequestIdProvider), () => requestIdProvider); } builder.Use <NegotiateMiddleware>(configuration, applicationName, endpoint, router, options, serverNameProvider, requestIdProvider, loggerFactory); builder.RunSignalR(configuration); // Fetch the trace manager from DI and add logger provider var traceManager = configuration.Resolver.Resolve <ITraceManager>(); if (traceManager != null) { loggerFactory.AddProvider(new TraceManagerLoggerProvider(traceManager)); } configuration.Resolver.Register(typeof(ILoggerFactory), () => loggerFactory); // TODO: Using IOptions looks wierd, thinking of a way removing it // share the same object all through var serviceOptions = Options.Create(options); // For safety, ALWAYS register abstract classes or interfaces // Some third-party DI frameworks such as Ninject, implicit self-binding concrete types: // https://github.com/ninject/ninject/wiki/dependency-injection-with-ninject#skipping-the-type-binding-bit--implicit-self-binding-of-concrete-types configuration.Resolver.Register(typeof(IOptions <ServiceOptions>), () => serviceOptions); var serviceProtocol = new ServiceProtocol(); configuration.Resolver.Register(typeof(IServiceProtocol), () => serviceProtocol); // allow override from tests var scm = configuration.Resolver.Resolve <IServiceConnectionManager>(); if (scm == null) { scm = new ServiceConnectionManager(applicationName, hubs); configuration.Resolver.Register(typeof(IServiceConnectionManager), () => scm); } var ccm = configuration.Resolver.Resolve <IClientConnectionManager>(); if (ccm == null) { ccm = new ClientConnectionManager(configuration, loggerFactory); configuration.Resolver.Register(typeof(IClientConnectionManager), () => ccm); } var atm = new AzureTransportManager(configuration.Resolver); configuration.Resolver.Register(typeof(ITransportManager), () => atm); var parser = new SignalRMessageParser(hubs, configuration.Resolver, loggerFactory.CreateLogger <SignalRMessageParser>()); configuration.Resolver.Register(typeof(IMessageParser), () => parser); var smb = new ServiceMessageBus(configuration.Resolver, loggerFactory.CreateLogger <ServiceMessageBus>()); configuration.Resolver.Register(typeof(IMessageBus), () => smb); var scf = configuration.Resolver.Resolve <IServiceConnectionFactory>(); if (scf == null) { var connectionFactory = new ConnectionFactory(serverNameProvider, loggerFactory); scf = new ServiceConnectionFactory(serviceProtocol, ccm, connectionFactory, loggerFactory, serverNameProvider); configuration.Resolver.Register(typeof(IServiceConnectionFactory), () => scf); } var sccf = new ServiceConnectionContainerFactory(scf, endpoint, router, options, loggerFactory); if (hubs?.Count > 0) { return(new ServiceHubDispatcher(hubs, scm, sccf, serviceOptions, loggerFactory)); } else { loggerFactory.CreateLogger <DispatcherHelper>().Log(LogLevel.Warning, "No hubs found."); return(null); } }
public static void RegisterSensorBuilder <T>(ServiceProtocol protocol, Func <ServiceFileRecord, ISensor> builder) where T : ISensor { store.Add(protocol, builder); }