/// <summary>
/// Connects to the server with the specified OpcUrl and credentials.
/// </summary>
public override void Connect(OpcUrl url, OpcConnectData connectData)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
if (Factory == null)
{
Factory = new Factory();
}
// connect to server.
base.Connect(url, connectData);
// all done if no subscriptions.
if (subscriptions_.Count == 0)
{
return;
}
// create subscriptions (should only happen if server has been deserialized).
SubscriptionCollection subscriptions = new SubscriptionCollection();
foreach (TsCAeSubscription template in subscriptions_)
{
// create subscription for template.
try { subscriptions.Add(EstablishSubscription(template)); }
catch
{
// ignored
}
}
// save new set of subscriptions.
subscriptions_ = subscriptions;
}
///////////////////////////////////////////////////////////////////////
#region Public Methods
/// <summary>
/// Connects to the server with the specified OpcUrl and credentials.
/// </summary>
public override void Connect(OpcUrl url, OpcConnectData connectData)
{
if (_factory == null)
{
_factory = new Com.Factory();
}
// connect to server.
base.Connect(url, connectData);
// all done if no subscriptions.
if (_subscriptions.Count == 0)
{
return;
}
// create subscriptions (should only happen if server has been deserialized).
SubscriptionCollection subscriptions = new SubscriptionCollection();
foreach (Ae.TsCAeSubscription template in _subscriptions)
{
// create subscription for template.
try { subscriptions.Add(EstablishSubscription(template)); }
catch { }
}
// save new set of subscriptions.
_subscriptions = subscriptions;
}
private async Task GetSubscriptions(string tenantId)
{
var requestUrl = "https://management.azure.com/subscriptions?api-version=2014-04-01";
try
{
HttpClient client = new HttpClient();
var data = await DependencyService.Get <IAuthenticator>().AuthenticateSilently(tenantId, App.ManagementResourceUri, App.ClientID);
//var loginAuthnority = "https://login.windows.net/" + tenantId;
//var data = await DependencyService.Get<IAuthenticator>().Authenticate(loginAuthnority, App.ManagementResourceUri, App.ClientID, App.returnUri.ToString());
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", data.AccessToken);
//client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", App.authResult.AccessToken);
var subsriptionResponse = await client.GetStringAsync(requestUrl);
var subscriptions = JsonConvert.DeserializeObject <SubscriptionResponse>(subsriptionResponse);
foreach (var subscription in subscriptions.SubscriptionCollection)
{
Console.WriteLine("subscrip: " + subscription.Id);
SubscriptionCollection.Add(subscription);
}
IsFirstRunComplete = true;
}
catch (Exception ex)
{
await DisplayAlert("Error!", ex.Message, "Dismiss");
}
}
/// <summary>
/// Contructs a server by de-serializing its OpcUrl from the stream.
/// </summary>
protected TsCAeServer(SerializationInfo info, StreamingContext context)
:
base(info, context)
{
int count = (int)info.GetValue(Names.COUNT, typeof(int));
_subscriptions = new SubscriptionCollection();
for (int ii = 0; ii < count; ii++)
{
Ae.TsCAeSubscription subscription = (Ae.TsCAeSubscription)info.GetValue(Names.SUBSCRIPTION + ii.ToString(), typeof(Ae.TsCAeSubscription));
_subscriptions.Add(subscription);
}
}
/// <summary>
/// Constructs a server by de-serializing its OpcUrl from the stream.
/// </summary>
protected TsCAeServer(SerializationInfo info, StreamingContext context)
:
base(info, context)
{
int count = (int)info.GetValue(Names.Count, typeof(int));
subscriptions_ = new SubscriptionCollection();
for (int ii = 0; ii < count; ii++)
{
var subscription = (TsCAeSubscription)info.GetValue(Names.Subscription + ii, typeof(TsCAeSubscription));
subscriptions_.Add(subscription);
}
}
public override void Connect(URL url, ConnectData connectData)
{
base.Connect(url, connectData);
if (this.m_subscriptions.Count != 0)
{
SubscriptionCollection subscriptions = new SubscriptionCollection();
foreach (Subscription subscription in this.m_subscriptions)
{
try
{
subscriptions.Add(this.EstablishSubscription(subscription));
}
catch
{
}
}
this.m_subscriptions = subscriptions;
}
}
/// <summary>
/// Creates a new event subscription.
/// </summary>
/// <param name="state">The initial state for the subscription.</param>
/// <returns>The new subscription object.</returns>
public ITsCAeSubscription CreateSubscription(Ae.TsCAeSubscriptionState state)
{
if (_server == null)
{
throw new NotConnectedException();
}
// create remote object.
ITsCAeSubscription subscription = ((ITsCAeServer)_server).CreateSubscription(state);
if (subscription != null)
{
// create wrapper.
Ae.TsCAeSubscription wrapper = new Ae.TsCAeSubscription(this, subscription, state);
_subscriptions.Add(wrapper);
return(wrapper);
}
// should never happen.
return(null);
}
/// <summary>
/// Creates a new event subscription.
/// </summary>
/// <param name="state">The initial state for the subscription.</param>
/// <returns>The new subscription object.</returns>
public ITsCAeSubscription CreateSubscription(TsCAeSubscriptionState state)
{
LicenseHandler.ValidateFeatures(LicenseHandler.ProductFeature.AlarmsConditions);
if (Server == null)
{
throw new NotConnectedException();
}
// create remote object.
ITsCAeSubscription subscription = ((ITsCAeServer)Server).CreateSubscription(state);
if (subscription != null)
{
// create wrapper.
var wrapper = new TsCAeSubscription(this, subscription, state);
subscriptions_.Add(wrapper);
return(wrapper);
}
// should never happen.
return(null);
}
//======================================================================
// Connection Management
/// <summary>
/// Connects to the server with the specified URL and credentials.
/// </summary>
public override void Connect(URL url, ConnectData connectData)
{
// connect to server.
base.Connect(url, connectData);
// all done if no subscriptions.
if (m_subscriptions.Count == 0)
{
return;
}
// create subscriptions (should only happen if server has been deserialized).
SubscriptionCollection subscriptions = new SubscriptionCollection();
foreach (Subscription template in m_subscriptions)
{
// create subscription for template.
try { subscriptions.Add(EstablishSubscription(template)); }
catch {}
}
// save new set of subscriptions.
m_subscriptions = subscriptions;
}
public async Task TransferSubscription(TransferType transferType, bool sendInitialValues)
{
const int kTestSubscriptions = 2;
const int kDelay = 2_000;
// create test session and subscription
var originSession = await ClientFixture.ConnectAsync(ServerUrl, SecurityPolicies.Basic256Sha256).ConfigureAwait(false);
bool originSessionOpen = transferType == TransferType.KeepOpen;
// create subscriptions
var originSubscriptions = new SubscriptionCollection();
var originSubscriptionCounters = new int[kTestSubscriptions];
var targetSubscriptionCounters = new int[kTestSubscriptions];
for (int ii = 0; ii < kTestSubscriptions; ii++)
{
// create subscription with static monitored items
var subscription = new Subscription(originSession.DefaultSubscription)
{
PublishingInterval = 1_000,
PublishingEnabled = true,
};
originSubscriptions.Add(subscription);
originSession.AddSubscription(subscription);
subscription.RepublishAfterTransfer = transferType == TransferType.DisconnectedRepublish;
subscription.Create();
// set defaults
subscription.DefaultItem.DiscardOldest = true;
subscription.DefaultItem.QueueSize = (ii == 0) ? 0U : 5;
subscription.DefaultItem.MonitoringMode = MonitoringMode.Reporting;
// create test set
var namespaceUris = Session.NamespaceUris;
var testSet = new List <NodeId>();
if (ii == 0)
{
testSet.AddRange(GetTestSetStatic(namespaceUris));
}
else
{
testSet.AddRange(GetTestSetSimulation(namespaceUris));
}
subscription.Handle = ii;
var list = CreateMonitoredItemTestSet(subscription, testSet).ToList();
list.ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
originSubscriptionCounters[(int)subscription.Handle]++;
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("Org:{0}: {1:20}, {2}, {3}, {4}", subscription.Id, item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
subscription.AddItems(list);
subscription.ApplyChanges();
}
// settle
await Task.Delay(kDelay).ConfigureAwait(false);
// persist the subscription state
var filePath = Path.GetTempFileName();
// close session, do not delete subscription
if (transferType != TransferType.KeepOpen)
{
originSession.DeleteSubscriptionsOnClose = false;
originSession.Save(filePath);
if (transferType == TransferType.CloseSession)
{
// graceful close
originSession.Close();
}
else
{
// force a socket dispose, to emulate network disconnect
// without closing session on server
originSession.TransportChannel.Dispose();
}
}
// wait
await Task.Delay(kDelay).ConfigureAwait(false);
// close session, do not delete subscription
if (transferType > TransferType.CloseSession)
{
originSession.Close();
}
// create target session
var targetSession = await ClientFixture.ConnectAsync(ServerUrl, SecurityPolicies.Basic256Sha256).ConfigureAwait(false);
// restore client state
var transferSubscriptions = new SubscriptionCollection();
if (transferType != TransferType.KeepOpen)
{
// load
transferSubscriptions.AddRange(targetSession.Load(filePath));
// hook notifications for log output
int ii = 0;
foreach (var subscription in transferSubscriptions)
{
subscription.Handle = ii;
subscription.MonitoredItems.ToList().ForEach(i => i.Notification += (MonitoredItem item, MonitoredItemNotificationEventArgs e) => {
targetSubscriptionCounters[(int)subscription.Handle]++;
foreach (var value in item.DequeueValues())
{
TestContext.Out.WriteLine("Tra:{0}: {1:20}, {2}, {3}, {4}", subscription.Id, item.DisplayName, value.Value, value.SourceTimestamp, value.StatusCode);
}
});
ii++;
}
}
else
{
transferSubscriptions.AddRange(originSubscriptions);
}
// wait
await Task.Delay(kDelay).ConfigureAwait(false);
// transfer restored subscriptions
var result = targetSession.TransferSubscriptions(transferSubscriptions, sendInitialValues);
Assert.IsTrue(result);
// validate results
for (int ii = 0; ii < transferSubscriptions.Count; ii++)
{
Assert.IsTrue(transferSubscriptions[ii].Created);
}
TestContext.Out.WriteLine("TargetSession is now SessionId={0}", targetSession.SessionId);
// wait for some events
await Task.Delay(kDelay).ConfigureAwait(false);
// stop publishing
foreach (var subscription in transferSubscriptions)
{
TestContext.Out.WriteLine("SetPublishingMode(false) for SessionId={0}, SubscriptionId={1}",
subscription.Session.SessionId, subscription.Id);
subscription.SetPublishingMode(false);
}
// validate expected counts
for (int jj = 0; jj < kTestSubscriptions; jj++)
{
TestContext.Out.WriteLine("Subscription {0}: OriginCounts {1}, TargetCounts {2} ",
jj, originSubscriptionCounters[jj], targetSubscriptionCounters[jj]);
var monitoredItemCount = transferSubscriptions[jj].MonitoredItemCount;
var originExpectedCount = sendInitialValues && originSessionOpen ? monitoredItemCount * 2 : monitoredItemCount;
var targetExpectedCount = sendInitialValues && !originSessionOpen ? monitoredItemCount : 0;
if (jj == 0)
{
// static nodes, expect only one set of changes, another one if send initial values was set
Assert.AreEqual(originExpectedCount, originSubscriptionCounters[jj]);
Assert.AreEqual(targetExpectedCount, targetSubscriptionCounters[jj]);
}
else
{
// dynamic nodes, expect only one set of changes, another one if send initial values was set
Assert.LessOrEqual(originExpectedCount, originSubscriptionCounters[jj]);
Assert.LessOrEqual(targetExpectedCount, targetSubscriptionCounters[jj]);
}
}
// close sessions
targetSession.Close();
if (originSessionOpen)
{
originSession.Close();
}
// cleanup
File.Delete(filePath);
}
