private long StartTraceBuilderProcess(long expId)
{
TraceBuilder traceBuilder = new TraceBuilder();
traceBuilder.BuildTraceFromRawFile((int)expId);
return(expId);
}
static void Inner(Tracer tracer)
{
var traceBuilder = new TraceBuilder(tracer);
var client = new HttpClient
{
BaseAddress = new Uri("http://service_a")
};
var url = $"/aworld/id/{_testId}";
traceBuilder.WithSpanName("MainWork")
.WithHttpCall(client, url, HttpMethod.Get)
.TraceIt(() =>
{
var response = client.GetAsync(url).Result;
if (!response.IsSuccessStatusCode)
{
throw new Exception("uncovered area for the demo.");
}
var responseBody = response.Content.ReadAsStringAsync().Result;
Console.WriteLine(responseBody);
});
}
public void SimpleTest()
{
var nodes = new List <Node> ();
nodes.Add(new TemporaryNode());
nodes.Add(new TemporaryNode());
nodes.Add(new TemporaryNode());
nodes.Add(new TemporaryNode());
nodes.Add(Target.R10);
var node = new ConditionalJumpNode(nodes [0], new ConditionalJumpNode(nodes [1], nodes [2], nodes [3]), nodes [4]);
Console.WriteLine(node);
var trace = new HashSet <Node> (TraceBuilder.BuildTrace(node));
bool fine = true;
foreach (Node n in trace)
{
fine &= !(n is ConditionalJumpNode);
}
fine &= trace.Contains(nodes [2]);
fine &= trace.Contains(nodes [3]);
fine &= trace.Contains(nodes [4]);
Assert.IsTrue(fine);
}
static void SingleRequest(Tracer tracer)
{
//Guid guid = Guid.NewGuid();
//IDictionary<string, object> keyValues = new Dictionary<string, object>();
//keyValues.Add("MyTraceId", guid.ToString());
var url = $"/api/aworld/{_testId}";
string spanName = "MainWork";
Guid guid = Guid.NewGuid();
Console.WriteLine("guid:{0}", guid);
var traceBuilder = new TraceBuilder(tracer);
var client = new HttpClient
{
BaseAddress = new Uri("https://localhost:44340")
};
traceBuilder.WithSpanName(spanName)
.WithTag(new OpenTracing.Tag.StringTag("MyCorelationId"), guid.ToString())
.WithHttpCall(client, url, HttpMethod.Get)
.TraceIt(() =>
{
CallServiceA(client, url);
});
}
public void BeginEntryAndEndLastEntry_BuildCorrectTree()
{
var root = new TestEntry("root");
var child1 = new TestEntry("child1");
var child2 = new TestEntry("child2");
var grandchild1 = new TestEntry("grandchild1");
var grandchild2 = new TestEntry("grandchild2");
var grandchild3 = new TestEntry("grandchild3");
var builder = new TraceBuilder();
builder.IsEnabled = true;
builder.BeginEntry(root);
builder.BeginEntry(child1);
builder.BeginEntry(grandchild1);
builder.EndLastEntry();
builder.BeginEntry(grandchild2);
builder.EndLastEntry();
builder.EndLastEntry();
builder.BeginEntry(child2);
builder.BeginEntry(grandchild3);
builder.EndLastEntry();
builder.EndLastEntry();
builder.EndLastEntry();
CollectionAssert.AreEqual(
new[] { root },
builder.Root.Children.ToArray()
);
CollectionAssert.AreEqual(
new[] { child1, child2 },
root.Children.ToArray()
);
CollectionAssert.AreEqual(
new[] { grandchild1, grandchild2 },
child1.Children.ToArray()
);
CollectionAssert.AreEqual(
new[] { grandchild3 },
child2.Children.ToArray()
);
Assert.AreEqual(0, grandchild1.Children.Count);
Assert.AreEqual(0, grandchild2.Children.Count);
Assert.AreEqual(0, grandchild3.Children.Count);
}
/// <summary>
/// Initializes a new instance of the <see cref="ServiceResolveContext"/> class.
/// </summary>
/// <param name="resolver">the service resolver using the context</param>
/// <param name="register">the service register</param>
/// <param name="constructionMode">the service construction mode for the resolve</param>
/// <param name="serviceType">the type of the service being resolved</param>
/// <param name="parentType">the type of the parent</param>
/// <param name="traceBuilder">
/// the trace builder; if <see langword="null"/> a new instance will be created.
/// </param>
/// <exception cref="ArgumentNullException">
/// thrown if the specified <paramref name="resolver"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown if the specified <paramref name="register"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// thrown if the specified <paramref name="serviceType"/> is <see langword="null"/>.
/// </exception>
public ServiceResolveContext(IServiceResolver resolver, IServiceRegister register,
ServiceConstructionMode constructionMode, Type serviceType, Type parentType = null,
TraceBuilder traceBuilder = null)
{
ParentType = parentType;
ConstructionMode = GetServiceConstructionMode(constructionMode, resolver);
Resolver = resolver ?? throw new ArgumentNullException(nameof(resolver));
Register = register ?? throw new ArgumentNullException(nameof(register));
ServiceType = serviceType ?? throw new ArgumentNullException(nameof(serviceType));
TraceBuilder = traceBuilder ?? new TraceBuilder();
}
public void Test_1()
{
Prepare();
var trace = TraceBuilder.CalculateTrace(model);
Assert.AreEqual(0, trace.Points[1].X);
Assert.AreEqual(1, trace.Points[1].Y);
Assert.AreEqual(0, trace.Points[2].X);
Assert.AreEqual(2, trace.Points[2].Y);
}
//--- Class Methods ---
public static IRollbarClient Create(RollbarConfiguration configuration)
{
var frame = new FrameCollectionBuilder();
var exception = new ExceptionInfoBuilder();
var trace = new TraceBuilder(exception, frame);
var traceChain = new TraceChainBuilder(trace);
var body = new BodyBuilder(trace, traceChain);
var title = new TitleBuilder();
var data = new DataBuilder(configuration, body, title);
return(new RollbarClient(configuration, new PayloadBuilder(configuration, data)));
}
private void function2(string FirstName, string LastName)
{
Console.WriteLine("function 2");
IEnumerable <MethodBase> methods = TraceBuilder.Build();
bool wasFirst = false;
Console.WriteLine();
Console.WriteLine("Trace stack:");
foreach (var method in methods)
{
if (!wasFirst)
{
wasFirst = method.Name == LastName;
}
if (wasFirst)
{
ParameterInfo[] parameters = method.GetParameters();
Console.WriteLine("Function: " + method.Name);
Console.Write("Parameters: ");
for (int i = 0; i < parameters.Length; i++)
{
if (i > 0)
{
Console.Write(", ");
}
Console.Write(string.Format("\t{0}: {1}", parameters[i].Name, parameters[i].ParameterType.ToString()));
}
Console.WriteLine();
}
if (method.Name == FirstName)
{
break;
}
}
}
private static void AddSide(Model _answer, int turn,
List <Block> blocks, List <RouteSide> sides,
ref int i, out TraceBuilder.Result trace, ref int startI)
{
var firstTurn = GetTurnElements(blocks);
_answer.Order.AddRange(firstTurn);
for (int j = 0; j < firstTurn.Count; j++)
{
_answer.Topology.Add(new TopologyItem(i, i + 1, turn));
i++;
}
trace = TraceBuilder.CalculateTrace(_answer);
sides.Add(new RouteSide(trace.Points[startI], startI, 4, turn, firstTurn.Count));
for (int j = 0; j < firstTurn.Count; j++)
{
sides[sides.Count - 1].details.Add(trace.Points[startI]);
startI++;
}
}
public void Start()
{
Iteration = 0;
while (true)
{
if (Token.IsCancellationRequested)
{
var model = Model.Copy(Best.Model);
model.Blocks.Clear();
model.Blocks.AddRange(_model.Blocks);
OnStepEvent?.Invoke(this, new FinalAnswer(model, _checker.Solve(model)));
throw new OperationCanceledException("Работа алгоритма остановлена в связи с отменой задачи");
}
if (Bots.Count(_ => !_.IsDead) == 0)
{
NextGeneration();
continue;
}
for (var i = 0; i < Bots.Count; i++)
{
var bot = Bots[i];
if (bot.IsDead)
{
continue;
}
ExecuteCommand(bot);
bot.Cur++;
var answer = bot.Root.ConvertToModel(bot.Current.Model);
var price = _checker.Solve(answer);
var trace = TraceBuilder.CalculateTrace(answer);
if (trace.Exceptions.Any() ||
price.Result < -1000) // TODO: const MIN_PRICE
{
bot.IsDead = true;
}
if (Math.Abs(price.Result - bot.Current.Price.Result) < Constants.Precision)
{
bot.DeadLoops++;
if (bot.DeadLoops > 100)
{
bot.IsDead = true;
}
}
else
{
bot.DeadLoops = 0;
}
bot.Current = new FinalAnswer(answer, price);
//OnStepEvent?.Invoke(this, bot.Current);
if (price > bot.Best.Price)
{
bot.Best = bot.Current;
if (price > Best.Price)
{
Best = bot.Best;
OnStepEvent?.Invoke(this, Best);
}
}
}
OnStepEvent?.Invoke(this, Best);
Iteration++;
}
}
