public async Task <object> ExecuteEndpointAsync(ExecutionContext context, AbstractEndpoint endpoint) { return(await Task.Run(() => { return ExecuteEndpoint(context, endpoint); })); }
private bool IsMatch(AbstractEndpoint callback, string url, Dictionary <string, object> matchedVariables) { if (callback.Parts == null) { return(false); } var urlParts = url.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries); for (var i = 0; i < urlParts.Length; i++) { if (i >= callback.Parts.Length) { return(false); } if (!urlParts[i].Equals(callback.Parts[i].Value, StringComparison.OrdinalIgnoreCase) && !callback.Parts[i].IsVariable) { return(false); } if (callback.Parts[i].IsVariable) { matchedVariables.Add(callback.Parts[i].Value, urlParts[i]); } } return(true); }
private void RegisterReplyMessageCorrelator() { lock (_replyMessageCorrelatorMonitor) { if (_replyMessageCorrelator != null) { return; } AbstractEndpoint correlator = null; IMessageHandler handler = new LocalReplyProducingMessageHandler(); if (_replyChannel is ISubscribableChannel) { correlator = new EventDrivenConsumer((ISubscribableChannel)_replyChannel, handler); } else if (_replyChannel is IPollableChannel) { PollingConsumer endpoint = new PollingConsumer( (IPollableChannel)_replyChannel, handler); endpoint.Trigger = new IntervalTrigger(TimeSpan.FromMilliseconds(10)); endpoint.ObjectFactory = ObjectFactory; endpoint.AfterPropertiesSet(); correlator = endpoint; } if (IsRunning) { if (correlator == null) { throw new InvalidOperationException("correlator must not be null"); } ((ILifecycle)correlator).Start(); } _replyMessageCorrelator = correlator; } }
protected virtual AbstractEndpoint CreateEndpoint(IMessageHandler handler, MethodInfo method, List <Attribute> annotations) { AbstractEndpoint endpoint = null; var inputChannelName = MessagingAttributeUtils.ResolveAttribute <string>(annotations, InputChannelProperty); if (!string.IsNullOrEmpty(inputChannelName)) { IMessageChannel inputChannel; try { inputChannel = ChannelResolver.ResolveDestination(inputChannelName); if (inputChannel == null) { inputChannel = new DirectChannel(ApplicationContext, inputChannelName); ApplicationContext.Register(inputChannelName, inputChannel); } } catch (DestinationResolutionException) { inputChannel = new DirectChannel(ApplicationContext, inputChannelName); ApplicationContext.Register(inputChannelName, inputChannel); } endpoint = DoCreateEndpoint(handler, inputChannel, annotations); } return(endpoint); }
public void Register(AbstractEndpoint callback) { if (!callback.HasCallback) { return; } logger.Debug($"Register() {callback.Name} {callback.Url} {callback.SessionId}"); if (string.IsNullOrEmpty(callback.Url)) { Unregister(callback.Name, callback.SessionId); if (callback.Schedule != null) { ScheduledEndpointManager?.SetEndpointSchedule(callback); } if (callback.SessionId == null) { Endpoints.TryAdd(callback.Name, callback); } else { if (!SessionManager.SessionExists(callback.SessionId)) { SessionManager.StartSession(callback.SessionId); } if (SessionManager.SessionExists(callback.SessionId)) { var session = SessionManager.GetSession(callback.SessionId); session.Endpoints.TryAdd(callback.Name, callback); } } } else { if (callback.UrlRegEx == null) { callback.Parts = callback.Url.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Select(m => new Part(m, m.StartsWith(":"))).ToArray(); if (callback.Parts.GroupBy(m => m.Value).Any(m => m.Count() > 1)) { throw new Exception("Duplicate variable name in URL."); } } var existingEndpoint = RestEndpoints.FirstOrDefault(m => m.Method == callback.Method && m.Url.Equals(callback.Url, StringComparison.OrdinalIgnoreCase)); if (existingEndpoint != null) { RestEndpoints.Remove(existingEndpoint); } RestEndpoints.Add(callback); } }
private static string CustomBuildPathForComponentCode(abs.IAbstractEndpoint endpoint, IService service, string subPath, bool useNewServiceName) { var result = string.Format(@"{0}\Components\{1}", endpoint.Project.Name, (useNewServiceName) ? service.InstanceName : service.OriginalInstanceName); if (subPath != string.Empty && subPath != null) { result = string.Format(@"{0}\Infrastructure\{1}\{2}", endpoint.Project.Name, subPath, (useNewServiceName) ? service.InstanceName : service.OriginalInstanceName); } return result; }
public void RegisterEndpoint(string endpointName, AbstractEndpoint endpoint) { if (endpoint is AbstractPollingEndpoint) { //DirectFieldAccessor accessor = new DirectFieldAccessor(endpoint); //if (accessor.getPropertyValue("trigger") == null) { ((AbstractPollingEndpoint)endpoint).Trigger = new IntervalTrigger(new TimeSpan(0, 0, 0, 0, 10)); //} } RegisterObject(endpointName, endpoint, this); }
public object ExecuteEndpoint(ExecutionContext context, AbstractEndpoint endpoint) { var executionService = this.executionServices.FirstOrDefault(m => m.Language == endpoint.Language); if (executionService == null) { throw new Exception($"Execution service for {endpoint.Language} not defined."); } return(executionService.ExecuteEndpoint(context, endpoint)); }
private void InitializeEndpoint() { lock (_initializationMonitor) { if (_initialized) { return; } AssertUtils.ArgumentHasText(_inputChannelName, "inputChannelName is required"); AssertUtils.IsTrue(_objectFactory.ContainsObject(_inputChannelName), "no such input channel '" + _inputChannelName + "' for endpoint '" + _objectName + "'"); IMessageChannel channel = (IMessageChannel)_objectFactory.GetObject(_inputChannelName, typeof(IMessageChannel)); if (channel is ISubscribableChannel) { if (_pollerMetadata != null) { throw new ArgumentException("A poller should not be specified for endpoint '" + _objectName + "', since '" + _inputChannelName + "' is a SubscribableChannel (not pollable)."); } _endpoint = new EventDrivenConsumer((ISubscribableChannel)channel, _handler); } else if (channel is IPollableChannel) { PollingConsumer pollingConsumer = new PollingConsumer((IPollableChannel)channel, _handler); if (_pollerMetadata == null) { _pollerMetadata = IntegrationContextUtils.GetDefaultPollerMetadata(_objectFactory); AssertUtils.ArgumentNotNull(_pollerMetadata, "No poller has been defined for endpoint '" + _objectName + "', and no default poller is available within the context."); } pollingConsumer.Trigger = _pollerMetadata.Trigger; pollingConsumer.MaxMessagesPerPoll = _pollerMetadata.MaxMessagesPerPoll; pollingConsumer.ReceiveTimeout = _pollerMetadata.ReceiveTimeout; pollingConsumer.TaskExecutor = _pollerMetadata.TaskExecutor; pollingConsumer.TransactionManager = _pollerMetadata.TransactionManager; pollingConsumer.TransactionDefinition = _pollerMetadata.TransactionDefinition; pollingConsumer.AdviceChain = _pollerMetadata.AdviceChain; _endpoint = pollingConsumer; } else { throw new ArgumentException("unsupported channel type: [" + channel.GetType() + "]"); } _endpoint.AutoStartup = _autoStartup; _endpoint.ObjectName = _objectName; _endpoint.ObjectFactory = _objectFactory; _endpoint.AfterPropertiesSet(); _initialized = true; } }
private async Task <IActionResult> RunScript(AbstractEndpoint endpoint, Dictionary <string, object> parameters = null, bool noSerialization = false) { try { var variables = new Dictionary <string, object> { { "Request", Request }, { "Response", Response }, { "User", HttpContext?.User?.Identity?.Name }, { "MemoryCache", _memoryCache }, { "UDConnectionManager", _connectionManager } }; try { if (HttpContext.Request.Cookies.ContainsKey("location") == true) { var location = HttpContext.Request.Cookies["location"]; if (!string.IsNullOrEmpty(location)) { location = Encoding.UTF8.GetString(Convert.FromBase64String(location)); var locationObject = JsonConvert.DeserializeObject <Location>(location); variables.Add("Location", locationObject); } } } catch (Exception ex) { Log.Error("RunScript() Exception processing geolocation. " + ex.Message); } ExecutionContext executionContext = new ExecutionContext(endpoint, variables, parameters, HttpContext?.User); executionContext.NoSerialization = noSerialization; if (HttpContext.Request.Headers.TryGetValue("UDConnectionId", out StringValues connectionId)) { executionContext.SessionId = _connectionManager.GetSessionId(connectionId); executionContext.ConnectionId = connectionId; } var result = await _executionService.ExecuteEndpointAsync(executionContext, endpoint); var actionResult = ConvertToActionResult(result); return(actionResult); } catch (Exception ex) { Log.Warn("RunScript() " + ex.Message + Environment.NewLine + ex.StackTrace); throw ex; } }
public ExecutionContext(AbstractEndpoint endpoint, Dictionary <string, object> variables, Dictionary <string, object> parameters, ClaimsPrincipal user) { Endpoint = endpoint; Variables = variables; Parameters = parameters; User = user; if (Variables == null) { Variables = new Dictionary <string, object>(); } if (Parameters == null) { Parameters = new Dictionary <string, object>(); } }
public object ExecuteEndpoint(ExecutionContext context, AbstractEndpoint endpoint) { if (endpoint.Language != Common.Models.Language.PowerShell) { throw new Exception($"Invalid language {endpoint.Language}"); } var psEndpoint = endpoint as Endpoint; var scriptBuilder = new StringBuilder(); var scriptBlockAst = psEndpoint.ScriptBlock.Ast as ScriptBlockAst; string header = string.Empty; if (scriptBlockAst.ParamBlock == null && context.Parameters.Any()) { if (Log.IsDebugEnabled) { Log.Debug("Parameters--------------"); foreach (var variable in context.Parameters) { Log.Debug($"{variable.Key} = {variable.Value}"); } } var paramBlockBuilder = new StringBuilder(); if (scriptBlockAst.UsingStatements != null) { foreach (var usingStatement in scriptBlockAst.UsingStatements) { paramBlockBuilder.AppendLine(usingStatement.ToString()); } } paramBlockBuilder.Append("param("); foreach (var parameter in context.Parameters) { paramBlockBuilder.Append($"${parameter.Key},"); } paramBlockBuilder.Remove(paramBlockBuilder.Length - 1, 1); paramBlockBuilder.Append(")"); paramBlockBuilder.AppendLine(); header = paramBlockBuilder.ToString(); } else if (scriptBlockAst.ParamBlock != null) { header = scriptBlockAst.ParamBlock.ToString(); } scriptBuilder.AppendLine(header); if (_dashboardService.Debugger.ShouldBreak(endpoint.Name)) { scriptBuilder.AppendLine("Wait-Debugger"); } foreach (var statement in scriptBlockAst.EndBlock.Statements) { scriptBuilder.AppendLine(statement.ToString()); } Collection <PSObject> output; string json; using (var ps = PowerShell.Create()) { using (var runspaceRef = _runspace.GetRunspace()) { runspaceRef.Runspace.ResetRunspaceState(); Runspace.DefaultRunspace = runspaceRef.Runspace; runspaceRef.Runspace.Name = endpoint.Name; ps.Runspace = runspaceRef.Runspace; var host = (UDHost)_host.GetValue(ps.Runspace); var ui = (UDHostUserInterface)host.UI; if (endpoint.Variables != null) { Log.Debug("Scope variables--------------"); SetVariables(ps.Runspace, endpoint.Variables); } if (context.Variables != null) { Log.Debug("Context variables--------------"); SetVariables(ps.Runspace, context.Variables); } SetVariable(ps, "DashboardHub", _hubContext); SetVariable(ps, "Cache", _memoryCache); SetVariable(ps, "StateRequestService", _stateRequestService); SetVariable(ps, "ConnectionId", context.ConnectionId); SetVariable(ps, Constants.SessionId, context.SessionId); SetVariable(ps, "ArgumentList", context.Endpoint.ArgumentList?.ToList()); SetVariable(ps, Constants.UDPage, context.Endpoint.Page); ui.HubContext = _hubContext; ui.ConnectionId = context.ConnectionId; if (context.User != null) { SetVariable(ps, "ClaimsPrinciple", context.User); SetVariable(ps, "ClaimsPrincipal", context.User); } ps.AddStatement().AddScript(scriptBuilder.ToString()); foreach (var parameter in context.Parameters) { ps.AddParameter(parameter.Key, parameter.Value); } try { output = ps.Invoke(); if (!context.IgnoreNonTerminatingErrors) { if (ps.HadErrors) { if (ps.Streams.Error.Any()) { var error = ps.Streams.Error[0].Exception.Message; foreach (var errorRecord in ps.Streams.Error) { Log.Warn($"Error executing endpoint {endpoint.Name}. {errorRecord} {Environment.NewLine} {errorRecord.ScriptStackTrace}"); } return(new { Error = new Error { Message = error } }); } } } } catch (Exception ex) { Log.Warn(ex, $"Error executing endpoint {endpoint.Name}."); return(new { Error = new Error { Message = ex.Message, Location = ex.StackTrace } }); } } } if (context.NoSerialization) { return(output.Select(m => m.BaseObject).ToArray()); } json = output.FirstOrDefault()?.BaseObject as string; if (json != null) { return(json); } return(output.Where(m => m != null).Select(m => m.BaseObject).ToList()); }
public Logger(AbstractEndpoint endpoint) { this.endpoint = endpoint; this.loggingLevel = LogLevel.INFO; }
private static string CustomBuildNamespaceForComponentCode(abs.IAbstractEndpoint endpoint, IService service) { return endpoint == null ? string.Empty : string.Format(@"{0}.Components.{1}", endpoint.Project.Data.RootNamespace, service.CodeIdentifier); }
public async Task SetEndpointSchedule(AbstractEndpoint endpoint) { var dataMap = new JobDataMap(); IJobDetail job; dataMap.Add(nameof(ScheduledEndpointJob.Endpoint), endpoint); dataMap.Add(nameof(ScheduledEndpointJob.ExecutionService), _executionService); dataMap.Add(nameof(ScheduledEndpointJob.MemoryCache), _memoryCache); if (endpoint.Schedule.Consecutive) { job = JobBuilder.Create <ScheduledEndpointJobConsecutive>() .WithIdentity(endpoint.Name) .UsingJobData(dataMap) .Build(); } else { job = JobBuilder.Create <ScheduledEndpointJob>() .WithIdentity(endpoint.Name) .UsingJobData(dataMap) .Build(); } ITrigger trigger = null; if (endpoint.Schedule.Cron != null) { if (endpoint.Schedule.Consecutive) { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSchedule(CronScheduleBuilder.CronSchedule(endpoint.Schedule.Cron) .WithMisfireHandlingInstructionIgnoreMisfires()) .Build(); } else { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSchedule(CronScheduleBuilder.CronSchedule(endpoint.Schedule.Cron)) .Build(); } } else { if (endpoint.Schedule.Repeat > 0) { if (job.ConcurrentExecutionDisallowed) { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSimpleSchedule(x => x .WithIntervalInSeconds((int)endpoint.Schedule.Every.TotalSeconds) .WithRepeatCount(endpoint.Schedule.Repeat) .WithMisfireHandlingInstructionIgnoreMisfires()) .Build(); } else { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSimpleSchedule(x => x .WithIntervalInSeconds((int)endpoint.Schedule.Every.TotalSeconds) .WithRepeatCount(endpoint.Schedule.Repeat)) .Build(); } } else { if (job.ConcurrentExecutionDisallowed) { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSimpleSchedule(x => x .WithIntervalInSeconds((int)endpoint.Schedule.Every.TotalSeconds) .RepeatForever() .WithMisfireHandlingInstructionIgnoreMisfires()) .Build(); } else { trigger = TriggerBuilder.Create() .WithIdentity(endpoint.Name) .StartNow() .WithSimpleSchedule(x => x .WithIntervalInSeconds((int)endpoint.Schedule.Every.TotalSeconds) .RepeatForever()) .Build(); } } } await _scheduler.ScheduleJob(job, trigger); }