func ProcResultReturned(handler *coreprocessing.Handler, inIns *coreprocessing.CoreInstruction) *coreprocessing.CoreInstruction {
var answer *transport.Answer
var resultChanges *connectionsupport.StateChanges
var errStr string
insType := coreprocessing.TypeInstructionSkip
errCode := 0
if cmd, exists := inIns.GetCommand(); exists {
// return status
resultChanges = &(connectionsupport.StateChanges{
ChangeType: connectionsupport.StateChangesTypeStatus,
Status: connectionsupport.ClientStatusActive})
if len((*cmd).Params.Task) < 1 {
errCode = transport.ErrorCodeMethodParamsFormatWrong
errStr = "Task Id does not exist."
}
} else {
errCode = transport.ErrorCodeCommandFormatWrong
errStr = "Command is empty."
}
if errCode > 0 {
insType = coreprocessing.TypeInstructionProblem
answer = inIns.MakeErrAnswer(errCode, errStr)
} else {
answer = inIns.MakeOkAnswer(
fmt.Sprintf("{\"ok\": true, \"status\": %d}", resultChanges.Status))
insType = coreprocessing.TypeInstructionOk
}
result := coreprocessing.NewCoreInstruction(insType)
result.SetAnswer(answer)
result.StateChanges = resultChanges
return result
}
func ProcUpdateStatus(handler *coreprocessing.Handler, inIns *coreprocessing.CoreInstruction) *coreprocessing.CoreInstruction {
insType := coreprocessing.TypeInstructionSkip
var answer *transport.Answer
var result *coreprocessing.CoreInstruction
var resultChanges *connectionsupport.StateChanges
var errStr string
errCode := 0
if cmd, exists := inIns.GetCommand(); exists {
// check params.data is number type
if newStatus, err := strconv.ParseUint(cmd.Params.Data, 10, 16); err == nil {
changes := connectionsupport.StateChanges{
ChangeType: connectionsupport.StateChangesTypeStatus,
Status: uint16(newStatus)}
resultChanges = &changes
answer = inIns.MakeOkAnswer(
fmt.Sprintf("{\"ok\": true, \"status\": %d}", newStatus))
insType = coreprocessing.TypeInstructionOk
} else {
errCode = transport.ErrorCodeMethodParamsFormatWrong
errStr = "Status has unexpected type."
}
} else {
errCode = transport.ErrorCodeCommandFormatWrong
errStr = "Command is empty."
}
if errCode > 0 {
insType = coreprocessing.TypeInstructionProblem
answer = inIns.MakeErrAnswer(errCode, errStr)
}
result = coreprocessing.NewCoreInstruction(insType)
result.SetAnswer(answer)
result.StateChanges = resultChanges
return result
}
// main method for client routing to server methods
func ProcRouteRpc(handler *coreprocessing.Handler, inIns *coreprocessing.CoreInstruction) *coreprocessing.CoreInstruction {
var answer *transport.Answer
var errStr string
var answerData string
insType := coreprocessing.TypeInstructionSkip
errCode := 0
// check methods
if cmd, exists := inIns.GetCommand(); exists {
rpcManager := coreprocessing.NewRpcServerManager()
variants := rpcManager.GetCidVariants((*cmd).Method)
if len(variants) > 0 {
var freeCid string
for _, serverCid := range variants {
if !handler.StateCheker.ClientBusy(serverCid) {
freeCid = serverCid
break
}
}
if len(freeCid) > 0 {
data := RpcAnswerData{
Cid: freeCid,
Task: handler.TaskIdGenerator.CreateTaskId()}
// TODO: to debug
rllogger.Outputf(rllogger.LogInfo, "rpc call: '%s()' -> %s", (*cmd).Method, data)
if strData, err := json.Marshal(data); err == nil {
answerData = string(strData)
rpcManager.ResultDirectionDict.Set(data.Task, (*inIns).Cid)
} else {
errCode = transport.ErrorCodeInternalProblem
errStr = fmt.Sprintf("Error dump %T: '%s'", data, err)
}
} else {
errCode = transport.ErrorCodeAllServerBusy
errStr = fmt.Sprintf("All server busy for method '%s'.", (*cmd).Method)
}
} else {
errCode = transport.ErrorCodeRemouteMethodNotExists
errStr = fmt.Sprintf("Method '%s' unregistred or workers lost.", (*cmd).Method)
}
} else {
errCode = transport.ErrorCodeCommandFormatWrong
errStr = "Command is empty."
}
if errCode > 0 {
insType = coreprocessing.TypeInstructionProblem
answer = inIns.MakeErrAnswer(errCode, errStr)
} else {
insType = coreprocessing.TypeInstructionOk
answer = inIns.MakeOkAnswer(answerData)
}
result := coreprocessing.NewCoreInstruction(insType)
result.SetAnswer(answer)
return result
}
// check token by client public key
func ProcAuth(handler *coreprocessing.Handler, inIns *coreprocessing.CoreInstruction) *coreprocessing.CoreInstruction {
// client sends in params:
// - json: {"key": "<key name>"}
// - data: "<base64 token string, use JWT protocol (random data inside)>"
// getting (search on option.KeyDir) client public key by name (in command params)
handler.Stat.AddOneMsg("auth_request")
changes := connectionsupport.StateChanges{
ChangeType: connectionsupport.StateChangesTypeAuth}
var result *coreprocessing.CoreInstruction
var resultErr error
var errCode int
if cmd, exists := inIns.GetCommand(); exists {
if authData, err := newAuthData(cmd.Params); err == nil {
if err := authData.Check(handler.Option); err != nil {
errCode = transport.ErrorCodeMethodAuthFailed
resultErr = err
}
} else {
resultErr = err
errCode = transport.ErrorCodeMethodParamsFormatWrong
}
} else {
errCode = transport.ErrorCodeCommandFormatWrong
resultErr = errors.New("Not found command in instruction.")
}
var answer *transport.Answer
var insType int
if errCode > 0 {
changes.Auth = false
answer = inIns.MakeErrAnswer(errCode, fmt.Sprint(resultErr))
insType = coreprocessing.TypeInstructionProblem
rllogger.Outputf(rllogger.LogWarn, "Failed auth from %s with error: %s", inIns.Cid, resultErr)
} else {
changes.Auth = true
handler.Stat.AddOneMsg("auth_successfull")
answer = inIns.MakeOkAnswer("{\"auth\":true}")
insType = coreprocessing.TypeInstructionOk
rllogger.Outputf(rllogger.LogDebug, "Successfull auth from %s", inIns.Cid)
}
result = coreprocessing.NewCoreInstruction(insType)
result.SetAnswer(answer)
result.StateChanges = &changes
return result
}
func ProcRegistration(handler *coreprocessing.Handler, inIns *coreprocessing.CoreInstruction) *coreprocessing.CoreInstruction {
insType := coreprocessing.TypeInstructionSkip
var answer *transport.Answer
var result *coreprocessing.CoreInstruction
var resultChanges *connectionsupport.StateChanges
var errStr string
errCode := 0
if cmd, exists := inIns.GetCommand(); exists {
info := ClientInfo{}
if loadErr := json.Unmarshal([]byte((*cmd).Params.Json), &info); loadErr == nil {
if (*handler).StateCheker.IsAuth(inIns.Cid) {
// TODO: need implimentation for replace current cid to old
switch info.Group {
case connectionsupport.GroupConnectionClient:
{
changes := connectionsupport.StateChanges{
ChangeType: connectionsupport.StateChangesTypeGroup,
ConnectionClientGroup: connectionsupport.GroupConnectionClient}
resultChanges = &changes
answer = inIns.MakeOkAnswer(
fmt.Sprintf("{\"ok\": true, \"cid\": \"%s\"}", inIns.Cid))
}
case connectionsupport.GroupConnectionServer:
{
dict := coreprocessing.NewMethodInstructionDict()
methodsCount := dict.RegisterClientMethods(info.Methods...)
rpcManager := coreprocessing.NewRpcServerManager()
rpcManager.Append(inIns.Cid, &(info.Methods))
answer = inIns.MakeOkAnswer(
fmt.Sprintf(
"{\"methods_count\": %d, \"ok\": true, \"cid\": \"%s\"}",
methodsCount, inIns.Cid))
changes := connectionsupport.StateChanges{
ChangeType: connectionsupport.StateChangesTypeGroup,
ConnectionClientGroup: connectionsupport.GroupConnectionServer}
resultChanges = &changes
}
case connectionsupport.GroupConnectionWsClient:
{
// denied
errCode = transport.ErrorCodeAccessDenied
errStr = "Web-socket client don't accepted on simple TCP socket."
}
default:
{
errCode = transport.ErrorCodeUnexpectedValue
errStr = "Unknown group, see the protocol specification."
}
}
} else {
errCode = transport.ErrorCodeAccessDenied
errStr = "Access denied."
}
} else {
errCode = transport.ErrorCodeMethodParamsFormatWrong
errStr = fmt.Sprint(loadErr)
}
} else {
errCode = transport.ErrorCodeCommandFormatWrong
errStr = "Command is empty."
}
if errCode > 0 {
insType = coreprocessing.TypeInstructionProblem
answer = inIns.MakeErrAnswer(errCode, errStr)
} else {
insType = coreprocessing.TypeInstructionOk
}
result = coreprocessing.NewCoreInstruction(insType)
result.SetAnswer(answer)
result.StateChanges = resultChanges
return result
}