/// <summary> /// Creates a Subscription. /// </summary> /// <param name="client">A instance of <see cref="ISessionClient"/>.</param> /// <param name="request">A <see cref="CreateSubscriptionRequest"/>.</param> /// <returns>A <see cref="Task"/> representing the asynchronous operation that returns a <see cref="CreateSubscriptionResponse"/>.</returns> public static async Task<CreateSubscriptionResponse> CreateSubscriptionAsync(this ISessionClient client, CreateSubscriptionRequest request) { if (request == null) { throw new ArgumentNullException("request"); } return (CreateSubscriptionResponse)await client.RequestAsync(request).ConfigureAwait(false); }
public async Task TransferSubscriptions() { // get or add application certificate. var localCertificate = this.localDescription.GetCertificate(); if (localCertificate == null) { throw new ServiceResultException(StatusCodes.BadSecurityChecksFailed, "Application certificate is missing."); } // discover available endpoints of server. var getEndpointsRequest = new GetEndpointsRequest { EndpointUrl = this.endpointUrl, ProfileUris = new[] { TransportProfileUris.UaTcpTransport } }; Console.WriteLine($"Discovering endpoints of '{getEndpointsRequest.EndpointUrl}'."); var getEndpointsResponse = await UaTcpDiscoveryClient.GetEndpointsAsync(getEndpointsRequest); var selectedEndpoint = getEndpointsResponse.Endpoints.OrderBy(e => e.SecurityLevel).Last(); IUserIdentity selectedUserIdentity = new UserNameIdentity("root", "secret"); var client = new UaTcpSessionClient( this.localDescription, localCertificate, selectedUserIdentity, selectedEndpoint); Console.WriteLine($"Creating session with endpoint '{client.RemoteEndpoint.EndpointUrl}'."); Console.WriteLine($"SecurityPolicy: '{client.RemoteEndpoint.SecurityPolicyUri}'."); Console.WriteLine($"SecurityMode: '{client.RemoteEndpoint.SecurityMode}'."); await client.OpenAsync(); Console.WriteLine($"Activated session '{client.SessionId}'."); var req = new CreateSubscriptionRequest { RequestedPublishingInterval = 1000, RequestedMaxKeepAliveCount = 20, PublishingEnabled = true }; var res = await client.CreateSubscriptionAsync(req); Console.WriteLine($"Created subscription '{res.SubscriptionId}'."); Console.WriteLine($"Aborting session '{client.SessionId}'."); await client.AbortAsync(); var client2 = new UaTcpSessionClient( this.localDescription, localCertificate, selectedUserIdentity, selectedEndpoint); await client2.OpenAsync(); Console.WriteLine($"Activated session '{client2.SessionId}'."); var req2 = new TransferSubscriptionsRequest { SubscriptionIds = new[] { res.SubscriptionId } }; var res2 = await client2.TransferSubscriptionsAsync(req2); Console.WriteLine($"Transferred subscription result '{res2.Results[0].StatusCode}'."); Assert.IsTrue(StatusCode.IsGood(res2.Results[0].StatusCode)); Console.WriteLine($"Closing session '{client2.SessionId}'."); await client2.CloseAsync(); }
/// <summary> /// Creates new subscriptions on the server. /// </summary> /// <param name="cancellationToken">A cancellation token. </param> /// <returns>A task.</returns> private async Task CreateNewSubscriptionsAsync(CancellationToken cancellationToken = default(CancellationToken)) { var subscriptionsChanged = new AsyncAutoResetEvent(); var handler = new NotifyCollectionChangedEventHandler((s, e) => subscriptionsChanged.Set()); this.Subscriptions.CollectionChanged += handler; try { while (!cancellationToken.IsCancellationRequested) { foreach (var subscription in this.Subscriptions) { if (subscription.Id == 0) { try { // create the subscription. var subscriptionRequest = new CreateSubscriptionRequest { RequestedPublishingInterval = subscription.PublishingInterval, RequestedMaxKeepAliveCount = subscription.KeepAliveCount, RequestedLifetimeCount = subscription.LifetimeCount > 0 ? subscription.LifetimeCount : (uint)(this.SessionTimeout / subscription.PublishingInterval), PublishingEnabled = false, // initially Priority = subscription.Priority }; var subscriptionResponse = await this.CreateSubscriptionAsync(subscriptionRequest); var id = subscription.Id = subscriptionResponse.SubscriptionId; // add the items. if (subscription.MonitoredItems.Count > 0) { var items = subscription.MonitoredItems.ToList(); var requests = items.Select(m => new MonitoredItemCreateRequest { ItemToMonitor = new ReadValueId { NodeId = m.NodeId, AttributeId = m.AttributeId, IndexRange = m.IndexRange }, MonitoringMode = m.MonitoringMode, RequestedParameters = new MonitoringParameters { ClientHandle = m.ClientId, DiscardOldest = m.DiscardOldest, QueueSize = m.QueueSize, SamplingInterval = m.SamplingInterval, Filter = m.Filter } }).ToArray(); var itemsRequest = new CreateMonitoredItemsRequest { SubscriptionId = id, ItemsToCreate = requests, }; var itemsResponse = await this.CreateMonitoredItemsAsync(itemsRequest); for (int i = 0; i < itemsResponse.Results.Length; i++) { var item = items[i]; var result = itemsResponse.Results[i]; item.ServerId = result.MonitoredItemId; if (StatusCode.IsBad(result.StatusCode)) { Log.Warn($"Error response from MonitoredItemCreateRequest for {item.NodeId}. {result.StatusCode}"); } } } // start publishing. if (subscription.PublishingEnabled) { var modeRequest = new SetPublishingModeRequest { SubscriptionIds = new[] { id }, PublishingEnabled = true, }; var modeResponse = await this.SetPublishingModeAsync(modeRequest); } } catch (ServiceResultException ex) { Log.Warn($"Error creating subscription '{subscription.GetType().Name}'. {ex.Message}"); } } } await subscriptionsChanged.WaitAsync().WithCancellation(cancellationToken); } } catch (OperationCanceledException) { } finally { this.Subscriptions.CollectionChanged -= handler; } }