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 }