public static void InvokeOnUnityThread(ServiceMethod callback)
{
lock (Singleton)
{
invokeOnUnityThreadCallbacks[invokeSwap].Add(callback);
}
}
protected virtual void Write(ServiceMethod serviceMethod)
{
this.WriteIdentifier(serviceMethod.Name);
this.Write("(");
var i = 0;
foreach (var parameter in serviceMethod.Parameters)
{
this.WriteIdentifier(parameter.Name);
this.Write(":");
this.WriteIdentifier(parameter.TypeName);
if (i++ < serviceMethod.Parameters.Count - 1)
{
this.Write(" ");
}
}
this.Write(")");
this.WriteLine();
using (this.AcquireIndentationContext())
{
this.WriteAnnotations(serviceMethod);
}
}
public string GetProto(IEnumerable <CqrsChannelInfo> cqrs)
{
// split methods to services
var services = cqrs.ToList().GroupBy(x => x.ServiceName);
// create services
var opts = new SchemaGenerationOptions();
opts.Syntax = ProtoSyntax.Proto3;
services.ForEach(grp => {
var svc = new Service
{
Name = grp.Key
};
grp.ForEach(x => {
var method = new ServiceMethod
{
InputType = x.ChReqType,
OutputType = x.ChRspEnvType,
Name = x.MethodName
};
svc.Methods.Add(method);
});
opts.Services.Add(svc);
});
var proto = Serializer.GetProto(opts);
return(proto);
}
protected virtual ServiceMethod ProcessMethod()
{
var retval = new ServiceMethod
{
Name = this.tokenizer.CurrentIdentifier
};
this.ReadNextToken();
if (this.tokenizer.CurrentToken == FicklefileToken.OpenParen)
{
this.ReadNextToken();
var parameters = new List <ServiceParameter>();
while (this.tokenizer.CurrentToken != FicklefileToken.CloseParen && this.tokenizer.CurrentToken != FicklefileToken.EndOfFile)
{
parameters.Add(this.ProcessParameter());
}
retval.Parameters = parameters;
this.ReadNextToken();
}
if (this.tokenizer.CurrentToken == FicklefileToken.Indent)
{
this.ReadNextToken();
while (this.tokenizer.CurrentToken != FicklefileToken.Dedent &&
this.tokenizer.CurrentToken != FicklefileToken.EndOfFile)
{
if (this.tokenizer.CurrentToken == FicklefileToken.Annotation)
{
var annotation = this.ProcessAnnotation();
this.SetAnnotation(retval, annotation);
if (annotation.Key == "content")
{
var contentParameterName = annotation.Value.Trim();
var serviceParameter = retval.Parameters.FirstOrDefault(c => c.Name == contentParameterName);
retval.ContentServiceParameter = serviceParameter;
}
}
else
{
throw new UnexpectedFicklefileTokenException(this.tokenizer.CurrentToken, null, FicklefileToken.Annotation);
}
}
this.Expect(FicklefileToken.Dedent);
this.ReadNextToken();
}
return(retval);
}
public static void InvokeOnUnityThread(ServiceMethod callback)
{
lock (Singleton)
{
invokeOnUnityThreadCallbacks[invokeSwap].Add(callback);
}
}
/// <summary>
/// 调用服务方法
/// </summary>
/// <param name="method">方法</param>
/// <param name="client">客户端对象</param>
/// <param name="packet">数据</param>
private void InvokeService(ServiceMethod method, SocketAsync <FastPacket> client, FastPacket packet)
{
// 执行Filter特性
foreach (var filter in method.Filters)
{
if (filter.OnExecuting(client, packet) == false)
{
return;
}
}
try
{
var parameters = this.GetParameters(method, client, packet);
var returnValue = method.Invoke(this, parameters);
if (method.HasReturn && client.IsConnected)
{
packet.SetBodyBinary(this.Serializer, returnValue);
client.Send(packet);
}
}
catch (Exception ex)
{
this.OnException(client, ex, packet);
}
}
public ServiceMethod SaveOrUpdateMerge(ServiceMethod serviceMethod)
{
object mergedObj = Session.Merge(serviceMethod);
HibernateTemplate.SaveOrUpdate(mergedObj);
return((ServiceMethod)mergedObj);
}
/// <summary>
/// Lists the methods.
/// </summary>
/// <param name="assemblyLocation">The assembly location.</param>
/// <param name="assemblyName">Name of the assembly.</param>
/// <param name="fullName">The full name.</param>
/// <returns></returns>
public ServiceMethodList ListMethods(string assemblyLocation, string assemblyName, string fullName)
{
Assembly assembly;
var serviceMethodList = new ServiceMethodList();
if (TryLoadAssembly(assemblyLocation, assemblyName, out assembly))
{
var type = assembly.GetType(fullName);
var methodInfos = type.GetMethods();
methodInfos.ToList().ForEach(info =>
{
var serviceMethod = new ServiceMethod {
Name = info.Name
};
var parameterInfos = info.GetParameters().ToList();
parameterInfos.ForEach(parameterInfo =>
serviceMethod.Parameters.Add(
new MethodParameter
{
DefaultValue = parameterInfo.DefaultValue == null ? string.Empty : parameterInfo.DefaultValue.ToString(),
EmptyToNull = false,
IsRequired = true,
Name = parameterInfo.Name,
Type = parameterInfo.ParameterType
}));
serviceMethodList.Add(serviceMethod);
});
}
return(serviceMethodList);
}
private void addServiceMethodBtn_Click(object sender, EventArgs e)
{
FindServiceMethodForm form = new FindServiceMethodForm();
form.FrontendApplication = FrontendApplication;
form.BackendApplication = BackendApplication;
if (form.ShowDialog() == DialogResult.OK)
{
ServiceMethod serviceMethod = MetaManagerServices.GetApplicationService().GetServiceMethodMapsById(form.ServiceMethod.Id);
foreach (WorkflowServiceMethod wfServiceMethod in Workflow.ServiceMethods)
{
if (wfServiceMethod.ServiceMethod.Id == serviceMethod.Id)
{
MessageBox.Show("The selected Service Method is already present in the Workflow.", "MetaManager");
return;
}
}
WorkflowServiceMethod workflowServiceMethod = new WorkflowServiceMethod();
workflowServiceMethod.ServiceMethod = serviceMethod;
workflowServiceMethod.Workflow = Workflow;
Workflow.ServiceMethods.Add(workflowServiceMethod);
Type activityType = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, new Dialog[0], new ServiceMethod[] { serviceMethod }, new DataAccess.Domain.Workflow[0]).Last();
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
typeProvider.AddAssembly(activityType.Assembly);
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
}
public void UpdateWorkflow(Workflow workflow)
{
MetaManagerServices.GetConfigurationManagementService().CheckOutDomainObject(workflow.Id, typeof(Workflow));
Workflow readWorkflow = WorkflowDao.FindById(workflow.Id);
XDocument x = XDocument.Load(XmlReader.Create(new StringReader(readWorkflow.WorkflowXoml)));
var dialogs = from d in x.Descendants()
where d.Attribute("DialogId") != null
select d;
foreach (XElement element in dialogs)
{
Dialog d = DialogDao.FindById(new Guid(element.Attribute("DialogId").Value));
element.Name = XName.Get(WorkflowTypeFactory.GetDialogActivityClassName(d), element.Name.NamespaceName);
}
var serviceMethods = from s in x.Descendants()
where s.Attribute("ServiceMethodId") != null
select s;
foreach (XElement element in serviceMethods)
{
ServiceMethod s = ServiceMethodDao.FindById(new Guid(element.Attribute("ServiceMethodId").Value));
element.Name = XName.Get(WorkflowTypeFactory.GetServiceMethodActivityClassName(s), element.Name.NamespaceName);
}
readWorkflow.WorkflowXoml = x.ToString();
WorkflowDao.SaveOrUpdate(readWorkflow);
}
protected IDbCommand CommandFromServiceMethod(TDbServer server, ServiceMethod serviceMethod)
{
var command = server.CreateCommand();
command.CommandText = serviceMethod.ExecuteAction;
command.CommandType = serviceMethod.ExecuteAction?.Contains("select") ?? true ? CommandType.Text : CommandType.StoredProcedure;
if (CommandTimeout != null)
{
command.CommandTimeout = CommandTimeout.Value;
}
if (server.GetType() != typeof(ODBCServer))
{
foreach (var methodParameter in serviceMethod.Parameters)
{
var dataParameter = DataParameterFromMethodParameter(command, methodParameter);
command.Parameters.Add(dataParameter);
}
}
else
{
var newCommandText = serviceMethod.Parameters.Aggregate(command.CommandText ?? string.Empty, (current, parameter) => current.Replace(DataListUtil.AddBracketsToValueIfNotExist(parameter.Name), parameter.Value));
command.CommandText = newCommandText;
}
return(command);
}
public ConfigureComponentForm()
{
InitializeComponent();
serviceMethod = null;
componentMap = null;
modelService = MetaManagerServices.GetModelService();
}
public View ConnectServiceMethodToView(Guid viewId, Guid serviceMethodId)
{
View theView = ModelService.GetDomainObject <View>(viewId);
ServiceMethod theServiceMethod = ModelService.GetDomainObject <ServiceMethod>(serviceMethodId);
if (theView.ServiceMethod != null)
{
if (theView.ServiceMethod.Id == theServiceMethod.Id)
{
return(theView);
}
else
{
List <IDomainObject> mappedPropertiesToDelete = new List <IDomainObject>();
mappedPropertiesToDelete.AddRange(theView.RequestMap.MappedProperties);
mappedPropertiesToDelete.AddRange(theView.ResponseMap.MappedProperties);
ModelService.StartSynchronizePropertyMapsInObjects(theView, null, mappedPropertiesToDelete);
}
}
theView.ServiceMethod = theServiceMethod;
ModelService.CreateAndSynchronizePropertyMaps(theServiceMethod, theView);
//Spara vyn
return(theView);
}
private static void ListReturnTypes(ServiceMethod serviceMethod, Type returnType)
{
var enumerableType = GetEnumerableType(returnType);
if (enumerableType != null)
{
if (enumerableType.IsPrimitive || enumerableType == typeof(decimal) || enumerableType == typeof(string))
{
serviceMethod.Dev2ReturnType = $"return: {returnType.Name}";
serviceMethod.IsObject = false;
}
else
{
var jObject = GetPropertiesJArray(enumerableType);
serviceMethod.Dev2ReturnType = jObject.ToString(Formatting.None);
serviceMethod.IsObject = true;
}
}
else
{
var jObject = GetPropertiesJObject(returnType);
serviceMethod.Dev2ReturnType = jObject.ToString(Formatting.None);
serviceMethod.IsObject = true;
}
}
private void PopulateComboxBoxes()
{
keyPropertyCbx.Items.Clear();
displayProperty1Cbx.Items.Clear();
displayProperty2Cbx.Items.Clear();
if (UXServiceComponent.ServiceMethod != null)
{
ServiceMethod serviceMethod = applicationService.GetServiceMethodMapsById(UXServiceComponent.ServiceMethod.Id);
serviceMethodTbx.Text = serviceMethod.Name;
foreach (MappedProperty property in serviceMethod.ResponseMap.MappedProperties)
{
keyPropertyCbx.Items.Add(property.Name);
displayProperty1Cbx.Items.Add(property.Name);
displayProperty2Cbx.Items.Add(property.Name);
}
keyPropertyCbx.SelectedItem = UXServiceComponent.KeyPropertyName;
if (UXServiceComponent.DisplayPropertyNames.Count > 0)
{
displayProperty1Cbx.SelectedItem = UXServiceComponent.DisplayPropertyNames[0];
if (UXServiceComponent.DisplayPropertyNames.Count > 1)
{
displayProperty2Cbx.SelectedItem = UXServiceComponent.DisplayPropertyNames[1];
}
}
}
}
public ServiceMethod GetMethod(MethodInfo methodInfo, MethodContexts context)
{
var method = new ServiceMethod(_methodNameMapper.GetMethodName(methodInfo));
var parameterContext = new MethodParameterContexts(context.Services);
var responseContext = new MethodResponseContexts(context.Services);
method.SourceMethod = methodInfo;
method.HttpMethod = _httpMethodMapper.MapHttpMethod(methodInfo);
method.Parameters =
(from parameterInfo in methodInfo.GetParameters()
let parameter = _serviceMethodParameterMapper.MapServiceMethodParameter(parameterInfo, parameterContext)
where parameter != null
select parameter).ToList();
method.Url = _methodUrlMapper.MapMethodUrl(methodInfo, method.Parameters);
method.Response = _methodReponseMapper.MapMethodResponse(methodInfo, responseContext);
method.Comment = _commentsProvider.GetComment(methodInfo);
return(method);
}
public Task Dispatch(ServerServiceImplement impl, ServiceMethod method)
{
switch (method.MethodId)
{
case 1001:
return((impl as IDbSyncNotifyImpl).NotifyPlayerLoaded((ulong)method.Args[0]));
case 2001:
return((impl as ILoginNotifyImpl).NotifyPlayerLogin((ulong)method.Args[0]));
case 3001:
return((impl as ILogicClientImpl).AskChangeName((ulong)method.Args[0], (string)method.Args[1]));
case 3002:
return((impl as ILogicClientImpl).AskAddMoney((ulong)method.Args[0], (uint)method.Args[1]));
case 3003:
return((impl as ILogicClientImpl).AskLearnSkill((ulong)method.Args[0], (uint)method.Args[1]));
case 4001:
return((impl as ILoginClientImpl).AskLogin((ulong)method.Args[0]));
}
return(Task.Run(() => { }));
}
public async Task <T> PostAsync <T>(ServiceMethod serviceMethod, MethodArgs args = null, IDictionary <string, IEnumerable <Stream> > files = null)
{
var authData = _authDataRetriever.GetAuthData();
var endpoint = _apiEndpointFactory.GetEndpoint(serviceMethod);
#region надо тестить!
HttpContent content;
if (files != null)
{
var dataContent = new MultipartFormDataContent
{
new FormUrlEncodedContent(args ?? new MethodArgs())
};
foreach (var filesPair in files)
{
var filesData = new MultipartContent();
filesPair.Value
.ToList()
.ForEach(stream =>
{
var streamContent = new StreamContent(stream);
streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data");
filesData.Add(streamContent);
});
filesData.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data");
filesData.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data");
dataContent.Add(filesData, filesPair.Key);
}
content = dataContent;
}
else
{
content = new FormUrlEncodedContent(args ?? new MethodArgs());
}
#endregion
var result = await endpoint.PostAsync(
serviceMethod.MethodName,
content,
GetCookieFromAuthData(authData),
_serviceUriBuilder
);
if (!result.IsSuccessStatusCode)
{
throw new RequestFailedException(
$"Attempt to load URL \"{result.RequestMessage.RequestUri}\" has failed.",
result
);
}
return(JsonConvert.DeserializeObject <T>(await result.Content.ReadAsStringAsync()));
}
// ReSharper disable InconsistentNaming
public void DbService_ToXml_WhenRecordSetHasBlankFields_ExpectNotPartOfOutputDescription()
// ReSharper restore InconsistentNaming
{
//------------Setup for test--------------------------
var dbService = new DbService();
var dbSource = new DbSource {
ResourceName = "Source"
};
var resourceId = Guid.NewGuid();
dbSource.ResourceID = resourceId;
dbService.Source = dbSource;
var serviceMethod = new ServiceMethod {
Name = "Method"
};
dbService.Method = serviceMethod;
var recordset = new Recordset {
Name = "SomeRecSet"
};
var recordsetField = new RecordsetField {
Alias = "SomeAlias", Name = ""
};
recordset.Fields.Add(recordsetField);
dbService.Recordset = recordset;
// ReSharper disable InconsistentNaming
const string expected = @"<Service ID=""00000000-0000-0000-0000-000000000000"" Name="""" ResourceType=""DbService"" IsValid=""false"">
<Actions>
<Action Name=""SomeRecSet"" Type=""InvokeStoredProc"" SourceID=""{0}"" SourceName=""Source"" ExecuteAction="""" SourceMethod=""Method"">
<Inputs />
<Outputs />
<OutputDescription><![CDATA[<z:anyType xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:d1p1=""http://schemas.datacontract.org/2004/07/Unlimited.Framework.Converters.Graph.Ouput"" i:type=""d1p1:OutputDescription"" xmlns:z=""http://schemas.microsoft.com/2003/10/Serialization/""><d1p1:DataSourceShapes xmlns:d2p1=""http://schemas.microsoft.com/2003/10/Serialization/Arrays""><d2p1:anyType i:type=""d1p1:DataSourceShape""><d1p1:_x003C_Paths_x003E_k__BackingField /></d2p1:anyType></d1p1:DataSourceShapes><d1p1:Format>ShapedXML</d1p1:Format></z:anyType>]]></OutputDescription>
</Action>
</Actions>
<AuthorRoles />
<Comment />
<Tags />
<HelpLink />
<UnitTestTargetWorkflowService />
<BizRule />
<WorkflowActivityDef />
<XamlDefinition />
<DataList />
<TypeOf>InvokeStoredProc</TypeOf>
<DisplayName></DisplayName>
<Category></Category>
<AuthorRoles></AuthorRoles>
<ErrorMessages />
</Service>";
// ReSharper restore InconsistentNaming
//------------Execute Test---------------------------
var xElement = dbService.ToXml();
//------------Assert Results-------------------------
Assert.AreEqual(string.Format(expected, resourceId), xElement.ToString());
}
public void TearDown <T>(Action <object> setupMethod)
{
var method = new ServiceMethod {
Service = typeof(T), Method = setupMethod
};
_teardownMethods.Enqueue(method);
}
public override void SetRequestLine(ServiceMethod method, Uri uri)
{
_host = uri.Host;
var path = uri.PathAndQuery;
Http.WriteRequestLine(ref _requestBuffer, ServiceProtocol.Https, method, Encoding.ASCII.GetBytes(path));
AddHeader("Host", _host);
}
public void Setup <T>(Action <object> setupMethod)
{
var method = new ServiceMethod {
Service = typeof(T), Method = setupMethod
};
_setupMethods.Enqueue(method);
}
void Read6001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[1];
if (br.ReadByte() == (byte)SerializeObjectMark.Common)
{
method.Args[0] = (new PlayerInfo()).Read(br);
}
}
public async Task Store(ServiceMethod serviceMethod)
{
if (!serviceMethod.HasChanges())
{
return;
}
await DispatchEvents(serviceMethod.PendingChanges).ConfigureAwait(false);
}
void Read3001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[2];
method.Args[0] = br.ReadUInt64();
if (br.ReadByte() == (byte)SerializeObjectMark.Common)
{
method.Args[1] = br.ReadString();
}
}
private IList<Interceptor> interceptorList = GlobalConfig.Instance.Interceptors; // 获取拦截器集合
#endregion Fields
#region Constructors
public Invocation(int methodIndex, ServiceMethod methodMetaData, ParamItem[] ParamItems,IRequest request)
{
MethodIndex = methodIndex;
MethodMetaData = methodMetaData;
// 初始化集合
ParamValues = ParamItems;
this.Request = request;
SystemErrors = new List<RspError>();
}
public string GetDefaultMapName()
{
ServiceMethod <string> method = (client) =>
{
return(client.GetDefaultMapName());
};
return(Invoke <string>(method));
}
public string GetSObjectFromCache(string moniker, ServiceMethod method)
{
var obj = mCache.TryGetFromCache(moniker);
if(obj != null && mCache.ShouldUpdate(moniker))
{
PreQueueSObject(moniker,method);
}
return obj;
}
public MapImage ExportMapImage(MapDescription MapDescription, ImageDescription ImageDescription)
{
ServiceMethod <MapImage> method = (client) =>
{
return(client.ExportMapImage(MapDescription, ImageDescription));
};
return(Invoke <MapImage>(method));
}
private void LoadWorkflow()
{
var dialogs = new List <Dialog>();
var serviceMethods = new List <ServiceMethod>();
var subworkflows = new List <DataAccess.Domain.Workflow>();
foreach (WorkflowDialog workflowDialog in Workflow.Dialogs)
{
Dialog dialog = MetaManagerServices.GetDialogService().GetDialogWithViewTree(workflowDialog.Dialog.Id);
dialogs.Add(dialog);
}
foreach (WorkflowServiceMethod workflowServiceMethod in Workflow.ServiceMethods)
{
ServiceMethod serviceMethod = MetaManagerServices.GetApplicationService().GetServiceMethodMapsById(workflowServiceMethod.ServiceMethod.Id);
serviceMethods.Add(serviceMethod);
}
foreach (WorkflowSubworkflow workflowSubworkflow in Workflow.Subworkflows)
{
DataAccess.Domain.Workflow subworkflow = MetaManagerServices.GetDialogService().GetWorkflowById(workflowSubworkflow.SubWorkflow.Id);
subworkflows.Add(subworkflow);
}
IList <Type> activityTypes = new List <Type>();
activityTypes = WorkflowTypeFactory.CreateActivities(Workflow, this.BackendApplication, dialogs, serviceMethods, subworkflows);
if ((activityTypes.Count > 0) && (!string.IsNullOrEmpty(Workflow.WorkflowXoml)))
{
Workflow.WorkflowXoml = ReplaceAssemblyReferences(Workflow.WorkflowXoml, activityTypes[0].Assembly.GetName().Name);
}
workflowControl.LoadWorkflow(Workflow.WorkflowXoml, Workflow.RuleSetXml);
workflowControl.RootActivity.Description = Workflow.Description;
TypeProvider typeProvider = workflowControl.GetService(typeof(ITypeProvider)) as TypeProvider;
if (activityTypes.Count > 0)
{
foreach (Type activityType in activityTypes)
{
workflowControl.ToolBox.AddToolBoxItem(new SelfHostToolboxItem(activityType));
}
typeProvider.AddAssembly(activityTypes[0].Assembly);
}
sessionType = RuleContextFactory.LoadUserSessionType(Workflow.Module.Application);
typeProvider.AddAssembly(sessionType.Assembly);
requestType = WorkflowTypeFactory.CreateRequestType(Workflow);
typeProvider.AddAssembly(requestType.Assembly);
GenerateMembers();
tbxName.Text = Workflow.Name;
}
public void CancelJob(string JobID)
{
ServiceMethod method = (client) =>
{
client.CancelJob(JobID);
};
Invoke(method);
}
public MapServerInfo GetServerInfo(string MapName)
{
ServiceMethod <MapServerInfo> method = (client) =>
{
return(client.GetServerInfo(MapName));
};
return(Invoke <MapServerInfo>(method));
}
public ServiceMethod SaveAndSynchronize(ServiceMethod serviceMethod)
{
Cdc.MetaManager.DataAccess.Domain.Action action = ModelService.GetDomainObject <Cdc.MetaManager.DataAccess.Domain.Action>(serviceMethod.MappedToAction.Id);
ModelService.CreateAndSynchronizePropertyMaps(action, serviceMethod);
serviceMethod = (DataAccess.Domain.ServiceMethod)ModelService.MergeSaveDomainObject(serviceMethod);
return(serviceMethod);
}
public static ServiceRetriever CreateRetriever(ServiceMethod method_)
{
switch (method_)
{
case ServiceMethod.GetObjects:
return new GetObjectServiceRetriever();
case ServiceMethod.FindFutures:
return new FindFuturesServiceRetriever();
case ServiceMethod.GetIntradayHistData:
return new GetHistDataRetriever();
case ServiceMethod.GetEventDates:
return new GetEventDatesRetrieve();
}
return null;
}
/// <summary>
/// Used to add service callbacks.
/// </summary>
/// <param name="update">Update callback.</param>
/// <param name="onGUI">OnGUI callback.</param>
/// <param name="destroy">OnDestroy callback.</param>
public static void AddService(ServiceMethod update, ServiceMethod onGUI, ServiceMethod destroy)
{
if (update != null)
{
updateService -= update;
updateService += update;
}
if (onGUI != null)
{
onguiService -= onGUI;
onguiService += onGUI;
}
if (destroy != null)
{
destroyService -= destroy;
destroyService += destroy;
}
}
public void Read(ServiceMethod method, BinaryReader br)
{
method.MethodId = br.ReadUInt32();
switch (method.MethodId)
{
case 1001:
Read1001(method, br);
break;
case 2001:
Read2001(method, br);
break;
case 3001:
Read3001(method, br);
method.NeedReturn = true;
break;
case 3002:
Read3002(method, br);
method.NeedReturn = true;
break;
case 3003:
Read3003(method, br);
method.NeedReturn = true;
break;
case 4001:
Read4001(method, br);
method.NeedReturn = true;
break;
case 5001:
Read5001(method, br);
break;
case 6001:
Read6001(method, br);
break;
}
}
void Read6001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[1];
if (br.ReadByte() == (byte)SerializeObjectMark.Common)
{
method.Args[0] = (new PlayerInfo()).Read(br);
}
}
void Write6001(ServiceMethod method, BinaryWriter bw)
{
if (method.Args[0] == null)
{
bw.Write((byte)SerializeObjectMark.IsNull);
}
else
{
bw.Write((byte)SerializeObjectMark.Common);
(method.Args[0] as PlayerInfo).Write(bw);
}
}
void Read5001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[0];
}
void Write5001(ServiceMethod method, BinaryWriter bw)
{
}
public string GetSObject(string moniker, ServiceMethod method)
{
var sobject = GetSObjectFromCache(moniker,method);
if(sobject == null)
{
var response = RequestQueue.Instance().QueueRequest(moniker,method);
if (response != null)
{
if (!response.Event.WaitOne(TimeSpan.FromMinutes(1)))
{
SLog.log.ErrorFormat("Timeout when waiting for request {0}", moniker);
}
try
{
response.Event.Dispose();
}
catch (Exception e)
{
SLog.log.ErrorFormat("Exception when disposing response event : {0}", e);
}
if (response.Response != null)
{
mCache.UpdateCache(moniker, response.Response.Xml);
}
else
{
// try cache again, maybe it came in the meantime
sobject = GetSObjectFromCache(moniker,method);
if (sobject != null)
{
return sobject;
}
}
if (response.Response != null)
{
return response.Response.Xml;
}
}
return null;
}
else if (mCache.ShouldUpdate(moniker)) // if item is old queue resubscription
{
PreQueueSObject(moniker,method);
}
return sobject;
}
void Write4001(ServiceMethod method, BinaryWriter bw)
{
bw.Write((ulong)method.Args[0]);
}
void Read3003(ServiceMethod method, BinaryReader br)
{
method.Args = new object[2];
method.Args[0] = br.ReadUInt64();
method.Args[1] = br.ReadUInt32();
}
void Write3003(ServiceMethod method, BinaryWriter bw)
{
bw.Write((ulong)method.Args[0]);
bw.Write((uint)method.Args[1]);
}
/// <summary>
/// Used to remove service callbacks.
/// </summary>
/// <param name="update">Update callback.</param>
/// <param name="onGUI">OnGUI callback.</param>
/// <param name="destroy">OnDestroy callback.</param>
public static void RemoveService(ServiceMethod update, ServiceMethod onGUI, ServiceMethod destroy)
{
if (update != null) updateService -= update;
if (onGUI != null) onguiService -= onGUI;
if (destroy != null) destroyService -= destroy;
}
void Write3001(ServiceMethod method, BinaryWriter bw)
{
bw.Write((ulong)method.Args[0]);
if (method.Args[1] == null)
{
bw.Write((byte)SerializeObjectMark.IsNull);
}
else
{
bw.Write((byte)SerializeObjectMark.Common);
(method.Args[1] as string).Write(bw);
}
}
/// <summary>
/// 如果匹配服务，则按照索引从 0 开始匹配参数
/// 规则：Param|[paramIndex]|[methodIndex] = [value]
/// </summary>
/// <param name="methodMD"></param>
/// <returns></returns>
private ParamItem[] parseParamter(ServiceMethod methodMD,int methodIndex)
{
IList<ParamItem> paramlst = new List<ParamItem>();
NameValueCollection form = request.Form;
string value;
string tmp = "Param|{0}|{1}";
for (int i = 0; i < methodMD.Params.Length; i++) {
value = form[string.Format(tmp, i, methodIndex)];
paramlst.Add(
new ParamItem(methodIndex, i, value)
);
}
return paramlst.ToArray();
}
private ServiceMethod ConvertToServiceMethod(MethodInfo methodInfo)
{
var serviceMethod = new ServiceMethod(CamelCase(methodInfo.Name), methodInfo.Name,
GetParameterString(methodInfo), GetParameterObject(methodInfo));
return serviceMethod;
}
public void Dispatch(ClientServiceImplement impl, ServiceMethod method)
{
switch (method.MethodId)
{
case 5001:
(impl as IClientLogicService).ServerMessageOk();
break;
case 6001:
(impl as IClientLoginService).SyncPlayerInfo((PlayerInfo)method.Args[0]);
break;
}
}
public void Write(ServiceMethod method, BinaryWriter bw)
{
bw.Write(method.MethodId);
switch (method.MethodId)
{
case 1001:
Write1001(method, bw);
break;
case 2001:
Write2001(method, bw);
break;
case 3001:
Write3001(method, bw);
break;
case 3002:
Write3002(method, bw);
break;
case 3003:
Write3003(method, bw);
break;
case 4001:
Write4001(method, bw);
break;
case 5001:
Write5001(method, bw);
break;
case 6001:
Write6001(method, bw);
break;
}
}
void Read4001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[1];
method.Args[0] = br.ReadUInt64();
}
public bool PreQueueSObject(string moniker, ServiceMethod method)
{
return (RequestQueue.Instance().QueueRequest(moniker,method) != null);
}
public QueuedResponse QueueRequest(string moniker, ServiceMethod serviceMethod)
{
//SLog.log.DebugFormat("About to queueReuest {0}", moniker);
lock (mSync)
{
if(mErroredRequests.ContainsKey(moniker))
{
// only allow re-request after 1 minute
var lastRequest = mErroredRequests[moniker];
if((DateTime.Now - lastRequest).TotalMinutes < 1)
{
return null;
}
else
{
mErroredRequests.Remove(moniker);
}
}
if (!mRequests.ContainsKey(moniker))
{
var responseEvent = new QueuedResponse
{
Event = new ManualResetEvent(false)
};
mRequests.Add(moniker, new QueuedRequest
{
Moniker = moniker,
ReponseEvent = responseEvent,
ServiceMethod=serviceMethod
});
//SLog.log.DebugFormat("QueueReuest {0} (queue length is {1})", moniker, mRequests.Count);
mNewRequests.Set();
return responseEvent;
}
return mRequests[moniker].ReponseEvent;
}
}
public void Write(ServiceMethod method, Task handle, BinaryWriter bw)
{
switch (method.MethodId)
{
case 3001:
bw.Write((handle as Task<bool>).Result);
break;
case 3002:
bw.Write((handle as Task<bool>).Result);
break;
case 3003:
bw.Write((handle as Task<bool>).Result);
break;
case 4001:
bw.Write((handle as Task<bool>).Result);
break;
}
}
void Read3001(ServiceMethod method, BinaryReader br)
{
method.Args = new object[2];
method.Args[0] = br.ReadUInt64();
if (br.ReadByte() == (byte)SerializeObjectMark.Common)
{
method.Args[1] = br.ReadString();
}
}
public Task Dispatch(ServerServiceImplement impl, ServiceMethod method)
{
switch (method.MethodId)
{
case 1001:
return (impl as IDbSyncNotifyImpl).NotifyPlayerLoaded((ulong)method.Args[0]);
case 2001:
return (impl as ILoginNotifyImpl).NotifyPlayerLogin((ulong)method.Args[0]);
case 3001:
return (impl as ILogicClientImpl).AskChangeName((ulong)method.Args[0], (string)method.Args[1]);
case 3002:
return (impl as ILogicClientImpl).AskAddMoney((ulong)method.Args[0], (uint)method.Args[1]);
case 3003:
return (impl as ILogicClientImpl).AskLearnSkill((ulong)method.Args[0], (uint)method.Args[1]);
case 4001:
return (impl as ILoginClientImpl).AskLogin((ulong)method.Args[0]);
}
return Task.Run(() => { });
}
/// <summary>
/// 生成函数头 function(param1,param2,param3,...)
/// </summary>
/// <param name="method"></param>
/// <returns></returns>
private string functionString(ServiceMethod method)
{
StringBuilder sbScript = new StringBuilder("function(");
foreach (ServiceMethodParam param in method.Params) {
sbScript.AppendFormat("{0},", param.Name);
}
sbScript.Append("callBackFunc");
sbScript.Append(")");
return sbScript.ToString();
}
