int registerFileDescForAsyncConn(int 		 			  fd,
                                 uint32_t				  actionmask_afterconn,
                                 AsyncCommBufferHandlers  methods_afterconn,
                                 void				     *userdata_afterconn,
                                 AsyncCommBuffer		 *newcommbuffer_afterconn)
{
    AsyncCommBufferHandlerUser userdata = NULL;
    userdata = rm_palloc0(AsyncCommContext,
                          sizeof(AsyncCommBufferHandlerUserData));
    userdata->ActionMaskForAfterConn = actionmask_afterconn;
    userdata->UserDataForAfterConn   = userdata_afterconn;
    userdata->MethodsForAfterConn	 = methods_afterconn;

    elog(DEBUG3, "Created AsyncComm Conn context.");

    int res = registerFileDesc(fd,
                               ASYNCCOMM_WRITE,
                               &AsyncCommBufferHandlersConn,
                               userdata,
                               newcommbuffer_afterconn);
    if ( res != FUNC_RETURN_OK )
    {
        elog(WARNING, "Fail to register communication in asynchronous connection "
             "progress.");
        rm_pfree(AsyncCommContext, userdata);
    }

    elog(DEBUG3, "Registered AsyncComm FD %d", fd);

    return res;
}
Beispiel #2
0
void freeBBST(BBST tree)
{
	clearBBST(tree);
	freeBBSTFreeNodes(tree);
	freeHASHTABLE(tree->NodeIndex);

	rm_pfree(tree->Context, tree);
}
void CleanUpHandler_Message(AsyncCommBuffer buffer)
{
	AsyncCommMessageHandlerContext context = (AsyncCommMessageHandlerContext)
											 (buffer->UserData);
	Assert( context->MessageCleanUpHandler != NULL );
	context->MessageCleanUpHandler(context);
	rm_pfree(AsyncCommContext, context);
	elog(DEBUG3, "Freed AsyncComm Message context.");
}
/* free simple array with allocated content. */
void freeSimpleArrayContent(SimpArrayPtr array)
{
	Assert( array != NULL );
	if ( array->Array != NULL ) {
		rm_pfree(array->Context, array->Array);
	}
	array->Array 	= NULL;
	array->Len 		= -1;
}
Beispiel #5
0
void freeBBSTFreeNodes(BBST tree)
{
	Assert( tree != NULL );
	while( tree->Free != NULL ) {
		BBSTNode tofree = tree->Free;
		tree->Free = tofree->Right;
		rm_pfree(tree->Context, tofree);
	}
}
void freeSimpleStringContent(SimpStringPtr  str)
{
	Assert( str != NULL );
	if ( str->Str != NULL ) {
		rm_pfree(str->Context, str->Str);
	}
	str->Str = NULL;
	str->Len = -1;
}
void resetResourceDeadLockDetector(ResqueueDeadLockDetector detector)
{
	List 	 *allss = NULL;
	ListCell *cell	= NULL;
	getAllPAIRRefIntoList(&(detector->Sessions), &allss);
	foreach(cell, allss)
	{
		SessionTrack strack = (SessionTrack)(((PAIR)lfirst(cell))->Value);
		rm_pfree(PCONTEXT, strack);
	}
void ReadReadyHandler_MsgServer(AsyncCommBuffer buffer)
{
	int					res				= FUNC_RETURN_OK;
	ConnectionTrack 	newtrack 		= NULL;
	ConnectionTrackData tmptrackdata;
	AsyncCommBuffer     newcommbuffer   = NULL;
	struct sockaddr_in	clientaddr;
	socklen_t			clientaddrlen	= sizeof(clientaddr);
	int					fd				= -1;

	/* Always accept the connection. */
	fd = accept(buffer->FD, (struct sockaddr *)&clientaddr, &clientaddrlen);
	if ( fd == -1 )
	{
		elog(WARNING, "Resource manager socket accept error is detected. errno %d",
					  errno);
		return;
	}

	/* Create AsyncComm Message handler instance. */
	AsyncCommMessageHandlerContext context = createConnTrackHandlerContext();

	/* Add new client fd into AsyncComm manager. */
	res = registerFileDesc(fd,
						   ASYNCCOMM_READBYTES | ASYNCCOMM_WRITEBYTES,
						   &AsyncCommBufferHandlersMessage,
						   context,
						   &newcommbuffer);
	if ( res != FUNC_RETURN_OK )
	{
		Assert(newcommbuffer == NULL);
		/* close the connection and cleanup. */
		closeConnectionRemote(&fd);
		rm_pfree(AsyncCommContext, context);
		return;
	}

	assignFileDescClientAddressInfo(newcommbuffer,
									NULL,
									0,
									&clientaddr,
									clientaddrlen);

	/* Let context able to track comm buffer. */
	context->AsyncBuffer = newcommbuffer;

	/* Call callback function to initialize context for message handlers. */
	InitHandler_Message(newcommbuffer);

	elog(DEBUG3, "Resource manager accepted one client connected from "
				 "%s:%d as FD %d.\n",
				 newcommbuffer->ClientAddrDotStr,
				 newcommbuffer->ClientAddrPort,
				 newcommbuffer->FD);
}
void freeSimpleStringTokens(SimpStringPtr   owner,
							SimpStringPtr  *tokens,
							int 			tokensize)
{
	for ( int i = 0 ; i < tokensize ; ++i )
	{
		freeSimpleStringContent(&((*tokens)[i]));
	}
	rm_pfree(owner->Context, *tokens);
	*tokens = NULL;
}
void WriteReadyHandler_Connect(AsyncCommBuffer buffer)
{
    /* Check the error from socket FD. */
    bool 	  shouldclose = false;
    int  	  error 	  = 0;
    socklen_t errlen 	  = sizeof(error);

    elog(DEBUG3, "AsyncConn FD %d is write ready for checking connection.",
         buffer->FD);

    int res = getsockopt(buffer->FD, SOL_SOCKET, SO_ERROR, (void *)&error, &errlen);
    if (res < 0)
    {
        elog(WARNING, "getsocketopt() on FD %d have errors raised. errno %d",
             buffer->FD,
             errno);
        shouldclose = true;
    }
    else if ( error > 0 )
    {
        elog(WARNING, "FD %d having errors raised. errno %d",
             buffer->FD,
             error);
        shouldclose = true;
    }

    if ( setConnectionLongTermNoDelay(buffer->FD) != FUNC_RETURN_OK )
    {
        shouldclose = true;
    }

    if ( shouldclose )
    {
        ErrorHandler_Connect(buffer);
        forceCloseFileDesc(buffer);
        return;
    }

    elog(DEBUG3, "AsyncConn FD %d is a good connection.", buffer->FD);

    /* Change to normal registered FD by changing callbacks and arguments. */
    AsyncCommBufferHandlerUser userdata = (AsyncCommBufferHandlerUser)(buffer->UserData);

    buffer->ActionMask = userdata->ActionMaskForAfterConn;
    buffer->UserData   = userdata->UserDataForAfterConn;
    buffer->Methods    = userdata->MethodsForAfterConn;
    Assert(getSMBContentSize(&(buffer->ReadBuffer)) == 0);

    elog(DEBUG3, "Freed AsyncComm Conn context ( connected ).");

    rm_pfree(AsyncCommContext, userdata);
}
Beispiel #11
0
void freeHostIPV4AddressesAsString(MCTYPE context, List **addresses)
{
	Assert( addresses != NULL );

	MEMORY_CONTEXT_SWITCH_TO(context)

	while( *addresses != NULL ) {
		rm_pfree(context, lfirst(list_head(*addresses)));
		*addresses = list_delete_first(*addresses);
	}

	MEMORY_CONTEXT_SWITCH_BACK
}
void ErrorHandler_Connect(AsyncCommBuffer buffer)
{
    elog(WARNING, "Resource manager socket connect has error raised.");

    AsyncCommBufferHandlerUser userdata = (AsyncCommBufferHandlerUser)(buffer->UserData);
    buffer->ActionMask = userdata->ActionMaskForAfterConn;
    buffer->UserData   = userdata->UserDataForAfterConn;
    buffer->Methods    = userdata->MethodsForAfterConn;
    rm_pfree(AsyncCommContext, userdata);

    elog(DEBUG3, "Freed AsyncComm Conn context ( error ).");

    buffer->Methods->ErrorReadyHandle(buffer);
}
void CleanUpHandler_Connect(AsyncCommBuffer buffer)
{
    elog(LOG, "Clean up handler in socket connect is called.");

    AsyncCommBufferHandlerUser userdata = (AsyncCommBufferHandlerUser)(buffer->UserData);
    buffer->ActionMask = userdata->ActionMaskForAfterConn;
    buffer->UserData   = userdata->UserDataForAfterConn;
    buffer->Methods    = userdata->MethodsForAfterConn;
    rm_pfree(AsyncCommContext, userdata);

    elog(DEBUG3, "Freed AsyncComm Conn context ( clean up ).");

    buffer->Methods->CleanUpHandle(buffer);
}
Beispiel #14
0
/* set array value. */
void setSimpleArrayWithContent( SimpArrayPtr  array,
					  	  	 	char		 *content,
					  	  	 	int		      length)
{
	Assert( array != NULL );

	if ( array->Array == NULL ) {
		array->Array = (char *)rm_palloc0(array->Context, length+1);
	}
	else if ( array->Len < length ) {
		rm_pfree(array->Context, array->Array);
		array->Array = (char *)rm_palloc0(array->Context, length+1);
	}
	memcpy(array->Array, content, length);
	array->Len = length;
}
void RB_freeClusterReport(List **segments)
{
	if (CurrentRBImp.freeClusterReport != NULL)
	{
		CurrentRBImp.freeClusterReport(segments);
		return;
	}

	MEMORY_CONTEXT_SWITCH_TO(PCONTEXT)
	/* default implementation for freeing the cluster report objects. */
	while( list_length(*segments) > 0 )
	{
		SegInfo seginfo = (SegInfo)lfirst(list_head(*segments));
		*segments = list_delete_first(*segments);
		rm_pfree(PCONTEXT, seginfo);
	}
	MEMORY_CONTEXT_SWITCH_BACK
}
Beispiel #16
0
void setSimpleStringWithContent( SimpStringPtr str,
					  	  	     char		  *content,
					  	  	     int		   length)
{
	Assert( str != NULL );

	if ( str->Str == NULL ) {
		//elog(RMLOG, "SET NEW SIMPSTRING: %d::%s", length, content);

		str->Str = (char *)rm_palloc0(str->Context, length+1);
	}
	else if ( str->Len < length ) {
		//elog(RMLOG, "SET UPD SIMPSTRING: %d::%s", length, content);

		rm_pfree(str->Context, str->Str);
		str->Str = (char *)rm_palloc0(str->Context, length+1);
	}
	memcpy(str->Str, content, length);
	str->Str[length] = '\0';
	str->Len = length;
}
int minusSessionInUseResource(ResqueueDeadLockDetector	detector,
							  int64_t					sessionid,
							  uint32_t 					memorymb,
							  double 					core)
{
	/* Build key */
	SimpArray key;
	setSimpleArrayRef(&key, (char *)&sessionid, sizeof(int64_t));

	/* Check if the session id exists. */
	PAIR pair = getHASHTABLENode(&(detector->Sessions), &key);
	if ( pair == NULL ) {
		return RESQUEMGR_NO_SESSIONID;
	}

	minusResourceBundleData(&(detector->InUseTotal), memorymb, core);

	SessionTrack sessiontrack = (SessionTrack)(pair->Value);
	Assert( sessiontrack != NULL );

	minusResourceBundleData(&(sessiontrack->InUseTotal), memorymb, core);

	Assert(detector->InUseTotal.Core >= 0.0 &&
		   detector->InUseTotal.MemoryMB >= 0);
	Assert(sessiontrack->InUseTotal.Core >= 0.0 &&
		   sessiontrack->InUseTotal.MemoryMB >= 0);

	/* If the session has no resource used, remove the session tracker. */
	if ( sessiontrack->InUseTotal.MemoryMB == 0 &&
		 sessiontrack->InUseTotal.Core == 0.0 )
	{
		rm_pfree(PCONTEXT, sessiontrack);
		removeHASHTABLENode(&(detector->Sessions), &key);
	}

	return FUNC_RETURN_OK;
}
void sentIncreaseMemoryQuotaCleanup(AsyncCommMessageHandlerContext context)
{
    /* Free user data in message */
	GRMContainerSet	ctns = (GRMContainerSet)(context->UserData);

	if ( ctns->Containers == NULL )
	{
		elog(DEBUG3, "Resource manager succeeded cleaning up data for increasing "
				     "memory quota message");
	}
	else
	{
		elog(WARNING, "Resource manager failed to cleanup data for increasing memory "
				  "quota message");
		processContainersAfterIncreaseMemoryQuota(ctns, false);
	}

	Assert( ctns->Containers == NULL );
	rm_pfree(PCONTEXT, (GRMContainerSet)(context->UserData));

	/* Mark that there is one RPC done for increasing resource quota. */
	DRMGlobalInstance->IncreaseMemoryRPCCounter--;
	Assert(DRMGlobalInstance->IncreaseMemoryRPCCounter >= 0);
}
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;
}
Beispiel #20
0
/******************************************************************************
 * 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;
}
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 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;
}
Beispiel #23
0
void freeHostAddress(MCTYPE context, HostAddress addr)
{
	rm_pfree(context, addr->Address);
	rm_pfree(context, addr);
}
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;
}