private async Task <ExecutionResponse> ExecuteFunctionAsync(string handler, string payload)
{
var buildPath = TestUtils.GetLambdaFunctionBuildPath("FunctionSignatureExamples");
var runtime = LocalLambdaRuntime.Initialize(buildPath);
var configInfo = new LambdaFunctionInfo
{
Name = "TestMethod",
Handler = handler
};
var function = runtime.LoadLambdaFunction(configInfo);
Assert.True(function.IsSuccess);
var request = new ExecutionRequest()
{
Function = function,
AWSRegion = "us-west-2",
Payload = payload
};
var response = await runtime.ExecuteLambdaFunctionAsync(request);
return(response);
}
public HtmlRenderer(ExecutionRequest request, ContentResponder contentResponder)
: base(request, contentResponder, "text/html", ".htm", ".html")
{
this.AppName = UriApplicationNameResolver.ResolveApplicationName(request.Request.Url);
this.ContentResponder = contentResponder;
this.ExecutionRequest = request;
}
public async Task RouteRequestAsync_ServiceWithGivenExecutionModelName_ShouldRouteSuccessfully()
{
const string modelName = "expected-model/v1";
var mockProcessor = new Mock<IExecutionProcessor>();
var mockServiceProvider = new Mock<IServiceProvider>();
var processorFactory = new NamedServiceFactory<IExecutionProcessor>(
new Dictionary<string, Func<IServiceProvider, IExecutionProcessor>>
{
[modelName] = sp => mockProcessor.Object
});
var execRequest = new ExecutionRequest
{
ExecutionId = Guid.NewGuid().ToString(),
ExecutionModelName = modelName
};
var execContext = new Core.Models.ExecutionContext
{
ExecutionId = execRequest.ExecutionId,
Status = ExecutionStatus.Succeeded
};
mockProcessor.Setup(ep => ep.ProcessRequestAsync(execRequest, CancellationToken.None))
.Returns(Task.FromResult(execContext));
var execRequestRouter = new ExecutionRequestRouter(processorFactory, mockServiceProvider.Object);
var actualExecContext = await execRequestRouter.RouteRequestAsync(execRequest, CancellationToken.None);
actualExecContext.Should().NotBeNull();
actualExecContext.Should().Be(execContext);
}
public void RouteRequestAsync_NoServiceWithGivenExecutionModelName_ShouldThrowException()
{
const string actualModelName = "actual-model/v1";
const string expectedModelName = "expected-model/v1";
var mockProcessor = new Mock<IExecutionProcessor>();
var mockServiceProvider = new Mock<IServiceProvider>();
var processorFactory = new NamedServiceFactory<IExecutionProcessor>(
new Dictionary<string, Func<IServiceProvider, IExecutionProcessor>>
{
[expectedModelName] = sp => mockProcessor.Object
});
var execRequest = new ExecutionRequest
{
ExecutionId = Guid.NewGuid().ToString(),
ExecutionModelName = actualModelName
};
var execRequestRouter = new ExecutionRequestRouter(processorFactory, mockServiceProvider.Object);
Func<Task> act = async () => await execRequestRouter.RouteRequestAsync(execRequest, CancellationToken.None);
act.Should().Throw<NotSupportedException>();
}
public async Task <Core.Models.ExecutionContext> ProcessRequestAsync(ExecutionRequest execRequest, CancellationToken cancelToken)
{
if (execRequest == null)
{
throw new ArgumentNullException(nameof(execRequest));
}
// We're about to execute the extension. Update the execution status to [Processing].
var execContext = execRequest.ToExecutionContext().UpdateStatus(ExecutionStatus.Processing);
logger.LogInformation($"Updating execution [{execRequest.ExecutionId}] status: [{execContext.Status}]...");
await UpdateExecutionStatusAsync(execRequest.UpdateExecutionStatusUrl, execContext.ToExecutionUpdate());
logger.LogInformation($"Processing execution request [{execRequest.ExecutionId}]...");
// Invoke the execution adapter and execute the extension.
execContext = await this.execAdapter.ExecuteAsync(execRequest, cancelToken);
logger.LogInformation($"Updating execution [{execRequest.ExecutionId}] status: [{execContext.Status}]...");
// All done! Update the execution status based on the response from the execution adapter.
await UpdateExecutionStatusAsync(execRequest.UpdateExecutionStatusUrl, execContext.ToExecutionUpdate());
return(execContext);
}
private ExecutionResponse ExecuteFunction(string handler, string payload)
{
var buildPath = Path.GetFullPath(@"../../../../LambdaFunctions/FunctionSignatureExamples/bin/debug/netcoreapp2.1");
var runtime = LocalLambdaRuntime.Initialize(buildPath);
var configInfo = new LambdaFunctionInfo
{
Name = "TestMethod",
Handler = handler
};
var function = runtime.LoadLambdaFunction(configInfo);
Assert.True(function.IsSuccess);
var request = new ExecutionRequest()
{
Function = function,
AWSRegion = "us-west-2",
Payload = payload
};
var response = runtime.ExecuteLambdaFunction(request);
return(response);
}
/// <summary>
/// The method executed server side
/// </summary>
/// <param name="request"></param>
public virtual void ExecuteRemoteAsync(AsyncExecutionRequest request) // this should be executing server side after encryption has been handled
{
Task.Run(() =>
{
AsyncCallbackService asyncCallback = _proxyFactory.GetProxy <AsyncCallbackService>(request.RespondToHostName, request.RespondToPort, Logger);
// This executes server side after the SecureChannel has decrypted and validated, need to set IsInitialized to true to
// ensure the request doesn't reinitialize to a state where it believes it is an execution request
// targeting SecureChannel since that is what is in the HttpContext.Request.Url
ExecutionRequest execRequest = new ExecutionRequest
{
ClassName = request.ClassName,
MethodName = request.MethodName,
Ext = "json",
ServiceProvider = ServiceProvider,
JsonParams = request.JsonParams,
IsInitialized = true,
Context = HttpContext
};
bool success = execRequest.Execute();
AsyncExecutionResponse response = new AsyncExecutionResponse
{
Success = success,
Request = request,
Result = execRequest.Result
};
asyncCallback.RecieveAsyncExecutionResponse(response);
});
}
/// <summary>
/// Runs a function in an Apps Script project. The project must be deployedfor use with the Apps Script Execution API.This method requires authorization with an OAuth 2.0 token that includes atleast one of the scopes listed in the [Authorization](#authorization)section; script projects that do not require authorization cannot beexecuted through this API. To find the correct scopes to include in theauthentication token, open the project in the script editor, then select**File > Project properties** and click the **Scopes** tab.
/// Documentation https://developers.google.com/script/v1/reference/scripts/run
/// Generation Note: This does not always build corectly. Google needs to standardise things I need to figuer out which ones are wrong.
/// </summary>
/// <param name="service">Authenticated Script service.</param>
/// <param name="scriptId">The script ID of the script to be executed. To find the script ID, openthe project in the script editor and select **File > Project properties**.</param>
/// <param name="body">A valid Script v1 body.</param>
/// <returns>OperationResponse</returns>
public static Operation Run(ScriptService service, string scriptId, ExecutionRequest body)
{
try
{
// Initial validation.
if (service == null)
{
throw new ArgumentNullException("service");
}
if (body == null)
{
throw new ArgumentNullException("body");
}
if (scriptId == null)
{
throw new ArgumentNullException(scriptId);
}
// Make the request.
return(service.Scripts.Run(body, scriptId).Execute());
}
catch (Exception ex)
{
throw new Exception("Request Scripts.Run failed.", ex);
}
}
private static void ExecuteRequest(ExecutionRequest request, LocalLambdaOptions localLambdaOptions, RunConfiguration runConfiguration)
{
try
{
var response = localLambdaOptions.LambdaRuntime.ExecuteLambdaFunctionAsync(request).GetAwaiter().GetResult();
runConfiguration.OutputWriter.WriteLine("Captured Log information:");
runConfiguration.OutputWriter.WriteLine(response.Logs);
if (response.IsSuccess)
{
runConfiguration.OutputWriter.WriteLine("Request executed successfully");
runConfiguration.OutputWriter.WriteLine("Response:");
runConfiguration.OutputWriter.WriteLine(response.Response);
}
else
{
runConfiguration.OutputWriter.WriteLine("Request failed to execute");
runConfiguration.OutputWriter.WriteLine($"Error:");
runConfiguration.OutputWriter.WriteLine(response.Error);
}
}
catch (Exception e)
{
runConfiguration.OutputWriter.WriteLine("Unknown error occurred in the Lambda test tool while executing request.");
runConfiguration.OutputWriter.WriteLine($"Error Message: {e.Message}");
runConfiguration.OutputWriter.WriteLine(e.StackTrace);
}
}
public HtmlRenderer(ExecutionRequest request, ContentResponder contentResponder)
: base(request, contentResponder, "text/html", ".htm", ".html")
{
this.AppName = AppConf.AppNameFromUri(request.Request.Url);
this.ContentResponder = contentResponder;
this.ExecutionRequest = request;
}
public virtual JsonRpcResponse Execute()
{
JsonRpcResponse response = new JsonRpcResponse();
// get the method from RpcMethods
MethodInfo mi = RpcMethods.FirstOrDefault(m => m.Name.Equals(Method, StringComparison.InvariantCultureIgnoreCase));
// if its not there get it from all methods
if (mi == null)
{
mi = AllMethods.FirstOrDefault(m => m.Name.Equals(Method, StringComparison.InvariantCultureIgnoreCase));
}
// if its not there set error in the response
if (mi == null)
{
response = GetErrorResponse(JsonRpcFaultCodes.MethodNotFound);
}
else
{
ExecutionRequest execRequest = ExecutionRequest.Create(Incubator, mi, GetInputParameters(mi));
if (execRequest.Execute())
{
response.Result = execRequest.Result;
}
else
{
response = GetErrorResponse(JsonRpcFaultCodes.InternalError);
}
}
return(response);
}
public void ApiKey_ExecutionRequestShouldValidateApiKey()
{
RegisterDb();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
string testName = MethodBase.GetCurrentMethod().Name;
IUserResolver mockUserResolver = Substitute.For <IUserResolver>();
mockUserResolver.GetUser(Arg.Any <IHttpContext>()).Returns("testUser");
LocalApiKeyManager.Default.UserResolver = mockUserResolver;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(testName.RandomLetters(6));
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
ExecutionRequest er = new ExecutionRequest("ApiKeyRequiredEcho", "Send", "json")
{
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.JsonTestRequest()
};
string data = ApiParameters.ParametersToJsonParamsObjectString("some random data");
er.InputString = data;
ValidationResult result = er.Validate();
result.Success.IsFalse();
List <ValidationFailures> failures = new List <ValidationFailures>(result.ValidationFailures);
failures.Contains(ValidationFailures.InvalidApiKeyToken).IsTrue();
}
/// <summary>
/// Converts an execution request core model to an API model
/// </summary>
/// <param name="coreModel"></param>
/// <returns></returns>
public static ExecutionRequestApiModel ToApiModel(this ExecutionRequest coreModel)
{
var apiModel = new ExecutionRequestApiModel
{
CreatedDateTimeUtc = coreModel.CreatedDateTimeUtc,
ExecutionId = coreModel.ExecutionId,
ExecutionModelName = coreModel.ExecutionModelName,
ExecutionParameters = coreModel.ExecutionParameters,
ExecutionProfileName = coreModel.ExecutionProfileName,
ExecutionTimeoutDateTimeUtc = coreModel.ExecutionTimeoutDateTimeUtc,
ExecutionTimeoutDuration = coreModel.ExecutionTimeoutDuration,
Executor = coreModel.Executor.ToApiModel(),
ExecutorProperties = coreModel.ExecutorProperties,
ExtensionId = coreModel.ExtensionId,
ExtensionSettings = coreModel.ExtensionSettings,
ExtensionVersionId = coreModel.ExtensionVersionId,
GetExecutionStatusUrl = coreModel.GetExecutionStatusUrl,
IsValidationSupported = coreModel.IsValidationSupported,
LastUpdatedDateTimeUtc = coreModel.LastUpdatedDateTimeUtc,
ObjectProviderName = coreModel.ObjectProviderName,
Priority = coreModel.Priority,
PutExecutionStatusUrl = coreModel.UpdateExecutionStatusUrl,
SignatureRsaKeyXml = coreModel.SignatureRsaKeyXml,
StatusUpdateKey = coreModel.StatusUpdateKey,
SupportedServices = coreModel.SupportedServices,
ValidateOnly = coreModel.ValidateOnly
};
ApplyInputObjectsToApiModel(coreModel, apiModel);
ApplyOutputObjectsToApiModel(coreModel, apiModel);
return(apiModel);
}
public void ApiKey_ExecutionRequestValidationShouldSucceedIfGoodToken()
{
Prepare();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
string methodName = MethodBase.GetCurrentMethod().Name;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(methodName);
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
string className = "ApiKeyRequiredEcho";
string method = "Send";
string data = ApiParameters.ParametersToJsonParamsArray("some random data").ToJson();
ExecutionRequest er = new ExecutionRequest(className, method, "json")
{
JsonParams = data,
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.FormUrlEncodedTestRequest()
};
er.ApiKeyResolver.SetKeyToken(er.Request.Headers, ApiParameters.GetStringToHash(className, method, data));
ValidationResult result = er.Validate();
Expect.IsTrue(result.Success);
}
public RemoteExecutionCompletedEventArgs(ExecutionRequest remotingRequest, ExecutionResponse response, ExecutionOptions options, float elapsedMilliseconds)
{
this.Request = remotingRequest;
this.Response = response;
this.Options = options;
this.ElapsedMilliseconds = elapsedMilliseconds;
}
public void ApiKey_ExecutionRequestValidationShouldFailIfBadToken()
{
RegisterDb();
ServiceProxySystem.Register <ApiKeyRequiredEcho>();
IUserResolver mockUserResolver = Substitute.For <IUserResolver>();
mockUserResolver.GetUser(Arg.Any <IHttpContext>()).Returns("testUser");
LocalApiKeyManager.Default.UserResolver = mockUserResolver;
string methodName = MethodBase.GetCurrentMethod().Name;
IApplicationNameProvider nameProvider = new TestApplicationNameProvider(methodName.RandomLetters(4));
IApiKeyProvider keyProvider = new LocalApiKeyProvider();
ExecutionRequest er = new ExecutionRequest("ApiKeyRequiredEcho", "Send", "json")
{
ApiKeyResolver = new ApiKeyResolver(keyProvider, nameProvider),
Request = new ServiceProxyTestHelpers.JsonTestRequest()
};
string data = ApiParameters.ParametersToJsonParamsObjectString("some random data");
er.InputString = data;
ApiKeyResolver resolver = new ApiKeyResolver(keyProvider, nameProvider);
resolver.SetKeyToken(er.Request.Headers, data);
er.Request.Headers[Headers.KeyToken] = "bad token value";
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success, "Validation should have failed");
List <ValidationFailures> failures = new List <ValidationFailures>(result.ValidationFailures);
Expect.IsTrue(failures.Contains(ValidationFailures.InvalidApiKeyToken), "ValidationFailure should have been InvalidApiKeyToken");
}
/// <summary>
/// The method executed server side
/// </summary>
/// <param name="request"></param>
public virtual void ExecuteRemoteAsync(AsyncExecutionRequest request) // this should be executing server side after encryption has been handled
{
Task.Run(() =>
{
AsyncCallbackService asyncCallback = _proxyFactory.GetProxy <AsyncCallbackService>(request.RespondToHostName, request.RespondToPort);
ExecutionRequest execRequest = new ExecutionRequest(request.ClassName, request.MethodName, "json")
{
ServiceProvider = ServiceProvider,
Context = HttpContext,
JsonParams = request.JsonParams
};
bool success = execRequest.Execute();
AsyncExecutionResponse response = new AsyncExecutionResponse
{
Success = success,
Request = request,
Result = execRequest.Result
};
if (!success)
{
if (execRequest?.Result is ValidationResult validation && validation.Success == false)
{
response.ValidationFailure = new ValidationFailure {
Message = validation.Message, Failures = validation.ValidationFailures
};
response.Result = null;
}
}
asyncCallback.RecieveAsyncExecutionResponse(response);
});
}
public async Task <Core.Models.ExecutionContext> ExecuteAsync(ExecutionRequest request, CancellationToken cancelToken)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (cancelToken == null)
{
throw new ArgumentNullException(nameof(cancelToken));
}
var apiModel = request.ToApiModel();
var apiUrl = $"{proxyConfig.BaseUrl.TrimEnd('/')}/";
var apiResponse = await jsonHttpClient.PostAsync <ExecutionContextApiModel>(apiUrl, apiModel);
switch (apiResponse.StatusCode)
{
case HttpStatusCode.OK:
return(apiResponse.Content.ToCoreModel());
default:
throw new HttpRequestException($"[Request {request.ExecutionId}]: " +
$"Execution adapter API [{apiUrl}] responded with an unexpected status code: [{apiResponse.StatusCode}].");
}
}
public static void ExecuteWithNoUi(LocalLambdaOptions localLambdaOptions, CommandLineOptions commandOptions, string lambdaAssemblyDirectory, RunConfiguration runConfiguration)
{
runConfiguration.OutputWriter.WriteLine("Executing Lambda function without web interface");
var lambdaProjectDirectory = Utils.FindLambdaProjectDirectory(lambdaAssemblyDirectory);
string configFile = DetermineConfigFile(commandOptions, lambdaAssemblyDirectory: lambdaAssemblyDirectory, lambdaProjectDirectory: lambdaProjectDirectory);
LambdaConfigInfo configInfo = LoadLambdaConfigInfo(configFile, commandOptions, lambdaAssemblyDirectory: lambdaAssemblyDirectory, lambdaProjectDirectory: lambdaProjectDirectory, runConfiguration);
LambdaFunction lambdaFunction = LoadLambdaFunction(configInfo, localLambdaOptions, commandOptions, lambdaAssemblyDirectory: lambdaAssemblyDirectory, lambdaProjectDirectory: lambdaProjectDirectory, runConfiguration);
string payload = DeterminePayload(localLambdaOptions, commandOptions, lambdaAssemblyDirectory: lambdaAssemblyDirectory, lambdaProjectDirectory: lambdaProjectDirectory, runConfiguration);
var awsProfile = commandOptions.AWSProfile ?? configInfo.AWSProfile;
if (!string.IsNullOrEmpty(awsProfile))
{
if (new Amazon.Runtime.CredentialManagement.CredentialProfileStoreChain().TryGetProfile(awsProfile, out _))
{
runConfiguration.OutputWriter.WriteLine($"... Setting AWS_PROFILE environment variable to {awsProfile}.");
}
else
{
runConfiguration.OutputWriter.WriteLine($"... Warning: Profile {awsProfile} not found in the aws credential store.");
awsProfile = null;
}
}
else
{
runConfiguration.OutputWriter.WriteLine("... No profile choosen for AWS credentials. The --profile switch can be used to configure an AWS profile.");
}
var awsRegion = commandOptions.AWSRegion ?? configInfo.AWSRegion;
if (!string.IsNullOrEmpty(awsRegion))
{
runConfiguration.OutputWriter.WriteLine($"... Setting AWS_REGION environment variable to {awsRegion}.");
}
else
{
runConfiguration.OutputWriter.WriteLine("... No default AWS region configured. The --region switch can be used to configure an AWS Region.");
}
// Create the execution request that will be sent into the LocalLambdaRuntime.
var request = new ExecutionRequest()
{
AWSProfile = awsProfile,
AWSRegion = awsRegion,
Payload = payload,
Function = lambdaFunction
};
ExecuteRequest(request, localLambdaOptions, runConfiguration);
if (runConfiguration.Mode == RunConfiguration.RunMode.Normal && commandOptions.PauseExit)
{
Console.WriteLine("Press any key to exist");
Console.ReadKey();
}
}
/// <summary>
/// Sets the content type then calls Render(request.Result, request.Response.OutputStream);
/// </summary>
/// <param name="request"></param>
public virtual void Respond(ExecutionRequest request)
{
IResponse response = request.Response;
object toRender = request.Result;
SetContentType(response);
Render(toRender, response.OutputStream);
}
public override bool TryRespond(IHttpContext context)
{
try
{
RequestWrapper request = context.Request as RequestWrapper;
ResponseWrapper response = context.Response as ResponseWrapper;
string appName = ApplicationNameResolver.ResolveApplicationName(context);
bool responded = false;
if (request != null && response != null)
{
string path = request.Url.AbsolutePath.ToLowerInvariant();
if (path.StartsWith("/{0}"._Format(ResponderSignificantName.ToLowerInvariant())))
{
if (path.StartsWith(MethodFormPrefixFormat._Format(ResponderSignificantName).ToLowerInvariant()))
{
responded = SendMethodForm(context);
}
else
{
responded = SendProxyCode(context);
}
}
else
{
ExecutionRequest execRequest = ResolveExecutionRequest(context, appName);
responded = execRequest.Execute();
if (responded)
{
// TODO: make this configurable
response.AddHeader("Access-Control-Allow-Origin", "*");
response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Access-Control-Allow-Headers, Authorization, X-Requested-With");
response.AddHeader("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
// ---
RenderResult(appName, path, execRequest);
}
}
}
if (responded)
{
OnResponded(context);
}
else
{
OnNotResponded(context);
}
return(responded);
}
catch (Exception ex)
{
Logger.AddEntry("An error occurred in {0}.{1}: {2}", ex, this.GetType().Name, MethodBase.GetCurrentMethod().Name, ex.Message);
OnNotResponded(context);
return(false);
}
}
public override Task <JObject> GetServiceConfigurationAsync(ExecutionRequest execRequest)
{
if (execRequest == null)
{
throw new ArgumentNullException(nameof(execRequest));
}
return(Task.FromResult(JObject.FromObject(execRequest)));
}
public void ShouldSetContext()
{
ExecutionRequest execRequest = CreateExecutionRequest("/TakesContextTest/Monkey.json");
ServiceProxySystem.Register <TakesContextTest>();
Expect.IsFalse(_setContextCalled.Value);
execRequest.Execute();
Expect.IsTrue(_setContextCalled.Value);
}
public void MissingClassShouldReturnClassNotSpecifiedResult()
{
ExecutionRequest er = new ExecutionRequest(null, "TestMethod", "json");
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success);
Expect.IsTrue(result.ValidationFailures.ToList().Contains(ValidationFailures.ClassNameNotSpecified));
OutFormat(result.Message);
}
public async ValueTask StartExecuting(ExecutionRequest request, CancellationToken token)
{
await using var context = _dbContextFactory.CreateDbContext();
request.Status = ExecutionRequestStatus.Executing;
request.StartedOn = DateTime.UtcNow;
context.ExecutionRequests.Update(request);
await context.SaveChangesAsync(token);
}
public void ExecutionRequestShouldNotBeInitialized()
{
string url = "http://blah.com/Monkey/GetPages.json";
RequestWrapper req = new RequestWrapper(new { Headers = new NameValueCollection(), Url = new Uri(url), HttpMethod = "GET" });
ResponseWrapper res = new ResponseWrapper(new object());
ProxyAlias alias = new ProxyAlias("Monkey", typeof(TestBam));
ExecutionRequest execRequest = new ExecutionRequest(req, res, new ProxyAlias[] { alias });
Expect.IsFalse(execRequest.IsInitialized);
}
public void MethodNotFoundShouldBeReturned()
{
ServiceProxySystem.Register <TestClass>();
ExecutionRequest er = new ExecutionRequest("TestClass", "MissingMethod", "json");
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success);
Expect.IsTrue(result.ValidationFailures.ToList().Contains(ValidationFailures.MethodNotFound));
Message.PrintLine(result.Message);
}
public void UnregisteredClassShoudReturnClassNotRegistered()
{
ServiceProxySystem.Unregister <TestClass>();
ExecutionRequest er = new ExecutionRequest("TestClass", "ShouldWork", "json");
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success);
Expect.IsTrue(result.ValidationFailures.ToList().Contains(ValidationFailures.ClassNotRegistered));
Message.PrintLine(result.Message);
}
public void MissingMethodShouldReturnMethodNotSpecified()
{
ServiceProxySystem.Register <TestClass>();
ExecutionRequest er = new ExecutionRequest("TestClass", "", "json");
ValidationResult result = er.Validate();
Expect.IsFalse(result.Success);
Expect.IsTrue(result.ValidationFailures.ToList().Contains(ValidationFailures.MethodNameNotSpecified));
OutLineFormat(result.Message);
}
public void ExecutionRequestShouldExecuteWithParameters()
{
string url = "/TestExecutor/DoExecuteWithParameters.json?input=bananas";
ExecutionRequest execRequest = CreateExecutionRequest(url);
TestExecutor execTarget = new TestExecutor();
execRequest.ServiceProvider.Set(typeof(TestExecutor), execTarget);
Expect.IsTrue(execRequest.Execute());
Expect.AreEqual("bananas", execRequest.Result);
}
/// <summary>
/// Preparing to call the API service.
/// </summary>
/// <returns>The Operation representing the API call</returns>
private async Task<Operation> ExecuteOperaionAsync()
{
var service = new ScriptService(new BaseClientService.Initializer
{
HttpClientInitializer = _credential,
ApplicationName = _appName
});
var request = new ExecutionRequest
{
Function = _funcName,
//DevMode = Debugger.IsAttached,
Parameters = this.Parameters
};
ScriptsResource.RunRequest runReq = service.Scripts.Run(request, _projectKey);
return await runReq.ExecuteAsync().ConfigureAwait(false);
}
/// <summary>
/// Main program execution request
/// </summary>
/// <param name="request"></param>
public void MainProgramExecutionRequest(ExecutionRequest request)
{
var config = TinyIoCContainer.Current.Resolve<AppConfig>();
string contextServer = ParameterUtil.Get(config.parameters, "ContextClientHost",
"tcp://localhost");
int contextPort = ParameterUtil.Get(config.parameters, "ContextServerPort",
5800);
var mainProgram = config.nodes.FirstOrDefault(s => s.name == "scriptcs_program");
if (mainProgram != null)
{
switch (request)
{
case ExecutionRequest.Start:
if (_mainProgramProcess == null)
{
var exeFile = Environment.ExpandEnvironmentVariables(mainProgram.process.path);
var args = string.Format("{3} -- {0} {1}:{2}", mainProgram.name, contextServer, contextPort,
Environment.ExpandEnvironmentVariables(mainProgram.process.args));
var workingDir = Path.GetDirectoryName(exeFile);
_mainProgramProcess = new Process
{
StartInfo =
{
UseShellExecute = true,
FileName = exeFile,
CreateNoWindow = true,
Arguments = args,
WorkingDirectory = workingDir ?? string.Empty
}
};
_mainProgramProcess.Start();
Log.InfoFormat("Started Process : {0} {1}", exeFile, args);
}
break;
case ExecutionRequest.Pause:
break;
case ExecutionRequest.Stop:
if (_mainProgramProcess != null && _mainProgramProcess.HasExited)
{
_mainProgramProcess.Dispose();
_mainProgramProcess = null;
}
if (_mainProgramProcess != null && !_mainProgramProcess.HasExited)
{
_mainProgramProcess.Kill();
_mainProgramProcess.Dispose();
_mainProgramProcess = null;
}
Log.Info("Stopped Main Program");
break;
default:
throw new ArgumentOutOfRangeException("request");
}
}
}
private void RunExecutors(IEnumerable<IContextExecutor> executors, object dataSource = null)
{
foreach (var executor in executors)
{
try
{
var request = new ExecutionRequest(_adapter, dataSource);
executor.Execute(request);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
}
