private void Interprete(FunctionMap map, bool reverse, Run run)
{
int currentWalk = 0;
foreach (List <FunctionID> original in stackWalks)
{
currentWalk++;
List <FunctionID> stackWalk;
if (reverse)
{
stackWalk = new List <FunctionID>(original);
stackWalk.Reverse();
}
else
{
stackWalk = original;
}
for (int i = 0; i < stackWalk.Count; i++)
{
Function function = Run.GetFunctionInfo(map, stackWalk[stackWalk.Count - i - 1], run, reverse);
if (function.lastWalk != currentWalk)
{
function.Samples++;
function.stackWalks.Add(new StackWalk(currentWalk, stackWalk.Count - i - 1, stackWalk));
}
function.lastWalk = currentWalk;
}
}
//foreach (List<FunctionID> stackWalk in stackWalks)
//{
// Function f = Run.GetFunctionInfo(map, stackWalk[0], run);
// f.ExclusiveSamples++;
//}
}
private AggregateFunctionContext CreateMemberContext(ClassMappingDescriptor descriptor, MemberMappingDescriptor member, FunctionMap functionMap)
{
Type implementationType = functionMap.GetTypeForFunction(member.AggregateMappingDescription.FunctionName);
string functionObjectName = string.Format("_{0}_to_{1}_Fn_",
member.AggregateMappingDescription.FunctionObject,
member.Member);
if (implementationType.IsGenericType)
{
if (member.IsArray || member.IsList)
{
Type instanceType = member.IsArray ?
member.AggregateMappingDescription.TargetType.GetElementType() :
member.AggregateMappingDescription.TargetType.GetGenericArguments()[0];
implementationType = implementationType.MakeGenericType(instanceType);
}
else
{
implementationType = implementationType.MakeGenericType(member.AggregateMappingDescription.TargetType);
}
}
IAggregateFunctionCodeGenerator generator = GetGeneratorImpl(implementationType, member);
return new AggregateFunctionContext(member,
descriptor,
implementationType,
functionObjectName,
generator);
}
public void Registration_Suceeds_For_Well_Implemented_Aggregate_Function()
{
FunctionMap map = new FunctionMap();
map.Register("test", typeof(TestFn<int>));
Type t1 = typeof(TestFn<int>);
Type t2 = map.GetTypeForFunction("test");
Assert.AreEqual(typeof(TestFn<int>), map.GetTypeForFunction("test"));
}
public AggregateExpressionBuilder(ClassMappingDescriptor descriptor, ICollection<MemberMappingDescriptor> members, FunctionMap functionMap)
{
m_contexts = new List<AggregateFunctionContext>(members.Count);
foreach (MemberMappingDescriptor member in members)
{
m_contexts.Add(CreateMemberContext(descriptor, member, functionMap));
}
}
public static Function GetFunctionInfo(FunctionMap functions, FunctionID id, Run run, bool reverse)
{
Function result;
if (!functions.TryGetValue(id, out result))
{
result = new Function(id, run, reverse);
functions[id] = result;
}
return(result);
}
public IWasmicSyntaxTree ParseText(string text)
{
var lexer = new WasmicLexer(text);
var functionMap = new FunctionMap();
var functions = new List <IWasmicSyntaxTree>();
var functionDefinitionGenerator = new FunctionDefinitionParser();
var heap = new LinearHeap();
while (lexer.Next.TokenType != TokenType.EndOfText)
{
switch (lexer.Next.TokenType)
{
case TokenType.Extern:
lexer.Advance(); // eat extern
var functionDefinition = functionDefinitionGenerator.Generate(lexer);
functionMap.Add(functionDefinition);
functions.Add(new Import(functionDefinition.Name.Split('.'), functionDefinition));
break;
default:
var functionGenerator = new FunctionParser(
lexer,
functionMap,
functionDefinitionGenerator,
heap
);
var function = functionGenerator.GetFunction();
functions.Add(function);
break;
}
if (lexer.Next.TokenType == TokenType.SemiColon)
{
lexer.Advance();
}
}
if (heap.IsAllocated)
{
functions = new[] { new Memory() }
.Concat(heap.GetAllocatedStrings().Select(v => new Data(v.offset, v.value) as IWasmicSyntaxTree))
.Concat(functions).ToList();
}
return(new Module(functions));
}
public void Update(Run run, FunctionMap functions)
{
this.functions = functions;
currentRun = run;
SuspendLayout();
Invalidate();
BeginUpdate();
foreach (Function method in SortFunctions(functions.Values))
{
AddItem(Nodes, method);
}
foreach (TreeNode item in Nodes)
{
EnsureComputed(item);
}
EndUpdate();
ResumeLayout();
}
public void Update(Run run, FunctionMap functions)
{
this.Nodes.Clear();
updating = true;
this.run = run;
this.functions = functions;
BeginUpdate();
List <Function> functionList = new List <Function>(functions.Values);
functionList.Sort(new Comparison <Function>(delegate(Function a, Function b)
{
return(a.Signature.Namespace.CompareTo(b.Signature.Namespace));
}));
foreach (Function function in functionList)
{
if (function.Signature.Namespace == "")
{
continue;
}
TreeNodeCollection items = this.Nodes;
foreach (string name in function.Signature.Namespace.Split('.'))
{
bool found = false;
foreach (TreeNode item in items)
{
if (item.Text == name)
{
items = item.Nodes;
found = true;
break;
}
}
if (!found)
{
TreeNode item = items.Add(name, name);
item.Checked = true;
items = item.Nodes;
}
}
}
EndUpdate();
updating = false;
}
private async Task OnActivityStateChanged(ActivityEventArgs eventArgs)
{
_retryCancellationTokenSource.Cancel();
_retryCancellationTokenSource = new CancellationTokenSource();
var logTimeModel = new LogTimeModel()
{
IsActive = eventArgs.IsActive,
Timestamp = eventArgs.TimeStamp,
};
var httpContent = new StringContent(
JsonSerializer.Serialize(logTimeModel),
Encoding.UTF8,
"application/json");
await _retryPolicy.ExecuteAsync(
(ctx, ct) => _httpClient.PostAsync(FunctionMap.Get(Function.LogTime), httpContent, ct),
_retryContext,
_retryCancellationTokenSource.Token);
}
public async Task TryRefreshToken(CancellationToken?cancellationToken = null)
{
using var request = new HttpRequestMessage(HttpMethod.Get, FunctionMap.Get(Function.RefreshJwtToken));
request.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);
var response = await _httpClient.SendAsync(request, cancellationToken ?? CancellationToken.None);
string jwtToken = null !;
if (response.IsSuccessStatusCode)
{
var responseString = await response.Content.ReadAsStringAsync();
if (!responseString.IsNullOrEmpty())
{
var refreshTokenResult = JsonSerializer.Deserialize <RefreshTokenResult>(responseString);
jwtToken = refreshTokenResult.Token;
}
}
_authService.JwtToken = jwtToken;
}
public void Retrieving_Unregistered_Function_Fails()
{
FunctionMap map = new FunctionMap();
map.GetTypeForFunction("test");
}
/// <summary>
///
/// </summary>
/// <param name="cs"></param>
public NameSection(CustomSection cs)
{
var stream = new MemoryStream((byte[])cs.Content);
var reader = new Reader(stream);
var previousSection = NameSubsection.Module;
var preSectionOffset = reader.Offset;
while (reader.TryReadVarUInt7(out var id)) //At points where TryRead is used, the stream can safely end.
{
if (id != 0 && (NameSubsection)id < previousSection)
{
throw new ModuleLoadException($"Sections out of order; section {(NameSubsection)id} encounterd after {previousSection}.", preSectionOffset);
}
var payloadLength = reader.ReadVarUInt32();
switch ((NameSubsection)id)
{
case NameSubsection.Module:
{
var nameLength = reader.ReadVarUInt32();
Name = reader.ReadString(nameLength);
}
break;
case NameSubsection.Function:
{
var count = reader.ReadVarUInt32();
Functions = new FunctionMap((int)count);
for (int i = 0; i < count; i++)
{
var index = reader.ReadVarUInt32();
var nameLength = reader.ReadVarUInt32();
var name = reader.ReadString(nameLength);
Functions.Add(index, name);
}
}
break;
case NameSubsection.Local:
{
var fun_count = reader.ReadVarUInt32();
Locals = new LocalMap((int)fun_count);
for (int f = 0; f < fun_count; f++)
{
var fun_index = reader.ReadVarUInt32();
var count = reader.ReadVarUInt32();
var nameMap = new NameMap((int)count);
Locals.Add(fun_index, nameMap);
for (int i = 0; i < count; i++)
{
var index = reader.ReadVarUInt32();
var nameLength = reader.ReadVarUInt32();
var name = reader.ReadString(nameLength);
nameMap.Add(index, name);
}
}
}
break;
}
previousSection = (NameSubsection)id;
}
}
public void Registration_Fails_If_Type_Doesnt_Implement_IAggregateFunction()
{
FunctionMap map = new FunctionMap();
map.Register("test", typeof(string));
}
public CodeGeneratorContext(IList<IMappingDescriptorProvider> providers, FunctionMap functionMap, AssemblerGenerationOptions options)
{
m_providers = providers;
m_functionMap = functionMap;
m_options = options;
}
public async Task ReturnsUnauthorizedResultIfNotAuthenticated()
{
// Arrange
var request = new DefaultHttpContext().Request;
string xsrfToken = $"xsrf-token-{DateTime.Now.Ticks}";
request.Headers.Add("Cookie", new CookieHeaderValue(Globals.XsrfTokenCookieAndHeaderName, xsrfToken).ToString());
request.Headers.Add(Globals.XsrfTokenCookieAndHeaderName, xsrfToken);
var durableClientMoq = new Mock <IDurableClient>();
var logMoq = new Mock <ILogger>();
// Getting the list of all functions to be validated
var functionsToBeCalled = typeof(DfmEndpoint).Assembly.DefinedTypes
.Where(t => t.IsClass)
.SelectMany(t => t.GetMethods(BindingFlags.Static | BindingFlags.Public))
.Where(m => m.CustomAttributes.Any(a => a.AttributeType == typeof(FunctionNameAttribute)))
.Select(m => m.Name)
.ToHashSet();
// Only these two methods should be publicly accessible as of today
functionsToBeCalled.Remove(nameof(ServeStatics.DfmServeStaticsFunction));
functionsToBeCalled.Remove(nameof(EasyAuthConfig.DfmGetEasyAuthConfigFunction));
// Collecting the list of functions that were actually called by this test
var functionsThatWereCalled = new HashSet <string>();
logMoq.Setup(log => log.Log(It.IsAny <LogLevel>(), It.IsAny <EventId>(), It.IsAny <It.IsAnyType>(), It.IsAny <Exception>(), It.IsAny <Func <It.IsAnyType, Exception, string> >()))
.Callback((LogLevel l, EventId i, object s, Exception ex, object o) =>
{
// Ensuring the correct type of exception was raised internally
Assert.IsInstanceOfType(ex, typeof(UnauthorizedAccessException));
Assert.AreEqual("No access token provided. Call is rejected.", ex.Message);
// Also extracting the function name, that was called, from current stack trace
foreach (var stackFrame in new StackTrace().GetFrames())
{
var method = stackFrame.GetMethod();
if (method.CustomAttributes.Any(a => a.AttributeType == typeof(FunctionNameAttribute)))
{
functionsThatWereCalled.Add(method.Name);
}
}
});
Environment.SetEnvironmentVariable(EnvVariableNames.DFM_HUB_NAME, string.Empty);
// Act
var results = new List <IActionResult>()
{
await About.DfmAboutFunction(request, "-", "TestHub", logMoq.Object),
await new CleanEntityStorage(null).DfmCleanEntityStorageFunction(request, durableClientMoq.Object, "-", "TestHub", logMoq.Object),
await new DeleteTaskHub(null).DfmDeleteTaskHubFunction(request, durableClientMoq.Object, "-", "TestHub", logMoq.Object),
await new IdSuggestions(null).DfmGetIdSuggestionsFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", logMoq.Object),
await ManageConnection.DfmManageConnectionFunction(request, "-", "TestHub", new Microsoft.Azure.WebJobs.ExecutionContext(), logMoq.Object),
await new IdSuggestions(null).DfmGetIdSuggestionsFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", logMoq.Object),
await new Orchestration(null).DfmGetOrchestrationFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", logMoq.Object),
await new Orchestration(null).DfmGetOrchestrationHistoryFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", logMoq.Object),
await new Orchestration(null).DfmStartNewOrchestrationFunction(request, durableClientMoq.Object, "-", "TestHub", logMoq.Object),
await new Orchestration(null).DfmPostOrchestrationFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", "todo", logMoq.Object),
await new Orchestration(null).DfmGetOrchestrationTabMarkupFunction(request, durableClientMoq.Object, "-", "TestHub", "abc", "todo", logMoq.Object),
await new Orchestrations(null).DfmGetOrchestrationsFunction(request, durableClientMoq.Object, "-", "TestHub", logMoq.Object),
await new PurgeHistory(null).DfmPurgeHistoryFunction(request, durableClientMoq.Object, "-", "TestHub", logMoq.Object),
await TaskHubNames.DfmGetTaskHubNamesFunction(request, logMoq.Object),
await FunctionMap.DfmGetFunctionMap(request, "-", "TestHub", logMoq.Object),
};
// Assert
results.ForEach(r => Assert.IsInstanceOfType(r, typeof(UnauthorizedResult)));
functionsToBeCalled.ExceptWith(functionsThatWereCalled);
Assert.IsTrue(functionsToBeCalled.Count == 0, "You forgot to test " + string.Join(", ", functionsToBeCalled));
}
public AggregateExpressionBuilder(ClassMappingDescriptor descriptor, ICollection <MemberMappingDescriptor> members, FunctionMap functionMap)
{
m_contexts = new List <AggregateFunctionContext>(members.Count);
foreach (MemberMappingDescriptor member in members)
{
m_contexts.Add(CreateMemberContext(descriptor, member, functionMap));
}
}
private AggregateFunctionContext CreateMemberContext(ClassMappingDescriptor descriptor, MemberMappingDescriptor member, FunctionMap functionMap)
{
Type implementationType = functionMap.GetTypeForFunction(member.AggregateMappingDescription.FunctionName);
string functionObjectName = string.Format("_{0}_to_{1}_Fn_",
member.AggregateMappingDescription.FunctionObject,
member.Member);
if (implementationType.IsGenericType)
{
if (member.IsArray || member.IsList)
{
Type instanceType = member.IsArray ?
member.AggregateMappingDescription.TargetType.GetElementType() :
member.AggregateMappingDescription.TargetType.GetGenericArguments()[0];
implementationType = implementationType.MakeGenericType(instanceType);
}
else
{
implementationType = implementationType.MakeGenericType(member.AggregateMappingDescription.TargetType);
}
}
IAggregateFunctionCodeGenerator generator = GetGeneratorImpl(implementationType, member);
return(new AggregateFunctionContext(member,
descriptor,
implementationType,
functionObjectName,
generator));
}
