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 frmScriptsLoaded(ScriptHost Host)
{
this.Host = Host;
InitializeComponent();
}
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);
}
