public static ProjectMethod FindMethodSymbolAndProjectInSolution(Solution solution, MethodDescriptor methodDescriptor)
{
ProjectMethod res;
res.Method = null;
res.Project = null;
foreach (var project in solution.Projects)
{
// Alternative method using SymbolFinder, it only works with methods in the solution
// Discarded by the moment
//var methodDeclarations = SymbolFinder.FindDeclarationsAsync(project, methodDescriptor.MethodName,false).Result;
//methodDeclarations = methodDeclarations.Where(ms => methodDescriptor.SameAsMethodSymbom(ms as IMethodSymbol));
//if (methodDeclarations.Count() > 0)
//{
// return methodDeclarations.First() as IMethodSymbol;
//}
//else
//{
// My own method
var method = FindMethodSymbolInProject(methodDescriptor, project);
if (method != null)
{
res.Project = project;
res.Method = method;
return res;
}
//}
}
return res;
}
public StatementProcessor(MethodDescriptor m,
PropGraphNodeDescriptor rv, PropGraphNodeDescriptor thisRef,
IEnumerable<PropGraphNodeDescriptor> parameters,
ProjectCodeProvider codeProvider)
{
// this.containerEntity = containerEntity;
this.ReturnVariable = rv;
this.Method = m;
this.ParameterNodes = parameters;
this.ThisRef = thisRef;
this.PropagationGraph = new PropagationGraph();
this.InstantiatedTypes = new HashSet<TypeDescriptor>();
this.RemovedTypes = new HashSet<TypeDescriptor>();
if (rv != null)
{
PropagationGraph.AddRet(rv);
}
if (thisRef != null)
{
PropagationGraph.Add(thisRef);
}
foreach (var parameter in this.ParameterNodes)
{
if (parameter != null)
{
PropagationGraph.Add(parameter);
}
}
//this.dispatcher = dispatcher;
}
public HubInvokerContext(IHub hub, StateChangeTracker tracker, MethodDescriptor methodDescriptor, object[] args)
{
Hub = hub;
MethodDescriptor = methodDescriptor;
Args = args;
StateTracker = tracker;
}
public HubInvokerContext(IHub hub, TrackingDictionary state, MethodDescriptor methodDescriptor, object[] args)
{
Hub = hub;
MethodDescriptor = methodDescriptor;
Args = args;
State = state;
}
public ActionResult Create(Type modelType, int index)
{
var typeMapping = ModelMappingManager.FindByType(modelType);
var mapping = typeMapping.Constructors.FirstOrDefault(m => m.Index == index);
if (mapping == null)
throw new RunningObjectsException(string.Format("No constructor found at index {0} for type {1}", index, modelType.PartialName()));
var descriptor = new MethodDescriptor(mapping, ControllerContext.GetActionDescriptor(RunningObjectsAction.Create));
return View(new Method(descriptor));
}
public void CallMethod(MethodDescriptor method, IRpcController controller, IMessage request, IMessage responsePrototype, Action<IMessage> done)
{
uint hash = method.Service.GetHash();
ExternalService externalService = exportedServicesIds[hash];
var requestId = externalService.GetNextRequestId();
callbacks.Enqueue(new Callback { Action = done, Builder = responsePrototype.WeakToBuilder(), RequestId = requestId });
ServerPacket data = new ServerPacket(externalService.Id, (int)GetMethodId(method), requestId, ListenerId).WriteMessage(request);
Send(data);
}
async internal Task<MethodEntity> CreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
MethodEntity methodEntity = null;
var tree = await this.GetSyntaxAsync(methodDescriptor);
if(tree==null)
{ }
var model = this.Compilation.GetSemanticModel(tree);
var methodEntityGenerator = new MethodSyntaxProcessor(model, this, tree, methodDescriptor);
methodEntity = methodEntityGenerator.ParseMethod();
return methodEntity;
}
public BaseMethodDeclarationSyntax FindMethodSyntax(MethodDescriptor method, out IMethodSymbol symbol)
{
var root = this.SyntaxTree.GetRoot();
var visitor = new MethodFinder(method, this.SemanticModel);
visitor.Visit(root);
Contract.Assert(visitor.Result != null);
symbol = (IMethodSymbol)this.SemanticModel.GetDeclaredSymbol(visitor.Result);
return visitor.Result;
}
public MethodDescriptor FindMethodImplementation(MethodDescriptor methodDescriptor, TypeDescriptor typeDescriptor)
{
var roslynMethod = FindMethod(methodDescriptor);
if (roslynMethod != null)
{
var roslynType = RoslynSymbolFactory.GetTypeByName(typeDescriptor.TypeName, this.Compilation);
var implementedMethod = Utils.FindMethodImplementation(roslynMethod, roslynType);
return new MethodDescriptor(implementedMethod);
}
// If we cannot resolve the method, we return the same method.
return methodDescriptor;
}
/// <summary>
/// We use this mapping as a cache of already computed callees info
/// </summary>
//public MethodEntityProcessor EntityProcessor { get; private set; }
//public ISet<E> NodesProcessing = new HashSet<E>();
//public ISet<CallConext<M,E>> NodesProcessing = new HashSet<CallConext<M,E>>();
/// <summary>
/// A method entity is built using the methods interface (params, return) and the propagation graph that is
/// initially populated with the variables, parameters and calls of the method
/// </summary>
/// <param name="methodDescriptor"></param>
/// <param name="mid"></param>
/// <param name="propGraph"></param>
/// <param name="instantiatedTypes"></param>
public MethodEntity(MethodDescriptor methodDescriptor,
MethodInterfaceData mid,
PropagationGraph propGraph,
IEnumerable<TypeDescriptor> instantiatedTypes)
: base()
{
this.MethodDescriptor = methodDescriptor;
this.EntityDescriptor = EntityFactory.Create(methodDescriptor);
this.MethodInterfaceData = mid;
this.PropGraph = propGraph;
this.InstantiatedTypes = new HashSet<TypeDescriptor>(instantiatedTypes);
}
public static IMethodSymbol FindMethodInCompilation(MethodDescriptor methodDescriptor, Compilation compilation)
{
var type = GetTypeByName(methodDescriptor.ClassName, compilation);
if (type != null)
{
var members = type.GetMembers(methodDescriptor.MethodName);
if (members.Count() > 0)
{
var member = members.First() as IMethodSymbol;
return member;
}
}
return null;
}
internal static IEntityDescriptor Create(MethodDescriptor methodDescriptor, IDispatcher dispatcher)
{
IEntityDescriptor result = null;
if (dispatcher is OrleansDispatcher)
{
var orleanDispatcher = (OrleansDispatcher)dispatcher;
//var guid = orleanDispatcher.GetGuidForMethod(methodDescriptor);
// I think we should consult the dispatcher about an existing ID for the descriptor
result = new OrleansEntityDescriptor(methodDescriptor); //System.Guid.NewGuid());
}
else
{
result = new MethodEntityDescriptor(methodDescriptor);
}
return result;
}
/// <summary>
/// We use this mapping as a cache of already computed callees info
/// </summary>
//public MethodEntityProcessor EntityProcessor { get; private set; }
//public ISet<E> NodesProcessing = new HashSet<E>();
//public ISet<CallConext<M,E>> NodesProcessing = new HashSet<CallConext<M,E>>();
/// <summary>
/// A method entity is built using the methods interface (params, return) and the propagation graph that is
/// initially populated with the variables, parameters and calls of the method
/// </summary>
/// <param name="methodDescriptor"></param>
/// <param name="mid"></param>
/// <param name="propGraph"></param>
/// <param name="instantiatedTypes"></param>
public MethodEntity(MethodDescriptor methodDescriptor,
MethodInterfaceData mid,
PropagationGraph propGraph,
IEntityDescriptor descriptor,
IEnumerable<TypeDescriptor> instantiatedTypes,
bool canBeAnalyzed = true)
: base()
{
this.MethodDescriptor = methodDescriptor;
this.EntityDescriptor = descriptor; // EntityFactory.Create(methodDescriptor);
this.MethodInterfaceData = mid;
this.propGraph = propGraph;
this.InstantiatedTypes = new HashSet<TypeDescriptor>(instantiatedTypes);
this.CanBeAnalized = canBeAnalyzed;
}
public void CallMethod(MethodDescriptor method, IRpcController controller, IMessage request, IMessage responsePrototype, Action<IMessage> done, ulong objectId)
{
var serviceName = method.Service.FullName;
var serviceHash = StringHashHelper.HashString(serviceName);
if (!this.Services.ContainsKey(serviceHash))
{
Logger.Error("Not bound to client service {0} [0x{1}] yet.", serviceName, serviceHash.ToString("X8"));
return;
}
var serviceId = this.Services[serviceHash];
var packet = new Packet(
new Header((byte)serviceId, (uint)(method.Index + 1), this._requestCounter++, (uint)request.SerializedSize, objectId),
request.ToByteArray());
this.Send(packet);
}
public async Task<Tuple<BaseMethodDeclarationSyntax, IMethodSymbol>> FindMethodSyntaxAsync(MethodDescriptor method)
{
var root = await this.SyntaxTree.GetRootAsync();
var visitor = new MethodFinder(method, this.SemanticModel);
visitor.Visit(root);
if (visitor.Result != null)
{
return new Tuple<BaseMethodDeclarationSyntax, IMethodSymbol>(
visitor.Result,
(IMethodSymbol)this.SemanticModel.GetDeclaredSymbol(visitor.Result)
);
}
else
{
return null;
}
}
async internal static Task<MethodEntity> FindProviderAndCreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
MethodEntity methodEntity = null;
var pair = await ProjectCodeProvider.GetProjectProviderAndSyntaxAsync(methodDescriptor);
if (pair != null)
{
var provider = pair.Item1;
var tree = pair.Item2;
var model = provider.Compilation.GetSemanticModel(tree);
var methodEntityGenerator = new MethodSyntaxProcessor(model, provider, tree, methodDescriptor);
methodEntity = methodEntityGenerator.ParseMethod();
}
else
{
var libraryMethodVisitor = new LibraryMethodProcessor(methodDescriptor);
methodEntity = libraryMethodVisitor.ParseLibraryMethod();
}
return methodEntity;
}
public void CallMethod(MethodDescriptor method, IMessage request, ulong localObjectId)
{
var serviceName = method.Service.FullName;
var serviceHash = StringHashHelper.HashIdentity(serviceName);
if (!this.Services.ContainsKey(serviceHash))
{
Logger.Error("Not bound to client service {0} [0x{1}] yet.", serviceName, serviceHash.ToString("X8"));
return;
}
var serviceId = this.Services[serviceHash];
var remoteObjectId = GetRemoteObjectID(localObjectId);
Logger.Debug("Calling {0} localObjectId={1}, remoteObjectId={2}", method.FullName, localObjectId, remoteObjectId);
var packet = new BNetPacket(
new BNetHeader((byte)serviceId, (uint)(method.Index + 1), this._requestCounter++, (uint)request.SerializedSize, remoteObjectId),
request.ToByteArray());
this.Connection.Send(packet);
}
private void WriteMethodDefinition(TextWriter output, MethodDescriptor item)
{
output.Write(item.Signature.IsFunction ? "Func " : "Proc ");
output.Write(string.Format("{0} entryPoint: {1}, frameSize:{2}\n",
item.Signature.Name,
item.EntryPoint,
item.VariableFrameSize));
output.Write(string.Format(".args {0}\n", item.Signature.ArgCount));
if (item.Signature.Params != null)
{
for (int i = 0; i < item.Signature.Params.Length; i++)
{
output.Write(string.Format("{0,-3}: ByVal={1}", i, item.Signature.Params[i].IsByValue.ToString()));
if (item.Signature.Params[i].HasDefaultValue)
{
output.Write(string.Format(" defValue: {0}\n", item.Signature.Params[i].DefaultValueIndex));
}
else
{
output.WriteLine();
}
}
}
}
public Task <PropagationEffects> AddMethodAsync(MethodDescriptor methodToAdd)
{
StatsHelper.RegisterMsg("ProjectGrain::AddMethod", this.GrainFactory);
return(this.projectCodeProvider.AddMethodAsync(methodToAdd));
}
public RequestContext(GoContext goContext, MethodDescriptor methodDescriptor)
{
GoContext = goContext;
MethodDescriptor = methodDescriptor;
}
public Task <MethodDescriptor> GetOverridenMethodAsync(MethodDescriptor methodDescriptor)
{
StatsHelper.RegisterMsg("ProjectGrain::GetOverridenMethod", this.GrainFactory);
return(this.projectCodeProvider.GetOverridenMethodAsync(methodDescriptor));
}
private static void WriteMethodInvocation(StringBuilder builder, MethodDescriptor methodDescriptor, string currentIndent)
{
builder.Append($".{methodDescriptor.Name}(");
WriteMethodParameters(builder, methodDescriptor, currentIndent);
builder.Append(")");
}
public override Task <IEntity> CreateMethodEntityAsync(MethodDescriptor methodDescriptor)
{
reachableMethods.Add(methodDescriptor);
return(base.CreateMethodEntityAsync(methodDescriptor));
}
private static string GetMethodName(MethodDescriptor method)
{
return(Json.CamelCase(method.Name));
}
public override Task <bool> IsReachableAsync(MethodDescriptor methodDescriptor)
{
return(Task.FromResult(this.MethodEntities.ContainsKey(methodDescriptor)));
}
public bool HasAttributes <T1, T2>() where T1 : Attribute where T2 : Attribute
{
return(MethodDescriptor.HasAttributes <T1, T2>());
}
// rpc to client
public void CallMethod(MethodDescriptor method, IMessage request)
{
CallMethod(method, request, 0);
}
public bool HasAttribute <T>() where T : Attribute
{
return(MethodDescriptor.HasAttribute <T>());
}
public bool HasActionOrHandlerAttribute <T>() where T : Attribute
{
return(MethodDescriptor.HasAttribute <T>() || HandlerTypeDescriptor.HasAttribute <T>());
}
public static uint GetMethodId(MethodDescriptor method)
{
return((uint)method.Options[bnet.protocol.Rpc.MethodId.Descriptor]);
}
private RestMethod(MethodDescriptor protoMethod, HttpMethod httpMethod, JsonParser parser, Func <IMessage, TranscodingOutput> contentFactory) => (_protoMethod, _httpMethod, _parser, FullName, _contentFactory) =
public override Task <IMethodEntityWithPropagator> GetMethodEntityAsync(MethodDescriptor methodDescriptor)
{
var methodEntityGrain = OrleansMethodEntity.GetMethodEntityGrain(grainFactory, methodDescriptor);
return(Task.FromResult <IMethodEntityWithPropagator>(methodEntityGrain));
}
public Task <bool> IsReachableAsync(MethodDescriptor methodDescriptor)
{
//StatsHelper.RegisterMsg("ProjectGrain::IsReachable", this.GrainFactory);
return(this.projectCodeProvider.IsReachableAsync(methodDescriptor));
}
private bool WriteTestMethodInvocationToken(string tokenName, int propertyIndex, StringBuilder builder, TestGenerationContext context, string testTemplate, MethodDescriptor methodDescriptor)
{
int numberOfParameters = methodDescriptor.MethodParameters.Count();
switch (tokenName)
{
case "TestedMethodName":
builder.Append(methodDescriptor.Name);
break;
case "TestMethodName":
this.WriteTestMethodName(builder, context, methodDescriptor);
break;
case "AsyncModifier":
if (methodDescriptor.IsAsync)
{
builder.Append("async");
}
break;
case "AsyncReturnType":
builder.Append(methodDescriptor.IsAsync ? "Task" : "void");
break;
case "ParameterSetupDefaults":
WriteParameterSetupDefaults(builder, context, methodDescriptor);
break;
case "ParameterSetupTodo":
for (int j = 0; j < numberOfParameters; j++)
{
builder.Append($"{methodDescriptor.MethodParameters[j].TypeInformation} {methodDescriptor.MethodParameters[j].ArgumentName} = TODO;");
if (j < numberOfParameters - 1)
{
builder.AppendLine();
}
}
break;
case "MethodInvocationPrefix":
if (methodDescriptor.HasReturnType)
{
builder.Append("var result = ");
}
if (methodDescriptor.IsAsync)
{
builder.Append("await ");
}
break;
case "MethodInvocation":
WriteMethodInvocation(builder, methodDescriptor, FindIndent(testTemplate, propertyIndex));
break;
default:
return(false);
}
return(true);
}
public Task <bool> IsReachableAsync(MethodDescriptor methodDescriptor)
{
return(solutionGrain.IsReachableAsync(methodDescriptor));
}
private void WriteTestMethod(StringBuilder builder, TestGenerationContext context, string testTemplate, MethodDescriptor methodDescriptor = null)
{
string filledTemplate = StringUtilities.ReplaceTokens(
testTemplate,
(tokenName, propertyIndex, builder2) =>
{
if (WriteGlobalToken(tokenName, builder2, context))
{
return;
}
if (this.WriteTestMethodCommonToken(tokenName, propertyIndex, builder2, context, testTemplate))
{
return;
}
if (methodDescriptor != null && this.WriteTestMethodInvocationToken(tokenName, propertyIndex, builder2, context, testTemplate, methodDescriptor))
{
return;
}
WriteTokenPassthrough(tokenName, builder2);
});
builder.Append(filledTemplate);
}
public override async Task <IMethodEntityWithPropagator> GetMethodEntityAsync(MethodDescriptor methodDescriptor)
{
IMethodEntityWithPropagator result;
await this.methodEntitiesMutex.WaitAsync();
try
{
if (!this.MethodEntities.TryGetValue(methodDescriptor, out result))
{
var methodEntity = await this.CreateMethodEntityAsync(methodDescriptor.BaseDescriptor) as MethodEntity;
if (methodDescriptor.IsAnonymousDescriptor)
{
methodEntity = methodEntity.GetAnonymousMethodEntity((AnonymousMethodDescriptor)methodDescriptor);
}
result = new MethodEntityWithPropagator(methodEntity, this);
//lock (this.methodEntities)
{
this.MethodEntities.TryAdd(methodDescriptor, result);
}
}
}
finally
{
this.methodEntitiesMutex.Release();
}
return(result);
}
private static bool WriteTestMethodNameToken(string tokenName, StringBuilder builder, MethodDescriptor methodDescriptor)
{
switch (tokenName)
{
case "TestedMethodName":
builder.Append(methodDescriptor.Name);
break;
default:
return(false);
}
return(true);
}
private static void WriteParameterSetupDefaults(StringBuilder builder, TestGenerationContext context, MethodDescriptor methodDescriptor)
{
int numberOfParameters = methodDescriptor.MethodParameters.Count();
for (int j = 0; j < numberOfParameters; j++)
{
TypeDescriptor typeInformation = methodDescriptor.MethodParameters[j].TypeInformation;
string argumentValue;
if (typeInformation.TypeSymbol != null)
{
// If we have proper type information, generate the default expression for this type
var generator = Microsoft.CodeAnalysis.Editing.SyntaxGenerator.GetGenerator(context.Document);
argumentValue = generator.DefaultExpression(typeInformation.TypeSymbol).ToString();
}
else
{
argumentValue = "TODO";
}
builder.Append($"{typeInformation} {methodDescriptor.MethodParameters[j].ArgumentName} = {argumentValue};");
if (j < numberOfParameters - 1)
{
builder.AppendLine();
}
}
}
public static MethodDescriptor[] GetMethodData(string ifaceName)
{
IntPtr buffer;
UInt16 count;
int res = typeinfo_GetAllMethodData(ifaceName, out buffer, out count);
if (res != 0) {
throw new Exception(String.Format("GetAllMethodData({0}) " +
"failed: {1:X8}",
ifaceName, res));
}
MethodDescriptor[] methods = new MethodDescriptor[count];
for (int i = 0; i < (UInt16)count; i++) {
IntPtr infoptr = Marshal.ReadIntPtr(buffer, i *
Marshal.SizeOf(typeof(IntPtr)));
try {
methods[i] = ConvertMethodDescriptor(infoptr, ifaceName, i);
} catch (Exception e) {
Console.WriteLine("skipping {0}[{1}]: {2}",
ifaceName, i, e.Message);
}
}
if (count > 0)
Marshal.FreeCoTaskMem(buffer);
return methods;
}
static ParamDescriptor BuildParamDescriptor(IntPtr paramptr, int index,
MethodDescriptor method)
{
XPTParamDescriptor xptpd = (XPTParamDescriptor)
Marshal.PtrToStructure(paramptr, typeof(XPTParamDescriptor));
ParamDescriptor pd = new ParamDescriptor();
pd.method = method;
pd.index = index;
pd.flags = (ParamFlags) xptpd.param_flags;
pd.type = xptpd.type;
return pd;
}
public override Task <bool> IsReachableAsync(MethodDescriptor methodDescriptor)
{
return(Task.FromResult(reachableMethods.Contains(methodDescriptor)));
}
static ParamDescriptor BuildRetValDescriptor(IntPtr paramptr,
MethodDescriptor method)
{
return BuildParamDescriptor(paramptr, -1, method);
}
private void WriteTestMethodName(StringBuilder builder, TestGenerationContext context, MethodDescriptor methodDescriptor)
{
string testMethodNameTemplate = this.Settings.GetTemplate(
context.TestFramework,
context.MockFramework,
TemplateType.TestMethodName);
string baseTestMethodName = StringUtilities.ReplaceTokens(
testMethodNameTemplate,
(tokenName2, propertyIndex2, builder2) =>
{
if (WriteGlobalToken(tokenName2, builder2, context))
{
return;
}
if (WriteTestMethodNameToken(tokenName2, builder2, methodDescriptor))
{
return;
}
WriteTokenPassthrough(tokenName2, builder2);
});
var testMethodName = CreateUniqueTestMethodName(context, baseTestMethodName);
context.UsedTestMethodNames.Add(testMethodName);
builder.Append(testMethodName);
}
public static bool IsExtensionForMethod(MethodDescriptor extension, MethodDescriptor method)
{
// methods must be same name
if (extension.info.Name != method.info.Name)
return false;
// first argument must be for target type
var extensionParameter = extension.info.GetParameters()[0];
if (extensionParameter.ParameterType != method.info.DeclaringType)
return false;
// remainging argument count must match
int parameterCount = method.info.GetParameters().Length;
if (extension.info.GetParameters().Length != parameterCount + 1)
return false;
return true;
}
private MethodDescriptor ConstructMethodDescriptor(MethodCallInfo mci, bool special)
{
MethodBase method = mci.GetStrongestOverride();
MethodDescriptor md = new MethodDescriptor(
method,
mci.EvaluatedArgumentsWithoutThis,
special ? mci.ArgumentVariabilities : VariabilityPattern.CreateDefault(method).Pattern);
var caller = mci.CallerTemplate.Decompilee;
var callerPd = caller as ProcessDescriptor;
var callerMd = caller as MethodDescriptor;
if (callerPd != null)
md.CallingProcess = callerPd;
else
md.CallingProcess = callerMd.CallingProcess;
return md;
}
static ParamDescriptor[] BuildParamDescriptorArray(IntPtr paramptr,
int count,
MethodDescriptor method)
{
ParamDescriptor[] parr = new ParamDescriptor[count];
for (int i = 0; i < count; i++) {
parr[i] = BuildParamDescriptor(paramptr, i, method);
paramptr = (IntPtr)(paramptr.ToInt32() + 8);
}
return parr;
}
public Task <IProjectCodeProvider> GetProjectCodeProviderAsync(MethodDescriptor methodDescriptor)
{
this.SetRequestContext();
return(solutionGrain.GetProjectCodeProviderAsync(methodDescriptor));
}
static MethodDescriptor ConvertMethodDescriptor(IntPtr xptinfo,
string ifaceName,
int index)
{
XPTMethodDescriptor info;
info = (XPTMethodDescriptor)
Marshal.PtrToStructure(xptinfo, typeof(XPTMethodDescriptor));
MethodDescriptor meth = new MethodDescriptor();
meth.ifaceName = ifaceName;
meth.index = index;
meth.name = System.Char.ToUpper(info.name[0]) + info.name.Substring(1);
meth.flags = (MethodFlags)info.flags;
meth.args = BuildParamDescriptorArray(info.args, info.numArgs, meth);
meth.result = BuildRetValDescriptor(info.result, meth);
if (meth.IsVisible()) {
meth.resultType = meth.FindResultType();
meth.BuildArgTypes();
}
return meth;
}
public Task <CodeGraphModel.SymbolReference> GetDeclarationInfoAsync(MethodDescriptor methodDescriptor)
{
StatsHelper.RegisterMsg("ProjectGrain::GetDeclarationInfo", this.GrainFactory);
return(this.projectCodeProvider.GetDeclarationInfoAsync(methodDescriptor));
}
public T GetActionOrHandlerAttribute <T>() where T : Attribute
{
return(MethodDescriptor.GetAttribute <T>() ?? HandlerTypeDescriptor.GetAttribute <T>());
}
public Task <IMethodEntityWithPropagator> GetMethodEntityAsync(MethodDescriptor methodDescriptor)
{
this.SetRequestContext();
return(solutionGrain.GetMethodEntityAsync(methodDescriptor));
}
// rpc to client
public void CallMethod(MethodDescriptor method, IMessage request)
{
Logger.Debug("CallMethod with 0 localObjectId");
CallMethod(method, request, 0);
}
public IEnumerable <T> GetActionOrHandlerAttributes <T>() where T : Attribute
{
return(MethodDescriptor.GetAttributes <T>()
.Union(HandlerTypeDescriptor.GetAttributes <T>()));
}
internal MethodEntityDescriptor(MethodDescriptor methodDescriptor)
{
this.methodDescriptor = methodDescriptor;
}
public T[] GetAttributes <T>() where T : Attribute
{
return(MethodDescriptor.GetAttributes <T>());
}
/// <summary>
/// Makes an RPC over remote client.
/// </summary>
/// <param name="method">The method to call.</param>
/// <param name="controller">The rpc controller.</param>
/// <param name="request">The request message.</param>
/// <param name="responsePrototype">The response message.</param>
/// <param name="done">Action to run when client responds RPC.</param>
public void CallMethod(MethodDescriptor method, IRpcController controller, IMessage request, IMessage responsePrototype, Action<IMessage> done)
{
var serviceName = method.Service.FullName;
var serviceHash = StringHashHelper.HashIdentity(serviceName);
if (!this.Services.ContainsKey(serviceHash))
{
Logger.Error("Not bound to client service {0} [0x{1}] yet.", serviceName, serviceHash.ToString("X8"));
return;
}
var serviceId = this.Services[serviceHash];
var token = this._tokenCounter++;
RPCCallbacks.Add(token, new RPCCallback(done, responsePrototype.WeakToBuilder()));
var packet = new PacketOut((byte)serviceId, MooNetRouter.GetMethodId(method), (uint)token, this._listenerId, request);
this.Connection.Send(packet);
}
public static IList <MethodDescriptor> Build(GoModel model)
{
var descriptors = new List <MethodDescriptor>();
foreach (var typeModel in model.Types)
{
var goAttribute = typeModel.Attributes.OfType <GoAttribute>().SingleOrDefault();
if (goAttribute == null)
{
continue;
}
foreach (var methodModel in typeModel.Methods)
{
var goRequestAttribute = methodModel.Attributes.OfType <GoRequestAttribute>().SingleOrDefault();
if (goRequestAttribute == null)
{
continue;
}
var interceptorDescriptors = model
.Interceptors
.Concat(typeModel.Interceptors)
.Concat(methodModel.Interceptors)
.Select(i => new InterceptorDescriptor(i))
.OrderBy(i => i.Order)
.ToArray();
var baseUrl = goAttribute.Url;
var path = goRequestAttribute.Path;
if (baseUrl.EndsWith("/") && path.StartsWith("/"))
{
baseUrl = baseUrl.Substring(0, baseUrl.Length - 1);
}
if (!baseUrl.EndsWith("/") && !path.StartsWith("/"))
{
path = path.Insert(0, "/");
}
var uri = baseUrl + path;
var returnType = methodModel.Method.ReturnType;
if (returnType.IsGenericType && typeof(Task).IsAssignableFrom(returnType))
{
returnType = returnType.GenericTypeArguments[0];
}
var methodDescriptor = new MethodDescriptor
{
ClienType = typeModel.Type,
Codec = methodModel.Codec,
InterceptorDescriptors = interceptorDescriptors,
Method = goRequestAttribute.Method,
MethodInfo = methodModel.Method,
ReturnType = returnType,
UrlTemplate = new TemplateString(uri, TemplateUtilities.GetVariables(uri))
};
var parameterModels = new List <ParameterDescriptor>(methodModel.Parameters.Count);
foreach (var parameterModel in methodModel.Parameters)
{
var parameterTarget = GetParameterTarget(methodDescriptor, parameterModel);
var parameterDescriptor = new ParameterDescriptor
{
Name = parameterModel.ParameterName,
ParameterType = parameterModel.ParameterInfo.ParameterType,
FormattingInfo = new ParameterFormattingInfo
{
FormatterName = GetFormatterName(parameterModel),
FormatterType = parameterModel.Attributes.OfType <CustomFormatterAttribute>().LastOrDefault()?.FormatterType,
Target = parameterTarget
}
};
parameterModels.Add(parameterDescriptor);
}
methodDescriptor.Parameters = parameterModels;
descriptors.Add(methodDescriptor);
}
}
return(descriptors);
}
public static uint GetMethodId(MethodDescriptor method)
{
return (uint)method.Options[bnet.protocol.Rpc.MethodId.Descriptor];
}
/// <summary>
/// 重写以将Default中的Array更改为List，使Args能修改
/// </summary>
public override IList <object> ResolveMethodParameters(MethodDescriptor method, IList <IJsonValue> values)
{
method.CheckNotNull("method");
return(method.Parameters.Zip(values, ResolveParameter).ToList());
}
