/// <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); }