func writeConnectionHeader(conn *connection) error {
// RPC_HEADER
if _, err := conn.con.Write(gohadoop.RPC_HEADER); err != nil {
log.Fatal("conn.Write gohadoop.RPC_HEADER", err)
return err
}
// RPC_VERSION
if _, err := conn.con.Write(gohadoop.VERSION); err != nil {
log.Fatal("conn.Write gohadoop.VERSION", err)
return err
}
// RPC_SERVICE_CLASS
if serviceClass, err := gohadoop.ConvertFixedToBytes(gohadoop.RPC_SERVICE_CLASS); err != nil {
log.Fatal("binary.Write", err)
return err
} else if _, err := conn.con.Write(serviceClass); err != nil {
log.Fatal("conn.Write RPC_SERVICE_CLASS", err)
return err
}
// AuthProtocol
if authProtocol, err := gohadoop.ConvertFixedToBytes(gohadoop.AUTH_PROTOCOL_NONE); err != nil {
log.Fatal("WTF AUTH_PROTOCOL_NONE", err)
return err
} else if _, err := conn.con.Write(authProtocol); err != nil {
log.Fatal("conn.Write gohadoop.AUTH_PROTOCOL_NONE", err)
return err
}
return nil
}
func sendRequest(c *Client, conn *connection, rpcCall *call) error {
//log.Println("About to call RPC: ", rpcCall.procedure)
// 0. RpcRequestHeaderProto
var clientId [16]byte = [16]byte(*c.ClientId)
rpcReqHeaderProto := hadoop_common.RpcRequestHeaderProto{RpcKind: &gohadoop.RPC_PROTOCOL_BUFFFER, RpcOp: &gohadoop.RPC_FINAL_PACKET, CallId: &rpcCall.callId, ClientId: clientId[0:16], RetryCount: &rpcCall.retryCount}
rpcReqHeaderProtoBytes, err := proto.Marshal(&rpcReqHeaderProto)
if err != nil {
log.Fatal("proto.Marshal(&rpcReqHeaderProto)", err)
return err
}
// 1. RequestHeaderProto
requestHeaderProto := rpcCall.procedure
requestHeaderProtoBytes, err := proto.Marshal(requestHeaderProto)
if err != nil {
log.Fatal("proto.Marshal(&requestHeaderProto)", err)
return err
}
// 2. Param
paramProto := rpcCall.request
paramProtoBytes, err := proto.Marshal(paramProto)
if err != nil {
log.Fatal("proto.Marshal(¶mProto)", err)
return err
}
totalLength := len(rpcReqHeaderProtoBytes) + sizeVarint(len(rpcReqHeaderProtoBytes)) + len(requestHeaderProtoBytes) + sizeVarint(len(requestHeaderProtoBytes)) + len(paramProtoBytes) + sizeVarint(len(paramProtoBytes))
var tLen int32 = int32(totalLength)
if totalLengthBytes, err := gohadoop.ConvertFixedToBytes(tLen); err != nil {
log.Fatal("ConvertFixedToBytes(totalLength)", err)
return err
} else {
if _, err := conn.con.Write(totalLengthBytes); err != nil {
log.Fatal("conn.con.Write(totalLengthBytes)", err)
return err
}
}
if err := writeDelimitedBytes(conn, rpcReqHeaderProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, rpcReqHeaderProtoBytes)", err)
return err
}
if err := writeDelimitedBytes(conn, requestHeaderProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, requestHeaderProtoBytes)", err)
return err
}
if err := writeDelimitedBytes(conn, paramProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, paramProtoBytes)", err)
return err
}
//log.Println("Succesfully sent request of length: ", totalLength)
return nil
}
func writeConnectionContext(c *Client, conn *connection, connectionId *connection_id, authProtocol gohadoop.AuthProtocol) error {
// Create hadoop_common.IpcConnectionContextProto
ugi, _ := gohadoop.CreateSimpleUGIProto()
ipcCtxProto := hadoop_common.IpcConnectionContextProto{UserInfo: ugi, Protocol: &connectionId.protocol}
// Create RpcRequestHeaderProto
var callId int32 = -3
var clientId [16]byte = [16]byte(*c.ClientId)
/*if (authProtocol == gohadoop.AUTH_PROTOCOL_SASL) {
callId = SASL_RPC_CALL_ID
}*/
rpcReqHeaderProto := hadoop_common.RpcRequestHeaderProto{RpcKind: &gohadoop.RPC_PROTOCOL_BUFFFER, RpcOp: &gohadoop.RPC_FINAL_PACKET, CallId: &callId, ClientId: clientId[0:16], RetryCount: &gohadoop.RPC_DEFAULT_RETRY_COUNT}
rpcReqHeaderProtoBytes, err := proto.Marshal(&rpcReqHeaderProto)
if err != nil {
log.Fatal("proto.Marshal(&rpcReqHeaderProto)", err)
return err
}
ipcCtxProtoBytes, _ := proto.Marshal(&ipcCtxProto)
if err != nil {
log.Fatal("proto.Marshal(&ipcCtxProto)", err)
return err
}
totalLength := len(rpcReqHeaderProtoBytes) + sizeVarint(len(rpcReqHeaderProtoBytes)) + len(ipcCtxProtoBytes) + sizeVarint(len(ipcCtxProtoBytes))
var tLen int32 = int32(totalLength)
totalLengthBytes, err := gohadoop.ConvertFixedToBytes(tLen)
if err != nil {
log.Fatal("ConvertFixedToBytes(totalLength)", err)
return err
} else if _, err := conn.con.Write(totalLengthBytes); err != nil {
log.Fatal("conn.con.Write(totalLengthBytes)", err)
return err
}
if err := writeDelimitedBytes(conn, rpcReqHeaderProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, rpcReqHeaderProtoBytes)", err)
return err
}
if err := writeDelimitedBytes(conn, ipcCtxProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, ipcCtxProtoBytes)", err)
return err
}
return nil
}
func sendSaslMessage(c *Client, conn *connection, message *hadoop_common.RpcSaslProto) error {
saslRpcHeaderProto := hadoop_common.RpcRequestHeaderProto{RpcKind: &gohadoop.RPC_PROTOCOL_BUFFFER,
RpcOp: &gohadoop.RPC_FINAL_PACKET,
CallId: &SASL_RPC_CALL_ID,
ClientId: SASL_RPC_DUMMY_CLIENT_ID,
RetryCount: &SASL_RPC_INVALID_RETRY_COUNT}
saslRpcHeaderProtoBytes, err := proto.Marshal(&saslRpcHeaderProto)
if err != nil {
log.Fatal("proto.Marshal(&saslRpcHeaderProto)", err)
return err
}
saslRpcMessageProtoBytes, err := proto.Marshal(message)
if err != nil {
log.Fatal("proto.Marshal(saslMessage)", err)
return err
}
totalLength := len(saslRpcHeaderProtoBytes) + sizeVarint(len(saslRpcHeaderProtoBytes)) + len(saslRpcMessageProtoBytes) + sizeVarint(len(saslRpcMessageProtoBytes))
var tLen int32 = int32(totalLength)
if totalLengthBytes, err := gohadoop.ConvertFixedToBytes(tLen); err != nil {
log.Fatal("ConvertFixedToBytes(totalLength)", err)
return err
} else {
if _, err := conn.con.Write(totalLengthBytes); err != nil {
log.Fatal("conn.con.Write(totalLengthBytes)", err)
return err
}
}
if err := writeDelimitedBytes(conn, saslRpcHeaderProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, saslRpcHeaderProtoBytes)", err)
return err
}
if err := writeDelimitedBytes(conn, saslRpcMessageProtoBytes); err != nil {
log.Fatal("writeDelimitedBytes(conn, saslRpcMessageProtoBytes)", err)
return err
}
return nil
}