/// <summary>
/// Get endpoint from session
/// </summary>
/// <param name="session"></param>
/// <returns></returns>
public static EndpointIdentifier GetEndpointId(SessionClient session)
{
var endpointModel = new EndpointModel {
Url = session.Endpoint.EndpointUrl.TrimEnd('/'),
SecurityPolicy = session.Endpoint.SecurityPolicyUri
};
switch (session.Endpoint.SecurityMode)
{
case MessageSecurityMode.Invalid:
throw new Exception("Invalid security mode: invalid");
case MessageSecurityMode.None:
endpointModel.SecurityMode = SecurityMode.None;
break;
case MessageSecurityMode.Sign:
endpointModel.SecurityMode = SecurityMode.Sign;
break;
case MessageSecurityMode.SignAndEncrypt:
endpointModel.SecurityMode = SecurityMode.SignAndEncrypt;
break;
}
return(new EndpointIdentifier(endpointModel));
}
public ActionResult GetInlineOAuthToken(string consumerKey, string consumerSecret, string callbackUrl, string serviceUri, string requestTokenUri, string authorizationUri, string accessTokenUri)
{
RequestTokenModel model = new RequestTokenModel();
model.ConsumerKey = consumerKey;
model.ConsumerSecret = consumerSecret;
EndpointModel endpointModel = new EndpointModel();
endpointModel.ServiceUri = serviceUri;
endpointModel.RequestTokenUri = requestTokenUri;
endpointModel.AuthorizationUri = authorizationUri;
endpointModel.AccessTokenUri = accessTokenUri;
model.EndpointModel = endpointModel;
AlwaysMoveForward.OAuth.Client.RestSharp.OAuthClient oauthClient = new AlwaysMoveForward.OAuth.Client.RestSharp.OAuthClient("", model.ConsumerKey, model.ConsumerSecret, model.EndpointModel);
try
{
IOAuthToken accessToken = oauthClient.GetInlineAccessToken(Realm.GetDefault());
model.Token = accessToken.Token;
model.Secret = accessToken.Secret;
}
catch (OAuthException authEx)
{
Session["problem"] = authEx.Report;
Response.Redirect("AccessDenied.aspx");
}
return(View("OauthCallback", model));
}
public void GetRequestToken(string consumerKey, string consumerSecret, string callbackUrl, string serviceUri, string requestTokenUri, string authorizationUri, string accessTokenUri)
{
RequestTokenModel model = new RequestTokenModel();
model.ConsumerKey = consumerKey;
model.ConsumerSecret = consumerSecret;
EndpointModel endpointModel = new EndpointModel();
endpointModel.ServiceUri = serviceUri;
endpointModel.RequestTokenUri = requestTokenUri;
endpointModel.AuthorizationUri = authorizationUri;
endpointModel.AccessTokenUri = accessTokenUri;
model.EndpointModel = endpointModel;
AlwaysMoveForward.OAuth.Client.RestSharp.OAuthClient oauthClient = new AlwaysMoveForward.OAuth.Client.RestSharp.OAuthClient("", model.ConsumerKey, model.ConsumerSecret, endpointModel);
if (oauthClient != null)
{
IOAuthToken requestToken = oauthClient.GetRequestToken(this.GenerateRealm(TestUserId, "*****@*****.**"), callbackUrl);
model.Token = requestToken.Token;
model.Secret = requestToken.Secret;
}
Session[model.Token] = model;
string authorizationUrl = oauthClient.GetUserAuthorizationUrl(model);
this.Response.Redirect(authorizationUrl, false);
}
public async Task <JsonResult> GetAdminSettings()
{
try
{
var resourceProvider =
await ClientFactory.AdminManagementClient.GetResourceProviderAsync
(CmpWapExtensionClient.RegisteredServiceName, Guid.Empty.ToString());
this.CmpWapExtensionServiceEndPoint =
EndpointModel.FromResourceProviderEndpoint(resourceProvider.AdminEndpoint);
return(this.JsonDataSet(this.CmpWapExtensionServiceEndPoint));
}
catch (ManagementClientException managementException)
{
// 404 means the CmpWapExtension resource provider is not yet configured, return an empty record.
if (managementException.StatusCode == HttpStatusCode.NotFound)
{
return(this.JsonDataSet(new EndpointModel()));
}
//Just throw if there is any other type of exception is encountered
throw;
}
}
private static void ApplyUpdate(OrchestratedBuildModel manifest, ITaskItem update)
{
string type = update.GetMetadata(nameof(UpdateType));
UpdateType updateType;
if (!Enum.TryParse(type, true, out updateType))
{
throw new ArgumentException(
$"UpdateType '{type}' on update '{update.ItemSpec}' is not valid.");
}
switch (updateType)
{
case UpdateType.AddOrMergeEndpoint:
var xml = XElement.Parse(update.GetMetadata(XmlMetadataName));
EndpointModel endpoint = EndpointModel.Parse(xml);
EndpointModel existingEndpoint = manifest.Endpoints
.FirstOrDefault(e => SameAttributes(endpoint.Attributes, e.Attributes));
if (existingEndpoint == null)
{
manifest.Endpoints.Add(endpoint);
}
else
{
existingEndpoint.Artifacts.Add(endpoint.Artifacts);
}
break;
}
}
/// <inheritdoc/>
public Task <T> ExecuteServiceAsync <T>(EndpointModel endpoint,
CredentialModel elevation, int priority, Func <Session, Task <T> > service,
TimeSpan?timeout, CancellationToken ct, Func <Exception, bool> handler)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (string.IsNullOrEmpty(endpoint.Url))
{
throw new ArgumentNullException(nameof(endpoint.Url));
}
var key = new EndpointIdentifier(endpoint);
while (!_cts.IsCancellationRequested)
{
var client = GetOrCreateSession(key);
if (!client.Inactive)
{
var scheduled = client.TryScheduleServiceCall(elevation, priority,
service, handler, timeout, ct, out var result);
if (scheduled)
{
// Session is owning the task to completion now.
return(result);
}
}
// Create new session next go around
EvictIfInactive(key);
}
return(Task.FromCanceled <T>(_cts.Token));
}
/// <inheritdoc/>
public async Task UnregisterAsync(EndpointModel endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var id = new EndpointIdentifier(endpoint);
_callbacks.TryRemove(id, out _);
await _lock.WaitAsync();
try {
// Remove any session
if (_clients.TryGetValue(id, out var client))
{
await Try.Async(client.CloseAsync);
Try.Op(client.Dispose);
_clients.Remove(id);
_logger.Debug("Endpoint {id} ({endpoint}) closed.",
id, endpoint.Url);
}
else
{
_logger.Debug(
"Session for endpoint {id} ({endpoint}) not found.",
endpoint.Url, id);
}
}
finally {
_lock.Release();
}
}
/// <inheritdoc/>
public async Task RegisterAsync(EndpointModel endpoint,
Func <EndpointConnectivityState, Task> callback)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
if (callback == null)
{
throw new ArgumentNullException(nameof(callback));
}
var id = new EndpointIdentifier(endpoint);
if (!_callbacks.TryAdd(id, callback))
{
_callbacks.AddOrUpdate(id, callback, (k, v) => callback);
}
await _lock.WaitAsync();
try {
// Add a persistent session
if (!_clients.TryGetValue(id, out var _))
{
_clients.Add(id, new ClientSession(
_opcApplicationConfig, id.Endpoint.Clone(), _logger,
NotifyStateChangeAsync, true, _maxOpTimeout));
_logger.Debug("Open session for endpoint {id} ({endpoint}).",
id, endpoint.Url);
}
}
finally {
_lock.Release();
}
}
/// <summary>
/// Overload which can only be cancelled.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="ct"></param>
/// <param name="endpoint"></param>
/// <param name="service"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority,
CancellationToken ct, Func <Session, Task <T> > service,
Func <Exception, bool> handler)
{
return(client.ExecuteServiceAsync(endpoint, elevation, priority, service,
null, ct, handler));
}
public async Task AddEndpoint(string endpoint)
{
var endpointModel = new EndpointModel {
Endpoint = endpoint
};
await _context.EndpointCollection.InsertOneAsync(endpointModel);
}
/// <summary>
/// Export using browse encoder
/// </summary>
/// <param name="endpoint"></param>
/// <param name="stream"></param>
/// <param name="diagnostics"></param>
/// <param name="ct"></param>
/// <returns></returns>
private async Task BrowseEncodeModelAsync(EndpointModel endpoint,
DiagnosticsModel diagnostics, Stream stream, CancellationToken ct)
{
using (var encoder = new BrowseStreamEncoder(_outer._client, endpoint,
stream, Encoding, diagnostics, _outer._logger, null)) {
await encoder.EncodeAsync(ct);
}
}
public async Task AddEndpoint(string endpoint)
{
var endpointModel = new EndpointModel {
Endpoint = endpoint
};
_dataContext.Add(endpointModel);
await _dataContext.SaveChangesAsync();
}
/// <summary>
/// Matches model
/// </summary>
/// <param name="endpoint"></param>
/// <param name="model"></param>
/// <returns></returns>
public static bool IsSameAs(this EndpointDescription endpoint,
EndpointModel model)
{
return
(endpoint.SecurityMode == (model.SecurityMode ?? SecurityMode.SignAndEncrypt)
.ToStackType() &&
endpoint.SecurityPolicyUri == model.SecurityPolicy);
}
/// <summary>
/// Create history encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="encoder"></param>
/// <param name="nodeId"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="maxValues"></param>
/// <param name="priority"></param>
public HistoryStreamEncoder(IEndpointServices client, EndpointModel endpoint,
IEncoder encoder, string nodeId, ILogger logger, CredentialModel elevation = null,
DateTime?startTime = null, DateTime?endTime = null, int?maxValues = null,
int priority = int.MaxValue) :
this(client, endpoint, nodeId, logger, elevation, startTime, endTime,
maxValues, priority)
{
_encoder = new ModelEncoder(encoder);
}
/// <summary>
/// Execute the service on the provided session.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
/// <param name="service"></param>
/// <param name="timeout"></param>
/// <param name="ct"></param>
/// <param name="exceptionHandler"></param>
/// <returns></returns>
public static Task <T> ExecuteServiceAsync <T>(this IEndpointServices client,
EndpointModel endpoint, CredentialModel elevation, int priority, Func <Session,
Task <T> > service, TimeSpan?timeout, CancellationToken ct,
Func <Exception, bool> exceptionHandler)
{
return(client.ExecuteServiceAsync(new ConnectionModel {
Endpoint = endpoint
},
elevation, priority, service, timeout, ct, exceptionHandler));
}
public static EndpointModel GetEndpoint(Guid id)
{
var item = fastpayTools.EndpointTable.Where(i => i.Id == id).FirstOrDefault();
var result = new EndpointModel()
{
Action = item.Action, CreateDate = item.CreateDate, EndPoint = item.EndPoint, Header = item.Header, Id = item.Id, IsDeleted = item.IsDeleted, ModifiedDate = item.ModifiedDate, Request = item.Request, RequestType = item.RequestType, Response = item.Response, ServiceName = item.ServiceName
};
return(result);
}
/// <summary>
/// Notify about session/endpoint state changes
/// </summary>
/// <param name="ep"></param>
/// <param name="state"></param>
/// <returns></returns>
private Task NotifyStateChangeAsync(EndpointModel ep, EndpointConnectivityState state)
{
var id = new EndpointIdentifier(ep);
if (_callbacks.TryGetValue(id, out var cb))
{
return(cb(state));
}
return(Task.CompletedTask);
}
protected EndpointModel GenerateEndPointModel()
{
EndpointConfiguration endpointConfiguration = EndpointConfiguration.GetInstance();
EndpointModel endpointModel = new EndpointModel();
endpointModel.ServiceUri = endpointConfiguration.ServiceUri;
endpointModel.RequestTokenUri = endpointConfiguration.RequestTokenUri;
endpointModel.AuthorizationUri = endpointConfiguration.AuthorizationUri;
endpointModel.AccessTokenUri = endpointConfiguration.AccessTokenUri;
return(endpointModel);
}
/// <summary>
/// Create new key
/// </summary>
/// <param name="endpoint"></param>
public ConnectionIdentifier(EndpointModel endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
Connection = new ConnectionModel {
Endpoint = endpoint.Clone()
};
_hash = Connection.CreateConsistentHash();
}
public EndpointViewModel(MainViewModel.ChangeScreen changeScreen)
{
_changeScreen = changeScreen;
EndpointData = new EndpointModel();
Endpoints = Network.GetNetworkInterfaces();
if (Endpoints.Any())
{
Endpoint = Endpoints[0];
}
EndpointData.Port = "80";
EndpointData.ServerName = "Messenger";
}
/// <summary>
/// Create node stream encoder
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="diagnostics"></param>
/// <param name="logger"></param>
/// <param name="elevation"></param>
/// <param name="priority"></param>
private BrowseStreamEncoder(IEndpointServices client, EndpointModel endpoint,
DiagnosticsModel diagnostics, ILogger logger, CredentialModel elevation, int priority)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
_elevation = elevation;
_diagnostics = diagnostics;
_priority = priority;
_browseStack.Push(ObjectIds.RootFolder);
_browseStack.Push(ObjectIds.TypesFolder);
}
private Task DisplayRuntimeException(HttpContext context, Exception ex)
{
var endpoint = context.GetEndpoint();
EndpointModel?endpointModel = null;
if (endpoint != null)
{
endpointModel = new EndpointModel();
endpointModel.DisplayName = endpoint.DisplayName;
if (endpoint is RouteEndpoint routeEndpoint)
{
endpointModel.RoutePattern = routeEndpoint.RoutePattern.RawText;
endpointModel.Order = routeEndpoint.Order;
var httpMethods = endpoint.Metadata.GetMetadata <IHttpMethodMetadata>()?.HttpMethods;
if (httpMethods != null)
{
endpointModel.HttpMethods = string.Join(", ", httpMethods);
}
}
}
var request = context.Request;
var title = Resources.ErrorPageHtml_Title;
if (ex is BadHttpRequestException badHttpRequestException)
{
var badRequestReasonPhrase = WebUtilities.ReasonPhrases.GetReasonPhrase(badHttpRequestException.StatusCode);
if (!string.IsNullOrEmpty(badRequestReasonPhrase))
{
title = badRequestReasonPhrase;
}
}
var model = new ErrorPageModel
{
Options = _options,
ErrorDetails = _exceptionDetailsProvider.GetDetails(ex),
Query = request.Query,
Cookies = request.Cookies,
Headers = request.Headers,
RouteValues = request.RouteValues,
Endpoint = endpointModel,
Title = title,
};
var errorPage = new ErrorPage(model);
return(errorPage.ExecuteAsync(context));
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public EndpointApiModel(EndpointModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Url = model.Url;
AlternativeUrls = model.AlternativeUrls;
Certificate = model.Certificate;
SecurityMode = model.SecurityMode;
SecurityPolicy = model.SecurityPolicy;
}
/// <summary>
/// Create client service to control publisher
/// </summary>
/// <param name="client"></param>
/// <param name="publisherUri"></param>
/// <param name="logger"></param>
public PublisherServerClient(IEndpointServices client, Uri publisherUri,
ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
if (publisherUri == null)
{
throw new ArgumentNullException(nameof(publisherUri));
}
_endpoint = new EndpointModel {
Url = publisherUri.ToString()
};
}
/// <summary>
/// Create api model from service model
/// </summary>
/// <param name="model"></param>
public EndpointApiModel(EndpointModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
Url = model.Url;
AlternativeUrls = model.AlternativeUrls;
User = model.User == null ? null :
new CredentialApiModel(model.User);
ServerThumbprint = model.ServerThumbprint;
SecurityMode = model.SecurityMode;
SecurityPolicy = model.SecurityPolicy;
}
/// <summary>
/// Create api model
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static EndpointApiModel ToApiModel(
this EndpointModel model)
{
if (model == null)
{
return(null);
}
return(new EndpointApiModel {
Url = model.Url,
AlternativeUrls = model.AlternativeUrls,
SecurityMode = (IIoT.OpcUa.Api.Registry.Models.SecurityMode?)model.SecurityMode,
SecurityPolicy = model.SecurityPolicy,
Certificate = model.Certificate,
});
}
/// <summary>
/// Create archiver
/// </summary>
/// <param name="client"></param>
/// <param name="endpoint"></param>
/// <param name="elevation"></param>
/// <param name="archive"></param>
/// <param name="contentType"></param>
/// <param name="startTime"></param>
/// <param name="endTime"></param>
/// <param name="maxValues"></param>
/// <param name="logger"></param>
public AddressSpaceArchiver(IEndpointServices client, EndpointModel endpoint,
CredentialModel elevation, IArchive archive, string contentType,
DateTime?startTime, DateTime?endTime, int?maxValues, ILogger logger)
{
_client = client ?? throw new ArgumentNullException(nameof(client));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_endpoint = endpoint ?? throw new ArgumentNullException(nameof(endpoint));
_archive = archive ?? throw new ArgumentNullException(nameof(endpoint));
_contentType = contentType ?? ContentMimeType.UaJson;
_startTime = startTime ?? DateTime.UtcNow.AddDays(-1);
_endTime = endTime ?? DateTime.UtcNow;
_maxValues = maxValues ?? short.MaxValue;
_elevation = elevation;
}
public override bool Execute()
{
// Leave out attributes if they would just have empty string values.
if (ManifestBranch == string.Empty)
{
ManifestBranch = null;
}
if (ManifestCommit == string.Empty)
{
ManifestCommit = null;
}
var identity = new BuildIdentity
{
Name = ManifestName,
BuildId = ManifestBuildId,
Branch = ManifestBranch,
Commit = ManifestCommit,
IsStable = IsStable,
VersionStamp = VersionStamp
};
var orchestratedBuild = new OrchestratedBuildModel(identity)
{
Endpoints = new List <EndpointModel>
{
EndpointModel.CreateOrchestratedBlobFeed(BlobFeedUrl)
}
};
foreach (ITaskItem buildManifestFile in BuildManifestFiles)
{
string contents = System.IO.File.ReadAllText(buildManifestFile.ItemSpec);
BuildModel build = BuildModel.Parse(XElement.Parse(contents));
foreach (PackageArtifactModel package in build.Artifacts.Packages)
{
package.OriginBuildName = build.Identity.Name;
}
orchestratedBuild.AddParticipantBuild(build);
}
System.IO.File.WriteAllText(File, orchestratedBuild.ToXml().ToString());
return(!Log.HasLoggedErrors);
}
public override bool Execute()
{
GitHubAuth gitHubAuth = null;
if (!string.IsNullOrEmpty(GitHubAuthToken))
{
gitHubAuth = new GitHubAuth(GitHubAuthToken, GitHubUser, GitHubEmail);
}
using (var gitHubClient = new GitHubClient(gitHubAuth))
{
var client = new BuildManifestClient(gitHubClient);
OrchestratedBuildModel manifest = client.FetchManifestAsync(
new GitHubProject(VersionsRepo, VersionsRepoOwner),
VersionsRepoRef,
VersionsRepoPath)
.Result;
OrchestratedBuild = CreateItem(manifest.Identity);
EndpointModel[] orchestratedFeeds = manifest.Endpoints
.Where(e => e.IsOrchestratedBlobFeed)
.ToArray();
if (orchestratedFeeds.Length != 1)
{
throw new Exception(
"Invalid manifest. Expected 1 orchestrated blob feed, " +
$"found {orchestratedFeeds.Length}.");
}
EndpointModel feed = orchestratedFeeds[0];
IEnumerable <ITaskItem> packageItems = feed.Artifacts.Packages.Select(CreateItem);
IEnumerable <ITaskItem> blobItems = feed.Artifacts.Blobs.Select(CreateItem);
OrchestratedBlobFeed = new[] { new TaskItem("Endpoint", feed.Attributes) };
OrchestratedBlobFeedArtifacts = packageItems.Concat(blobItems).ToArray();
IEnumerable <ITaskItem> buildItems = manifest.Builds.Select(CreateItem);
OrchestratedBuildConstituents = buildItems.ToArray();
}
return(!Log.HasLoggedErrors);
}
/// <inheritdoc/>
public Task Unregister(EndpointModel endpoint)
{
if (endpoint == null)
{
throw new ArgumentNullException(nameof(endpoint));
}
var id = new EndpointIdentifier(endpoint);
_callbacks.TryRemove(id, out _);
// Remove persistent session
if (_clients.TryRemove(id, out var client))
{
return(Try.Async(client.CloseAsync));
}
return(Task.CompletedTask);
}
