public void ShouldSetScriptEnvironment() { var environment = new ScriptEnvironment(new string[0]); var scriptHost = new ScriptHost(new Mock<IScriptPackManager>().Object, environment); scriptHost.Env.ShouldEqual(environment); }
public DotNetFunctionDescriptorProvider(ScriptHost host, ScriptHostConfiguration config, ICompilationServiceFactory compilationServiceFactory) : base(host, config) { _assemblyLoader = new FunctionAssemblyLoader(config.RootScriptPath); _compilationServiceFactory = compilationServiceFactory; }
internal CSharpFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings, IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader) : base(host, functionMetadata) { _host = host; _functionEntryPointResolver = functionEntryPointResolver; _assemblyLoader = assemblyLoader; _metadataResolver = new FunctionMetadataResolver(functionMetadata, TraceWriter); _inputBindings = inputBindings; _outputBindings = outputBindings; _triggerInputName = GetTriggerInputName(functionMetadata); _metrics = host.ScriptConfig.HostConfig.GetService<IMetricsLogger>(); InitializeFileWatcherIfEnabled(); _resultProcessor = CreateResultProcessor(); _functionValueLoader = FunctionValueLoader.Create(CreateFunctionTarget); _reloadScript = ReloadScript; _reloadScript = _reloadScript.Debounce(); _restorePackages = RestorePackages; _restorePackages = _restorePackages.Debounce(); }
internal DotNetFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings, IFunctionEntryPointResolver functionEntryPointResolver, FunctionAssemblyLoader assemblyLoader, ICompilationServiceFactory compilationServiceFactory, ITraceWriterFactory traceWriterFactory = null) : base(host, functionMetadata, traceWriterFactory) { _metricsLogger = Host.ScriptConfig.HostConfig.GetService<IMetricsLogger>(); _functionEntryPointResolver = functionEntryPointResolver; _assemblyLoader = assemblyLoader; _metadataResolver = new FunctionMetadataResolver(functionMetadata, host.ScriptConfig.BindingProviders, TraceWriter); _compilationService = compilationServiceFactory.CreateService(functionMetadata.ScriptType, _metadataResolver); _inputBindings = inputBindings; _outputBindings = outputBindings; _triggerInputName = functionMetadata.Bindings.FirstOrDefault(b => b.IsTrigger).Name; InitializeFileWatcher(); _resultProcessor = CreateResultProcessor(); _functionLoader = new FunctionLoader<MethodInfo>(CreateFunctionTarget); _reloadScript = ReloadScript; _reloadScript = _reloadScript.Debounce(); _restorePackages = RestorePackages; _restorePackages = _restorePackages.Debounce(); }
public void ShouldSetScriptEnvironment() { var environment = new ScriptEnvironment(new string[0]); var scriptHost = new ScriptHost(null, environment); scriptHost.Env.ShouldEqual(environment); }
internal ScriptFunctionInvoker(string scriptFilePath, ScriptHost host, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings) : base(host, functionMetadata) { _scriptFilePath = scriptFilePath; _inputBindings = inputBindings; _outputBindings = outputBindings; _metrics = host.ScriptConfig.HostConfig.GetService<IMetricsLogger>(); }
internal ScriptFunctionInvoker(string scriptFilePath, ScriptHost host, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings, ITraceWriterFactory traceWriterFactory = null) : base(host, functionMetadata, traceWriterFactory) { _scriptFilePath = scriptFilePath; _host = host; _inputBindings = inputBindings; _outputBindings = outputBindings; }
internal PowerShellFunctionInvoker(ScriptHost host, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings, ITraceWriterFactory traceWriterFactory = null) : base(host, functionMetadata, traceWriterFactory) { _host = host; _scriptFilePath = functionMetadata.ScriptFile; _functionName = functionMetadata.Name; _inputBindings = inputBindings; _outputBindings = outputBindings; }
public FunctionDescriptorProviderTests() { string rootPath = Path.Combine(Environment.CurrentDirectory, @"TestScripts\Node"); ScriptHostConfiguration config = new ScriptHostConfiguration { RootScriptPath = rootPath }; _settingsManager = ScriptSettingsManager.Instance; _host = ScriptHost.Create(_settingsManager, config); _provider = new TestDescriptorProvider(_host, config); }
public Script(TabControl tabControl, ScriptHost host) { _host = host; var tabPage = new TabPage(); tabPage.Text = "New Script"; tabControl.Controls.Add(tabPage); tabControl.SelectedTab = tabPage; var splitContainer = new SplitContainer(); splitContainer.Dock = DockStyle.Fill; splitContainer.Name = "splitContainer1"; splitContainer.Orientation = Orientation.Horizontal; splitContainer.SplitterDistance = 500; splitContainer.TabIndex = 4; tabPage.Controls.Add(splitContainer); tabPage.Location = new System.Drawing.Point(4, 22); tabPage.Name = "tabPage1"; tabPage.Padding = new System.Windows.Forms.Padding(5); tabPage.Size = new System.Drawing.Size(670, 527); tabPage.TabIndex = 0; tabPage.UseVisualStyleBackColor = true; var scriptEditor = new FastColoredTextBox(); scriptEditor.Dock = DockStyle.Fill; scriptEditor.Font = new Font("Courier New", 12.0F, FontStyle.Regular, GraphicsUnit.Point, ((byte)(0))); scriptEditor.Location = new Point(0, 0); scriptEditor.Name = "_scriptEditor"; scriptEditor.Size = new Size(660, 257); scriptEditor.TabIndex = 3; scriptEditor.Text = ""; scriptEditor.KeyPress += new KeyPressEventHandler(this._scriptEditor_KeyPress); scriptEditor.KeyUp += new KeyEventHandler(this._scriptEditor_KeyUp); scriptEditor.TextChanged += new EventHandler<TextChangedEventArgs>(scriptEditor_TextChanged); var output = new RichTextBox(); output.Dock = DockStyle.Fill; output.Name = "_output"; output.ReadOnly = true; output.TabIndex = 0; output.Text = ""; output.Font = new Font("Courier New", 12.0F, FontStyle.Regular, GraphicsUnit.Point, ((byte)(0))); splitContainer.Panel1.Controls.Add(scriptEditor); splitContainer.Panel2.Controls.Add(output); this.TabPage = tabPage; this.TabControl = tabControl; this.ScriptEditor = scriptEditor; this.OutputControl = output; }
internal NodeFunctionInvoker(ScriptHost host, BindingMetadata trigger, FunctionMetadata functionMetadata, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings) : base(host, functionMetadata) { _trigger = trigger; string scriptFilePath = functionMetadata.Source.Replace('\\', '/'); _script = string.Format(CultureInfo.InvariantCulture, _functionTemplate, scriptFilePath); _inputBindings = inputBindings; _outputBindings = outputBindings; _metrics = host.ScriptConfig.HostConfig.GetService<IMetricsLogger>(); InitializeFileWatcherIfEnabled(); }
internal FunctionInvokerBase(ScriptHost host, FunctionMetadata functionMetadata, ITraceWriterFactory traceWriterFactory = null) { Host = host; Metadata = functionMetadata; _metrics = host.ScriptConfig.HostConfig.GetService<IMetricsLogger>(); // Function file logging is only done conditionally traceWriterFactory = traceWriterFactory ?? new FunctionTraceWriterFactory(functionMetadata.Name, Host.ScriptConfig); TraceWriter traceWriter = traceWriterFactory.Create(); FileTraceWriter = traceWriter.Conditional(t => Host.FileLoggingEnabled && (!(t.Properties?.ContainsKey(ScriptConstants.TracePropertyPrimaryHostKey) ?? false) || Host.IsPrimary)); // The global trace writer used by the invoker will write all traces to both // the host trace writer as well as our file trace writer TraceWriter = host.TraceWriter != null ? new CompositeTraceWriter(new TraceWriter[] { FileTraceWriter, host.TraceWriter }) : FileTraceWriter; // Apply the function name as an event property to all traces var functionTraceProperties = new Dictionary<string, object> { { ScriptConstants.TracePropertyFunctionNameKey, Metadata.Name } }; TraceWriter = TraceWriter.Apply(functionTraceProperties); }
internal NodeFunctionInvoker(ScriptHost host, BindingMetadata trigger, FunctionMetadata metadata, bool omitInputParameter, Collection<FunctionBinding> inputBindings, Collection<FunctionBinding> outputBindings) { _host = host; _trigger = trigger; _triggerParameterName = trigger.Name; _omitInputParameter = omitInputParameter; string scriptFilePath = metadata.Source.Replace('\\', '/'); _script = string.Format(FunctionTemplate, scriptFilePath); _inputBindings = inputBindings; _outputBindings = outputBindings; _functionMetadata = metadata; if (host.ScriptConfig.FileWatchingEnabled) { string functionDirectory = Path.GetDirectoryName(scriptFilePath); _fileWatcher = new FileSystemWatcher(functionDirectory, "*.*") { IncludeSubdirectories = true, EnableRaisingEvents = true }; _fileWatcher.Changed += OnScriptFileChanged; _fileWatcher.Created += OnScriptFileChanged; _fileWatcher.Deleted += OnScriptFileChanged; _fileWatcher.Renamed += OnScriptFileChanged; } if (_host.ScriptConfig.FileLoggingEnabled) { string logFilePath = Path.Combine(_host.ScriptConfig.RootLogPath, "Function", _functionMetadata.Name); _fileTraceWriter = new FileTraceWriter(logFilePath, TraceLevel.Verbose); } else { _fileTraceWriter = NullTraceWriter.Instance; } }
public TheGetMethod() { _scriptHost = new ScriptHost(_mockScriptPackManager.Object, new ScriptEnvironment(new string[0])); _mockScriptPackManager.Setup(s => s.Get<IScriptPackContext>()).Returns(_mockContext.Object); }
internal void HostStarted(ScriptHost scriptHost) { if (scriptHost == null || scriptHost.Functions == null) { return; } foreach (var function in scriptHost.Functions) { if (function == null || function.Metadata == null) { continue; } _eventGenerator.LogFunctionDetailsEvent( appName, GetNormalizedString(function.Name), function.Metadata != null ? SerializeBindings(function.Metadata.InputBindings) : GetNormalizedString(null), function.Metadata != null ? SerializeBindings(function.Metadata.OutputBindings) : GetNormalizedString(null), function.Metadata.ScriptType.ToString(), function.Metadata != null ? function.Metadata.IsDisabled : false); } }
public void ShouldSetScriptArgsWhenConstructed() { var scriptArgs = new string[0]; var scriptHost = new ScriptHost(null, scriptArgs); scriptHost.ScriptArgs.ShouldEqual(scriptArgs); }
public override void Init() { var actions = new PluginMethodCollection(); foreach (var action in ScriptExecuted) { actions.RegisterMethod(action.Metadata, action.Value); } scriptHost = new ScriptHost(actions, Logger, RunScript); foreach (var plugin in Context.GetAllPlugins()) { GetScriptEvents(plugin); } }
internal AutoWebProxyState Compile(Uri engineScriptLocation, string scriptBody, byte[] buffer) { if (closed != 0) { throw new ObjectDisposedException(GetType().Name); } if (jscriptObject != null) { jscript.Close(); } scriptText = null; scriptBytes = null; jscriptObject = new JScriptEngine(); jscript = (IActiveScript) jscriptObject; host = new ScriptHost(); GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() Binding to ScriptHost#" + ValidationHelper.HashString(this)); jscriptParser = new ActiveScriptParseWrapper(jscriptObject); jscriptParser.InitNew(); jscript.SetScriptSite(host); jscript.SetScriptState(ScriptState.Initialized); // // Inform the script engine that this host implements the IInternetHostSecurityManager interface, which // is used to prevent the script code from using any ActiveX objects. // IObjectSafety objSafety = jscript as IObjectSafety; if (objSafety != null) { Guid guid = Guid.Empty; GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() Setting up IInternetHostSecurityManager"); objSafety.SetInterfaceSafetyOptions(ref guid, ComConstants.INTERFACE_USES_SECURITY_MANAGER, ComConstants.INTERFACE_USES_SECURITY_MANAGER); objSafety = null; } EXCEPINFO exceptionInfo = new EXCEPINFO(); object result = null; try { jscriptParser.ParseScriptText(scriptBody, null, null, null, IntPtr.Zero, 0, ScriptText.IsPersistent | ScriptText.IsVisible, out result, out exceptionInfo); GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() ParseScriptText() success:" + ValidationHelper.ToString(exceptionInfo.bstrDescription) + " result:" + ValidationHelper.ToString(result)); } catch (Exception exception) { if (NclUtilities.IsFatal(exception)) throw; if (exception is TargetInvocationException) { exception = exception.InnerException; } COMException comException = exception as COMException; if (comException == null || comException.ErrorCode != (int) HRESULT.SCRIPT_E_REPORTED) { throw; } GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() Script load error:[" + host.ExceptionMessage == null ? "" : host.ExceptionMessage + "]"); throw new COMException(SR.GetString(SR.net_jscript_load, host.ExceptionMessage), comException.ErrorCode); } catch { GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() Script load error:[Non-CLS Compliant Exception]"); throw; } jscript.AddNamedItem(c_ScriptHelperName, ScriptItem.GlobalMembers | ScriptItem.IsPersistent | ScriptItem.IsVisible); // This part can run global code - time it out if necessary. jscript.GetCurrentScriptThreadID(out interruptThreadId); TimerThread.Timer timer = s_TimerQueue.CreateTimer(s_InterruptCallback, this); activeTimer = timer; try { jscript.SetScriptState(ScriptState.Started); jscript.SetScriptState(ScriptState.Connected); } finally { activeTimer = null; timer.Cancel(); } jscript.GetScriptDispatch(null, out script); GlobalLog.Print("AutoWebProxyScriptWrapper#" + ValidationHelper.HashString(this) + "::Compile() Got IDispatch:" + ValidationHelper.ToString(dispatch)); scriptText = scriptBody; scriptBytes = buffer; return AutoWebProxyState.CompilationSuccess; }
private void InitializeScriptObjects() { AffeCompiler compiler = new AffeCompiler(typeof(ScriptHost)); ScriptingEnvironment.InstallBase(compiler); ScriptingEnvironment.InstallMath(compiler); this.mScriptHost = new ScriptHost(); this.mInitScript.Compiler = compiler; this.mInitScript.TargetObject = this.mScriptHost; this.mFrameScript.Compiler = compiler; this.mFrameScript.TargetObject = this.mScriptHost; this.mBeatScript.Compiler = compiler; this.mBeatScript.TargetObject = this.mScriptHost; this.mVertexScript.Compiler = compiler; this.mVertexScript.TargetObject = this.mScriptHost; this.mNeedInit = true; this.MakeStaticDirty(); this.mInitScript.MadeDirty += this.OnInitMadeDirty; this.mFrameScript.MadeDirty += this.OnOtherMadeDirty; this.mVertexScript.MadeDirty += this.OnOtherMadeDirty; }
protected FunctionDescriptorProvider(ScriptHost host, ScriptHostConfiguration config) { Host = host; Config = config; }
private static IFunctionMetadataResolver CreateMetadataResolver(ScriptHost host, ICollection <IScriptBindingProvider> bindingProviders, FunctionMetadata functionMetadata, ILogger logger) { return(new ScriptFunctionMetadataResolver(functionMetadata.ScriptFile, bindingProviders, logger)); }
internal FunctionInvokerBase(ScriptHost host, FunctionMetadata functionMetadata) { Host = host; Metadata = functionMetadata; TraceWriter = CreateTraceWriter(host.ScriptConfig, functionMetadata.Name); }
public frmScriptsLoaded(ScriptHost Host) { this.Host = Host; InitializeComponent(); }
public DotNetFunctionDescriptorProvider(ScriptHost host, ScriptJobHostOptions config, ICollection <IScriptBindingProvider> bindingProviders, IMetricsLogger metricsLogger, ILoggerFactory loggerFactory) : this(host, config, bindingProviders, new DotNetCompilationServiceFactory(loggerFactory), metricsLogger, loggerFactory) { }
public static void AssertEvaluation(string code, object value, ScriptHost host) { var result = Execute(code, host); Assert.Equal(value, result.Value); }
internal FunctionInvokerBase(ScriptHost host, FunctionMetadata functionMetadata, string logDirName = null) { Host = host; Metadata = functionMetadata; FunctionLogger = new FunctionLogger(host, logDirName ?? functionMetadata.Name); }
public DotNetFunctionDescriptorProvider(ScriptHost host, ScriptHostConfiguration config) : this(host, config, new DotNetCompilationServiceFactory(host.TraceWriter)) { }
internal FunctionInvokerBase(ScriptHost host, FunctionMetadata functionMetadata, ILoggerFactory loggerFactory, string logDirName = null) { Host = host; Metadata = functionMetadata; FunctionLogger = loggerFactory.CreateLogger(LogCategories.CreateFunctionCategory(functionMetadata.Name)); }
public HttpFunctionDescriptorProvider(ScriptHost host, ScriptJobHostOptions config, ICollection <IScriptBindingProvider> bindingProviders, IFunctionInvocationDispatcher dispatcher, ILoggerFactory loggerFactory, IApplicationLifetime applicationLifetime, TimeSpan workerInitializationTimeout) : base(host, config, bindingProviders, dispatcher, loggerFactory, applicationLifetime, workerInitializationTimeout) { }
public TestDescriptorProvider(ScriptHost host, ScriptHostConfiguration config) : base(host, config) { }
public MockInvoker(ScriptHost host, FunctionMetadata metadata, ITraceWriterFactory traceWriterFactory = null) : base(host, metadata, traceWriterFactory) { }
public ScriptFunctionInvokerBase(ScriptHost host, FunctionMetadata functionMetadata, ITraceWriterFactory traceWriterFactory) : base(host, functionMetadata, traceWriterFactory) { }
public MockInvoker(ScriptHost host, FunctionMetadata metadata) : base(host, metadata) { }
public TheGetMethod() { _scriptHost = new ScriptHost(_mockScriptPackManager.Object); _mockScriptPackManager.Setup(s => s.Get<IScriptPackContext>()).Returns(_mockContext.Object); }
private static void ExecuteScript(UserScript script, ScriptHost scriptHost, Logger logger, object[] args) { try { //var engine = new JScriptEngine(WindowsScriptEngineFlags.EnableDebugging); var engine = new JScriptEngine(); engine.AddHostObject("host", scriptHost); string initArgsScript = string.Format("var arguments = {0};", args.ToJson()); engine.Execute(initArgsScript); engine.Execute(script.Body); } catch (Exception ex) { var messge = string.Format("Error in user script {0}", script.Name); logger.ErrorException(messge, ex); } }
public static void WarmUp(WebHostSettings settings) { var traceWriter = new FileTraceWriter(Path.Combine(settings.LogPath, "Host"), TraceLevel.Info); ScriptHost host = null; try { traceWriter.Info("Warm up started"); string rootPath = settings.ScriptPath; if (Directory.Exists(rootPath)) { Directory.Delete(rootPath, true); } Directory.CreateDirectory(rootPath); string content = ReadResourceString("Functions.host.json"); File.WriteAllText(Path.Combine(rootPath, "host.json"), content); // read in the C# function string functionPath = Path.Combine(rootPath, "Test-CSharp"); Directory.CreateDirectory(functionPath); content = ReadResourceString("Functions.Test_CSharp.function.json"); File.WriteAllText(Path.Combine(functionPath, "function.json"), content); content = ReadResourceString("Functions.Test_CSharp.run.csx"); File.WriteAllText(Path.Combine(functionPath, "run.csx"), content); // read in the F# function functionPath = Path.Combine(rootPath, "Test-FSharp"); Directory.CreateDirectory(functionPath); content = ReadResourceString("Functions.Test_FSharp.function.json"); File.WriteAllText(Path.Combine(functionPath, "function.json"), content); content = ReadResourceString("Functions.Test_FSharp.run.fsx"); File.WriteAllText(Path.Combine(functionPath, "run.fsx"), content); traceWriter.Info("Warm up functions deployed"); ScriptHostConfiguration config = new ScriptHostConfiguration { RootScriptPath = rootPath, FileLoggingMode = FileLoggingMode.Never, RootLogPath = settings.LogPath, TraceWriter = traceWriter, FileWatchingEnabled = false }; config.HostConfig.StorageConnectionString = null; config.HostConfig.DashboardConnectionString = null; host = ScriptHost.Create(config); traceWriter.Info(string.Format("Starting Host (Id={0})", host.ScriptConfig.HostConfig.HostId)); host.Start(); var arguments = new Dictionary <string, object> { { "input", "{}" } }; host.CallAsync("Test-CSharp", arguments).Wait(); host.CallAsync("Test-FSharp", arguments).Wait(); host.Stop(); traceWriter.Info("Warm up succeeded"); } catch (Exception ex) { traceWriter.Error(string.Format("Warm up failed: {0}", ex)); } finally { host?.Dispose(); traceWriter.Dispose(); } }
public CSharpFunctionDescriptionProvider(ScriptHost host, ScriptHostConfiguration config) : base(host, config) { _assemblyLoader = new FunctionAssemblyLoader(config.RootScriptPath); }
public TabbedScriptEditor(ScriptHost host) { _host = host; InitializeComponent(); }
public TheGetMethod() { _scriptHost = new ScriptHost(_mockScriptPackManager.Object, new ScriptEnvironment(new string[0], _mockConsole.Object, new Printers(_mockSerializer.Object))); _mockScriptPackManager.Setup(s => s.Get <IScriptPackContext>()).Returns(_mockContext.Object); }
public HostStarted(ScriptHost host) { Host = host; }
public ScriptFunctionDescriptorProvider(ScriptHost host, ScriptHostConfiguration config) : base(host, config) { }
private void SetControlMode(ControlMode controlMode) { m_ControlMode = controlMode; if (m_ControlMode == ControlMode.Macro) { // Stop script and remove if (m_ScriptHost != null && m_ScriptHost.IsRunning) { m_ScriptHost.Stop(); m_ScriptHost = null; } // Setup callback to interceptor Interceptor.Callback = new InterceptionDelegate(m_MacroPlayer.OnReceiveData); recordButton.Enabled = true; recordToolStripMenuItem.Enabled = true; loopCheckBox.Enabled = true; loopCheckBox.Checked = m_MacroPlayer.Loop; loopToolStripMenuItem.Enabled = true; recordOnTouchToolStripMenuItem.Enabled = true; scriptButton.Enabled = false; saveToolStripMenuItem.Enabled = true; saveAsToolStripMenuItem.Enabled = true; clearMacroToolStripMenuItem.Enabled = true; trimMacroToolStripMenuItem.Enabled = true; } else if (m_ControlMode == ControlMode.Script) { // Stop macro player if (m_MacroPlayer.IsRecording) { m_MacroPlayer.Record(); } m_MacroPlayer.Stop(); // Setup callback to interceptor Interceptor.Callback = new InterceptionDelegate(m_ScriptHost.OnReceiveData); recordButton.Enabled = false; recordToolStripMenuItem.Enabled = false; loopCheckBox.Enabled = false; loopCheckBox.Checked = false; loopToolStripMenuItem.Enabled = false; recordOnTouchToolStripMenuItem.Enabled = false; scriptButton.Enabled = true; saveToolStripMenuItem.Enabled = false; saveAsToolStripMenuItem.Enabled = false; clearMacroToolStripMenuItem.Enabled = false; trimMacroToolStripMenuItem.Enabled = false; currentTickToolStripStatusLabel.Text = CURRENT_TICK_DEFAULT_TEXT; } else if (m_ControlMode == ControlMode.Remapper) { // Stop macro player if (m_MacroPlayer.IsRecording) { m_MacroPlayer.Record(); } m_MacroPlayer.Stop(); // Stop script if (m_ScriptHost != null && m_ScriptHost.IsRunning) { m_ScriptHost.Stop(); } // Setup callback to interceptor Interceptor.Callback = new InterceptionDelegate(m_Remapper.OnReceiveData); } else if (m_ControlMode == ControlMode.StatusChecker) { // Stop macro player if (m_MacroPlayer.IsRecording) { m_MacroPlayer.Record(); } m_MacroPlayer.Stop(); // Stop script if (m_ScriptHost != null && m_ScriptHost.IsRunning) { m_ScriptHost.Stop(); } // Setup callback to interceptor Interceptor.Callback = new InterceptionDelegate(m_StatusChecker.OnReceiveData); } }
public MockInvoker(ScriptHost host, IMetricsLogger metrics, IFunctionMetadataManager functionMetadataManager, FunctionMetadata metadata, ILoggerFactory loggerFactory) : base(host, metadata, loggerFactory) { _instanceLogger = new FunctionInstanceLogger(functionMetadataManager, metrics); }
public async Task Generate_EndToEnd() { // construct our TimerTrigger attribute ([TimerTrigger("00:00:02", RunOnStartup = true)]) Collection <ParameterDescriptor> parameters = new Collection <ParameterDescriptor>(); ParameterDescriptor parameter = new ParameterDescriptor("timerInfo", typeof(TimerInfo)); ConstructorInfo ctorInfo = typeof(TimerTriggerAttribute).GetConstructor(new Type[] { typeof(string) }); PropertyInfo runOnStartupProperty = typeof(TimerTriggerAttribute).GetProperty("RunOnStartup"); CustomAttributeBuilder attributeBuilder = new CustomAttributeBuilder( ctorInfo, new object[] { "00:00:02" }, new PropertyInfo[] { runOnStartupProperty }, new object[] { true }); parameter.CustomAttributes.Add(attributeBuilder); parameters.Add(parameter); // create the FunctionDefinition FunctionMetadata metadata = new FunctionMetadata(); TestInvoker invoker = new TestInvoker(); FunctionDescriptor function = new FunctionDescriptor("TimerFunction", invoker, metadata, parameters, null, null, null); Collection <FunctionDescriptor> functions = new Collection <FunctionDescriptor>(); functions.Add(function); // Get the Type Attributes (in this case, a TimeoutAttribute) ScriptHostConfiguration scriptConfig = new ScriptHostConfiguration(); scriptConfig.FunctionTimeout = TimeSpan.FromMinutes(5); Collection <CustomAttributeBuilder> typeAttributes = ScriptHost.CreateTypeAttributes(scriptConfig); // generate the Type Type functionType = FunctionGenerator.Generate("TestScriptHost", "TestFunctions", typeAttributes, functions); // verify the generated function MethodInfo method = functionType.GetMethod("TimerFunction"); TimeoutAttribute timeoutAttribute = (TimeoutAttribute)functionType.GetCustomAttributes().Single(); Assert.Equal(TimeSpan.FromMinutes(5), timeoutAttribute.Timeout); Assert.True(timeoutAttribute.ThrowOnTimeout); Assert.True(timeoutAttribute.TimeoutWhileDebugging); ParameterInfo triggerParameter = method.GetParameters()[0]; TimerTriggerAttribute triggerAttribute = triggerParameter.GetCustomAttribute <TimerTriggerAttribute>(); Assert.NotNull(triggerAttribute); // start the JobHost which will start running the timer function JobHostConfiguration config = new JobHostConfiguration() { TypeLocator = new TypeLocator(functionType) }; config.UseTimers(); JobHost host = new JobHost(config); await host.StartAsync(); await Task.Delay(3000); await host.StopAsync(); // verify our custom invoker was called Assert.True(invoker.InvokeCount >= 2); }