/// <summary>
/// Serialize <see cref="RequestInit"/>.
/// </summary>
/// <param name="request">Request to serialize</param>
private void SerializeRequestBody(RequestInit request)
{
this.binaryWriter.Write((ulong)request.SessionId);
this.binaryWriter.Write((string)request.SessionPwd);
this.binaryWriter.Write((bool)request.ROInterfaceRequiresLocks);
this.binaryWriter.Write((byte)request.Redirection);
}
private void OnNewConnection(IConnection connection)
{
connection.OnPacketReceived = packet =>
{
Task.Run(async() =>
{
RequestCall call = protocol.DeserializeRequest(packet, packet.Length, this.protocolVersion);
RequestResponse response;
switch (call.Request.RequestType)
{
case RingMasterRequestType.Init:
{
RequestInit initRequest = (RequestInit)call.Request;
response = new RequestResponse();
response.Content = new string[] { string.Empty + initRequest.SessionId, Guid.NewGuid().ToString() };
response.ResultCode = (int)RingMasterException.Code.Ok;
break;
}
default:
{
response = await this.requestHandler.Request(call.Request);
break;
}
}
response.CallId = call.CallId;
connection.Send(this.protocol.SerializeResponse(response, this.protocolVersion));
});
};
connection.OnConnectionLost = () => { };
}
public void selectedCard(bool isOpen, int index)
{
if (isOpen)
{
//유저카드선택
}
else
{
//필드카드선택
if (!isInit)
{
RequestInit req = new RequestInit(roomNo);
SocketManager.Instance().sendMessage(req);
IndicatorManager.Instance().show("다른 유져의 선택을 기다립니다.");
}
else
{
//attack
userListPanel.attackGuide.gameObject.SetActive(true);
}
}
}
/// <summary>
/// Initializes the connection with the server.
/// </summary>
/// <param name="connection">Connection to initialize</param>
/// <param name="sessionId">Id of the session</param>
/// <param name="sessionPassword">Session Password</param>
/// <returns>Task that tracks completion of this method</returns>
private async Task Init(
IConnection connection,
ulong sessionId,
string sessionPassword)
{
RequestInit.RedirectionPolicy redirectionPolicy = this.configuration.MustTransparentlyForwardRequests
? RequestInit.RedirectionPolicy.ForwardPreferred
: RequestInit.RedirectionPolicy.RedirectPreferred;
var initRequest = new RequestInit(
sessionId,
sessionPassword,
readOnlyInterfaceRequiresLocks: this.configuration.RequireLockForReadOnlyOperations,
redirection: redirectionPolicy);
var requestWrapper = this.RegisterRequest(initRequest);
RingMasterClientEventSource.Log.Init(requestWrapper.CallId, sessionId, sessionPassword);
await this.SendRequest(connection, requestWrapper);
RequestResponse response = await requestWrapper.TaskCompletionSource.Task;
ThrowIfError(response);
}
/// <summary>
/// Deserialize <see cref="IZooKeeperRequest"/>
/// </summary>
/// <param name="xid">the callid</param>
/// <param name="type">type of the call</param>
/// <param name="sessionState">The PerSession State</param>
/// <param name="ringMasterRequest">The ring master request.</param>
/// <exception cref="System.ArgumentException">unknown type + type</exception>
/// <returns>The Zookeeper Request</returns>
private IZooKeeperRequest DeserializeZooKeeperRequest(int xid, ZooKeeperRequestType type, ZkprPerSessionState sessionState, out IRingMasterRequest ringMasterRequest)
{
ringMasterRequest = null;
switch (type)
{
case ZooKeeperRequestType.Notification: // "0" for Createing a session
ringMasterRequest = null;
return(this.DeserializeNotification(xid));
case ZooKeeperRequestType.CreateSession:
ZkprProtocolMessages.CreateSession cs = this.DeserializeCreateSession();
ringMasterRequest = new RequestInit((ulong)cs.SessionId, cs.IsNullPassword ? string.Empty : cs.Password);
sessionState.ConnectRecieved = true;
return(cs);
case ZooKeeperRequestType.Exists:
ZkprProtocolMessages.Exists ex = this.DeserializeExists(xid);
ringMasterRequest = new RequestExists(ex.Path, ex.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse));
return(ex);
case ZooKeeperRequestType.GetChildren:
ZkprProtocolMessages.GetChildren gc = this.DeserializeGetChildren(xid);
ringMasterRequest = new RequestGetChildren(gc.Path, gc.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null);
return(gc);
case ZooKeeperRequestType.GetChildren2:
ZkprProtocolMessages.GetChildren2 gc2 = this.DeserializeGetChildren2(xid);
ringMasterRequest = new RequestGetChildren(gc2.Path, gc2.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null);
return(gc2);
case ZooKeeperRequestType.GetData:
ZkprProtocolMessages.GetData gd = this.DeserializeGetData(xid);
ringMasterRequest = new RequestGetData(gd.Path, RequestGetData.GetDataOptions.None, gd.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse));
return(gd);
case ZooKeeperRequestType.Create:
ZkprProtocolMessages.Create cr = this.DeserializeCreate(xid);
IReadOnlyList <Acl> acls = this.TranslateZkprAclListToRMAclList(cr.Acls);
CreateMode cm = this.TranslateZkprCreatFlagsToRmCreateMode(cr.Flags);
ringMasterRequest = new RequestCreate(cr.Path, cr.Data, acls, cm);
return(cr);
case ZooKeeperRequestType.Create2:
ZkprProtocolMessages.Create2 cr2 = this.DeserializeCreate2(xid);
IReadOnlyList <Acl> acls2 = this.TranslateZkprAclListToRMAclList(cr2.Acls);
CreateMode cm2 = this.TranslateZkprCreatFlagsToRmCreateMode(cr2.Flags);
ringMasterRequest = new RequestCreate(cr2.Path, cr2.Data, acls2, cm2);
return(cr2);
case ZooKeeperRequestType.SetData:
ZkprProtocolMessages.SetData sd = this.DeserializeSetData(xid);
ringMasterRequest = new RequestSetData(sd.Path, sd.Data, sd.Version);
return(sd);
case ZooKeeperRequestType.Delete:
ZkprProtocolMessages.Delete dl = this.DeserializeDelete(xid);
ringMasterRequest = new RequestDelete(dl.Path, dl.Version, false);
return(dl);
case ZooKeeperRequestType.Ping:
ringMasterRequest = null;
return(this.DeserializePing(xid));
case ZooKeeperRequestType.CloseSession:
ringMasterRequest = null;
sessionState.ConnectRecieved = false; // Renegotiate the CreateSession
return(this.DeserializeCloseSession(xid));
case ZooKeeperRequestType.GetACL:
ZkprProtocolMessages.GetACL ga = this.DeserializeGetACL(xid);
ringMasterRequest = new RequestGetAcl(ga.Path, null);
return(ga);
case ZooKeeperRequestType.SetACL:
ZkprProtocolMessages.SetACL sa = this.DeserializeSetACL(xid);
IReadOnlyList <Acl> sa_acls = this.TranslateZkprAclListToRMAclList(sa.Acls);
ringMasterRequest = new RequestSetAcl(sa.Path, sa_acls, sa.Version);
return(sa);
case ZooKeeperRequestType.Multi:
ZkprProtocolMessages.Multi mu = this.DeserializeMulti(xid);
IReadOnlyList <Op> rmOps = this.TranslateZkprOpsListToRmOpsList(mu.Ops);
ringMasterRequest = new RequestMulti(rmOps, false);
return(mu);
case ZooKeeperRequestType.Auth:
ZkprProtocolMessages.Auth au = this.DeserializeAuth(xid);
ringMasterRequest = new RequestSetAuth(au.RmAuthId);
return(au);
case ZooKeeperRequestType.Check:
case ZooKeeperRequestType.Sync:
case ZooKeeperRequestType.Reconfig:
case ZooKeeperRequestType.SetWatches:
case ZooKeeperRequestType.RemoveWatches:
case ZooKeeperRequestType.CreateContainer:
case ZooKeeperRequestType.DeleteContainer:
case ZooKeeperRequestType.Sasl:
case ZooKeeperRequestType.Error:
default:
break;
}
return(null);
}
