public ProcessResult FillContent(XElement contentControl, IEnumerable<IContentItem> items)
{
var processResult = new ProcessResult();
var handled = false;
foreach (var contentItem in items)
{
var itemProcessResult = FillContent(contentControl, contentItem);
if (!itemProcessResult.Handled) continue;
handled = true;
if (!itemProcessResult.Success)
processResult.Errors.AddRange(itemProcessResult.Errors);
}
if (!handled) return ProcessResult.NotHandledResult;
if (processResult.Success && _isNeedToRemoveContentControls)
{
// Remove the content control for the table and replace it with its contents.
foreach (var xElement in contentControl.AncestorsAndSelf(W.sdt))
{
xElement.RemoveContentControl();
}
}
return processResult;
}
public ProcessResult Start()
{
ProcessResult totalResult = new ProcessResult();
if (!_fileSystem.DirectoryExists(_settings.BasePath))
{
_fileSystem.CreateDirectory(_settings.BasePath);
}
string subdir = CreateNewSubdirName(DateTime.Now);
_settings.UpdateOutputPath(subdir);
if (!_fileSystem.DirectoryExists(_settings.OutputPath))
{
_fileSystem.CreateDirectory(_settings.OutputPath);
}
foreach (BaseProcess process in _processes)
{
totalResult = process.Process();
if (totalResult.ResultCode == ExitCode.Failure)
{
break;
}
}
CleanUp();
return totalResult;
}
public void SetValues(ProcessResult result)
{
this.buttonTestDetails.Visible = false;
_result = result;
if (result.TestResults != null)
{
this.labelTestsFailingCount.Text = result.TestResults.CountFailed.ToString();
this.labelTestsPassingCount.Text = result.TestResults.CountPassed.ToString();
this.labelTestsExecutedCount.Text = result.TestResults.CountExecuted.ToString();
if (result.TestResults.CountFailed > 0)
{
this.buttonTestDetails.Visible = true;
}
if (result.TestResults.CoveredAssemblies != null)
{
foreach (CoveredAssembly assembly in result.TestResults.CoveredAssemblies)
{
listBoxCoverage.Items.Add(assembly.Name + " " + assembly.GetCoverage().ToString() + "%");
}
}
}
}
/// <summary>
/// Creates a processing result with the specified state.
/// </summary>
/// <param name="state">The state.</param>
/// <param name="message">The message.</param>
/// <returns></returns>
public static ProcessResult Create(ProcessState state, string message)
{
var result = new ProcessResult();
result.State = state;
result.Message = message;
return result;
}
public ProcessResult Execute(ProcessInfo processInfo, ProjectItem item, TaskExecutionContext context)
{
var outputFile = context.GeneratePathInWorkingDirectory(item.NameOrType + ".log");
if ((this.Item == null) || (this.Context == null))
{
return this.Execute(processInfo,
item.Project.Name,
item.NameOrType,
outputFile);
}
Assert.AreEqual(this.FileName, processInfo.FileName);
var actual = processInfo.Arguments == null ? null : processInfo.Arguments.ToString();
Assert.AreEqual(this.Arguments, actual);
Assert.AreEqual(this.WorkingDirectory, processInfo.WorkingDirectory);
Assert.AreSame(this.Item, item);
Assert.AreEqual(this.Context, context);
var fileSystemMock = new Mock<IFileSystem>();
fileSystemMock.Setup(fs => fs.OpenFileForRead(outputFile)).Returns(new MemoryStream());
var result = new ProcessResult(
fileSystemMock.Object,
outputFile,
this.ExitCode,
this.TimedOut,
this.Failed);
return result;
}
public void doWork(BackgroundWorker worker, DoWorkEventArgs args)
{
Exception processEx = null;
Thread.CurrentThread.CurrentUICulture = new CultureInfo(Constantes.language);
this.modLog.Info(String.Format("Starting worker thread: [{0}]", this.getType().ToString()));
try
{
this.doSpecificWork(worker, args);
}
catch (Exception ex) {
processEx = ex;
}
finally
{
try
{
ProcessResult pr = new ProcessResult(this.getType());
pr.ProcessException = processEx;
pr.ProcessOutput = args.Result;
if (returnUpdatedDbStats)
{
pr.DbStatistics = this.chargeData.getDbStatistics();
}
// Cambiamos el resultado del objeto 'DoWorkEventArgs' (lo que devolvemos hacia fuera) por nuestro
// objeto ProcessResult, que además de tener el resultado como tal (processOutput) tiene incluida
// la posible excepción que el proceso haya podido lanzar, y las estadísticas actualizadas de BBDD.
args.Result = pr;
}
catch (Exception) { }
}
this.modLog.Info(String.Format("Finished worker thread: [{0}]", this.getType().ToString()));
}
public void Match(Func<AccountLine, AccountLine, bool> matchmethod)
{
this.match = matchmethod;
ProcessResult pRes = new ProcessResult(skbRepo.GetAll(), true);
do
{
pRes = ProcessMatches(pRes.UnMatched);
} while (pRes.AnyChange);
}
/// <summary>
/// Get modified files
/// </summary>
/// <param name="processResult">stdout process result</param>
/// <param name="from">start date and time (not used)</param>
/// <param name="to">end date and time (not used)</param>
/// <returns></returns>
public Modification[] GetModifications(ProcessResult processResult, DateTime from, DateTime to)
{
Modification[] Result = null;
string StdOut = processResult.StandardOutput;
StringReader reader = new StringReader(StdOut);
JediVCSFileInfoList Files = GetJediVCSFileInfoList(reader);
Result = GetModifiedFiles(Files);
return Result;
}
public static void Log(ProcessResult result)
{
using (var stream = File.Open(path, FileMode.Open, FileAccess.Write))
{
results.Add(result);
var serializer = new DataContractJsonSerializer(typeof(List<ProcessResult>));
serializer.WriteObject(stream, results);
stream.Flush();
}
}
public void GetModificationsDoesNotCreateLabelWhenThereAreNoModifications()
{
ProcessResult result = new ProcessResult("",string.Empty, 0, false);
Modification[] emptyArray = new Modification[0];
_historyParser.SetupResult("Parse", emptyArray, typeof(TextReader), typeof(DateTime), typeof(DateTime));
_executor.ExpectAndReturn("Execute", result, new IsTypeOf(typeof(ProcessInfo)));
_executor.ExpectNoCall("Execute", typeof(ProcessInfo));
_vss.GetModifications(IntegrationResultMother.CreateSuccessful(DateTime.Now), IntegrationResultMother.CreateSuccessful(DateTime.Now));
}
public ProcessTaskResult(ProcessResult result)
{
this.result = result;
if (Failed())
{
Log.Info("Task execution failed");
Log.Info("Task output: " + result.StandardOutput);
if (! StringUtil.IsBlank(result.StandardError)) Log.Info("Task error: " + result.StandardError);
}
}
public static bool TryExecuteJava(string command, out ProcessResult result)
{
if (command == null)
throw new ArgumentNullException("command");
var javaPath = GetJavaInstallationPath() + "\\bin\\";
var filename = javaPath + "java.exe";
return TryExecute(filename, command, out result);
}
/// <summary>
/// Formata a saída
/// </summary>
/// <param name="word"></param>
/// <param name="pos"></param>
/// <param name="deadCats"></param>
private static void FormatOutput(string word, ProcessResult result)
{
if (!result.found)
{
Console.WriteLine(String.Format("Palavra não encontrada. Gatos mortos = {2}", word, result.index.ToString(), result.deadCats.ToString()));
}
else
{
Console.WriteLine(String.Format("Palavra '{0}' encontrada na posição {1}. Gatos mortos = {2}", word, result.index.ToString(), result.deadCats.ToString()));
}
}
/// <summary>
/// Constructor of ProcessTaskResult
/// </summary>
/// <param name="result">Process result data.</param>
/// <param name="ignoreStandardOutputOnSuccess">Set this to true if you do not want the standard output (stdout) of the process to be merged in the build log; otherwise false.</param>
public ProcessTaskResult(ProcessResult result, bool ignoreStandardOutputOnSuccess)
{
this.result = result;
this.ignoreStandardOutputOnSuccess = ignoreStandardOutputOnSuccess;
if (this.CheckIfSuccess())
{
Log.Info("Task output: " + result.StandardOutput);
string input = result.StandardError;
if (!string.IsNullOrEmpty(input))
Log.Info("Task error: " + result.StandardError);
}
}
public void LogStatistics(Settings settings, ProcessResult result)
{
DateTime now = DateTime.Now;
string path = GetLogFilePath(now, settings);
string timestamp = GetTimeStamp(now);
XmlDocument doc = GetXmlDocument(path);
XmlNode root = GetRootNode(doc);
AppendTimestampNode(result, timestamp, doc, root);
Save(doc, path);
}
public void ReadStandardErrorOnlyReturnsOutputLines()
{
var filename = "testoutput.txt";
var fileSystemMock = GenerateFileSystemMock(filename, "OLine 1", "ELine 2");
var result = new ProcessResult(
fileSystemMock.Object,
filename,
0,
false);
var actual = result.ReadStandardError().ToArray();
var expected = new[] { "Line 2" };
CollectionAssert.AreEqual(expected, actual);
}
public void FillContent(XElement contentControl, IContentItem item)
{
if (!(item is ImageContent))
{
_processResult = ProcessResult.NotHandledResult;
return;
}
var field = item as ImageContent;
// If image bytes was not provided, then doing nothing
if (field.Binary == null || field.Binary.Length == 0) { return; }
// If there isn't a field with that name, add an error to the error string,
// and continue with next field.
if (contentControl == null)
{
_processResult.Errors.Add(String.Format("Field Content Control '{0}' not found.",
field.Name));
return;
}
var blip = contentControl.DescendantsAndSelf(A.blip).First();
if (blip == null)
{
_processResult.Errors.Add(String.Format("Image to replace for '{0}' not found.",
field.Name));
return;
}
// Creating a new image part
var imagePart = _context.WordDocument.MainDocumentPart.AddImagePart(field.MIMEType);
// Writing image bytes to it
using (BinaryWriter writer = new BinaryWriter(imagePart.GetStream()))
{
writer.Write(field.Binary);
}
// Setting reference for CC to newly uploaded image
blip.Attribute(R.embed).Value = _context.WordDocument.MainDocumentPart.GetIdOfPart(imagePart);
//var imageId = blip.Attribute(R.embed).Value;
//var xmlPart = _context.WordDocument.MainDocumentPart.GetPartById(imageId);
//if (xmlPart is ImagePart)
//{
// ImagePart imagePart = xmlPart as ImagePart;
// using (BinaryWriter writer = new BinaryWriter(imagePart.GetStream()))
// {
// writer.Write(field.Binary);
// }
//}
}
public ProcessResult FillContent(XElement contentControl, IEnumerable<IContentItem> items)
{
_processResult = new ProcessResult();
foreach (var contentItem in items)
{
FillContent(contentControl, contentItem);
}
if (_processResult.Success && _isNeedToRemoveContentControls)
contentControl.RemoveContentControl();
return _processResult;
}
public static bool TryExecute(string filename, string args, out ProcessResult result)
{
// Set HomeDirectory for shorter paths ?
if (filename == null)
throw new ArgumentNullException("filename");
if (args == null)
args = string.Empty;
string output = string.Empty;
string error = string.Empty;
int exitCode = -1;
var processStartInfo = new ProcessStartInfo(filename, args)
{
CreateNoWindow = true,
WindowStyle = ProcessWindowStyle.Hidden,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true
// WorkingDirectory ?
};
// Try Execute
try
{
using (var process = Process.Start(processStartInfo))
{
output = process.StandardOutput.ReadToEnd();
error = process.StandardError.ReadToEnd();
exitCode = process.ExitCode;
//if (!process.HasExited) // Needed ? Dispose will probably fix this ?
// process.Kill();
}
}
catch (Exception e)
{
// Store exeception in ExecuteResult ?
// Log error somehow ? try/catch in caller instead ?
// Output to output, or ErrorList ?
}
result = new ProcessResult(output, error, exitCode);
return result.ExitCode == 0;
}
public static ProcessResult StartProcess(string workingDirectory, string cmdName, string argument, ProcessWindowStyle style = ProcessWindowStyle.Hidden)
{
ProcessResult rlt = new ProcessResult();
Process proc = new Process();
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.FileName = cmdName;
proc.StartInfo.Arguments = argument;
proc.StartInfo.WindowStyle = style;
proc.StartInfo.WorkingDirectory = workingDirectory;
proc.StartInfo.CreateNoWindow = true;
proc.Start();
StreamReader reader = proc.StandardOutput;
proc.WaitForExit();
rlt.Process = proc;
return rlt;
}
public void LogEvent_BuildFailure_AddEvent_EvellntAdded()
{
Settings settings = new Settings();
settings.BasePath = @"c:\";
StatisticsLoggerStub stub = new StatisticsLoggerStub();
ProcessResult r = new ProcessResult();
r.TestResults.CoveredAssemblies = new CoveredAssemblySet();
CoveredAssembly assembly = new CoveredAssembly();
assembly.Name = "thename";
r.TestResults.CoveredAssemblies.Add(assembly);
stub.LogStatistics(settings, r);
Assert.AreEqual(1, stub.XmlDocument.SelectNodes("timestamps/timestamp/assembly[@id='thename']").Count);
Assert.IsTrue(stub.IsSaved);
}
public void ConstructorSetsPropertiesForError()
{
var filename = "testoutput.txt";
var fileSystemMock = GenerateFileSystemMock(filename, "OLine 1", "ELine 2");
var exitCode = 32;
var result = new ProcessResult(
fileSystemMock.Object,
filename,
exitCode,
false);
Assert.AreEqual(filename, result.OutputPath);
Assert.AreEqual(exitCode, result.ExitCode);
Assert.IsFalse(result.TimedOut);
Assert.IsTrue(result.Failed);
Assert.IsFalse(result.Succeeded);
Assert.AreEqual(1, result.NumberOfOutputLines);
Assert.AreEqual(1, result.NumberOfErrorLines);
Assert.IsTrue(result.HasErrorOutput);
}
public void FillContent(XElement contentControl, IContentItem item)
{
if (!(item is FieldContent))
{
_processResult = ProcessResult.NotHandledResult;
return;
}
var field = item as FieldContent;
// If there isn't a field with that name, add an error to the error string,
// and continue with next field.
if (contentControl == null)
{
_processResult.Errors.Add(String.Format("Field Content Control '{0}' not found.",
field.Name));
return;
}
contentControl.ReplaceContentControlWithNewValue(field.Value);
}
/// <summary>
/// Creates a new process and adds it to the tracking list.
/// </summary>
/// <returns>New Process objects</returns>
public static ProcessResult CreateProcess(string AppName, bool bAllowSpew, string LogName, Dictionary<string, string> Env = null, UnrealBuildTool.LogEventType SpewVerbosity = UnrealBuildTool.LogEventType.Console)
{
var NewProcess = HostPlatform.Current.CreateProcess(LogName);
if (Env != null)
{
foreach (var EnvPair in Env)
{
if (NewProcess.StartInfo.EnvironmentVariables.ContainsKey(EnvPair.Key))
{
NewProcess.StartInfo.EnvironmentVariables.Remove(EnvPair.Key);
}
if (!String.IsNullOrEmpty(EnvPair.Value))
{
NewProcess.StartInfo.EnvironmentVariables.Add(EnvPair.Key, EnvPair.Value);
}
}
}
var Result = new ProcessResult(AppName, NewProcess, bAllowSpew, LogName, SpewVerbosity: SpewVerbosity);
AddProcess(Result);
return Result;
}
public ProcessResult Pay(string dataPackage, string key, string iv)
{
//положить деньги в банк:
ProcessResult res = new ProcessResult();
string xml = String.Empty;
try
{
string decryptedKey = CryptoHelper.RSADecrypt(key);
string decryptedIV = CryptoHelper.RSADecrypt(iv);
xml = CryptoHelper.SymmetricDecrypt(dataPackage, decryptedKey, decryptedIV);
}
catch (Exception e)
{
res.content = "Error: " + e.Message;
res.signature = CryptoHelper.Sign(res.content);
return res;
}
Models.Payment pay = GetPaymentInstanceByInfo(xml);
res.content = PaymentDAL.Instance.AddMoneyToAccount(pay).ToString();
PaymentDAL.Instance.AddPaymentToDatabase(pay);
res.signature = CryptoHelper.Sign(res.content);
return res;
}
public async Task StatusChanged(ProcessResult processResult)
{
}
override public ProcessResult Process(ProcessResult lastSiblingResult, TriggerObject trigObject) // lastSiblingResult used for conditionals
{
return(ProcessResult.Break);
}
/// <summary>
/// Performs the actions needed to add an authentication challenge to the inner IHttpActionResult, if needed.
/// </summary>
///
/// <param name="context">The authentication challenge context to consider.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
///
/// <returns>A Task that will perform the authentication challenge.</returns>
///
/// <remarks>
/// This method will be executed by the framework after the action has executed, regardless of whether or not a challenge
/// should be generated. Before generating the challenge, determine if it
/// </remarks>
///
public async Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var request = context.Request;
// If there was an authenticated principal associated with the request or there was a result generated that should not
// overridden, then no challenge is needed.
if ((cancellationToken.IsCancellationRequested) || (request.GetRequestContext()?.Principal != null) || (!OrderFulfillmentAuthenticateAttributeAttribute.ShouldOverrideResponse(context)))
{
return;
}
var result = OrderFulfillmentAuthenticateAttributeAttribute.ProcessRequest(request, cancellationToken, true);
// If there was no available handler located after processing the request, then attempt to retrieve the
// default challenge handler.
if (result == null)
{
var handler = OrderFulfillmentAuthenticateAttributeAttribute.SelectDefaultChallengeHandler(request.GetDependencyScope());
if (handler != null)
{
result = new ProcessResult(OrderFulfillmentAuthenticateAttributeAttribute.EmptyStringDictionary, handler);
}
}
// If there was no available challenge handler, authentication is not possible. Make
// no alterations to the current response.
if ((cancellationToken.IsCancellationRequested) || (result == null))
{
return;
}
// If the handler was able to produce a challenge, then clear any existing result/response and
// set the new Unauthorized with the correct challenge.
var challenge = result.AuthenticationHandler.GenerateChallenge(result.AuthenticationTokens, context);
if (challenge != null)
{
context.ActionContext.Response?.Dispose();
context.ActionContext.Response = null;
context.Result = new UnauthorizedResult(new[] { challenge }, request);
try
{
var locator = request.GetDependencyScope();
var logger = (locator.GetService(typeof(ILogger)) as ILogger);
if (logger != null)
{
var body = await request.SafeReadContentAsStringAsync();
logger.WithCorrelationId(request?.GetOrderFulfillmentCorrelationId())
.Information($"Response: {{Response}} { Environment.NewLine } Authentication is needed; a challenge was issued for {{Route}} with Headers: [{{Headers}}]",
HttpStatusCode.Unauthorized,
request?.RequestUri,
request?.Headers);
}
}
catch
{
// Do nothing; logging is a non-critical operation that should not cause
// cascading failures.
}
}
}
private void ExpectToExecuteWithArgumentsAndReturn(string args, ProcessResult returnValue)
{
mockProcessExecutor.ExpectAndReturn("Execute", returnValue, NewProcessInfo(args, DefaultWorkingDirectory));
}
private static bool IsAlias(string command)
{
ProcessResult result = ProcessHelper.Run("git", "config --get alias." + command);
return(!string.IsNullOrEmpty(result.Output));
}
static void PrintExitCode(ProcessResult result)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine($"Process exited with code {result.ExitCode}.");
Console.ResetColor();
}
public void SubmitsTracesWithNetStandard(string packageVersion, bool enableCallTarget)
{
SetCallTargetSettings(enableCallTarget);
// ALWAYS: 77 spans
// - NpgsqlCommand: 21 spans (3 groups * 7 spans)
// - DbCommand: 42 spans (6 groups * 7 spans)
// - IDbCommand: 14 spans (2 groups * 7 spans)
//
// NETSTANDARD: +56 spans
// - DbCommand-netstandard: 42 spans (6 groups * 7 spans)
// - IDbCommand-netstandard: 14 spans (2 groups * 7 spans)
//
// CALLTARGET: +7 spans
// - IDbCommandGenericConstrant<NpgsqlCommand>: 7 spans (1 group * 7 spans)
//
// NETSTANDARD + CALLTARGET: +7 spans
// - IDbCommandGenericConstrant<NpgsqlCommand>-netstandard: 7 spans (1 group * 7 spans)
#if NET452
var expectedSpanCount = 77;
#else
var expectedSpanCount = 133;
#endif
if (enableCallTarget)
{
#if NET452
expectedSpanCount = 84;
#else
expectedSpanCount = 147;
#endif
}
const string dbType = "postgres";
const string expectedOperationName = dbType + ".query";
const string expectedServiceName = "Samples.Npgsql-" + dbType;
// NOTE: opt into the additional instrumentation of calls into netstandard.dll
// see https://github.com/DataDog/dd-trace-dotnet/pull/753
SetEnvironmentVariable("OTEL_TRACE_NETSTANDARD_ENABLED", "true");
int agentPort = TcpPortProvider.GetOpenPort();
using (var agent = new MockTracerAgent(agentPort))
using (ProcessResult processResult = RunSampleAndWaitForExit(agent.Port, packageVersion: packageVersion))
{
Assert.True(processResult.ExitCode >= 0, $"Process exited with code {processResult.ExitCode}");
var spans = agent.WaitForSpans(expectedSpanCount, operationName: expectedOperationName);
int actualSpanCount = spans.Where(s => s.ParentId.HasValue).Count(); // Remove unexpected DB spans from the calculation
// Assert.Equal(expectedSpanCount, spans.Count); // Assert an exact match once we can correctly instrument the generic constraint case
if (enableCallTarget)
{
Assert.Equal(expectedSpanCount, actualSpanCount);
}
else
{
Assert.True(actualSpanCount == expectedSpanCount || actualSpanCount == expectedSpanCount + 4, $"expectedSpanCount={expectedSpanCount}, expectedSpanCount+4={expectedSpanCount + 4}, actualSpanCount={actualSpanCount}");
}
foreach (var span in spans)
{
Assert.Equal(expectedOperationName, span.Name);
Assert.Equal(expectedServiceName, span.Service);
Assert.Equal(SpanTypes.Sql, span.Type);
Assert.Equal(dbType, span.Tags[Tags.DbType]);
Assert.False(span.Tags?.ContainsKey(Tags.Version), "External service span should not have service version tag.");
}
}
}
private static Task <ProcessResult> StartProcessFull(
string command,
ProcessPriorityClass priorityClass,
ProcessTaskParams parameters,
Action <string> progress,
CancellationToken?cancellation,
params string[] arguments)
{
var proc = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = command,
Arguments = string.Join(" ", arguments),
RedirectStandardError = true,
RedirectStandardOutput = true,
CreateNoWindow = true,
UseShellExecute = false,
ErrorDialog = false,
StandardOutputEncoding = Encoding.UTF8,
StandardErrorEncoding = Encoding.UTF8,
},
EnableRaisingEvents = true,
};
var exited = new TaskCompletionSource <ProcessResult>();
var result = new ProcessResult(proc, parameters);
proc.Exited += (sender, args) =>
{
var exitcode = proc.ExitCode;
if (exitcode == 0)
{
exited.SetResult(result);
}
else
{
exited.TrySetException(new InvalidOperationException(string.Join("\r\n", result.ErrorLines.Any() ? result.ErrorLines : result.ResultLines)));
}
proc.Dispose();
};
proc.ErrorDataReceived += (sender, args) =>
{
if (!string.IsNullOrWhiteSpace(args.Data))
{
result.ErrorLines.AddLast(args.Data);
if ((result.Parameters.ErrorLinesLimit != -1) && (result.ErrorLines.Count > result.Parameters.ErrorLinesLimit))
{
result.ErrorLines.RemoveFirst();
}
progress?.Invoke(args.Data);
}
};
proc.OutputDataReceived += (sender, args) =>
{
result.ResultLines.AddLast(args.Data);
if ((result.Parameters.ResultLinesLimit != -1) && (result.ResultLines.Count > result.Parameters.ResultLinesLimit))
{
result.ResultLines.RemoveFirst();
}
};
proc.Start();
proc.PriorityClass = priorityClass;
proc.BeginErrorReadLine();
proc.BeginOutputReadLine();
cancellation?.Register(() =>
{
proc.Kill();
proc.Dispose();
exited.TrySetCanceled();
});
return(exited.Task);
}
/// <summary>
/// Uninstall the dnscrypt-proxy service.
/// </summary>
/// <returns>A ProcessResult.</returns>
public ProcessResult Uninstall()
{
var processResult = new ProcessResult();
try
{
// we do not check if the proxy is installed,
// just let them clear the registry.
const int timeout = 9000;
using (var process = new Process())
{
process.StartInfo.FileName = Path.Combine(Directory.GetCurrentDirectory(),
Global.DnsCryptProxyFolder, Global.DnsCryptProxyExecutableName);
process.StartInfo.Arguments = "--uninstall";
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.Start();
if (process.WaitForExit(timeout))
{
if (process.ExitCode == 0)
{
processResult.Success = true;
}
else
{
processResult.Success = false;
}
}
else
{
// Timed out.
throw new Exception("Timed out");
}
}
}
catch (Exception exception)
{
processResult.StandardError = exception.Message;
processResult.Success = false;
}
return processResult;
}
/// <summary>
/// Linear edge-refinement pass, followed by smoothing and projection
/// - Edges are processed in prime-modulo-order to break symmetry
/// - smoothing is done in parallel if EnableParallelSmooth = true
/// - Projection pass if ProjectionMode == AfterRefinement
/// - number of modified edges returned in ModifiedEdgesLastPass
/// </summary>
public virtual void BasicRemeshPass()
{
if (mesh.TriangleCount == 0) // badness if we don't catch this...
{
return;
}
begin_pass();
// Iterate over all edges in the mesh at start of pass.
// Some may be removed, so we skip those.
// However, some old eid's may also be re-used, so we will touch
// some new edges. Can't see how we could efficiently prevent this.
//
begin_ops();
int cur_eid = start_edges();
bool done = false;
ModifiedEdgesLastPass = 0;
do
{
if (mesh.IsEdge(cur_eid))
{
ProcessResult result = ProcessEdge(cur_eid);
if (result == ProcessResult.Ok_Collapsed || result == ProcessResult.Ok_Flipped || result == ProcessResult.Ok_Split)
{
ModifiedEdgesLastPass++;
}
}
if (Cancelled()) // expensive to check every iter?
{
return;
}
cur_eid = next_edge(cur_eid, out done);
} while (done == false);
end_ops();
if (Cancelled())
{
return;
}
begin_smooth();
if (EnableSmoothing && SmoothSpeedT > 0)
{
if (EnableSmoothInPlace)
{
FullSmoothPass_InPlace(EnableParallelSmooth);
}
else
{
FullSmoothPass_Buffer(EnableParallelSmooth);
}
DoDebugChecks();
}
end_smooth();
if (Cancelled())
{
return;
}
begin_project();
if (target != null && ProjectionMode == TargetProjectionMode.AfterRefinement)
{
FullProjectionPass();
DoDebugChecks();
}
end_project();
if (Cancelled())
{
return;
}
end_pass();
}
private static void VerifyResult(ProcessResult result)
{
Assert.Equal("", result.Output);
Assert.Equal("", result.Errors);
Assert.Equal(0, result.ExitCode);
}
/// <summary>
///
/// </summary>
/// <param name="arguments"></param>
/// <returns></returns>
private static ProcessResult ExecuteWithArguments(string arguments)
{
var processResult = new ProcessResult();
try
{
var dnsCryptProxyExecutablePath = Path.Combine(Directory.GetCurrentDirectory(), Global.DnsCryptProxyFolder,
Global.DnsCryptProxyExecutableName);
if (!File.Exists(dnsCryptProxyExecutablePath))
{
throw new Exception($"Missing {dnsCryptProxyExecutablePath}");
}
const int timeout = 9000;
using var process = new Process();
process.StartInfo.FileName = dnsCryptProxyExecutablePath;
process.StartInfo.Arguments = arguments;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
var output = new StringBuilder();
var error = new StringBuilder();
using var outputWaitHandle = new AutoResetEvent(false);
using var errorWaitHandle = new AutoResetEvent(false);
process.OutputDataReceived += (sender, e) =>
{
if (e.Data == null)
{
outputWaitHandle.Set();
}
else
{
output.AppendLine(e.Data);
}
};
process.ErrorDataReceived += (sender, e) =>
{
if (e.Data == null)
{
errorWaitHandle.Set();
}
else
{
error.AppendLine(e.Data);
}
};
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
if (process.WaitForExit(timeout) &&
outputWaitHandle.WaitOne(timeout) &&
errorWaitHandle.WaitOne(timeout))
{
if (process.ExitCode == 0)
{
processResult.StandardOutput = output.ToString();
processResult.StandardError = error.ToString();
processResult.Success = true;
}
else
{
processResult.StandardOutput = output.ToString();
processResult.StandardError = error.ToString();
processResult.Success = false;
}
}
else
{
// Timed out.
throw new Exception("Timed out");
}
}
catch (Exception exception)
{
Logger.Error(exception, "ExecuteWithArguments");
processResult.StandardError = exception.Message;
processResult.Success = false;
}
return(processResult);
}
private async Task <bool> CheckCreateCategoryProcessIsValid(string categoryNameToCreate, ProcessResult proccessedResult)
{
Category categoryToCreate = await _categoryRepository.Get(p => p.Name == categoryNameToCreate);
if (categoryToCreate != null)
{
proccessedResult.Message = Constants.CategoryService.CategoryToCreateAlreadyExist;
return(false);
}
return(true);
}
/// <summary>
/// Realiza el registro de un Parámetro Sección
/// </summary>
/// <param name="filtro">Parámetro Sección a Registrar</param>
/// <returns>Indicador de Error</returns>
public ProcessResult <string> RegistrarParametroSeccion(ParametroSeccionRequest filtro)
{
string result = "0";
var resultadoProceso = new ProcessResult <string>();
try
{
if (filtro.CodigoParametro == null)
{
throw new Exception();
}
var seccionRepetida = BuscarParametroSeccion(new ParametroSeccionRequest()
{
CodigoParametro = filtro.CodigoParametro,
Nombre = filtro.Nombre
}).Result.Where(item => filtro.CodigoSeccion == null || item.CodigoSeccion != filtro.CodigoSeccion).FirstOrDefault();
if (seccionRepetida != null)
{
result = "2";
resultadoProceso.Result = result;
resultadoProceso.IsSuccess = true;
return(resultadoProceso);
}
if (filtro.CodigoSeccion == null)
{
var parametroSeccionUltimo = BuscarParametroSeccion(new ParametroSeccionRequest()
{
CodigoParametro = filtro.CodigoParametro,
EstadoRegistro = null
}).Result.OrderByDescending(item => item.CodigoSeccion).FirstOrDefault();
filtro.CodigoSeccion = parametroSeccionUltimo != null ? parametroSeccionUltimo.CodigoSeccion + 1 : 1;
parametroSeccionEntityRepository.Insertar(ParametroSeccionAdapter.ObtenerParametroSeccionEntity(filtro));
}
else
{
var entity = ParametroSeccionAdapter.ObtenerParametroSeccionEntity(filtro);
var entityActual = parametroSeccionEntityRepository.GetById(filtro.CodigoParametro, filtro.CodigoSeccion);
entityActual.Nombre = entity.Nombre;
entityActual.CodigoTipoDato = entity.CodigoTipoDato;
entityActual.IndicadorPermiteModificar = entity.IndicadorPermiteModificar;
entityActual.IndicadorObligatorio = entity.IndicadorObligatorio;
entityActual.CodigoParametroRelacionado = entity.CodigoParametroRelacionado;
entityActual.CodigoSeccionRelacionado = entity.CodigoSeccionRelacionado;
entityActual.CodigoSeccionRelacionadoMostrar = entity.CodigoSeccionRelacionadoMostrar;
parametroSeccionEntityRepository.Editar(entityActual);
}
parametroSeccionEntityRepository.GuardarCambios();
resultadoProceso.IsSuccess = true;
}
catch (Exception e)
{
result = "-1";
resultadoProceso.Result = result;
resultadoProceso.IsSuccess = false;
resultadoProceso.Exception = new ApplicationLayerException <ParametroValorService>(e);
}
return(resultadoProceso);
}
public static async Task <ProcessResult> ExecuteShellCommand(string command, string arguments, int timeout)
{
var result = new ProcessResult();
using (var process = new Process())
{
process.StartInfo.FileName = command;
process.StartInfo.Arguments = arguments;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardInput = true;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.CreateNoWindow = true;
var outputBuilder = new StringBuilder();
var outputCloseEvent = new TaskCompletionSource <bool>();
process.OutputDataReceived += (s, e) =>
{
// Поток output закрылся (процесс завершил работу)
if (string.IsNullOrEmpty(e.Data))
{
outputCloseEvent.SetResult(true);
}
else
{
outputBuilder.AppendLine(e.Data);
}
};
var errorBuilder = new StringBuilder();
var errorCloseEvent = new TaskCompletionSource <bool>();
process.ErrorDataReceived += (s, e) =>
{
// Поток error закрылся (процесс завершил работу)
if (string.IsNullOrEmpty(e.Data))
{
errorCloseEvent.SetResult(true);
}
else
{
errorBuilder.AppendLine(e.Data);
}
};
bool isStarted;
try
{
isStarted = process.Start();
}
catch (Exception error)
{
// Usually it occurs when an executable file is not found or is not executable
result.Completed = true;
result.ExitCode = -1;
result.Output = error.Message;
isStarted = false;
}
if (isStarted)
{
// Reads the output stream first and then waits because deadlocks are possible
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// Creates task to wait for process exit using timeout
var waitForExit = WaitForExitAsync(process, timeout);
// Create task to wait for process exit and closing all output streams
var processTask = Task.WhenAll(waitForExit, outputCloseEvent.Task, errorCloseEvent.Task);
// Waits process completion and then checks it was not completed by timeout
if (await Task.WhenAny(Task.Delay(timeout), processTask) == processTask && waitForExit.Result)
{
result.Completed = true;
result.ExitCode = process.ExitCode;
// Adds process output if it was completed with error
if (process.ExitCode != 0)
{
result.Output = $"{outputBuilder}{errorBuilder}";
}
}
else
{
try
{
// Kill hung process
process.Kill();
}
catch
{
}
}
}
}
return(result);
}
public void SubmitTraces(string packageVersion, bool enableCallTarget)
{
List <MockTracerAgent.Span> spans = null;
try
{
SetCallTargetSettings(enableCallTarget);
SetEnvironmentVariable("DD_TRACE_DEBUG", "1");
SetEnvironmentVariable("DD_DUMP_ILREWRITE_ENABLED", "1");
int agentPort = TcpPortProvider.GetOpenPort();
using (var agent = new MockTracerAgent(agentPort))
using (ProcessResult processResult = RunDotnetTestSampleAndWaitForExit(agent.Port, packageVersion: packageVersion))
{
spans = agent.WaitForSpans(ExpectedSpanCount)
.Where(s => !(s.Tags.TryGetValue(Tags.InstrumentationName, out var sValue) && sValue == "HttpMessageHandler"))
.ToList();
// Check the span count
Assert.Equal(ExpectedSpanCount, spans.Count);
// ***************************************************************************
// the following is a temporal skip to avoid flakiness on xunit 2.2.0 version
if (spans.Count == 0 && packageVersion == "2.2.0")
{
return;
}
// ***************************************************************************
foreach (var targetSpan in spans)
{
// check the name
Assert.Equal("xunit.test", targetSpan.Name);
// check the CIEnvironmentValues decoration.
CheckCIEnvironmentValuesDecoration(targetSpan);
// check the runtime values
CheckRuntimeValues(targetSpan);
// check the suite name
AssertTargetSpanEqual(targetSpan, TestTags.Suite, TestSuiteName);
// check the test type
AssertTargetSpanEqual(targetSpan, TestTags.Type, TestTags.TypeTest);
// check the test framework
AssertTargetSpanContains(targetSpan, TestTags.Framework, "xUnit");
// check the version
AssertTargetSpanEqual(targetSpan, "version", "1.0.0");
// checks the origin tag
CheckOriginTag(targetSpan);
// Check the Environment
AssertTargetSpanEqual(targetSpan, Tags.Env, "integration_tests");
// check specific test span
switch (targetSpan.Tags[TestTags.Name])
{
case "SimplePassTest":
CheckSimpleTestSpan(targetSpan);
break;
case "SimpleSkipFromAttributeTest":
CheckSimpleSkipFromAttributeTest(targetSpan);
break;
case "SimpleErrorTest":
CheckSimpleErrorTest(targetSpan);
break;
case "TraitPassTest":
CheckSimpleTestSpan(targetSpan);
CheckTraitsValues(targetSpan);
break;
case "TraitSkipFromAttributeTest":
CheckSimpleSkipFromAttributeTest(targetSpan);
CheckTraitsValues(targetSpan);
break;
case "TraitErrorTest":
CheckSimpleErrorTest(targetSpan);
CheckTraitsValues(targetSpan);
break;
case "SimpleParameterizedTest":
CheckSimpleTestSpan(targetSpan);
AssertTargetSpanAnyOf(
targetSpan,
TestTags.Parameters,
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleParameterizedTest(xValue: 1, yValue: 1, expectedResult: 2)\"},\"arguments\":{\"xValue\":\"1\",\"yValue\":\"1\",\"expectedResult\":\"2\"}}",
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleParameterizedTest(xValue: 2, yValue: 2, expectedResult: 4)\"},\"arguments\":{\"xValue\":\"2\",\"yValue\":\"2\",\"expectedResult\":\"4\"}}",
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleParameterizedTest(xValue: 3, yValue: 3, expectedResult: 6)\"},\"arguments\":{\"xValue\":\"3\",\"yValue\":\"3\",\"expectedResult\":\"6\"}}",
"{\"metadata\":{\"test_name\":\"SimpleParameterizedTest(xValue: 1, yValue: 1, expectedResult: 2)\"},\"arguments\":{\"xValue\":\"1\",\"yValue\":\"1\",\"expectedResult\":\"2\"}}",
"{\"metadata\":{\"test_name\":\"SimpleParameterizedTest(xValue: 2, yValue: 2, expectedResult: 4)\"},\"arguments\":{\"xValue\":\"2\",\"yValue\":\"2\",\"expectedResult\":\"4\"}}",
"{\"metadata\":{\"test_name\":\"SimpleParameterizedTest(xValue: 3, yValue: 3, expectedResult: 6)\"},\"arguments\":{\"xValue\":\"3\",\"yValue\":\"3\",\"expectedResult\":\"6\"}}");
break;
case "SimpleSkipParameterizedTest":
CheckSimpleSkipFromAttributeTest(targetSpan);
// On callsite the parameters tags are being sent with no parameters, this is not required due the whole test is skipped.
// That behavior has changed in calltarget.
if (!enableCallTarget)
{
AssertTargetSpanAnyOf(
targetSpan,
TestTags.Parameters,
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleSkipParameterizedTest\"},\"arguments\":{\"xValue\":\"(default)\",\"yValue\":\"(default)\",\"expectedResult\":\"(default)\"}}",
"{\"metadata\":{\"test_name\":\"SimpleSkipParameterizedTest\"},\"arguments\":{\"xValue\":\"(default)\",\"yValue\":\"(default)\",\"expectedResult\":\"(default)\"}}");
}
break;
case "SimpleErrorParameterizedTest":
CheckSimpleErrorTest(targetSpan);
AssertTargetSpanAnyOf(
targetSpan,
TestTags.Parameters,
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleErrorParameterizedTest(xValue: 1, yValue: 0, expectedResult: 2)\"},\"arguments\":{\"xValue\":\"1\",\"yValue\":\"0\",\"expectedResult\":\"2\"}}",
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleErrorParameterizedTest(xValue: 2, yValue: 0, expectedResult: 4)\"},\"arguments\":{\"xValue\":\"2\",\"yValue\":\"0\",\"expectedResult\":\"4\"}}",
"{\"metadata\":{\"test_name\":\"Samples.XUnitTests.TestSuite.SimpleErrorParameterizedTest(xValue: 3, yValue: 0, expectedResult: 6)\"},\"arguments\":{\"xValue\":\"3\",\"yValue\":\"0\",\"expectedResult\":\"6\"}}",
"{\"metadata\":{\"test_name\":\"SimpleErrorParameterizedTest(xValue: 1, yValue: 0, expectedResult: 2)\"},\"arguments\":{\"xValue\":\"1\",\"yValue\":\"0\",\"expectedResult\":\"2\"}}",
"{\"metadata\":{\"test_name\":\"SimpleErrorParameterizedTest(xValue: 2, yValue: 0, expectedResult: 4)\"},\"arguments\":{\"xValue\":\"2\",\"yValue\":\"0\",\"expectedResult\":\"4\"}}",
"{\"metadata\":{\"test_name\":\"SimpleErrorParameterizedTest(xValue: 3, yValue: 0, expectedResult: 6)\"},\"arguments\":{\"xValue\":\"3\",\"yValue\":\"0\",\"expectedResult\":\"6\"}}");
break;
}
// check remaining tag (only the name)
Assert.Single(targetSpan.Tags);
}
}
}
catch
{
WriteSpans(spans);
throw;
}
}
public string GetCode(Type type)
{
var result = new ProcessResult();
return(templateEngine.GetViewModelCode(type));
}
private static void VerifyResult(ProcessResult result)
{
Assert.Equal("", result.Output);
Assert.Equal("", result.Errors);
Assert.Equal(0, result.ExitCode);
}
public static async Task <ProcessResult> RunProcessAsync(string command, string arguments, string workingdir, int timeout)
{
var result = new ProcessResult();
using (var process = new Process())
{
process.StartInfo.FileName = command;
process.StartInfo.Arguments = arguments;
process.StartInfo.WorkingDirectory = workingdir;
process.StartInfo.UseShellExecute = false;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
process.StartInfo.CreateNoWindow = true;
var outputBuilder = new StringBuilder();
var outputCloseEvent = new TaskCompletionSource <bool>();
process.OutputDataReceived += (s, e) =>
{
if (e.Data == null)
{
outputCloseEvent.SetResult(true);
}
else
{
outputBuilder.Append(e.Data);
outputBuilder.Append('\n');
}
};
var errorBuilder = new StringBuilder();
var errorCloseEvent = new TaskCompletionSource <bool>();
process.ErrorDataReceived += (s, e) =>
{
if (e.Data == null)
{
errorCloseEvent.SetResult(true);
}
else
{
errorBuilder.Append(e.Data);
errorBuilder.Append('\n');
}
};
var isStarted = process.Start();
if (!isStarted)
{
result.ExitCode = process.ExitCode;
return(result);
}
// Reads the output stream first and then waits because deadlocks are possible
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// Creates task to wait for process exit using timeout
var waitForExit = WaitForExitAsync(process, timeout);
// Create task to wait for process exit and closing all output streams
var processTask = Task.WhenAll(waitForExit, outputCloseEvent.Task, errorCloseEvent.Task);
// Waits process completion and then checks it was not completed by timeout
if (await Task.WhenAny(Task.Delay(timeout), processTask) == processTask && waitForExit.Result)
{
result.ExitCode = process.ExitCode;
result.Output = outputBuilder.ToString();
result.Error = errorBuilder.ToString();
}
else
{
try
{
// Kill hung process
process.Kill();
}
catch
{
// ignored
}
}
}
return(result);
}
// Returns 0 on success, 1 on failure.
public static int DiffCommand(Config config)
{
DiffTool diffTool = NewDiffTool(config);
string diffString = $"{diffTool.Name} {config.Metric} Diffs for ";
bool needPrefix = false;
if (config.CoreLib)
{
diffString += "System.Private.CoreLib.dll";
needPrefix = true;
}
else if (config.DoFrameworks)
{
diffString += "System.Private.CoreLib.dll, framework assemblies";
needPrefix = true;
}
if (config.Benchmarks)
{
if (needPrefix)
{
diffString += ", ";
}
diffString += "benchstones and benchmarks game in " + config.TestRoot;
needPrefix = true;
}
else if (config.DoTestTree)
{
if (needPrefix)
{
diffString += ", ";
}
diffString += "assemblies in " + config.TestRoot;
needPrefix = true;
}
foreach (string assembly in config.AssemblyList)
{
if (needPrefix)
{
diffString += ", ";
}
diffString += assembly;
needPrefix = true;
}
Console.WriteLine($"Beginning {diffString}");
// Create subjob that runs jit-dasm or jit-dasm-pmi (which should be in path)
// with the relevent coreclr assemblies/paths.
List <string> commandArgs = new List <string>();
commandArgs.Add("--platform");
commandArgs.Add(config.CoreRoot);
if (config.GenerateGCInfo)
{
commandArgs.Add("--gcinfo");
}
if (config.Tier0)
{
commandArgs.Add("--tier0");
diffString += " [tier0]";
}
if (config.GenerateDebugInfo)
{
commandArgs.Add("--debuginfo");
}
if (config.Verbose)
{
commandArgs.Add("--verbose");
}
if (config.AltJit != null)
{
commandArgs.Add("--altjit");
commandArgs.Add(config.AltJit);
}
if ((config.DoCommand == Commands.PmiDiff) && config.Cctors)
{
commandArgs.Add("--cctors");
diffString += " [invoking .cctors]";
}
DateTime startTime = DateTime.Now;
List <AssemblyInfo> assemblyWorkList = GenerateAssemblyWorklist(config);
DasmResult dasmResult = diffTool.RunDasmTool(commandArgs, assemblyWorkList);
Console.WriteLine($"Completed {diffString} in {(DateTime.Now - startTime).TotalSeconds:F2}s");
string basePath = Path.Combine(config.OutputPath, "base");
string diffPath = Path.Combine(config.OutputPath, "diff");
Console.WriteLine($"Diffs (if any) can be viewed by comparing: {basePath} {diffPath}");
Console.WriteLine("");
Console.WriteLine($"git diff --no-index --diff-filter=M --exit-code --numstat {diffPath} {basePath}");
Console.WriteLine("");
// Analyze completed run.
if (config.DoAnalyze && config.DoDiffCompiles && config.DoBaseCompiles)
{
List <string> analysisArgs = new List <string>();
analysisArgs.Add("--base");
analysisArgs.Add(Path.Combine(config.OutputPath, "base"));
analysisArgs.Add("--diff");
analysisArgs.Add(Path.Combine(config.OutputPath, "diff"));
analysisArgs.Add("--count");
analysisArgs.Add(config.Count.ToString());
analysisArgs.Add("--recursive");
analysisArgs.Add("--metric");
analysisArgs.Add(config.Metric);
analysisArgs.Add("--note");
string jitName = config.AltJit ?? "default jit";
analysisArgs.Add($"\"{diffString} for {config.Arch} {jitName}\"");
if (config.tsv)
{
analysisArgs.Add("--tsv");
analysisArgs.Add(Path.Combine(config.OutputPath, "diffs.tsv"));
}
if (config.Verbose)
{
Console.WriteLine("Analyze command: {0} {1}",
s_analysisTool, String.Join(" ", analysisArgs));
}
Console.WriteLine($"Analyzing {config.Metric} diffs...");
startTime = DateTime.Now;
ProcessResult analyzeResult = Utility.ExecuteProcess(s_analysisTool, analysisArgs);
Console.WriteLine($"Completed analysis in {(DateTime.Now - startTime).TotalSeconds:F2}s");
}
// Report any failures to generate asm at the very end (again). This is so
// this information doesn't get buried in previous output.
if (!dasmResult.Success)
{
Console.Error.WriteLine("");
Console.Error.WriteLine("Warning: Failures detected generating asm: {0} base, {1} diff{2}",
dasmResult.BaseErrors, dasmResult.DiffErrors, (dasmResult.CaughtException ? ", exception occurred" : ""));
return(1); // failure result
}
else
{
return(0); // success result
}
}
/// <summary>
/// This pass only does edge splits. Returns number of split edges.
/// Tracks previously-split
/// </summary>
public int FastSplitIteration()
{
if (mesh.TriangleCount == 0) // badness if we don't catch this...
{
return(0);
}
PushState();
EnableFlips = EnableCollapses = EnableSmoothing = false;
ProjectionMode = TargetProjectionMode.NoProjection;
begin_pass();
// Iterate over all edges in the mesh at start of pass.
// Some may be removed, so we skip those.
// However, some old eid's may also be re-used, so we will touch
// some new edges. Can't see how we could efficiently prevent this.
//
begin_ops();
IEnumerable <int> edgesItr = EdgesIterator();
if (modified_edges == null)
{
modified_edges = new HashSet <int>();
}
else
{
edges_buffer.Clear(); edges_buffer.AddRange(modified_edges);
edgesItr = edges_buffer;
modified_edges.Clear();
}
int startEdges = Mesh.EdgeCount;
int splitEdges = 0;
// When we split an edge, we need to check it and the adjacent ones we added.
// Because of overhead in ProcessEdge, it is worth it to do a distance-check here
double max_edge_len_sqr = MaxEdgeLength * MaxEdgeLength;
SplitF = (edgeID, a, b, vNew) => {
Vector3d v = Mesh.GetVertex(vNew);
foreach (int eid in Mesh.VtxEdgesItr(vNew))
{
Index2i ev = Mesh.GetEdgeV(eid);
int othervid = (ev.a == vNew) ? ev.b : ev.a;
if (mesh.GetVertex(othervid).DistanceSquared(ref v) > max_edge_len_sqr)
{
queue_edge(eid);
}
}
//queue_one_ring(vNew);
};
ModifiedEdgesLastPass = 0;
int processedLastPass = 0;
foreach (int cur_eid in edgesItr)
{
if (Cancelled())
{
goto abort_compute;
}
if (mesh.IsEdge(cur_eid))
{
Index2i ev = mesh.GetEdgeV(cur_eid);
Index2i ov = mesh.GetEdgeOpposingV(cur_eid);
processedLastPass++;
ProcessResult result = ProcessEdge(cur_eid);
if (result == ProcessResult.Ok_Split)
{
// new edges queued by SplitF
ModifiedEdgesLastPass++;
splitEdges++;
}
}
}
end_ops();
//System.Console.WriteLine("FastSplitIteration: start {0} end {1} processed: {2} modified: {3} queue: {4}",
// startEdges, Mesh.EdgeCount, processedLastPass, ModifiedEdgesLastPass, modified_edges.Count);
abort_compute:
SplitF = null;
PopState();
end_pass();
return(splitEdges);
}
/// <summary>
/// process remove
/// </summary>
/// <param name="selector">regex replace selector</param>
/// <param name="result">pre process result</param>
/// <returns>new process result</returns>
public override ProcessResult ProcessRemove(RegexReplaceSelector selector, ProcessResult result)
{
return(ProcessNeed(selector, result));
}
public virtual void RemeshIteration()
{
if (mesh.TriangleCount == 0) // badness if we don't catch this...
{
return;
}
begin_pass();
// Iterate over all edges in the mesh at start of pass.
// Some may be removed, so we skip those.
// However, some old eid's may also be re-used, so we will touch
// some new edges. Can't see how we could efficiently prevent this.
//
begin_ops();
IEnumerable <int> edgesItr = EdgesIterator();
if (modified_edges == null)
{
modified_edges = new HashSet <int>();
}
else
{
edges_buffer.Clear(); edges_buffer.AddRange(modified_edges);
edgesItr = edges_buffer;
modified_edges.Clear();
}
int startEdges = Mesh.EdgeCount;
int flips = 0, splits = 0, collapes = 0;
ModifiedEdgesLastPass = 0;
int processedLastPass = 0;
foreach (int cur_eid in edgesItr)
{
if (Cancelled())
{
return;
}
if (mesh.IsEdge(cur_eid))
{
Index2i ev = mesh.GetEdgeV(cur_eid);
Index2i ov = mesh.GetEdgeOpposingV(cur_eid);
// TODO: optimize the queuing here, are over-doing it!
// TODO: be able to queue w/o flip (eg queue from smooth never requires flip check)
processedLastPass++;
ProcessResult result = ProcessEdge(cur_eid);
if (result == ProcessResult.Ok_Collapsed)
{
queue_one_ring(ev.a); queue_one_ring(ev.b);
queue_one_ring(ov.a); queue_one_ring(ov.b);
ModifiedEdgesLastPass++;
collapes++;
}
else if (result == ProcessResult.Ok_Split)
{
queue_one_ring(ev.a); queue_one_ring(ev.b);
queue_one_ring(ov.a); queue_one_ring(ov.b);
ModifiedEdgesLastPass++;
splits++;
}
else if (result == ProcessResult.Ok_Flipped)
{
queue_one_ring(ev.a); queue_one_ring(ev.b);
queue_one_ring(ov.a); queue_one_ring(ov.b);
ModifiedEdgesLastPass++;
flips++;
}
}
}
end_ops();
//System.Console.WriteLine("RemeshIteration: start {0} end {1} processed: {2} modified: {3} queue: {4}",
// startEdges, Mesh.EdgeCount, processedLastPass, ModifiedEdgesLastPass, modified_edges.Count);
//System.Console.WriteLine(" flips {0} splits {1} collapses {2}", flips, splits, collapes);
if (Cancelled())
{
return;
}
begin_smooth();
if (EnableSmoothing && SmoothSpeedT > 0)
{
TrackedSmoothPass(EnableParallelSmooth);
DoDebugChecks();
}
end_smooth();
if (Cancelled())
{
return;
}
begin_project();
if (ProjectionTarget != null && ProjectionMode == TargetProjectionMode.AfterRefinement)
{
//FullProjectionPass();
if (UseFaceAlignedProjection)
{
for (int i = 0; i < FaceProjectionPassesPerIteration; ++i)
{
TrackedFaceProjectionPass();
}
}
else
{
TrackedProjectionPass(EnableParallelProjection);
}
DoDebugChecks();
}
end_project();
end_pass();
}
public override string GetOSVersionInformation()
{
ProcessResult result = ProcessHelper.Run("sw_vers", args: string.Empty, redirectOutput: true);
return(string.IsNullOrWhiteSpace(result.Output) ? result.Errors : result.Output);
}
private static void PrintStdOutAndErr(Tye.Hosting.Model.Service service, string replica, ProcessResult result)
{
if (result.ExitCode != 0)
{
if (result.StandardOutput != null)
{
service.Logs.OnNext($"[{replica}]: {result.StandardOutput}");
}
if (result.StandardError != null)
{
service.Logs.OnNext($"[{replica}]: {result.StandardError}");
}
}
}
/// <summary>
/// Realiza el registro de un de Parametro Valor
/// </summary>
/// <param name="filtro">Parametro Valor a Registrar</param>
/// <returns>Indicador de Error</returns>
public ProcessResult <string> RegistrarParametroValor(ParametroValorRequest filtro)
{
string result = "0";
var resultadoProceso = new ProcessResult <string>();
try
{
var listSecciones = parametroSeccionService.BuscarParametroSeccion(new ParametroSeccionRequest()
{
CodigoParametro = filtro.CodigoParametro
}).Result;
int codigoValor = 0;
bool isActualizacion = false;
if (filtro.CodigoValor == null)
{
var ultimoParametroValor = BuscarParametroValor(new ParametroValorRequest()
{
CodigoParametro = filtro.CodigoParametro,
EstadoRegistro = null
}).Result.OrderBy(itemOrderBy => itemOrderBy.CodigoValor).LastOrDefault();
if (ultimoParametroValor != null)
{
codigoValor = ultimoParametroValor.CodigoValor + 1;
}
else
{
codigoValor = 1;
}
}
else
{
codigoValor = (int)filtro.CodigoValor;
isActualizacion = true;
}
using (TransactionScope scope = new TransactionScope())
{
try
{
foreach (var item in filtro.RegistroCadena)
{
bool isSeccionExistente = false;
var seccionActual = listSecciones.Where(itemWhere => itemWhere.CodigoSeccion.ToString() == item.Key).FirstOrDefault();
ParametroValorResponse parametroValorActual = null;
if (isActualizacion)
{
parametroValorActual = BuscarParametroValor(new ParametroValorRequest()
{
CodigoParametro = filtro.CodigoParametro,
CodigoSeccion = seccionActual.CodigoSeccion,
CodigoValor = codigoValor
}).Result.FirstOrDefault();
isSeccionExistente = (parametroValorActual != null) ? true : false;
}
string value = "";
switch (seccionActual.CodigoTipoDato)
{
case "ENT":
value = item.Value;
break;
case "DEC":
value = item.Value.Replace(',', '.');
break;
case "FEC":
value = item.Value;
break;
default:
value = item.Value;
break;
}
ParametroValorLogic logic = new ParametroValorLogic();
logic.CodigoParametro = (int)filtro.CodigoParametro;
logic.CodigoSeccion = seccionActual.CodigoSeccion;
logic.CodigoValor = codigoValor;
logic.Valor = value;
if (!isActualizacion || !isSeccionExistente)
{
logic.EstadoRegistro = DatosConstantes.EstadoRegistro.Activo;
if (parametroValorLogicRepository.RegistrarParametroValor(logic) <= 0)
{
throw new Exception();
}
}
else
{
logic.EstadoRegistro = null;
if (parametroValorLogicRepository.ModificarParametroValor(logic) <= 0)
{
throw new Exception();
}
}
}
scope.Complete();
resultadoProceso.Result = "1";
resultadoProceso.IsSuccess = true;
}
catch (Exception e)
{
scope.Dispose();
throw e;
}
}
}
catch (Exception)
{
result = "-1";
resultadoProceso.Result = result;
resultadoProceso.IsSuccess = false;
}
return(resultadoProceso);
}
public async Task StartOrchestratorScheduler(
[OrchestrationTrigger]
IDurableOrchestrationContext context,
ILogger log)
{
var taskItem = context.GetInput <TaskItem>();
if (taskItem == null)
{
var error = new ProcessResult {
Sucess = false, Information = "Error getting task information"
};
AddLog(log, error);
return;
}
TaskTypeEnum taskType = (TaskTypeEnum)taskItem.TaskType;
string prepare = ActivityFunctionPrepare(taskType);
string process = ActivityFunctionProcess(taskType);
string complete = ActivityFunctionComplete(taskType);
double secondInAFullDay = 86400;
//// hvordan tjekker vi at task'en ikke allerde er scheduleret ?
//// i så fald skal den terminineres.
var date = context.CurrentUtcDateTime.Hour > taskItem.MonitorHour ? context.CurrentUtcDateTime.AddDays(1) : context.CurrentUtcDateTime;
var nextTime = new DateTime(date.Year, date.Month, date.Day, taskItem.MonitorHour, 0, 0);
var pollingInterval = nextTime.Subtract(context.CurrentUtcDateTime).TotalSeconds;
DateTime expiryTime = new DateTime(3000, 1, 1);
while (context.CurrentUtcDateTime < expiryTime)
{
// Orchestration sleeps until this time.
var nextCheck = context.CurrentUtcDateTime.AddSeconds(pollingInterval);
await context.CreateTimer(nextCheck, CancellationToken.None);
var resultPrepare = await context.CallActivityAsync <ProcessResult>(prepare, taskItem.CustomerId);
AddLog(log, resultPrepare);
if (resultPrepare.Sucess)
{
var resultProcess = await context.CallActivityAsync <ProcessResult>(process, taskItem.CustomerId);
AddLog(log, resultProcess);
if (resultProcess.Sucess)
{
var resultComplete = await context.CallActivityAsync <ProcessResult>(complete, taskItem.CustomerId);
AddLog(log, resultComplete);
}
}
// her sikres at denne uendelig løkke, ikke medfører at durable storage account fyldes op.
context.ContinueAsNew(null); // her har man mulighed for at have informationer til næste genneløb
pollingInterval = secondInAFullDay;
}
}
private void CryptoObfuscate(string file, string signatureFileName, bool testLoad = false, bool debug = false, bool renameSymbols = false, bool embed = false)
{
bool isProgram = Path.GetExtension(file).ToLower() == ".exe";
if (!isProgram && embed)
{
return;
}
SystemConsole.Write("Obfuscate <cyan>{0}<default>...", Path.GetFileName(file));
Stopwatch watch = Stopwatch.StartNew();
string @namespace = ".";
string sourceDir = Path.GetDirectoryName(file);
string workDir = FileSystem.Combine(sourceDir, "tmp");
string obprojFile = FileSystem.Combine(workDir, Path.GetFileName(file) + ".obproj");
Directory.CreateDirectory(workDir);
using (StreamWriter writer = File.CreateText(obprojFile))
{
writer.WriteLine($"<Project ProjectFileVersion=\"4\" UseRelativePaths=\"True\" CheckVersionsWhileResolvingAssemblies=\"True\" DisabledFromMSBuild=\"False\" ID=\"" + Guid.NewGuid() + "\">");
writer.WriteLine($" <SearchDirectories />");//{Path.GetFileNameWithoutExtension(file)}
writer.WriteLine($" <OutputSettings OutputPath=\"{workDir}\" MainAssemblyPath=\"{workDir}\" OverwriteInputFiles=\"False\">");
writer.WriteLine($" </OutputSettings>");
writer.WriteLine($" <ObfuscationSettings RenamingScheme=\"2\" UseOverloadedFieldNames=\"True\" UseOverloadedMethodNames=\"True\" HonorObfuscationAttributes=\"True\" ExcludeSerializedTypes=\"True\" ProcessInlineStrings=\"True\" ForceXAMLProcessingModeExclude=\"False\" ForceRenameParams=\"False\" EncryptionActive=\"True\" CompressionActive=\"True\" />");
writer.WriteLine($" <Assembly Load=\"true\" Path=\"{file}\" KeyFilePath=\"{signatureFileName}\" KeyFileContainsPublicKeyOnly=\"False\" Rfc3161TimestampURL=\"False\" Embed=\"True\" AddExceptionReporting=\"False\" IsWinRTAssembly=\"False\">");
writer.WriteLine($" <ObfuscationSettings EncryptStrings=\"True\" EncryptMethods=\"True\" EncryptConstants=\"True\" SuppressReflector=\"{isProgram}\" ReduceMetaData=\"{isProgram}\" ObfuscationDisposition=\"1\" FlowObfuscation=\"1\" CodeMasking=\"0\" SuppressILDASM=\"True\" SuppressReflection=\"False\" CombineResources=\"True\" EncryptResources=\"True\" CompressResources=\"True\" MarkAsSealed=\"{isProgram}\" EnableTamperDetection=\"True\" EnableAntiDebugging=\"{isProgram}\" SymbolRenaming=\"{renameSymbols}\" HideExternalCalls=\"True\" HideInternalCalls=\"True\" GeneratePdbFile=\"False\" ObfuscatePdbFileNames=\"False\" IncludeLocalVariablesInPdbFile=\"True\" Encrypt=\"{isProgram}\" Compress=\"{isProgram}\" MSBuild=\"False\" ObfuscatedNamespace=\"{@namespace}\" RetainNamespace=\"False\" ModuleInitializationMethod=\"\" LicensingMerge=\"False\" RemoveConstants=\"{isProgram}\">");
writer.WriteLine($" </ObfuscationSettings>");
writer.WriteLine($" </Assembly>");
if (embed)
{
foreach (string dll in Directory.GetFiles(Path.GetDirectoryName(file), "*.dll"))
{
writer.WriteLine($" <Assembly Load=\"true\" Path=\"{dll}\" KeyFilePath=\"{signatureFileName}\" KeyFileContainsPublicKeyOnly=\"False\" Rfc3161TimestampURL=\"False\" Embed=\"True\" AddExceptionReporting=\"False\" IsWinRTAssembly=\"False\">");
writer.WriteLine($" <ObfuscationSettings EncryptStrings=\"True\" EncryptMethods=\"True\" EncryptConstants=\"True\" SuppressReflector=\"{isProgram}\" ReduceMetaData=\"{isProgram}\" ObfuscationDisposition=\"1\" FlowObfuscation=\"1\" CodeMasking=\"0\" SuppressILDASM=\"True\" SuppressReflection=\"False\" CombineResources=\"True\" EncryptResources=\"True\" CompressResources=\"True\" MarkAsSealed=\"{isProgram}\" EnableTamperDetection=\"True\" EnableAntiDebugging=\"{isProgram}\" SymbolRenaming=\"{renameSymbols}\" HideExternalCalls=\"True\" HideInternalCalls=\"True\" GeneratePdbFile=\"False\" ObfuscatePdbFileNames=\"False\" IncludeLocalVariablesInPdbFile=\"True\" Encrypt=\"{isProgram}\" Compress=\"{isProgram}\" MSBuild=\"False\" ObfuscatedNamespace=\"{@namespace}\" RetainNamespace=\"False\" ModuleInitializationMethod=\"\" LicensingMerge=\"False\" RemoveConstants=\"{isProgram}\">");
writer.WriteLine($" </ObfuscationSettings>");
writer.WriteLine($" </Assembly>");
}
}
writer.WriteLine($" <Warnings SaveWarningsToFile=\"\" FailOnUnsuppressedWarning=\"False\" SaveSuppressedWarnings=\"False\" SaveUnsuppressedWarnings=\"False\" />");
writer.WriteLine($"</Project>");
}
ProcessResult result = Shell.FindAndRun("co", "Crypto Obfuscator", $"projectfile={obprojFile}");
if (debug)
{
foreach (string line in result.Combined.SplitNewLine())
{
if (line.Trim().Length > 0)
{
SystemConsole.WriteLine("D " + line.Trim());
}
}
}
if (result.ExitCode != 0)
{
SystemConsole.WriteLine(" {0} <red>error", StringExtensions.FormatTime(watch.Elapsed));
SystemConsole.WriteLine();
foreach (string line in result.Combined.SplitNewLine())
{
SystemConsole.WriteLine(new XTItem(XTColor.Red, XTStyle.Default, line));
}
throw new Exception("Obfuscation Exception");
}
SystemConsole.WriteLine(" {0} <green>ok", StringExtensions.FormatTime(watch.Elapsed));
ObfucatorComplete(sourceDir, file, embed, testLoad);
}
/// <summary>
/// Gets the most recent folder version via Vault's versionhistory command.
///
/// If we don't yet have a folder version, we need to get one so getSource and LabelSource have a version to work with,
/// whether there's been changes or not. (On a forced build or a multi-source control setup, we might get and/or label
/// when there's been no change.)
///
/// So if we have no folder version, we get the latest version of the folder via Vault's versionhistory command and see
/// if the timestamp on that folder is more recent than the last build. If we already have a folder version, we simply
/// ask Vault to give us the most recent folder version after then one we already know about.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
/// <returns></returns>
private bool GetFolderVersion(IIntegrationResult from, IIntegrationResult to)
{
bool bFoundChanges = false;
// If we don't yet have a folder version, we need to just get the latest, rather than checking for a change.
bool bForceGetLatestVersion = (_folderVersion == 0);
// get version history
ProcessResult result = ExecuteWithRetries(VersionHistoryProcessInfo(from, to, bForceGetLatestVersion));
// parse out changes
string versionHistory = Vault3.ExtractXmlFromOutput(result.StandardOutput);
XmlDocument versionHistoryXml = new XmlDocument();
versionHistoryXml.LoadXml(versionHistory);
XmlNodeList versionNodeList = versionHistoryXml.SelectNodes("/vault/history/item");
XmlNode folderVersionNode = null;
if (bForceGetLatestVersion)
{
Debug.Assert(versionNodeList.Count == 1, "Attempted to retrieve folder's current version and got no results.");
folderVersionNode = versionNodeList.Item(0);
}
else
{
Debug.Assert(versionNodeList.Count == 0 || versionNodeList.Count == 1, "Vault versionhistory -rowlimit 1 returned more than 1 row.");
if (versionNodeList.Count == 1)
{
folderVersionNode = versionNodeList.Item(0);
// We asked vault for only new folder versions, so if we got one, the folder has changed.
bFoundChanges = true;
}
}
if (folderVersionNode != null)
{
if (bForceGetLatestVersion)
{
// We asked Vault for the most recent folder version. We have to check its date to
// see if this represents a change since the last integration.
XmlAttribute dateAttr = (XmlAttribute)folderVersionNode.Attributes.GetNamedItem("date");
Debug.Assert(dateAttr != null, "date attribute not found in version history");
DateTime dtLastChange = DateTime.Parse(dateAttr.Value, culture);
if (dtLastChange > from.StartTime)
{
bFoundChanges = true;
}
}
// get the new most recent folder version
XmlAttribute versionAttr = (XmlAttribute)folderVersionNode.Attributes.GetNamedItem("version");
Debug.Assert(versionAttr != null, "version attribute not found in version history");
_folderVersion = long.Parse(versionAttr.Value);
Log.Debug("Most recent folder version: " + _folderVersion);
// get the new most recent TxId
XmlAttribute txIdAttr = (XmlAttribute)folderVersionNode.Attributes.GetNamedItem("txid");
Debug.Assert(txIdAttr != null, "txid attribute not found in version history");
_lastTxID = long.Parse(txIdAttr.Value);
Log.Debug("Most recent TxID: " + _lastTxID);
}
return(bFoundChanges);
}
private ProcessResult ProcessFile(string ifcFile, StreamWriter writer)
{
RemoveFiles(ifcFile);
long geomTime = -1; long parseTime = -1;
using (EventTrace eventTrace = LoggerFactory.CreateEventTrace())
{
ProcessResult result = new ProcessResult() { Errors = -1 };
try
{
Stopwatch watch = new Stopwatch();
watch.Start();
using (XbimModel model = ParseModelFile(ifcFile,Params.Caching))
{
parseTime = watch.ElapsedMilliseconds;
string xbimFilename = BuildFileName(ifcFile, ".xbim");
//model.Open(xbimFilename, XbimDBAccess.ReadWrite);
//if (_params.GeometryV1)
// XbimMesher.GenerateGeometry(model, Logger, null);
//else
//{
Xbim3DModelContext context = new Xbim3DModelContext(model);
context.CreateContext(XbimGeometryType.PolyhedronBinary);
//}
geomTime = watch.ElapsedMilliseconds - parseTime;
//XbimSceneBuilder sb = new XbimSceneBuilder();
//string xbimSceneName = BuildFileName(ifcFile, ".xbimScene");
//sb.BuildGlobalScene(model, xbimSceneName);
// sceneTime = watch.ElapsedMilliseconds - geomTime;
IIfcFileHeader header = model.Header;
watch.Stop();
IfcOwnerHistory ohs = model.Instances.OfType<IfcOwnerHistory>().FirstOrDefault();
result = new ProcessResult
{
ParseDuration = parseTime,
GeometryDuration = geomTime,
// SceneDuration = sceneTime,
FileName = ifcFile.Remove(0,Params.TestFileRoot.Length).TrimStart('\\'),
Entities = model.Instances.Count,
IfcSchema = header.FileSchema.Schemas.FirstOrDefault(),
IfcDescription = String.Format("{0}, {1}", header.FileDescription.Description.FirstOrDefault(), header.FileDescription.ImplementationLevel),
GeometryEntries = model.GeometriesCount,
IfcLength = ReadFileLength(ifcFile),
XbimLength = ReadFileLength(xbimFilename),
// SceneLength = ReadFileLength(xbimSceneName),
IfcProductEntries = model.Instances.CountOf<IfcProduct>(),
IfcSolidGeometries = model.Instances.CountOf<IfcSolidModel>(),
IfcMappedGeometries = model.Instances.CountOf<IfcMappedItem>(),
BooleanGeometries = model.Instances.CountOf<IfcBooleanResult>(),
Application = ohs == null ? "Unknown" : ohs.OwningApplication.ToString(),
};
model.Close();
}
}
catch (Exception ex)
{
Logger.Error(String.Format("Problem converting file: {0}", ifcFile), ex);
result.Failed = true;
}
finally
{
result.Errors = (from e in eventTrace.Events
where (e.EventLevel == EventLevel.ERROR)
select e).Count();
result.Warnings = (from e in eventTrace.Events
where (e.EventLevel == EventLevel.WARN)
select e).Count();
result.FileName = ifcFile.Remove(0, Params.TestFileRoot.Length).TrimStart('\\');
if (eventTrace.Events.Count > 0)
{
CreateLogFile(ifcFile, eventTrace.Events);
}
lock (thisLock)
{
writer.WriteLine(result.ToCsv());
writer.Flush();
}
}
return result;
}
}
private void Obfuscar(string file, string signatureFile, bool testLoad, bool debug, bool embed = false)
{
bool isProgram = Path.GetExtension(file).ToLower() == ".exe";
if (!isProgram && embed)
{
return;
}
SystemConsole.Write("Obfuscate <cyan>{0}<default>...", Path.GetFileName(file));
Stopwatch watch = Stopwatch.StartNew();
string sourceDir = Path.GetDirectoryName(file);
string workDir = FileSystem.Combine(sourceDir, "tmp");
string configFile = FileSystem.Combine(workDir, "obfuscar.xml");
Directory.CreateDirectory(workDir);
using (StreamWriter writer = File.CreateText(configFile))
{
writer.WriteLine($"<?xml version='1.0'?>");
writer.WriteLine($"<Obfuscator>");
writer.WriteLine($"<Var name=\"InPath\" value=\"{sourceDir}\" />");
writer.WriteLine($"<Var name=\"OutPath\" value=\"{workDir}\" />");
writer.WriteLine($"<Var name=\"HidePrivateApi\" value=\"true\" />");
writer.WriteLine($"<Var name=\"KeepPublicApi\" value=\"true\" />");
writer.WriteLine($"<Var name=\"KeyFile\" value=\"{signatureFile}\" />");
writer.WriteLine($"<Var name=\"RegenerateDebugInfo\" value=\"true\" />");
writer.WriteLine($"<Module file=\"{file}\" />");
if (embed)
{
foreach (string dll in Directory.GetFiles(Path.GetDirectoryName(file), "*.dll"))
{
writer.WriteLine($"<Module file=\"{dll}\" />");
}
}
writer.WriteLine($"</Obfuscator>");
}
ProcessResult result = Shell.FindAndRun("Obfuscar.Console", "Obfuscar Console", $"-s \"{configFile}\"");
if (debug)
{
foreach (string line in result.Combined.SplitNewLine())
{
if (line.Trim().Length > 0)
{
SystemConsole.WriteLine("D " + line.Trim());
}
}
}
if (result.ExitCode != 0)
{
SystemConsole.WriteLine(" {0} <red>error", StringExtensions.FormatTime(watch.Elapsed));
SystemConsole.WriteLine();
foreach (string line in result.Combined.SplitNewLine())
{
SystemConsole.WriteLine(new XTItem(XTColor.Red, XTStyle.Default, line));
}
throw new Exception("Obfuscation Exception");
}
SystemConsole.WriteLine(" {0} <green>ok", StringExtensions.FormatTime(watch.Elapsed));
ObfucatorComplete(sourceDir, file, embed, testLoad);
}
private void VerifyResultAndOutput(ProcessResult result, TempDirectory path, string expectedOutput)
{
using (var resultFile = GetResultFile(path, "hello.exe"))
{
VerifyResult(result);
var runningResult = RunCompilerOutput(resultFile);
Assert.Equal(expectedOutput, runningResult.Output);
}
}
/// <summary>
/// Retorna el valor por defecto de las variables de sistema
/// </summary>
/// <param name="filtro">Datos de la variable de sistema</param>
/// <returns>Retorna el valor por defecto</returns>
public ProcessResult <string> ObtenerValorDefecto(ValorPorDefectoRequest filtro, UnidadOperativaResponse unidadOperativa)
{
var resultado = new ProcessResult <string>();
try
{
switch (filtro.IdentificadorVariable)
{
case DatosConstantes.IdentificadorVariableDefecto.NumeroContrato:
resultado.Result = "";
break;
case DatosConstantes.IdentificadorVariableDefecto.NombreProyecto:
resultado.Result = filtro.NombreUnidadOperativa;
break;
case DatosConstantes.IdentificadorVariableDefecto.NombreEmpresa:
case DatosConstantes.IdentificadorVariableDefecto.DniPrimerRepresentanteEmpresa:
case DatosConstantes.IdentificadorVariableDefecto.PrimerRepresentanteEmpresa:
case DatosConstantes.IdentificadorVariableDefecto.DniSegundoRepresentanteEmpresa:
case DatosConstantes.IdentificadorVariableDefecto.SegundoRepresentanteEmpresa:
resultado.Result = ObtenerDatoUnidadOperativa(filtro.IdentificadorVariable, unidadOperativa);
break;
case DatosConstantes.IdentificadorVariableDefecto.RucProveedor:
resultado.Result = filtro.RucProveedor;
break;
case DatosConstantes.IdentificadorVariableDefecto.NombreProveedor:
case DatosConstantes.IdentificadorVariableDefecto.ProveedorNombre:
resultado.Result = filtro.NombreProveedor;
break;
case DatosConstantes.IdentificadorVariableDefecto.MonedaContrato:
resultado.Result = filtro.DescripcionMoneda;
break;
case DatosConstantes.IdentificadorVariableDefecto.MontoContrato:
resultado.Result = filtro.MontoContratoString;
break;
case DatosConstantes.IdentificadorVariableDefecto.PlazoVigenciaDesde:
case DatosConstantes.IdentificadorVariableDefecto.FechaInicioContrato:
resultado.Result = filtro.FechaInicioContratoString;
break;
case DatosConstantes.IdentificadorVariableDefecto.PlazoVigenciaHasta:
case DatosConstantes.IdentificadorVariableDefecto.FechaFinContrato:
resultado.Result = filtro.FechaFinContratoString;
break;
case DatosConstantes.IdentificadorVariableDefecto.FechaActual:
resultado.Result = DateTime.Today.ToString(DatosConstantes.Formato.FormatoFecha);
break;
case DatosConstantes.IdentificadorVariableDefecto.FechaActualLetra:
resultado.Result = DateTime.Today.ToString(DatosConstantes.Formato.FormatoFecha);
break;
default:
resultado.Result = "";
break;
}
}
catch (Exception e)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <VariableService>(e);
}
return(resultado);
}
/// <summary>
/// Install the dnscrypt-proxy service.
/// </summary>
/// <returns>A ProcessResult.</returns>
public ProcessResult Install()
{
var processResult = new ProcessResult();
try
{
if (!IsDnsCryptProxyInstalled())
{
const bool actAsGateway = false;
const int timeout = 9000;
var arguments = "--install";
// update the registry
WriteRegistry(DnsCryptProxy.Type);
arguments += " -R \"" + DnsCryptProxy.Parameter.ResolverName + "\"";
arguments += " -L \"" +
Path.Combine(Directory.GetCurrentDirectory(), Global.DnsCryptProxyFolder,
Global.DnsCryptProxyResolverListName) + "\"";
if (actAsGateway)
{
arguments += " -a 0.0.0.0";
}
if (DnsCryptProxy.Type == DnsCryptProxyType.Primary)
{
arguments += " -a " + Global.PrimaryResolverAddress + ":" + Global.PrimaryResolverPort;
}
else
{
arguments += " -a " + Global.SecondaryResolverAddress + ":" + Global.SecondaryResolverPort;
}
// always use ephermeral keys
arguments += " -E";
using (var process = new Process())
{
process.StartInfo.FileName = Path.Combine(Directory.GetCurrentDirectory(),
Global.DnsCryptProxyFolder, Global.DnsCryptProxyExecutableName);
process.StartInfo.Arguments = arguments;
process.StartInfo.UseShellExecute = false;
process.StartInfo.CreateNoWindow = true;
process.StartInfo.WindowStyle = ProcessWindowStyle.Hidden;
process.StartInfo.RedirectStandardOutput = true;
process.StartInfo.RedirectStandardError = true;
var output = new StringBuilder();
var error = new StringBuilder();
using (var outputWaitHandle = new AutoResetEvent(false))
using (var errorWaitHandle = new AutoResetEvent(false))
{
process.OutputDataReceived += (sender, e) =>
{
if (e.Data == null)
{
outputWaitHandle.Set();
}
else
{
output.AppendLine(e.Data);
}
};
process.ErrorDataReceived += (sender, e) =>
{
if (e.Data == null)
{
errorWaitHandle.Set();
}
else
{
error.AppendLine(e.Data);
}
};
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
if (process.WaitForExit(timeout) &&
outputWaitHandle.WaitOne(timeout) &&
errorWaitHandle.WaitOne(timeout))
{
if (process.ExitCode == 0)
{
ReadRegistry(DnsCryptProxy.Type);
processResult.StandardOutput = output.ToString();
processResult.StandardError = error.ToString();
processResult.Success = true;
}
else
{
processResult.StandardOutput = output.ToString();
processResult.StandardError = error.ToString();
processResult.Success = false;
}
}
else
{
// Timed out.
throw new Exception("Timed out");
}
}
}
}
}
catch (Exception exception)
{
processResult.StandardError = exception.Message;
processResult.Success = false;
}
return processResult;
}
/// <summary>
/// Registrar Variable
/// </summary>
/// <param name="filtro">Variable a registrar</param>
/// <returns>Indicador de conformidad
/// 0: Registro satisfactorio
/// 2: Identificador repetido
/// 3: Nombre repetido
/// -1: Ocurrio un Error Inesperado</returns>
public ProcessResult <string> RegistrarVariable(VariableRequest filtro)
{
ProcessResult <string> resultado = new ProcessResult <string>();
resultado.Result = "0";
try
{
var listaVariable = BuscarVariable(new VariableRequest()
{
}).Result;
//Validar si el Idetificador de la variable es repetido
if (listaVariable.Any(itemAny => (filtro.CodigoVariable == null || new Guid(filtro.CodigoVariable) != itemAny.CodigoVariable) &&
(filtro.IndicadorGlobal == true || itemAny.CodigoPlantilla == new Guid(filtro.CodigoPlantilla)) &&
itemAny.Identificador == filtro.Identificador))
{
resultado.Result = "2";
resultado.IsSuccess = false;
return(resultado);
}
//Validar si el Nombre de la variable es repetido
if (listaVariable.Any(itemAny => (filtro.CodigoVariable == null || new Guid(filtro.CodigoVariable) != itemAny.CodigoVariable) &&
(filtro.IndicadorGlobal == true || itemAny.CodigoPlantilla == new Guid(filtro.CodigoPlantilla)) &&
itemAny.Nombre == filtro.Nombre))
{
resultado.Result = "3";
resultado.IsSuccess = false;
return(resultado);
}
var entidad = VariableAdapter.ObtenerVariableEntityDesdeVariableRequest(filtro);
if (filtro.CodigoVariable == null)
{
variableEntityRepository.Insertar(entidad);
variableEntityRepository.GuardarCambios();
//Agregar una columna por default si es tabla
if (entidad.CodigoTipo == DatosConstantes.TipoVariable.Tabla)
{
var campo = new VariableCampoEntity();
campo.CodigoVariableCampo = Guid.NewGuid();
campo.CodigoVariable = entidad.CodigoVariable;
campo.Nombre = "Título";
campo.Orden = 1;
campo.Tamanio = 100;
campo.TipoAlineamiento = "center";
variableCampoEntityRepository.Insertar(campo);
variableCampoEntityRepository.GuardarCambios();
}
}
else
{
var varibleActual = variableEntityRepository.GetById(entidad.CodigoVariable);
varibleActual.CodigoPlantilla = entidad.CodigoPlantilla;
varibleActual.CodigoTipo = entidad.CodigoTipo;
varibleActual.Identificador = entidad.Identificador;
varibleActual.Nombre = entidad.Nombre;
varibleActual.IndicadorGlobal = entidad.IndicadorGlobal;
varibleActual.Descripcion = entidad.Descripcion;
varibleActual.IndicadorVariableSistema = entidad.IndicadorVariableSistema;
variableEntityRepository.Editar(varibleActual);
variableEntityRepository.GuardarCambios();
}
resultado.IsSuccess = true;
}
catch (Exception e)
{
resultado.Result = "-1";
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <VariableService>(e);
}
return(resultado);
}
