public ProgramPairResults(
ProgramResult debugResult, ProgramResult releaseResult,
ChecksumSite debugFirstUnmatch, ChecksumSite releaseFirstUnmatch)
{
DebugResult = debugResult;
ReleaseResult = releaseResult;
DebugFirstUnmatch = debugFirstUnmatch;
ReleaseFirstUnmatch = releaseFirstUnmatch;
}
private static long GetEnergyFee(long Energy_usage, long energy_frozen, long energy_total)
{
if (energy_total <= 0)
{
return(0);
}
BigInteger result = new BigInteger(energy_frozen);
result = BigInteger.Multiply(result, new BigInteger(Energy_usage));
result = BigInteger.Divide(result, new BigInteger(energy_total));
return((long)result);
}
public TestResult RunTest(string name, IMachine machine, ITestResultBin bin, IDictionary <string, string> env)
{
ITestResource res = Repo.GetResource(name);
TestResult tr = new TestResult();
try
{
string winDirectory = TestPathPrefix + name + "\\" + DateTime.Now.Ticks + "\\";
string targetFileName = winDirectory + name + ".bat";
using (Stream s = res.Read())
{
machine.PutFile(targetFileName, s);
}
ProgramResult result = machine.RunProgram(targetFileName, "", winDirectory, env);
// Hoover up artifacts *SLUURRRRRP*
var artifacts = machine.ListFiles(winDirectory);
foreach (var fileName in artifacts)
{
string tempFile = Path.GetTempFileName();
using (FileStream fs = File.Create(tempFile))
{
machine.GetFile(fileName, fs);
fs.Seek(0, SeekOrigin.Begin);
bin.PutArtifact(new ArtifactInfo()
{
Name = fileName,
Description = fileName,
FileName = fileName
}, fs);
}
File.Delete(tempFile);
}
tr.Success = result.ExitCode == 0;
} catch (Exception e)
{
tr.Success = false;
tr.StandardError = e.Message;
}
return(tr);
}
private static ProgramPairResults RunPairAsync(AssemblyLoadContext alc, ProgramPair pair)
{
ProgramResult debugResult = RunAndGetResultAsync(pair.Debug);
ProgramResult releaseResult = RunAndGetResultAsync(pair.Release);
ChecksumSite unmatch1 = null;
ChecksumSite unmatch2 = null;
if (debugResult.Checksum != releaseResult.Checksum && pair.TrackOutput)
{
int index;
int count = Math.Min(debugResult.ChecksumSites.Count, releaseResult.ChecksumSites.Count);
for (index = 0; index < count; index++)
{
ChecksumSite val1 = debugResult.ChecksumSites[index];
ChecksumSite val2 = releaseResult.ChecksumSites[index];
if (val1 != val2)
{
break;
}
}
if (index < debugResult.ChecksumSites.Count)
{
unmatch1 = debugResult.ChecksumSites[index];
}
if (index < releaseResult.ChecksumSites.Count)
{
unmatch2 = releaseResult.ChecksumSites[index];
}
}
return(new ProgramPairResults(debugResult, releaseResult, unmatch1, unmatch2));
ProgramResult RunAndGetResultAsync(byte[] bytes)
{
Assembly asm = alc.LoadFromStream(new MemoryStream(bytes));
MethodInfo mainMethodInfo = asm.GetType("Program").GetMethod("Main");
Action <IRuntime> entryPoint = (Action <IRuntime>)Delegate.CreateDelegate(typeof(Action <IRuntime>), mainMethodInfo);
var runtime = new Runtime();
List <ChecksumSite> TakeChecksumSites()
{
// A reference to the runtime stays in the loaded assembly and there may be a lot of checksum sites
// so during reduction this can use a lot of memory.
List <ChecksumSite> checksumSites = runtime.ChecksumSites;
runtime.ChecksumSites = null;
return(checksumSites);
}
if (pair.TrackOutput)
{
runtime.ChecksumSites = new List <ChecksumSite>();
}
int threadID = Environment.CurrentManagedThreadId;
List <Exception> exceptions = null;
void FirstChanceExceptionHandler(object sender, FirstChanceExceptionEventArgs args)
{
if (Environment.CurrentManagedThreadId == threadID)
{
(exceptions ??= new List <Exception>()).Add(args.Exception);
}
}
AppDomain.CurrentDomain.FirstChanceException += FirstChanceExceptionHandler;
try
{
entryPoint(runtime);
}
catch
{
// We consider the innermost exception the root cause and only report it.
// Otherwise we may be confusing the viewer about what the problem is.
// Consider for example (adapted from a real example):
// try
// {
// value = -1;
// FunctionThatJitAssertsInDebug();
// value = 1;
// }
// finally
// {
// int.MinValue / value;
// }
// We are interested in the JIT assert that was hit, and not the OverflowException
// thrown because value = 1 did not get to run.
Exception ex = exceptions[0];
if (ex is InvalidProgramException && ex.Message.Contains("JIT assert failed"))
{
return(new ProgramResult
{
Kind = ProgramResultKind.HitsJitAssert,
Checksum = runtime.FinishHashCode(),
ChecksumSites = TakeChecksumSites(),
JitAssertError = ex.Message,
});
}
return(new ProgramResult
{
Kind = ProgramResultKind.ThrowsException,
Checksum = runtime.FinishHashCode(),
ChecksumSites = TakeChecksumSites(),
ExceptionType = ex.GetType().FullName,
ExceptionText = ex.ToString(),
ExceptionStackTrace = ex.StackTrace,
});
}
finally
{
AppDomain.CurrentDomain.FirstChanceException -= FirstChanceExceptionHandler;
}
return(new ProgramResult
{
Kind = ProgramResultKind.RunsSuccessfully,
Checksum = runtime.FinishHashCode(),
ChecksumSites = TakeChecksumSites(),
});
}
}
private ProgramResult RunControllerSoftwareWithFeedback(int[] memory, ProgramResult state, Sys device, int input)
{
device.Write(input);
return(state.Resume(memory));
}
public void Go()
{
try
{
if (this.vm != null)
{
TransactionCapsule tx = new TransactionCapsule(this.transaction);
if (null != this.block &&
this.block.IsGenerateMyself &&
tx.ContractResult != contractResult.Unknown &&
tx.ContractResult == contractResult.OutOfTime)
{
this.result = this.program.Result;
this.program.SpendAllEnergy();
OutOfTimeException e = VMExceptions.AlreadyTimeOut();
this.runtime_error = e.Message;
this.result.Exception = e;
throw e;
}
vm.Play(program);
this.result = this.program.Result;
if (this.is_static_call)
{
long call_value = TransactionCapsule.GetCallValue(this.transaction.RawData.Contract[0]);
long call_token_value = TransactionCapsule.GetCallTokenValue(this.transaction.RawData.Contract[0]);
if (call_value > 0 || call_token_value > 0)
{
this.runtime_error = "constant cannot set call value or call token value.";
this.result.RejectInternalTransaction();
}
return;
}
if (this.transaction_type == TransactionType.TX_CONTRACT_CREATION_TYPE &&
!this.result.IsRevert)
{
byte[] code = this.program.Result.HReturn;
long save_code_energy = (long)code.Length * EnergyCost.CREATE_DATA;
long after_Spend = this.program.EnergyLimitLeft.ToLong() - save_code_energy;
if (after_Spend < 0)
{
if (this.result.Exception == null)
{
this.result.Exception = VMExceptions.NotEnoughSpendEnergy(
"save just created contract code",
save_code_energy,
this.program.EnergyLimitLeft.ToLong());
}
}
else
{
this.result.SpendEnergy(save_code_energy);
if (VMConfig.AllowTvmConstantinople)
{
this.deposit.SaveCode(this.program.ContractAddress.GetNoLeadZeroesData(), code);
}
}
}
if (this.result.Exception != null || this.result.IsRevert)
{
this.result.DeleteAccount.Clear();
this.result.LogInfos.Clear();
this.result.ResetFutureRefund();
this.result.RejectInternalTransaction();
if (this.result.Exception != null)
{
if (!(this.result.Exception is TransferException))
{
this.program.SpendAllEnergy();
}
this.runtime_error = this.result.Exception.Message;
throw this.result.Exception;
}
else
{
this.runtime_error = "REVERT opcode executed";
}
}
else
{
this.deposit.Commit();
if (this.log_info_parser != null)
{
List <ContractTrigger> triggers = this.log_info_parser.ParseLogInfos(this.program.Result.LogInfos, this.deposit);
this.program.Result.Triggers = triggers;
}
}
}
else
{
this.deposit.Commit();
}
}
catch (VMStackOverFlowException e)
{
this.program.SpendAllEnergy();
this.result = this.program.Result;
this.result.Exception = e;
this.result.RejectInternalTransaction();
this.runtime_error = this.result.Exception.Message;
Logger.Info("JVMStackOverFlowException : " + this.result.Exception.Message);
}
catch (OutOfTimeException e)
{
this.program.SpendAllEnergy();
this.result = this.program.Result;
this.result.Exception = e;
this.result.RejectInternalTransaction();
this.runtime_error = result.Exception.Message;
Logger.Info("timeout : " + this.result.Exception.Message);
}
catch (System.Exception e)
{
if (!(e is TransferException))
{
this.program.SpendAllEnergy();
}
this.result = this.program.Result;
this.result.RejectInternalTransaction();
if (this.result.Exception == null)
{
Logger.Error(e.Message);
this.result.Exception = new System.Exception("Unknown exception");
}
if (this.runtime_error == null || this.runtime_error.Length == 0)
{
this.runtime_error = this.result.Exception.Message;
}
Logger.Info("runtime result is : " + this.result.Exception.Message);
}
this.trace.SetBill(this.result.EnergyUsed);
}
public async Task <IActionResult> Result(int id, string filePath)
{
Problem problem = await dbContext.Problems.Include(m => m.Tests).FirstOrDefaultAsync(p => p.ProblemID == id);
if (problem == null)
{
return(RedirectToAction(nameof(List)));
}
if (!System.IO.File.Exists(filePath))
{
return(RedirectToAction(nameof(Solve), new { id }));
}
string parentFolderPath = Directory.GetParent(filePath).FullName;
ResultViewModel viewModel = new ResultViewModel()
{
ProblemID = problem.ProblemID,
Name = problem.Name,
ShowFailedTestCases = problem.ShowFailedTestCases
};
UserProgram userProgram = new UserProgram();
var result = userProgram.SetSource(filePath);
viewModel.CompilationResult = result;
if (result.Status == UserProgram.Result.StatusType.Failed)
{
Directory.Delete(parentFolderPath, true);
return(View(viewModel));
}
result = userProgram.Compile();
viewModel.CompilationResult = result;
if (result.Status == UserProgram.Result.StatusType.Failed)
{
Directory.Delete(parentFolderPath, true);
viewModel.CompilationResult = result;
return(View(viewModel));
}
int passed = 0;
foreach (Test t in problem.Tests)
{
result = userProgram.Execute(t.GivenInput);
ResultViewModel.TestResult testResult = new ResultViewModel.TestResult()
{
Test = t, ExecutionResult = result
};
if (result.Status == UserProgram.Result.StatusType.Successful)
{
// Format expected output lines
string[] expectedOutputLines = t.ExpectedOutput.Split('\n');
for (int i = 0; i < expectedOutputLines.Length; i++)
{
expectedOutputLines[i] = expectedOutputLines[i].Trim('\u202c').Trim();
}
result = userProgram.EvaluateAndGetResultIfFailed(expectedOutputLines);
if (result.Status == UserProgram.Result.StatusType.Successful)
{
passed++;
}
testResult.EvaluationResult = result;
viewModel.TestResults.Add(testResult);
}
else
{
viewModel.TestResults.Add(testResult);
}
}
viewModel.PassedTests = passed;
try
{
Directory.Delete(parentFolderPath, true);
}
catch (UnauthorizedAccessException) // Sometimes the process isn't killed fast enough
{
Thread.Sleep(100);
Directory.Delete(parentFolderPath, true);
}
ApplicationUser partialUser = await userManager.GetUserAsync(User);
ApplicationUser currentUser = await userManager.Users
.Include(u => u.ProblemResults)
.ThenInclude(r => r.FirstResult)
.Include(u => u.ProblemResults)
.ThenInclude(r => r.BestResult)
.FirstOrDefaultAsync(u => u == partialUser);
if (currentUser != null)
{
bool hasProblem = currentUser.ProblemResults.Exists(r => r.ProblemID == problem.ProblemID);
bool gotPerfectPercentage = false;
if (hasProblem)
{
ProblemResult problemResult = currentUser.ProblemResults.Where(r => r.ProblemID == problem.ProblemID).First();
int bestPercentage = problemResult.BestResult.PercentageResult;
gotPerfectPercentage = bestPercentage < 100;
}
bool isAdmin = await userManager.IsInRoleAsync(currentUser, "Admin");
// A unique user solved the problem and is not an Admin
if (passed == problem.Tests.Count && (!hasProblem || (hasProblem && gotPerfectPercentage)) && !isAdmin)
{
problem.TimesSolved++;
if (await TryUpdateModelAsync(problem))
{
try
{
await dbContext.SaveChangesAsync();
}
catch (DbUpdateException)
{
return(View(viewModel));
}
}
}
ProgramResult programResult = viewModel.GetProgramResult();
if (currentUser.ProblemResults.Exists(r => r.ProblemID == problem.ProblemID))
{
// Tried to solve the problem again
ProblemResult problemResult = currentUser.ProblemResults.First(r => r.ProblemID == problem.ProblemID);
if (programResult.PercentageResult > problemResult.BestResult.PercentageResult)
{
if (problemResult.BestResult != problemResult.FirstResult)
{
dbContext.Remove(problemResult.BestResult);
}
problemResult.BestResult = programResult;
}
}
else
{
// Solved this problem for the first time
ProblemResult problemResult = new ProblemResult()
{
ProblemID = problem.ProblemID,
FirstResult = programResult,
BestResult = programResult
};
currentUser.ProblemResults.Add(problemResult);
}
await userManager.UpdateAsync(currentUser);
}
return(View(viewModel));
}
public static TransactionInfoCapsule BuildInstance(TransactionCapsule transaction, BlockCapsule block, TransactionTrace trace)
{
TransactionInfo result = new TransactionInfo();
ReceiptCapsule receipt = trace.Receipt;
result.Result = TransactionInfo.Types.code.Sucess;
if (trace.RuntimeError.IsNotNullOrEmpty() ||
trace.Result.Exception != null)
{
result.Result = TransactionInfo.Types.code.Failed;
result.ResMessage = ByteString.CopyFromUtf8(trace.RuntimeError);
}
result.Id = ByteString.CopyFrom(transaction.Id.Hash);
ProgramResult program_result = trace.Result;
long fee = program_result.TransactionResult.Fee
+ receipt.EnergyFee
+ receipt.NetFee
+ receipt.MultiSignFee;
result.Fee = fee;
result.ContractResult.Add(ByteString.CopyFrom(program_result.HReturn));
result.ContractAddress = ByteString.CopyFrom(program_result.ContractAddress);
result.UnfreezeAmount = program_result.TransactionResult.UnfreezeAmount;
result.AssetIssueID = program_result.TransactionResult.AssetIssueID;
result.ExchangeId = program_result.TransactionResult.ExchangeId;
result.WithdrawAmount = program_result.TransactionResult.WithdrawAmount;
result.ExchangeReceivedAmount = program_result.TransactionResult.ExchangeReceivedAmount;
result.ExchangeInjectAnotherAmount = program_result.TransactionResult.ExchangeInjectAnotherAmount;
result.ExchangeWithdrawAnotherAmount = program_result.TransactionResult.ExchangeWithdrawAnotherAmount;
List <TransactionInfo.Types.Log> logs = new List <TransactionInfo.Types.Log>();
program_result.LogInfos.ForEach(info => logs.Add(LogInfo.BuildLog(info)));
result.Log.AddRange(logs);
if (block != null)
{
result.BlockNumber = block.Instance.BlockHeader.RawData.Number;
result.BlockTimeStamp = block.Instance.BlockHeader.RawData.Timestamp;
}
result.Receipt = receipt.Receipt;
if (Args.Instance.VM.SaveInternalTx == true && program_result.InternalTransactions != null)
{
foreach (var tx in program_result.InternalTransactions)
{
Protocol.InternalTransaction internal_transaction = new Protocol.InternalTransaction();
internal_transaction.Hash = ByteString.CopyFrom(tx.Hash);
internal_transaction.CallerAddress = ByteString.CopyFrom(tx.SendAddress);
internal_transaction.TransferToAddress = ByteString.CopyFrom(tx.TransferToAddress);
CallValueInfo call_value_info = new CallValueInfo();
call_value_info.CallValue = tx.Value;
internal_transaction.CallValueInfo.Add(call_value_info);
foreach (var token_info in tx.TokenInfo)
{
call_value_info = new CallValueInfo();
call_value_info.TokenId = token_info.Key;
call_value_info.CallValue = token_info.Value;
internal_transaction.CallValueInfo.Add(call_value_info);
}
internal_transaction.Note = ByteString.CopyFrom(Encoding.UTF8.GetBytes(tx.Note));
internal_transaction.Rejected = tx.IsReject;
result.InternalTransactions.Add(internal_transaction);
}
}
return(new TransactionInfoCapsule(result));
}
