public SendOrPostCallbackItem(SendOrPostCallback callback, object state, ExecutionType type) { _method = callback; _state = state; _exeType = type; }
internal SendOrPostCallbackItem(SendOrPostCallback callback, object state, ExecutionType type) { mMethod = callback; mState = state; mExeType = type; }
public bool ExecuteWrite (ExecutionType type, Transaction transaction) { if (type == ExecutionType.OnlyOnce) { return DoWrite(transaction.Isolateds, transaction.Action); } else { while (!DoWrite(transaction.Isolateds, transaction.Action)); } return true; }
public AndParallelExecution(ParallelExecutionContext executionContext) { _executionContext = executionContext; _executionContext.ExecutionCompleted += delegate { if (ExecutionCompleted != null) ExecutionCompleted(); }; ThenExecute = new ExecutionType(_executionContext); }
/// <summary> /// Prefered Constructor /// </summary> /// <param name="traceLine">The Line in the trace file containing the instruction</param> public Instruction(string traceLine) { string[] tokens = traceLine.Split(' '); this.address = int.Parse(tokens[0]); this.instruction = tokens[1]; this.executionType = getExecutionType(tokens[1]); // Nop instructions have no arguments if (this.executionType != ExecutionType.Nop) this.setArguments(tokens[2]); }
public string ToString(ExecutionType execution) { StringBuilder builder = new StringBuilder(); List<IModule> modules = ReferenceHelper.SortModulesByReference(Modules); for (int i = modules.Count - 1; i >= 0; i--) { if (EnumHelpers.ExecutionTypeMatchesRequirement(execution, modules[i].Execution)) { builder.AppendLine(IModuleToPrjLine(modules[i])); } } return builder.ToString(); }
public static bool ExecutionTypeMatchesRequirement(ExecutionType requirement, ExecutionType current) { if (requirement == ExecutionType.All) { return true; } else if (requirement == ExecutionType.SimulationOnly && current == ExecutionType.SimulationOnly || current == ExecutionType.All) { return true; } else if (requirement == ExecutionType.SynthesisOnly && current == ExecutionType.SynthesisOnly || current == ExecutionType.All) { return true; } return false; }
public async ValueTask QueueAsync(Func <IServiceScopeFactory, CancellationToken, ValueTask> task, ExecutionType executionType = ExecutionType.Await) => await _queue.Writer.WriteAsync(new BackgroundTask(task, executionType));
public void ReportAction(Int64 gas, UInt256 value, Address from, Address?to, ReadOnlyMemory <Byte> input, ExecutionType callType, Boolean isPrecompileCall = false) { }
public void ReportAction(long gas, UInt256 value, Address @from, Address to, byte[] input, ExecutionType callType, bool isPrecompileCall = false) { _currentTxTracer.ReportAction(gas, value, @from, to, input, callType, isPrecompileCall); }
private Task <object> ExecuteAsync(ExecutionType executionType, CommandType commandType, string commandText, IsolationLevel isolationLevel, SqlParameter[] parameters) { return(ExecuteAsync <object>(executionType, commandType, commandText, isolationLevel, parameters)); }
public async Task <int> ExecuteNonQueryAsync(ExecutionType executionType, CommandType commandType, string commandText, IsolationLevel isolationLevel, params SqlParameter[] parameters) { return((int) await ExecuteAsync(executionType, commandType, commandText, isolationLevel, parameters).ConfigureAwait(false)); }
public void ReportAction(long gas, UInt256 value, Address @from, Address to, byte[] input, ExecutionType callType, bool isPrecompileCall = false) { }
private void ProcessArguments(string[] args) { for (int index = 0; index < args.Length; ++index) { var arg = args[index]; var moreArgs = index < args.Length - 1; if ((arg == "-a" || arg == "--assembly") && moreArgs) { string assemblyName = args[++index]; _assemblies.Add(assemblyName); } else if ((arg == "-b" || arg == "--benchmark") && moreArgs) { string benchmark = args[++index]; _benchmarks.Add(benchmark); } else if ((arg == "-p" || arg == "--param") && moreArgs) { string param = args[++index]; int pos = param.IndexOf('='); string key = pos > 0 ? param.Substring(0, pos) : param; string value = pos > 0 ? param.Substring(pos + 1) : null; _parameters[param] = value; } else if ((arg == "-c" || arg == "--config") && moreArgs) { _configurationFile = args[++index]; } else if ((arg == "-r" || arg == "--report") && moreArgs) { _reportFile = args[++index]; } else if ((arg == "-d" || arg == "--duration") && moreArgs) { _duration = Converter.StringToInteger(args[++index], 60); } else if ((arg == "-m" || arg == "--measure") && moreArgs) { _measurementType = args[++index].ToLowerInvariant() == "nominal" ? MeasurementType.Nominal : MeasurementType.Peak; } else if ((arg == "-e" || arg == "--execute") && moreArgs) { var execution = args[++index].ToLowerInvariant(); _executionType = execution == "seq" || execution == "sequential" ? ExecutionType.Sequential : ExecutionType.Proportional; } else if ((arg == "-n" || arg == "--nominal") && moreArgs) { _nominalRate = Converter.StringToDouble(args[++index], 1); } else if (arg == "-f" || arg == "--force") { _forceContinue = true; } else if (arg == "-h" || arg == "--help") { _showHelp = true; } else if (arg == "-B" || arg == "--show-benchmarks") { _showBenchmarks = true; } else if (arg == "-P" || arg == "--show-params") { _showParameters = true; } else if (arg == "-e" || arg == "--environment") { _benchmarkEnvironment = true; } } }
public void ReportCall(long gas, UInt256 value, Address @from, Address to, byte[] input, ExecutionType callType) { ParityTraceAction action = new ParityTraceAction(); action.From = @from; action.To = to; action.Value = value; action.Input = input; action.Gas = gas; action.CallType = GetCallType(callType); PushCall(action); }
internal SendOrPostCallbackItem(SendOrPostCallback callback, object state, ExecutionType type) { _method = callback; _state = state; _executionType = type; }
public TransactionAction(Int64 gas, UInt256 value, Address from, Address?to, ReadOnlyMemory <Byte> input, ExecutionType callType, Boolean isPrecompileCall) => (this.Gas, this.Value, this.From, this.To, this.Input, this.CallType, this.IsPrecompileCall) = (gas, value, from, to, input.ToArray(), callType, isPrecompileCall);
public async Task <HttpOperationResponse <ODataValueOfIEnumerableOfJobDto> > StartJob(string inputArgs, string jobNameSearchTerm, ExecutionType executionType = ExecutionType.Background) { await InitializeHeaders(); var jobsStartJobsParameters = new Dictionary <long?, JobsStartJobsParameters>(); switch (executionType) { case ExecutionType.Foreground: jobsStartJobsParameters = await BuildStartJobParameters(inputArgs, jobNameSearchTerm, "Personal", "KD2ME87R"); break; case ExecutionType.Background: jobsStartJobsParameters = await BuildStartJobParameters(inputArgs, jobNameSearchTerm); break; default: jobsStartJobsParameters = await BuildStartJobParameters(inputArgs, jobNameSearchTerm); break; } // Start job return(await _uiPathWebApi110.Jobs.StartJobsWithHttpMessagesAsync(jobsStartJobsParameters.FirstOrDefault().Value, customHeaders : _headers, xUIPATHOrganizationUnitId : jobsStartJobsParameters.FirstOrDefault().Key)); }
private List<MethodInfo> GetExecutionMethods(Type testType, ExecutionType executionType) { List<MethodInfo> methods = new List<MethodInfo>(); Type executionAttribute = null; switch (executionType) { case ExecutionType.PreHost: executionAttribute = typeof(VsIdePreHostExecutionMethod); break; case ExecutionType.PostHost: executionAttribute = typeof(VsIdePostHostExecutionMethod); break; default: throw new ArgumentException("Unknow Execution Type."); } foreach (var m in testType.GetMethods()) { bool hasCustomAttribute = m.GetCustomAttributes(executionAttribute, true).Length >= 1; if (hasCustomAttribute && !m.IsAbstract && m.IsStatic && m.GetParameters().Length == 0) { methods.Add(m); } else if (hasCustomAttribute) { HostProcessErrorHandler( String.Format("Method {0} is attributed with {1} but cannot be run Pre/Post Host. " + "Methods must be Static and have no parameters." , m.ToString() , executionType.ToString()) , TestOutcome.Warning , false); } } return methods; }
private void PrePostHostCodeExecution(ITestElement testElement, ITestContext testContext, ExecutionType executionType) { Assembly testAssembly = null; Type testType = null; List<MethodInfo> preExecuteMethods = null; String currentMethod = String.Empty; String testClassName = String.Empty; object testObject = null; object[] parameters = new object[] { }; try { testAssembly = Assembly.LoadFrom(testElement.Storage); testClassName = GetTestClassName(testElement); testType = testAssembly.GetType(testClassName); preExecuteMethods = GetExecutionMethods(testType, executionType); if (preExecuteMethods.Count > 0) { if (HostExists()) CleanupHostSide(); testObject = Activator.CreateInstance(testType); foreach (var preExecuteMethod in preExecuteMethods) { currentMethod = preExecuteMethod.Name; preExecuteMethod.Invoke(testObject, parameters); } } } catch (Exception e) { String method = String.Empty; if (currentMethod != String.Empty) { method = " in Method: " + currentMethod; } else { method = "before method execution"; } HostProcessErrorHandler( String.Format("Pre-Host Code Execution Failed {0}. Error: {1}.", method, e.ToString()) , TestOutcome.Warning , false); } }
/// <summary> /// Called to run/compile/check/prolint the current program /// </summary> public static void StartProgressExec(ExecutionType executionType) { CurrentOperation currentOperation; if (!Enum.TryParse(executionType.ToString(), true, out currentOperation)) currentOperation = CurrentOperation.Run; // process already running? if (Plug.CurrentFileObject.CurrentOperation >= CurrentOperation.Prolint) { UserCommunication.NotifyUnique("KillExistingProcess", "This file is already being compiled, run or lint-ed.<br>Please wait the end of the previous action,<br>or click the link below to interrupt the previous action :<br><a href='#'>Click to kill the associated prowin process</a>", MessageImg.MsgRip, currentOperation.GetAttribute<CurrentOperationAttr>().Name, "Already being compiled/run", args => { KillCurrentProcess(); StartProgressExec(executionType); args.Handled = true; }, 5); return; } if (!Abl.IsCurrentProgressFile) { UserCommunication.Notify("Can only compile and run progress files!", MessageImg.MsgWarning, "Invalid file type", "Progress files only", 10); return; } if (string.IsNullOrEmpty(Plug.CurrentFilePath) || !File.Exists(Plug.CurrentFilePath)) { UserCommunication.Notify("Couldn't find the following file :<br>" + Plug.CurrentFilePath, MessageImg.MsgError, "Execution error", "File not found", 10); return; } if (!Config.Instance.CompileKnownExtension.Split(',').Contains(Path.GetExtension(Plug.CurrentFilePath))) { UserCommunication.Notify("Sorry, the file extension " + Path.GetExtension(Plug.CurrentFilePath).ProQuoter() + " isn't a valid extension for this action!<br><i>You can change the list of valid extensions in the settings window</i>", MessageImg.MsgWarning, "Invalid file extension", "Not an executable", 10); return; } // update function prototypes ProGenerateCode.UpdateFunctionPrototypesIfNeeded(true); // prolint? check that the StartProlint.p program is created, or do it if (executionType == ExecutionType.Prolint) { if (!File.Exists(Config.FileStartProlint)) if (!Utils.FileWriteAllBytes(Config.FileStartProlint, DataResources.StartProlint)) return; } // launch the compile process for the current file Plug.CurrentFileObject.ProgressExecution = new ProExecution { ListToCompile = new List<FileToCompile> { new FileToCompile(Plug.CurrentFilePath) }, OnExecutionEnd = OnSingleExecutionEnd, OnExecutionOk = OnSingleExecutionOk }; if (!Plug.CurrentFileObject.ProgressExecution.Do(executionType)) return; // change file object current operation, set flag Plug.CurrentFileObject.CurrentOperation |= currentOperation; FilesInfo.UpdateFileStatus(); // clear current errors (updates the current file info) FilesInfo.ClearAllErrors(Plug.CurrentFilePath, true); }
internal object Execute(Context context, ExecutionType executionType) { var arguments = from child in Children select child.Execute(context, ExecutionType.Argument); return(Token.Execute(arguments, context, executionType)); }
private static void SetSystem(ref IDictionary <int, SystemLayer> layers, EntitySystem system, int layer, ExecutionType executionType) { if (!layers.ContainsKey(layer)) { layers[layer] = new SystemLayer(); } var updateBag = layers[layer][executionType]; if (!updateBag.Contains(system)) { updateBag.Add(system); } //#if !FULLDOTNET // layers = (from d in layers orderby d.Key ascending select d).ToDictionary(pair => pair.Key, pair => pair.Value); //#endif }
private void RunImpl(Response response, dynamic args, ExecutionType executionType) { lock (_lock) { _attachMode = executionType == ExecutionType.Attach; SetExceptionBreakpoints(args.__exceptionOptions); SoftDebuggerRemoteArgs listenArgs; if (executionType == ExecutionType.Attach) { // validate argument 'address' string host = getString(args, "address"); if (host == null) { SendErrorResponse(response, 3007, "Property 'address' is missing or empty."); return; } // validate argument 'port' int port = getInt(args, "port", -1); if (port == -1) { SendErrorResponse(response, 3008, "Property 'port' is missing."); return; } IPAddress address = Utilities.ResolveIPAddress(host); if (address == null) { SendErrorResponse(response, 3013, "Invalid address '{host}'.", new { host }); return; } listenArgs = new SoftDebuggerConnectArgs("Godot", IPAddress.Loopback, port); } else { listenArgs = new SoftDebuggerListenArgs("Godot", IPAddress.Loopback, 0); } // ------ _debuggeeKilled = false; string godotExecutablePath = (string)args.executable; string godotProjectDir = (string)args.godotProjectDir; var startInfo = new GodotDebuggerStartInfo(executionType, godotExecutablePath, processOutputListener: this, listenArgs) { WorkingDirectory = godotProjectDir }; _session.Run(startInfo, _debuggerSessionOptions); _debuggeeExecuting = true; } }
private EntitySystem SetSystem(Type systemType, EntitySystem system, GameLoopType gameLoopType, int layer = 0, ExecutionType executionType = ExecutionType.Synchronous) { system.EntityWorld = _entityWorld; if (_systems.ContainsKey(systemType)) { _systems[systemType].Add(system); } else { var genericType = typeof(List <>); var listType = genericType.MakeGenericType(systemType); _systems[systemType] = (IList)Activator.CreateInstance(listType); _systems[systemType].Add(system); } switch (gameLoopType) { case GameLoopType.Draw: { SetSystem(ref _drawLayers, system, layer, executionType); } break; case GameLoopType.Update: { SetSystem(ref _updateLayers, system, layer, executionType); } break; } if (!_mergedBag.Contains(system)) { _mergedBag.Add(system); } system.Bit = _systemBitManager.GetBitFor(system); return(system); }
public async Task <IEnumerable <T> > ExecuteReaderAsync <T>(ExecutionType executionType, CommandType commandType, string commandText, IsolationLevel isolationLevel, Func <IDataReader, T> callback, params SqlParameter[] parameters) { return((IEnumerable <T>) await ExecuteAsync(executionType, commandType, commandText, isolationLevel, parameters, callback).ConfigureAwait(false)); }
public T SetSystem <T>(T system, GameLoopType gameLoopType, int layer = 0, ExecutionType executionType = ExecutionType.Synchronous) where T : EntitySystem { return((T)SetSystem(system.GetType(), system, gameLoopType, layer, executionType)); }
public Task <object> ExecuteScalarAsync(ExecutionType executionType, CommandType commandType, string commandText, IsolationLevel isolationLevel, params SqlParameter[] parameters) { return(ExecuteAsync(executionType, commandType, commandText, isolationLevel, parameters)); }
public TransactionReceipt Execute( Transaction transaction, BlockHeader block) { TransactionTrace trace = null; if (_tracer.IsTracingEnabled) { trace = new TransactionTrace(); } IReleaseSpec spec = _specProvider.GetSpec(block.Number); Address recipient = transaction.To; UInt256 value = transaction.Value; UInt256 gasPrice = transaction.GasPrice; long gasLimit = (long)transaction.GasLimit; byte[] machineCode = transaction.Init; byte[] data = transaction.Data ?? Bytes.Empty; Address sender = transaction.SenderAddress; if (_logger.IsTrace) { _logger.Trace($"SPEC: {spec.GetType().Name}"); _logger.Trace("HASH: " + transaction.Hash); _logger.Trace("IS_CONTRACT_CREATION: " + transaction.IsContractCreation); _logger.Trace("IS_MESSAGE_CALL: " + transaction.IsMessageCall); _logger.Trace("IS_TRANSFER: " + transaction.IsTransfer); _logger.Trace("SENDER: " + sender); _logger.Trace("TO: " + transaction.To); _logger.Trace("GAS LIMIT: " + transaction.GasLimit); _logger.Trace("GAS PRICE: " + transaction.GasPrice); _logger.Trace("VALUE: " + transaction.Value); _logger.Trace("DATA_LENGTH: " + (transaction.Data?.Length ?? 0)); _logger.Trace("NONCE: " + transaction.Nonce); } if (sender == null) { if (_logger.IsTrace) { _logger.Trace($"SENDER_NOT_SPECIFIED"); } return(GetNullReceipt(block, 0L)); } long intrinsicGas = _intrinsicGasCalculator.Calculate(transaction, spec); if (_logger.IsTrace) { _logger.Trace("INTRINSIC GAS: " + intrinsicGas); } if (gasLimit < intrinsicGas) { if (_logger.IsTrace) { _logger.Trace($"GAS_LIMIT_BELOW_INTRINSIC_GAS {gasLimit} < {intrinsicGas}"); } return(GetNullReceipt(block, 0L)); } if (gasLimit > block.GasLimit - block.GasUsed) { if (_logger.IsTrace) { _logger.Trace($"BLOCK_GAS_LIMIT_EXCEEDED {gasLimit} > {block.GasLimit} - {block.GasUsed}"); } return(GetNullReceipt(block, 0L)); } if (!_stateProvider.AccountExists(sender)) { if (_logger.IsTrace) { _logger.Trace($"SENDER_ACCOUNT_DOES_NOT_EXIST {sender}"); } _stateProvider.CreateAccount(sender, 0); } UInt256 senderBalance = _stateProvider.GetBalance(sender); if ((ulong)intrinsicGas * gasPrice + value > senderBalance) { if (_logger.IsTrace) { _logger.Trace($"INSUFFICIENT_SENDER_BALANCE: ({sender})b = {senderBalance}"); } return(GetNullReceipt(block, 0L)); } if (transaction.Nonce != _stateProvider.GetNonce(sender)) { if (_logger.IsTrace) { _logger.Trace($"WRONG_TRANSACTION_NONCE: {transaction.Nonce} (expected {_stateProvider.GetNonce(sender)})"); } return(GetNullReceipt(block, 0L)); } _stateProvider.IncrementNonce(sender); _stateProvider.SubtractFromBalance(sender, (ulong)gasLimit * gasPrice, spec); _stateProvider.Commit(spec); long unspentGas = gasLimit - intrinsicGas; long spentGas = gasLimit; List <LogEntry> logEntries = new List <LogEntry>(); if (transaction.IsContractCreation) { Rlp addressBaseRlp = Rlp.Encode( Rlp.Encode(sender), Rlp.Encode(_stateProvider.GetNonce(sender) - 1)); Keccak addressBaseKeccak = Keccak.Compute(addressBaseRlp); recipient = new Address(addressBaseKeccak); } int snapshot = _stateProvider.TakeSnapshot(); int storageSnapshot = _storageProvider.TakeSnapshot(); _stateProvider.SubtractFromBalance(sender, value, spec); byte statusCode = StatusCode.Failure; HashSet <Address> destroyedAccounts = new HashSet <Address>(); try { if (transaction.IsContractCreation) { // TODO: review tests around it as it fails on Ropsten 230881 when we throw an exception if (_stateProvider.AccountExists(recipient) && !_stateProvider.IsEmptyAccount(recipient)) { // TODO: review // throw new TransactionCollisionException(); } } if (transaction.IsTransfer) // TODO: this is never called and wrong, to be removed { _stateProvider.SubtractFromBalance(sender, value, spec); _stateProvider.AddToBalance(recipient, value, spec); statusCode = StatusCode.Success; } else { bool isPrecompile = recipient.IsPrecompiled(spec); ExecutionEnvironment env = new ExecutionEnvironment(); env.Value = value; env.TransferValue = value; env.Sender = sender; env.ExecutingAccount = recipient; env.CurrentBlock = block; env.GasPrice = gasPrice; env.InputData = data ?? new byte[0]; env.CodeInfo = isPrecompile ? new CodeInfo(recipient) : machineCode == null?_virtualMachine.GetCachedCodeInfo(recipient) : new CodeInfo(machineCode); env.Originator = sender; ExecutionType executionType = isPrecompile ? ExecutionType.DirectPrecompile : transaction.IsContractCreation ? ExecutionType.DirectCreate : ExecutionType.Transaction; TransactionSubstate substate; byte[] output; using (EvmState state = new EvmState(unspentGas, env, executionType, false)) { (output, substate) = _virtualMachine.Run(state, spec, trace); unspentGas = state.GasAvailable; } if (substate.ShouldRevert) { if (_logger.IsTrace) { _logger.Trace("REVERTING"); } logEntries.Clear(); destroyedAccounts.Clear(); _stateProvider.Restore(snapshot); _storageProvider.Restore(storageSnapshot); } else { if (transaction.IsContractCreation) { long codeDepositGasCost = output.Length * GasCostOf.CodeDeposit; if (spec.IsEip170Enabled && output.Length > 0x6000) { codeDepositGasCost = long.MaxValue; } if (unspentGas < codeDepositGasCost && spec.IsEip2Enabled) { throw new OutOfGasException(); } if (unspentGas >= codeDepositGasCost) { Keccak codeHash = _stateProvider.UpdateCode(output); _stateProvider.UpdateCodeHash(recipient, codeHash, spec); unspentGas -= codeDepositGasCost; } } logEntries.AddRange(substate.Logs); foreach (Address toBeDestroyed in substate.DestroyList) { destroyedAccounts.Add(toBeDestroyed); } statusCode = StatusCode.Success; } spentGas = Refund(gasLimit, unspentGas, substate, sender, gasPrice, spec); } } catch (Exception ex) when(ex is EvmException || ex is OverflowException) // TODO: OverflowException? still needed? hope not { if (_logger.IsTrace) { _logger.Trace($"EVM EXCEPTION: {ex.GetType().Name}"); } logEntries.Clear(); destroyedAccounts.Clear(); _stateProvider.Restore(snapshot); _storageProvider.Restore(storageSnapshot); } foreach (Address toBeDestroyed in destroyedAccounts) { if (_logger.IsTrace) { _logger.Trace($"DESTROYING: {toBeDestroyed}"); } _stateProvider.DeleteAccount(toBeDestroyed); } if (_logger.IsTrace) { _logger.Trace("GAS SPENT: " + spentGas); } if (!destroyedAccounts.Contains(block.Beneficiary)) { if (!_stateProvider.AccountExists(block.Beneficiary)) { _stateProvider.CreateAccount(block.Beneficiary, (ulong)spentGas * gasPrice); } else { _stateProvider.AddToBalance(block.Beneficiary, (ulong)spentGas * gasPrice, spec); } } _storageProvider.Commit(spec); _stateProvider.Commit(spec); block.GasUsed += spentGas; if (_tracer.IsTracingEnabled) { trace.Gas = spentGas; _tracer.SaveTrace(Transaction.CalculateHash(transaction), trace); } return(BuildTransactionReceipt(block, statusCode, logEntries.Any() ? logEntries.ToArray() : LogEntry.EmptyLogs, recipient)); }
public void ReportAction(long gas, UInt256 value, Address @from, Address to, byte[] input, ExecutionType callType, bool isPrecompileCall = false) => throw new InvalidOperationException(ErrorMessage);
/// <summary> /// allows to prepare the execution environnement by creating a unique temp folder /// and copying every critical files into it /// Then execute the progress program /// </summary> /// <returns></returns> public bool Do(ExecutionType executionType) { if (ListToCompile == null) ListToCompile = new List<FileToCompile>(); ExecutionType = executionType; // check prowin32.exe if (!File.Exists(ProEnv.ProwinPath)) { UserCommunication.NotifyUnique("ProExecutionChecks", "The file path to Prowin.exe is incorrect : <div class='ToolTipcodeSnippet'>" + ProEnv.ProwinPath + "</div>You must provide a valid path before executing this action<br><i>You can change this path in the <a href='go'>set environment page</a></i>", MessageImg.MsgWarning, "Execution error", "Invalid file path", args => { Appli.Appli.GoToPage(PageNames.SetEnvironment); UserCommunication.CloseUniqueNotif("ProExecutionChecks"); args.Handled = true; }, 10); return false; } // check compilation dir if (executionType == ExecutionType.Compile && !ProEnv.CompileLocally && (!Path.IsPathRooted(ProEnv.BaseCompilationPath))) { UserCommunication.NotifyUnique("ProExecutionChecks", "The path for the compilation base directory is incorrect : <div class='ToolTipcodeSnippet'>" + (string.IsNullOrEmpty(ProEnv.BaseCompilationPath) ? "it's empty!" : ProEnv.BaseCompilationPath) + "</div>You must provide a valid path before executing this action :<br><br><i>1. Either change the compilation directory<br>2. Or toggle the option to compile next to the source file!<br><br>The options are configurable in the <a href='go'>set environment page</a></i>", MessageImg.MsgWarning, "Execution error", "Invalid file path", args => { Appli.Appli.GoToPage(PageNames.SetEnvironment); UserCommunication.CloseUniqueNotif("ProExecutionChecks"); args.Handled = true; }, 10); return false; } // create a unique temporary folder LocalTempDir = Path.Combine(Config.FolderTemp, _proExecutionCounter + "-" + DateTime.Now.ToString("yyMMdd_HHmmssfff")); if (!Utils.CreateDirectory(LocalTempDir)) return false; // for each file of the list var filesListPath = Path.Combine(LocalTempDir, "files.list"); StringBuilder filesListcontent = new StringBuilder(); var count = 1; foreach (var fileToCompile in ListToCompile) { if (!File.Exists(fileToCompile.InputPath)) { UserCommunication.Notify("Couldn't find the following file :<br>" + fileToCompile.InputPath, MessageImg.MsgError, "Execution error", "File not found", 10); return false; } // if current file and the file has unsaved modif, we copy the content to a temp file, otherwise we just use the input path (also use the input path for .cls files!) if (fileToCompile.InputPath.Equals(Plug.CurrentFilePath) && (Npp.GetModify || (fileToCompile.BaseFileName ?? "").StartsWith("_")) && !Path.GetExtension(fileToCompile.InputPath).Equals(".cls")) { fileToCompile.CompInputPath = Path.Combine(LocalTempDir, "tmp_" + DateTime.Now.ToString("yyMMdd_HHmmssfff_") + count + Path.GetExtension(fileToCompile.InputPath)); Utils.FileWriteAllText(fileToCompile.CompInputPath, Npp.Text, Encoding.Default); } else { fileToCompile.CompInputPath = fileToCompile.InputPath; } if (executionType != ExecutionType.Compile) continue; // we set where the *.lst and *.r files will be generated by the COMPILE command var baseFileName = Path.GetFileNameWithoutExtension(fileToCompile.CompInputPath); var lastDeployment = ProEnv.Deployer.GetTargetDirsNeededForFile(fileToCompile.InputPath, 0).Last(); // for *.cls files, as many *.r files are generated, we need to compile in a temp directory // we need to know which *.r files were generated for each input file // so each file gets his own sub tempDir if ((lastDeployment.DeployType != DeployType.Move) || Config.Instance.CompileForceUseOfTemp || Path.GetExtension(fileToCompile.InputPath).Equals(".cls") ) { var subTempDir = Path.Combine(LocalTempDir, count.ToString()); // if the deployment dir is not on the same disk as the temp folder, we create a temp dir // as close to the final deployment as possible (= in the deployment base dir!) if (lastDeployment.DeployType != DeployType.Ftp && !string.IsNullOrEmpty(DistantRootTempDir) && DistantRootTempDir.Length > 2 && !DistantRootTempDir.Substring(0, 2).EqualsCi(LocalTempDir.Substring(0, 2))) { if (Utils.CreateDirectory(DistantRootTempDir, FileAttributes.Hidden)) DistantTempDir = Path.Combine(DistantRootTempDir, _proExecutionCounter + "-" + DateTime.Now.ToString("yyMMdd_HHmmssfff")); else DistantTempDir = LocalTempDir; subTempDir = Path.Combine(DistantTempDir, count.ToString()); } if (!Utils.CreateDirectory(subTempDir)) return false; fileToCompile.CompOutputDir = subTempDir; fileToCompile.CompOutputLst = Path.Combine(subTempDir, baseFileName + ".lst"); fileToCompile.CompOutputR = Path.Combine(subTempDir, baseFileName + ".r"); } else { // if we want to move the r-code somewhere during the deployment, then we will compile the r-code // directly there, because it's faster than generating it in a temp folder and moving it afterward fileToCompile.CompOutputDir = lastDeployment.TargetDir; if (!Utils.CreateDirectory(fileToCompile.CompOutputDir)) return false; fileToCompile.CompOutputLst = Path.Combine(fileToCompile.CompOutputDir, baseFileName + ".lst"); fileToCompile.CompOutputR = Path.Combine(fileToCompile.CompOutputDir, baseFileName + ".r"); } // feed files list filesListcontent.AppendLine(fileToCompile.CompInputPath.ProQuoter() + " " + fileToCompile.CompOutputDir.ProQuoter() + " " + fileToCompile.CompOutputLst.ProQuoter()); count++; } Utils.FileWriteAllText(filesListPath, filesListcontent.ToString(), Encoding.Default); // when running a procedure, check that a .r is not hiding the program, if that's the case we warn the user if (executionType == ExecutionType.Run && !_dontWarnAboutRCode && ListToCompile.Count >= 1) { if (File.Exists(Path.ChangeExtension(ListToCompile.First().InputPath, ".r"))) { UserCommunication.NotifyUnique("rcodehide", "Friendly warning, an <b>r-code</b> <i>(i.e. *.r file)</i> is hiding the current program<br>If you modified it since the last compilation you might not have the expected behavior...<br><br><i>" + "stop".ToHtmlLink("Click here to not show this message again for this session") + "</i>", MessageImg.MsgWarning, "Execution warning", "An Rcode hides the program", args => { _dontWarnAboutRCode = true; UserCommunication.CloseUniqueNotif("rcodehide"); }, 5); } } // Move ini file into the execution dir var baseIniPath = ""; if (File.Exists(ProEnv.IniPath)) { baseIniPath = Path.Combine(LocalTempDir, "base.ini"); // we need to copy the .ini but we must delete the PROPATH= part, as stupid as it sounds, if we leave a huge PROPATH // in this file, it increases the compilation time by a stupid amount... unbelievable i know, but trust me, it does... var encoding = TextEncodingDetect.GetFileEncoding(ProEnv.IniPath); var fileContent = Utils.ReadAllText(ProEnv.IniPath, encoding); var regex = new Regex("^PROPATH=.*$", RegexOptions.Multiline | RegexOptions.IgnoreCase); var matches = regex.Match(fileContent); if (matches.Success) fileContent = regex.Replace(fileContent, @"PROPATH="); Utils.FileWriteAllText(baseIniPath, fileContent, encoding); } // Move pf file into the execution dir var basePfPath = ""; if (File.Exists(ProEnv.GetPfPath())) { basePfPath = Path.Combine(LocalTempDir, "base.pf"); File.Copy(ProEnv.GetPfPath(), basePfPath); } // set common info on the execution LogPath = Path.Combine(LocalTempDir, "run.log"); ProcessStartDir = executionType == ExecutionType.Run ? Path.GetDirectoryName(ListToCompile.First().InputPath) ?? LocalTempDir : LocalTempDir; ProgressWin32 = ProEnv.ProwinPath; if (executionType == ExecutionType.Database) ExtractDbOutputPath = Path.Combine(LocalTempDir, ExtractDbOutputPath); ProgressionFilePath = Path.Combine(LocalTempDir, "compile.progression"); DatabaseConnectionLog = Path.Combine(LocalTempDir, "db.ko"); NotificationOutputPath = Path.Combine(LocalTempDir, "postExecution.notif"); var propathToUse = string.Join(",", ProEnv.GetProPathDirList); string fileToExecute = ""; if (executionType == ExecutionType.Appbuilder) { fileToExecute = ListToCompile.First().InputPath; } else if (executionType == ExecutionType.Database) { // for database extraction, we need to copy the DumpDatabase program fileToExecute = "db_" + DateTime.Now.ToString("yyMMdd_HHmmssfff") + ".p"; if (!Utils.FileWriteAllBytes(Path.Combine(LocalTempDir, fileToExecute), DataResources.DumpDatabase)) return false; } else if (executionType == ExecutionType.Prolint) { // prolint, we need to copy the StartProlint program fileToExecute = "prolint_" + DateTime.Now.ToString("yyMMdd_HHmmssfff") + ".p"; ProlintOutputPath = Path.Combine(LocalTempDir, "prolint.log"); StringBuilder prolintProgram = new StringBuilder(); prolintProgram.AppendLine("&SCOPED-DEFINE PathFileToProlint " + ListToCompile.First().CompInputPath.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE PathProlintOutputFile " + ProlintOutputPath.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE PathToStartProlintProgram " + Config.FileStartProlint.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE UserName " + Config.Instance.UserName.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE PathActualFilePath " + ListToCompile.First().InputPath.ProQuoter()); var filename = Path.GetFileName(Plug.CurrentFilePath); if (FileTag.Contains(filename)) { var fileInfo = FileTag.GetLastFileTag(filename); prolintProgram.AppendLine("&SCOPED-DEFINE FileApplicationName " + fileInfo.ApplicationName.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE FileApplicationVersion " + fileInfo.ApplicationVersion.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE FileWorkPackage " + fileInfo.WorkPackage.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE FileBugID " + fileInfo.BugId.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE FileCorrectionNumber " + fileInfo.CorrectionNumber.ProQuoter()); prolintProgram.AppendLine("&SCOPED-DEFINE FileDate " + fileInfo.CorrectionDate.ProQuoter()); } var encoding = TextEncodingDetect.GetFileEncoding(Config.FileStartProlint); Utils.FileWriteAllText(Path.Combine(LocalTempDir, fileToExecute), Utils.ReadAllText(Config.FileStartProlint, encoding).Replace(@"/*<inserted_3P_values>*/", prolintProgram.ToString()), encoding); } else if (executionType == ExecutionType.DeploymentHook) { fileToExecute = "hook_" + DateTime.Now.ToString("yyMMdd_HHmmssfff") + ".p"; StringBuilder hookProc = new StringBuilder(); hookProc.AppendLine("&SCOPED-DEFINE ApplicationName " + ProEnv.Name.ProQuoter()); hookProc.AppendLine("&SCOPED-DEFINE ApplicationSuffix " + ProEnv.Suffix.ProQuoter()); hookProc.AppendLine("&SCOPED-DEFINE StepNumber " + DeploymentStep); hookProc.AppendLine("&SCOPED-DEFINE SourceDirectory " + DeploymentSourcePath.ProQuoter()); hookProc.AppendLine("&SCOPED-DEFINE DeploymentDirectory " + ProEnv.BaseCompilationPath.ProQuoter()); var encoding = TextEncodingDetect.GetFileEncoding(Config.FileDeploymentHook); Utils.FileWriteAllText(Path.Combine(LocalTempDir, fileToExecute), Utils.ReadAllText(Config.FileDeploymentHook, encoding).Replace(@"/*<inserted_3P_values>*/", hookProc.ToString()), encoding); } else if (executionType == ExecutionType.DataDigger || executionType == ExecutionType.DataReader) { // need to init datadigger? if (!File.Exists(Path.Combine(Config.FolderDataDigger, "DataDigger.p"))) { if (!Utils.FileWriteAllBytes(Path.Combine(Config.FolderDataDigger, "DataDigger.zip"), DataResources.DataDigger)) return false; if (!Utils.ExtractAll(Path.Combine(Config.FolderDataDigger, "DataDigger.zip"), Config.FolderDataDigger)) return false; } // add the datadigger folder to the propath propathToUse = Config.FolderDataDigger + "," + propathToUse; } else { if (ListToCompile.Count == 1) fileToExecute = ListToCompile.First().CompInputPath; } // prepare the .p runner var runnerPath = Path.Combine(LocalTempDir, "run_" + DateTime.Now.ToString("yyMMdd_HHmmssfff") + ".p"); StringBuilder runnerProgram = new StringBuilder(); runnerProgram.AppendLine("&SCOPED-DEFINE ExecutionType " + executionType.ToString().ToUpper().ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE ToExecute " + fileToExecute.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE LogFile " + LogPath.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE ExtractDbOutputPath " + ExtractDbOutputPath.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE propathToUse " + (LocalTempDir + "," + propathToUse).ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE ExtraPf " + ProEnv.ExtraPf.Trim().ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE BasePfPath " + basePfPath.Trim().ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE CompileWithLst " + ProEnv.CompileWithListing); runnerProgram.AppendLine("&SCOPED-DEFINE ToCompileListFile " + filesListPath.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE CreateFileIfConnectFails " + DatabaseConnectionLog.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE CompileProgressionFile " + ProgressionFilePath.ProQuoter()); runnerProgram.AppendLine("&SCOPED-DEFINE DbConnectionMandatory " + NeedDatabaseConnection); runnerProgram.AppendLine("&SCOPED-DEFINE NotificationOutputPath " + NotificationOutputPath.ProQuoter()); runnerProgram.Append(Encoding.Default.GetString(DataResources.ProgressRun)); Utils.FileWriteAllText(runnerPath, runnerProgram.ToString(), Encoding.Default); // preferably, we use the batch mode because it's faster than the client mode var batchMode = (executionType == ExecutionType.CheckSyntax || executionType == ExecutionType.Compile || executionType == ExecutionType.Database); // no batch mode option? batchMode = batchMode && !Config.Instance.NeverUseProwinInBatchMode; // multiple compilation, we don't want to show all those Prowin in the task bar... batchMode = batchMode && !NoBatch; // Parameters StringBuilder Params = new StringBuilder(); if (executionType == ExecutionType.DataDigger || executionType == ExecutionType.DataReader) Params.Append(" -s 10000 -d dmy -E -rereadnolock -h 255 -Bt 4000 -tmpbsize 8"); if (executionType != ExecutionType.Run) Params.Append(" -T " + LocalTempDir.Trim('\\').ProQuoter()); if (!string.IsNullOrEmpty(baseIniPath)) Params.Append(" -ini " + baseIniPath.ProQuoter()); if (batchMode) Params.Append(" -b"); Params.Append(" -p " + runnerPath.ProQuoter()); if (!string.IsNullOrWhiteSpace(ProEnv.CmdLineParameters)) Params.Append(" " + ProEnv.CmdLineParameters.Trim()); ExeParameters = Params.ToString(); // we supress the splashscreen if (!batchMode) MoveSplashScreenNoError(Path.Combine(Path.GetDirectoryName(ProgressWin32) ?? "", "splashscreen.bmp"), Path.Combine(Path.GetDirectoryName(ProgressWin32) ?? "", "splashscreen-3p-disabled.bmp")); // Start a process var pInfo = new ProcessStartInfo { FileName = ProEnv.ProwinPath, Arguments = ExeParameters, WorkingDirectory = ProcessStartDir }; if (batchMode) { pInfo.WindowStyle = ProcessWindowStyle.Hidden; pInfo.CreateNoWindow = true; } Process = new Process { StartInfo = pInfo, EnableRaisingEvents = true }; Process.Exited += ProcessOnExited; try { Process.Start(); } catch (Exception e) { UserCommunication.NotifyUnique("ProwinFailed", "Couldn't start a new prowin process!<br>Please check that the file path to prowin32.exe is correct in the <a href='go'>set environment page</a>.<br><br>Below is the technical error that occured :<br><div class='ToolTipcodeSnippet'>" + e.Message + "</div>", MessageImg.MsgError, "Execution error", "Can't start a prowin process", args => { Appli.Appli.GoToPage(PageNames.SetEnvironment); UserCommunication.CloseUniqueNotif("ProwinFailed"); args.Handled = true; }, 10); } //UserCommunication.Notify("New process starting...<br><br><b>FileName :</b><br>" + ProEnv.ProwinPath + "<br><br><b>Parameters :</b><br>" + ExeParameters + "<br><br><b>Temporary directory :</b><br><a href='" + TempDir + "'>" + TempDir + "</a>"); return true; }
public EstimateGasTracerTests(bool useCreates) { _executionType = useCreates ? ExecutionType.Create : ExecutionType.Call; }
public void Execute(Transaction transaction, BlockHeader block, ITxTracer txTracer, bool readOnly) { IReleaseSpec spec = _specProvider.GetSpec(block.Number); Address recipient = transaction.To; UInt256 value = transaction.Value; UInt256 gasPrice = transaction.GasPrice; long gasLimit = (long)transaction.GasLimit; byte[] machineCode = transaction.Init; byte[] data = transaction.Data ?? Bytes.Empty; Address sender = transaction.SenderAddress; if (_logger.IsTrace) { _logger.Trace($"Executing tx {transaction.Hash}"); } if (sender == null) { TraceLogInvalidTx(transaction, "SENDER_NOT_SPECIFIED"); if (txTracer.IsTracingReceipt) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } return; } long intrinsicGas = _intrinsicGasCalculator.Calculate(transaction, spec); if (_logger.IsTrace) { _logger.Trace($"Intrinsic gas calculated for {transaction.Hash}: " + intrinsicGas); } if (gasLimit < intrinsicGas) { TraceLogInvalidTx(transaction, $"GAS_LIMIT_BELOW_INTRINSIC_GAS {gasLimit} < {intrinsicGas}"); if (txTracer.IsTracingReceipt) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } return; } if (gasLimit > block.GasLimit - block.GasUsed) { TraceLogInvalidTx(transaction, $"BLOCK_GAS_LIMIT_EXCEEDED {gasLimit} > {block.GasLimit} - {block.GasUsed}"); if (txTracer.IsTracingReceipt) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } return; } if (!_stateProvider.AccountExists(sender)) { TraceLogInvalidTx(transaction, $"SENDER_ACCOUNT_DOES_NOT_EXIST {sender}"); if (gasPrice == UInt256.Zero) { _stateProvider.CreateAccount(sender, UInt256.Zero); } } UInt256 senderBalance = _stateProvider.GetBalance(sender); if ((ulong)intrinsicGas * gasPrice + value > senderBalance) { TraceLogInvalidTx(transaction, $"INSUFFICIENT_SENDER_BALANCE: ({sender})_BALANCE = {senderBalance}"); if (txTracer.IsTracingReceipt) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } return; } if (transaction.Nonce != _stateProvider.GetNonce(sender)) { TraceLogInvalidTx(transaction, $"WRONG_TRANSACTION_NONCE: {transaction.Nonce} (expected {_stateProvider.GetNonce(sender)})"); if (txTracer.IsTracingReceipt) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } return; } _stateProvider.IncrementNonce(sender); _stateProvider.SubtractFromBalance(sender, (ulong)gasLimit * gasPrice, spec); // TODO: I think we can skip this commit and decrease the tree operations this way _stateProvider.Commit(_specProvider.GetSpec(block.Number), txTracer.IsTracingState ? txTracer : null); long unspentGas = gasLimit - intrinsicGas; long spentGas = gasLimit; int stateSnapshot = _stateProvider.TakeSnapshot(); int storageSnapshot = _storageProvider.TakeSnapshot(); _stateProvider.SubtractFromBalance(sender, value, spec); byte statusCode = StatusCode.Failure; TransactionSubstate substate = null; try { if (transaction.IsContractCreation) { recipient = Address.OfContract(sender, _stateProvider.GetNonce(sender) - 1); if (_stateProvider.AccountExists(recipient)) { if ((_virtualMachine.GetCachedCodeInfo(recipient)?.MachineCode?.Length ?? 0) != 0 || _stateProvider.GetNonce(recipient) != 0) { if (_logger.IsTrace) { _logger.Trace($"Contract collision at {recipient}"); // the account already owns the contract with the code } throw new TransactionCollisionException(); } _stateProvider.UpdateStorageRoot(recipient, Keccak.EmptyTreeHash); } } bool isPrecompile = recipient.IsPrecompiled(spec); ExecutionEnvironment env = new ExecutionEnvironment(); env.Value = value; env.TransferValue = value; env.Sender = sender; env.ExecutingAccount = recipient; env.CurrentBlock = block; env.GasPrice = gasPrice; env.InputData = data ?? new byte[0]; env.CodeInfo = isPrecompile ? new CodeInfo(recipient) : machineCode == null?_virtualMachine.GetCachedCodeInfo(recipient) : new CodeInfo(machineCode); env.Originator = sender; ExecutionType executionType = transaction.IsContractCreation ? ExecutionType.Create : ExecutionType.Call; using (EvmState state = new EvmState(unspentGas, env, executionType, isPrecompile, true, false)) { substate = _virtualMachine.Run(state, spec, txTracer); unspentGas = state.GasAvailable; } if (substate.ShouldRevert || substate.IsError) { if (_logger.IsTrace) { _logger.Trace("Restoring state from before transaction"); } _stateProvider.Restore(stateSnapshot); _storageProvider.Restore(storageSnapshot); } else { // tks: there is similar code fo contract creation from init and from CREATE // this may lead to inconsistencies (however it is tested extensively in blockchain tests) if (transaction.IsContractCreation) { long codeDepositGasCost = substate.Output.Length * GasCostOf.CodeDeposit; if (spec.IsEip170Enabled && substate.Output.Length > 0x6000) { codeDepositGasCost = long.MaxValue; } if (unspentGas < codeDepositGasCost && spec.IsEip2Enabled) { throw new OutOfGasException(); } if (unspentGas >= codeDepositGasCost) { Keccak codeHash = _stateProvider.UpdateCode(substate.Output); _stateProvider.UpdateCodeHash(recipient, codeHash, spec); unspentGas -= codeDepositGasCost; } } foreach (Address toBeDestroyed in substate.DestroyList) { if (_logger.IsTrace) { _logger.Trace($"Destroying account {toBeDestroyed}"); } _stateProvider.DeleteAccount(toBeDestroyed); } statusCode = StatusCode.Success; } spentGas = Refund(gasLimit, unspentGas, substate, sender, gasPrice, spec); } catch (Exception ex) when(ex is EvmException || ex is OverflowException) // TODO: OverflowException? still needed? hope not { if (_logger.IsTrace) { _logger.Trace($"EVM EXCEPTION: {ex.GetType().Name}"); } _stateProvider.Restore(stateSnapshot); _storageProvider.Restore(storageSnapshot); } if (_logger.IsTrace) { _logger.Trace("Gas spent: " + spentGas); } Address gasBeneficiary = block.GasBeneficiary; if (statusCode == StatusCode.Failure || !(substate?.DestroyList.Contains(gasBeneficiary) ?? false)) { if (!_stateProvider.AccountExists(gasBeneficiary)) { _stateProvider.CreateAccount(gasBeneficiary, (ulong)spentGas * gasPrice); } else { _stateProvider.AddToBalance(gasBeneficiary, (ulong)spentGas * gasPrice, spec); } } if (!readOnly) { _storageProvider.Commit(txTracer.IsTracingState ? txTracer : null); _stateProvider.Commit(spec, txTracer.IsTracingState ? txTracer : null); } else { _storageProvider.Reset(); _stateProvider.Reset(); } if (!readOnly) { block.GasUsed += spentGas; } if (txTracer.IsTracingReceipt) { if (statusCode == StatusCode.Failure) { txTracer.MarkAsFailed(recipient, (long)transaction.GasLimit); } else { txTracer.MarkAsSuccess(recipient, spentGas, substate.Output, substate.Logs.Any() ? substate.Logs.ToArray() : LogEntry.EmptyLogs); } } }
internal void setExecutionLevel(ExecutionType executionType) { ExecutionLevel = executionType; }
public ExecutionObject(ExecutionType executionType) { ExecutionType = executionType; }
private void SetData_ExecuteCode(object sender, EventArgs e) { string approversName = string.Empty; var approvers = GetApprovers(this.ApprovalData); approversName = String.Join(",", approvers.ToArray()); Approvers = approvers.Select(p => new TaskInfo() { Approver = p, MessageTitle = this.ApprovalData.MessageTitle, Message = this.ApprovalData.Message, MailEnable = this.ApprovalData.EnableEmail, TaskContentType = this.ApprovalData.TaskContenType, TaskTitle = this.ApprovalData.TaskTitle, AppendTitle = this.ApprovalData.AppendTitle, TaskInstruction = this.ApprovalData.TaskInstruction, DueDate = this.ApprovalData.DueDate, TaskDuration = this.ApprovalData.DurationPerTask, UpdatedProperties = this.ApprovalData.UpdatedProperties, TaskEvents = this.ApprovalData.TaskEvents, }).ToList(); MultiTaskReplicator_ExecutionType = (ExecutionType)Enum.Parse(typeof(ExecutionType), this.ApprovalData.TaskSequenceType); workflowProperties.LogToWorkflowHistory(SPWorkflowHistoryEventType.WorkflowComment, "Begin approval level: " + ApprovalData.LevelName , MultiTaskReplicator_ExecutionType.ToString()); workflowProperties.LogToWorkflowHistory(SPWorkflowHistoryEventType.WorkflowComment, "Tasks was created and sent to : " + approversName, string.Empty); }
private static XElement CreateFileElement(string path, string type, string library, ExecutionType assoc) { XElement element = new XElement(xm + "file"); element.SetAttributeValue(xm + "name", path); element.SetAttributeValue(xm + "type", type); if (!string.IsNullOrEmpty(library)) { element.Add(new XElement(xm + "library", new XAttribute(xm + "name", library))); } // Determine Association for sim/synthesis if (EnumHelpers.ExecutionTypeMatchesRequirement(ExecutionType.SimulationOnly, assoc)) { XElement childAssociation = new XElement(xm + "association"); childAssociation.SetAttributeValue(xm + "name", "BehavioralSimulation"); element.Add(childAssociation); } if (EnumHelpers.ExecutionTypeMatchesRequirement(ExecutionType.SynthesisOnly, assoc)) { XElement childAssociation = new XElement(xm + "association"); childAssociation.SetAttributeValue(xm + "name", "Implementation"); element.Add(childAssociation); } return element; }
public override object Execute(IEnumerable <object> args, Context context, ExecutionType executionType) => SystemCallInvoker.Execute(Representation, args.ToArray());
public bool Equals(BrowserConfiguration other) => ExecutionType.Equals(other?.ExecutionType) && BrowserType.Equals(other?.BrowserType) && ShouldCaptureHttpTraffic.Equals(other?.ShouldCaptureHttpTraffic) && Size.Equals(other?.Size) && ShouldAutomaticallyScrollToVisible.Equals(other?.ShouldAutomaticallyScrollToVisible);
public void ReportAction(long gas, UInt256 value, Address @from, Address to, ReadOnlyMemory <byte> input, ExecutionType callType, bool isPrecompileCall = false) => throw new OperationCanceledException(ErrorMessage);
public EvmState(long gasAvailable, ExecutionEnvironment env, ExecutionType executionType, bool isPrecompile, bool isTopLevel, bool isContinuation) : this(gasAvailable, env, executionType, isPrecompile, isTopLevel, -1, -1, 0L, 0L, false, isContinuation) { GasAvailable = gasAvailable; Env = env; }
public JsonNetResult CategoryTree(bool includeHidden = false, bool includeImages = false) { ExecutionType executionType = ExecutionType.local; Stopwatch stopWatch = new Stopwatch(); stopWatch.Start(); //Get the subdomain (if exists) for the api call string accountNameKey = Common.GetSubDomain(Request.Url); if (String.IsNullOrEmpty(accountNameKey)) { return(new JsonNetResult { Data = "Not found" }); //return Request.CreateResponse(HttpStatusCode.NotFound); } List <CategoryTreeModel> categoryTree = null; CategoryTreeJson categoryTreeJson = null; string localCacheKey = accountNameKey + ":categorytree:" + includeHidden + ":" + includeImages; #region (Plan A) Get json from local cache try { categoryTreeJson = (CategoryTreeJson)HttpRuntime.Cache[localCacheKey]; } catch (Exception e) { var error = e.Message; //TODO: Log: error message for local cache call } #endregion if (categoryTreeJson == null) { #region (Plan B) Get Public json from second layer of Redis Cache IDatabase cache = CoreServices.RedisConnectionMultiplexers.RedisMultiplexer.GetDatabase(); string pathAndQuery = Common.GetApiPathAndQuery(Request.Url); string hashApiKey = accountNameKey + ":apicache"; string hashApiField = pathAndQuery; try { var redisApiValue = cache.HashGet(hashApiKey, hashApiField); if (redisApiValue.HasValue) { categoryTreeJson = JsonConvert.DeserializeObject <CategoryTreeJson>(redisApiValue); executionType = ExecutionType.redis_secondary; } } catch { } #endregion if (categoryTreeJson == null) { #region (Plan C) Get category data from Redis Cache and rebuild try { //IDatabase cache = CoreServices.RedisConnectionMultiplexers.RedisMultiplexer.GetDatabase(); string hashMainKey = accountNameKey + ":categories"; string hashMainField = "tree:public"; if (includeHidden == true) { hashMainField = "tree:private"; } try { var redisValue = cache.HashGet(hashMainKey, hashMainField); if (redisValue.HasValue) { categoryTree = JsonConvert.DeserializeObject <List <ApplicationCategorizationService.CategoryTreeModel> >(redisValue); executionType = ExecutionType.redis_main; } } catch { } } catch (Exception e) { var error = e.Message; //TODO: Log: error message for Redis call } #endregion if (categoryTree == null) { #region (Plan D) Get data from WCF var applicationCategorizationServiceClient = new ApplicationCategorizationService.ApplicationCategorizationServiceClient(); try { applicationCategorizationServiceClient.Open(); categoryTree = applicationCategorizationServiceClient.GetCategoryTree(accountNameKey, includeHidden, Common.SharedClientKey).ToList(); executionType = ExecutionType.wcf; WCFManager.CloseConnection(applicationCategorizationServiceClient); } catch (Exception e) { #region Manage Exception string exceptionMessage = e.Message.ToString(); var currentMethod = System.Reflection.MethodBase.GetCurrentMethod(); string currentMethodString = currentMethod.DeclaringType.FullName + "." + currentMethod.Name; // Abort the connection & manage the exception WCFManager.CloseConnection(applicationCategorizationServiceClient, exceptionMessage, currentMethodString); #endregion } #endregion } } #region Transform into json object, add images & cache locally or locally and radisAPI layer if (categoryTreeJson != null) { //Just cache locally (we got json from the api redis layer) HttpRuntime.Cache.Insert(localCacheKey, categoryTreeJson, null, DateTime.Now.AddMinutes(Common.CategorizationCacheTimeInMinutes), TimeSpan.Zero); } else if (categoryTree != null) { //Transform categories into JSON and cache BOTH locally AND into redis categoryTreeJson = Transforms.Json.CategorizationTransforms.CategoryTree(accountNameKey, categoryTree, includeImages); HttpRuntime.Cache.Insert(localCacheKey, categoryTreeJson, null, DateTime.Now.AddMinutes(Common.CategorizationCacheTimeInMinutes), TimeSpan.Zero); try { cache.HashSet(hashApiKey, hashApiField, JsonConvert.SerializeObject(categoryTreeJson), When.Always, CommandFlags.FireAndForget); } catch { } } #endregion } if (categoryTreeJson != null) { //Add execution data stopWatch.Stop(); categoryTreeJson.executionType = "test"; categoryTreeJson.executionType = executionType.ToString(); categoryTreeJson.executionTime = stopWatch.Elapsed.TotalMilliseconds + "ms"; } JsonNetResult jsonNetResult = new JsonNetResult(); jsonNetResult.Formatting = Newtonsoft.Json.Formatting.Indented; jsonNetResult.SerializerSettings.DateTimeZoneHandling = DateTimeZoneHandling.Local; //<-- Convert UTC times to LocalTime jsonNetResult.Data = categoryTreeJson; return(jsonNetResult); }
public GasEstimationTests(bool useCreates) { _executionType = useCreates ? ExecutionType.Create : ExecutionType.Call; }
public void ReportCall(long gas, UInt256 value, Address @from, Address to, byte[] input, ExecutionType callType) { _currentTxTracer.ReportCall(gas, value, @from, to, input, callType); }
public void setExecutionType(ExecutionType executionType) { this.executionType = executionType; }