int sendRUAlive(char *seghostname)
{
int res = FUNC_RETURN_OK;
AsyncCommBuffer newcommbuffer = NULL;
SegResource segres = NULL;
int32_t segid = SEGSTAT_ID_INVALID;
Assert(seghostname != NULL);
res = getSegIDByHostName(seghostname, strlen(seghostname), &segid);
if ( res != FUNC_RETURN_OK )
{
elog(WARNING, "Resource manager cannot get registered host %s when send RUAlive message, "
"error code: %d",
seghostname,
res);
return res;
}
segres = getSegResource(segid);
Assert(segres != NULL);
bool oldstat = setSegResRUAlivePending(segres, true);
if( oldstat != false )
{
Assert(false);
}
/* Build request. */
SelfMaintainBufferData tosend;
initializeSelfMaintainBuffer(&tosend, PCONTEXT);
RPCRequestRUAliveData request;
request.Reserved = 0;
appendSMBVar(&tosend, request);
AsyncCommMessageHandlerContext context =
(AsyncCommMessageHandlerContext)
rm_palloc0(AsyncCommContext,
sizeof(AsyncCommMessageHandlerContextData));
context->inMessage = false;
context->MessageRecvReadyHandler = NULL;
context->MessageRecvedHandler = receivedRUAliveResponse;
context->MessageSendReadyHandler = NULL;
context->MessageSentHandler = sentRUAlive;
context->MessageErrorHandler = sentRUAliveError;
context->MessageCleanUpHandler = sentRUAliveCleanUp;
context->UserData = (void *)segres;
/* Connect to HAWQ RM server */
res = registerAsyncConnectionFileDesc(NULL,
seghostname,
rm_segment_port,
ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
&AsyncCommBufferHandlersMessage,
context,
&newcommbuffer);
if ( res != FUNC_RETURN_OK )
{
rm_pfree(AsyncCommContext, context);
elog(WARNING, "Fail to register asynchronous connection for sending "
"RUAlive message. %d", res);
return res;
}
buildMessageToCommBuffer(newcommbuffer,
tosend.Buffer,
tosend.Cursor+1,
REQUEST_RM_RUALIVE,
0,
0);
destroySelfMaintainBuffer(&tosend);
context->AsyncBuffer = newcommbuffer;
InitHandler_Message(newcommbuffer);
return FUNC_RETURN_OK;
}
int decreaseMemoryQuota(char *seghostname,
GRMContainerSet rescontainerset)
{
int res = FUNC_RETURN_OK;
AsyncCommBuffer commbuffer = NULL;
GRMContainerSet ctns = NULL;
Assert( seghostname != NULL );
Assert( rescontainerset->Containers != NULL );
/* Move resource containers that should be returned to communication context.*/
ctns = createGRMContainerSet();
moveGRMContainerSetContainerList(ctns, rescontainerset);
/* Build request */
SelfMaintainBufferData tosend;
initializeSelfMaintainBuffer(&tosend, PCONTEXT);
RPCRequestUpdateMemoryQuotaData request;
request.MemoryQuotaDelta = ctns->Allocated.MemoryMB;
GRMContainer firstcont = getGRMContainerSetContainerFirst(ctns);
Assert( firstcont != NULL );
request.MemoryQuotaTotalPending = firstcont->Resource->Allocated.MemoryMB +
firstcont->Resource->OldInuse.MemoryMB;
Assert( request.MemoryQuotaTotalPending >= 0 );
elog(LOG, "Resource manager decrease host %s memory quota "UINT64_FORMAT" MB, "
"Expected total memory quota after decreasing is " UINT64_FORMAT" MB. "
"Include %d MB old in-use memory quota.",
seghostname,
request.MemoryQuotaDelta,
request.MemoryQuotaTotalPending,
firstcont->Resource->OldInuse.MemoryMB);
appendSMBVar(&tosend, request);
/* Set content to send and add to AsyncComm framework */
AsyncCommMessageHandlerContext context =
(AsyncCommMessageHandlerContext)rm_palloc0(AsyncCommContext,
sizeof(AsyncCommMessageHandlerContextData));
context->inMessage = false;
context->UserData = ctns;
context->MessageRecvReadyHandler = NULL;
context->MessageRecvedHandler = recvDecreaseMemoryQuotaResponse;
context->MessageSendReadyHandler = NULL;
context->MessageSentHandler = sentDecreaseMemoryQuota;
context->MessageErrorHandler = sentDecreaseMemoryQuotaError;
context->MessageCleanUpHandler = sentDecreaseMemoryQuotaCleanup;
res = registerAsyncConnectionFileDesc(NULL,
seghostname,
rm_segment_port,
ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
&AsyncCommBufferHandlersMessage,
context,
&commbuffer);
if ( res != FUNC_RETURN_OK )
{
elog(LOG, "Resource manager failed to set connection to segment host %s "
"on port %d to decrease memory quota.",
seghostname,
rm_segment_port);
processContainersAfterDecreaseMemoryQuota(ctns, false);
freeGRMContainerSet(ctns);
rm_pfree(AsyncCommContext, context);
return res;
}
else
{
elog(DEBUG3, "Resource manager succeeded set connection to segment host %s "
"on port %d to decrease memory quota.",
seghostname,
rm_segment_port);
}
buildMessageToCommBuffer(commbuffer,
tosend.Buffer,
tosend.Cursor+1,
REQUEST_RM_DECREASE_MEMORY_QUOTA,
0,
0);
destroySelfMaintainBuffer(&tosend);
context->AsyncBuffer = commbuffer;
InitHandler_Message(commbuffer);
return FUNC_RETURN_OK;
}
int callSyncRPCRemote(const char *hostname,
uint16_t port,
const char *sendbuff,
int sendbuffsize,
uint16_t sendmsgid,
uint16_t exprecvmsgid,
SelfMaintainBuffer recvsmb,
char *errorbuf,
int errorbufsize)
{
int fd = -1;
int res = FUNC_RETURN_OK;
AsyncCommBuffer newcommbuffer = NULL;
AsyncCommMessageHandlerContext context = NULL;
SyncRPCContextData userdata;
/* Connect to the server side. */
res = connectToServerRemote(hostname, port, &fd);
if ( res != FUNC_RETURN_OK )
{
snprintf(errorbuf, errorbufsize,
"failed to connect to remote socket server %s:%d",
hostname,
port);
elog(WARNING, "%s", errorbuf);
goto exit;
}
initializeSyncRPContent(&userdata, recvsmb, exprecvmsgid);
context = createMessageHandlerContext(&userdata);
res = registerFileDesc(fd,
NULL,
ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
&AsyncCommBufferHandlersMessage,
context,
&newcommbuffer);
if ( res != FUNC_RETURN_OK )
{
rm_pfree(AsyncCommContext, context);
snprintf(errorbuf, errorbufsize,
"failed to register socket connection fd %d connected to %s:%d "
"for resource rpc communication",
fd,
hostname, port);
elog(WARNING, "%s", errorbuf);
goto exit;
}
buildMessageToCommBuffer(newcommbuffer,
sendbuff,
sendbuffsize,
sendmsgid,
0,
0);
context->AsyncBuffer = newcommbuffer;
InitHandler_Message(newcommbuffer);
/* Wait for the complete of the communication. */
while( true )
{
processAllCommFileDescs();
if ( userdata.CommStatus == SYNC_RPC_COMM_IDLE )
{
break;
}
else if ( QueryCancelPending )
{
/*
* We find that this QD wants to cancel the query, we don't need
* to continue the communication.
*/
res = TRANSCANCEL_INPROGRESS;
break;
}
}
res = res == TRANSCANCEL_INPROGRESS ? res : userdata.Result;
/* Close and cleanup */
closeAndRemoveAllRegisteredFileDesc();
if (res != FUNC_RETURN_OK)
{
elog(WARNING, "Sync RPC framework (inet) finds exception raised.");
switch(res)
{
case COMM2RM_CLIENT_FAIL_SEND:
snprintf(errorbuf, errorbufsize, "failed to send content");
break;
case COMM2RM_CLIENT_FAIL_RECV:
snprintf(errorbuf, errorbufsize, "failed to receive content");
break;
case REQUESTHANDLER_WRONGMESSAGE:
snprintf(errorbuf, errorbufsize, "wrong message was received");
break;
default:
Assert(false);
}
}
return res;
exit:
elog(LOG, "Close fd %d at once", fd);
closeConnectionRemote(&fd);
return res;
}
int callSyncRPCDomain(const char *sockfile,
const char *sendbuff,
int sendbuffsize,
uint16_t sendmsgid,
uint16_t exprecvmsgid,
SelfMaintainBuffer recvsmb)
{
static char dfilename[1024];
int fd = -1;
int res = FUNC_RETURN_OK;
AsyncCommBuffer newcommbuffer = NULL;
AsyncCommMessageHandlerContext context = NULL;
SyncRPCContextData userdata;
/* Connect to the server side. */
res = connectToServerDomain(sockfile, 0, &fd, 0, dfilename);
if ( res != FUNC_RETURN_OK )
{
elog(WARNING, "Fail to connect to domain socket server %s, result %d",
sockfile,
res);
goto exit;
}
initializeSyncRPContent(&userdata, recvsmb, exprecvmsgid);
context = createMessageHandlerContext(&userdata);
res = registerFileDesc(fd,
dfilename,
ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
&AsyncCommBufferHandlersMessage,
context,
&newcommbuffer);
if ( res != FUNC_RETURN_OK )
{
rm_pfree(AsyncCommContext, context);
elog(WARNING, "Fail to register FD for synchronous communication. %d", res);
goto exit;
}
buildMessageToCommBuffer(newcommbuffer,
sendbuff,
sendbuffsize,
sendmsgid,
0,
0);
context->AsyncBuffer = newcommbuffer;
InitHandler_Message(newcommbuffer);
/* Wait for the complete of the communication. */
while( true )
{
processAllCommFileDescs();
if ( userdata.CommStatus == SYNC_RPC_COMM_IDLE )
{
break;
}
else if ( QueryCancelPending )
{
/*
* We find that this QD wants to cancel the query, we don't need
* to continue the communication.
*/
res = TRANSCANCEL_INPROGRESS;
break;
}
}
res = res == TRANSCANCEL_INPROGRESS ? res : userdata.Result;
/* Close and cleanup */
closeAndRemoveAllRegisteredFileDesc();
if (res != FUNC_RETURN_OK)
{
elog(WARNING, "Sync RPC framework (domain) finds exception raised.");
}
return res;
exit:
closeConnectionDomain(&fd, dfilename);
return res;
}
/******************************************************************************
* I aM Alive.
*
* Request:
* |<----------- 64 bits (8 bytes) ----------->|
* +----------+--------------------------------+
* | TDC | BDC | Reserved |
* +----------+----------+---------------------+
* | |
* | Machine ID info |
* | |
* +-------------------------------------------+ _____ 64bit aligned
*
* Response:
* |<----------- 64 bits (8 bytes) ----------->|
* +---------------------+---------------------+
* | heartbeat result | Reserved |
* +---------------------+---------------------+ _____ 64bit aligned
*
******************************************************************************/
int sendIMAlive(int *errorcode,
char *errorbuf,
int errorbufsize)
{
int res = FUNC_RETURN_OK;
AsyncCommBuffer newcommbuffer = NULL;
Assert( DRMGlobalInstance->LocalHostStat != NULL );
/* Build request. */
SelfMaintainBufferData tosend;
initializeSelfMaintainBuffer(&tosend, PCONTEXT);
RPCRequestHeadIMAliveData requesthead;
requesthead.TmpDirCount = getDQueueLength(&DRMGlobalInstance->LocalHostTempDirectories);
requesthead.TmpDirBrokenCount = DRMGlobalInstance->LocalHostStat->FailedTmpDirNum;
requesthead.Reserved = 0;
appendSMBVar(&tosend, requesthead);
appendSelfMaintainBuffer(&tosend,
(char *)(DRMGlobalInstance->LocalHostStat),
offsetof(SegStatData, Info) +
DRMGlobalInstance->LocalHostStat->Info.Size);
/* Set content to send and add to AsyncComm framework. */
AsyncCommMessageHandlerContext context =
rm_palloc0(AsyncCommContext,
sizeof(AsyncCommMessageHandlerContextData));
context->inMessage = false;
context->UserData = NULL;
context->MessageRecvReadyHandler = NULL;
context->MessageRecvedHandler = receivedIMAliveResponse;
context->MessageSendReadyHandler = NULL;
context->MessageSentHandler = sentIMAlive;
context->MessageErrorHandler = sentIMAliveError;
context->MessageCleanUpHandler = sentIMAliveCleanUp;
/* Connect to HAWQ RM server */
res = registerAsyncConnectionFileDesc(NULL,
DRMGlobalInstance->SendToStandby?
standby_addr_host:
master_addr_host,
rm_master_port,
ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
&AsyncCommBufferHandlersMessage,
context,
&newcommbuffer);
if ( res != FUNC_RETURN_OK )
{
rm_pfree(AsyncCommContext, context);
elog(WARNING, "Fail to register asynchronous connection for sending "
"IMAlive message. %d", res);
return res;
}
buildMessageToCommBuffer(newcommbuffer,
tosend.Buffer,
tosend.Cursor + 1,
REQUEST_RM_IMALIVE,
0,
0);
destroySelfMaintainBuffer(&tosend);
context->AsyncBuffer = newcommbuffer;
InitHandler_Message(newcommbuffer);
return FUNC_RETURN_OK;
}
