Exemplo n.º 1
0
void
tr_runInEventThread( struct tr_handle *       handle,
                     void               func( void* ),
                     void *                   user_data )
{
    assert( handle );
    assert( handle->events );

    if( tr_amInThread( handle->events->thread ) )
    {
        (func)( user_data );
    }
    else
    {
        const char         ch = 'r';
        int                fd = handle->events->fds[1];
        tr_lock *          lock = handle->events->lock;
        struct tr_run_data data;

        tr_lockLock( lock );
        pipewrite( fd, &ch, 1 );
        data.func = func;
        data.user_data = user_data;
        pipewrite( fd, &data, sizeof( data ) );
        tr_lockUnlock( lock );
    }
}
Exemplo n.º 2
0
void
tr_runInEventThread( tr_session * session,
                     void func( void* ), void * user_data )
{
    assert( tr_isSession( session ) );
    assert( session->events != NULL );

    if( tr_amInThread( session->events->thread ) )
    {
        (func)( user_data );
    }
    else
    {
        const char         ch = 'r';
        int                fd = session->events->fds[1];
        tr_lock *          lock = session->events->lock;
        struct tr_run_data data;

        tr_lockLock( lock );
        pipewrite( fd, &ch, 1 );
        data.func = func;
        data.user_data = user_data;
        pipewrite( fd, &data, sizeof( data ) );
        tr_lockUnlock( lock );
    }
}
Exemplo n.º 3
0
void yuv_write_frame (int fd, unsigned char *yuv[], int width,
                      int height)
{

   pipewrite (fd, "FRAME\n", 6);

/*FIXME! this is subject to be extended to work with lav2yuv: */

   pipewrite (fd, yuv[0], width*height);
   pipewrite (fd, yuv[1], width*height/4);
   pipewrite (fd, yuv[2], width*height/4);
   
}
Exemplo n.º 4
0
static void *
block_tx_client_thread (void *vdata)
{
    BlockTxClient *client = vdata;
    BlockTxInfo *info = client->info;
    BlockTxClientDoneCB cb = client->cb;
    evutil_socket_t data_fd;
    gboolean restart;

retry:
    data_fd = connect_chunk_server (info->cs);
    if (data_fd < 0) {
        info->result = BLOCK_CLIENT_NET_ERROR;
        if (!info->transfer_once) {
            pipewrite (info->done_pipe[1], &info->result, sizeof(info->result));
            /* Transfer manager always expects an ENDED response. */
            int rsp = BLOCK_CLIENT_ENDED;
            pipewrite (info->done_pipe[1], &rsp, sizeof(rsp));
        }
        return vdata;
    }
    client->data_fd = data_fd;

    if (send_handshake (data_fd, info) < 0) {
        if (!info->transfer_once) {
            pipewrite (info->done_pipe[1], &info->result, sizeof(info->result));
            int rsp = BLOCK_CLIENT_ENDED;
            pipewrite (info->done_pipe[1], &rsp, sizeof(rsp));
        }
        evutil_closesocket (client->data_fd);
        return vdata;
    }

    client->recv_buf = evbuffer_new ();

    restart = client_thread_loop (client);

    if (restart) {
        seaf_message ("Restarting block tx client.\n");
        memset (client, 0, sizeof(BlockTxClient));
        client->info = info;
        client->cb = cb;
        client->info->result = BLOCK_CLIENT_UNKNOWN;
        goto retry;
    }

    return vdata;
}
Exemplo n.º 5
0
size_t
url_execute_fwrite(void *ptr, size_t size, URL_FILE *file, CopyState pstate)
{
    URL_EXECUTE_FILE *efile = (URL_EXECUTE_FILE *) file;
    int fd = efile->handle->pipes[EXEC_DATA_P];
    size_t offset = 0;
    const char* p = (const char* ) ptr;

    size_t n;
    /* ensure all data in buffer is send out to pipe*/
    while(size > offset)
    {
        n = pipewrite(fd,p,size - offset);

        if(n == -1) return -1;

        if(n == 0) break;

        offset += n;
        p = (const char*)ptr + offset;
    }

    if(offset < size) elog(WARNING,"partial write, expected %lu, written %lu", size, offset);

    return offset;
}
Exemplo n.º 6
0
void
yuv_write_header (int fd, int width, int height, int frame_rate_code)
{
   char str[256];

   snprintf (str, sizeof (str), "YUV4MPEG %d %d %d\n",
             width, height, frame_rate_code);
   pipewrite (fd, str, strlen (str));
}
//PAGEBREAK!
// Write to file f.
int
filewrite(struct file *f, char *addr, int n) {
	int r;

	if (f->writable == 0) {
		return -1;
	}

	if (f->type == FD_PIPE) {
		return pipewrite(f->pipe, addr, n);
	}

	if (f->type == FD_INODE) {
		// write a few blocks at a time to avoid exceeding
		// the maximum log transaction size, including
		// i-node, indirect block, allocation blocks,
		// and 2 blocks of slop for non-aligned writes.
		// this really belongs lower down, since writei()
		// might be writing a device like the console.
		int max = ((LOGSIZE - 1 - 1 - 2) / 2) * 512;
		int i = 0;

		while (i < n) {
			int n1 = n - i;

			if (n1 > max) {
				n1 = max;
			}

			begin_trans();
			ilock(f->ip);

			if ((r = writei(f->ip, addr + i, f->off, n1)) > 0) {
				f->off += r;
			}

			iunlock(f->ip);
			commit_trans();

			if (r < 0) {
				break;
			}

			if (r != n1) {
				panic("short filewrite");
			}

			i += r;
		}

		return i == n ? n : -1;
	}

	panic("filewrite");
}
Exemplo n.º 8
0
tr_timer*
tr_timerNew( struct tr_handle * handle,
             timer_func         func,
             void *             user_data,
             uint64_t           interval_milliseconds )
{
    tr_timer * timer;

    assert( handle );
    assert( handle->events );

    timer = tr_new0( tr_timer, 1 );
    tr_timevalMsec( interval_milliseconds, &timer->tv );
    timer->func = func;
    timer->user_data = user_data;
    timer->eh = handle->events;
    evtimer_set( &timer->event, timerCallback, timer );

    if( tr_amInThread( handle->events->thread ) )
    {
        evtimer_add( &timer->event,  &timer->tv );
    }
    else
    {
        const char ch = 't';
        int        fd = handle->events->fds[1];
        tr_lock *  lock = handle->events->lock;

        tr_lockLock( lock );
        pipewrite( fd, &ch, 1 );
        pipewrite( fd, &timer, sizeof( timer ) );
        tr_lockUnlock( lock );
    }

    return timer;
}
Exemplo n.º 9
0
void
tr_runInEventThread (tr_session * session,
                     void func (void*), void * user_data)
{
  assert (tr_isSession (session));
  assert (session->events != NULL);

  if (tr_amInThread (session->events->thread))
    {
      (func)(user_data);
    }
  else
    {
      int fd;
      char ch;
      ssize_t res_1;
      ssize_t res_2;
      tr_event_handle * e = session->events;
      struct tr_run_data data;

      tr_lockLock (e->lock);

      fd = e->fds[1];
      ch = 'r';
      res_1 = pipewrite (fd, &ch, 1);

      data.func = func;
      data.user_data = user_data;
      res_2 = pipewrite (fd, &data, sizeof (data));

      tr_lockUnlock (e->lock);

      if ((res_1 == -1) || (res_2 == -1))
        tr_logAddError ("Unable to write to libtransmisison event queue: %s", tr_strerror(errno));
    }
}
Exemplo n.º 10
0
/*
 * Return cluster report including all node status. The response should be
 * handled asynchronously.
 */
int RB_LIBYARN_getClusterReport(const char  *quename,
								List 	   **machines,
								double 	    *maxcapacity)
{
	int		 res		= FUNC_RETURN_OK;
	uint32_t MessageID	= RM2RB_GET_CLUSTERREPORT;
	int		 piperes	= 0;

	if ( PipeReceivePending )
	{
		elog(DEBUG5, "YARN resource broker skip sending cluster report due to "
					 "not getting response of last request.");
		return FUNC_RETURN_OK;
	}

	/* Write request to pipe */
	SelfMaintainBufferData sendBuffer;
	initializeSelfMaintainBuffer(&sendBuffer, PCONTEXT);
	appendSMBVar(&sendBuffer, MessageID);
	appendSelfMaintainBufferTill64bitAligned(&sendBuffer);

	RPCRequestRBGetClusterReportHeadData request;
	request.QueueNameLen = __SIZE_ALIGN64(strlen(quename) + 1);
	request.Reserved     = 0;
	appendSMBVar(&sendBuffer, request);
	appendSMBStr(&sendBuffer, quename);
	appendSelfMaintainBufferTill64bitAligned(&sendBuffer);

	piperes = pipewrite(ResBrokerRequestPipe[1],
						sendBuffer.Buffer,
						sendBuffer.Cursor + 1);
	if ( piperes != sendBuffer.Cursor + 1 )
	{
		elog(WARNING, "YARN mode resource broker failed to generate cluster "
					  "report request to resource broker process through pipe. "
				      "Wrote length %d, expected length %d, errno %d",
				      piperes,
				      sendBuffer.Cursor + 1,
					  errno);
		res = RESBROK_PIPE_ERROR;
	}
	destroySelfMaintainBuffer(&sendBuffer);
	elog(LOG, "YARN mode resource broker generated cluster report request to "
			  "resource broker process.");
	PipeReceivePending = res == FUNC_RETURN_OK;
	return res;
}
Exemplo n.º 11
0
static gboolean
do_break_loop (BlockTxClient *client)
{
    if (client->info->transfer_once) {
        shutdown_client (client);
        return TRUE;
    } else {
        int rsp = client->info->result;
        pipewrite (client->info->done_pipe[1], &rsp, sizeof(rsp));

        if (client->info->result != BLOCK_CLIENT_SUCCESS)
            shutdown_client (client);

        client->break_loop = FALSE;

        return FALSE;
    }
}
Exemplo n.º 12
0
Arquivo: file.c Projeto: tmfahey/cs537
// Write to file f.  Addr is kernel address.
int
filewrite(struct file *f, char *addr, int n)
{
  int r;

  if(f->writable == 0)
    return -1;
  if(f->type == FD_PIPE)
    return pipewrite(f->pipe, addr, n);
  if(f->type == FD_INODE){
    ilock(f->ip);
    if((r = writei(f->ip, addr, f->off, n)) > 0)
      f->off += r;
    iunlock(f->ip);
    return r;
  }
  panic("filewrite");
}
Exemplo n.º 13
0
static int
handle_auth_rsp_content_cb (char *content, int clen, void *cbarg)
{
    BlockTxClient *client = cbarg;
    AuthResponse *rsp;

    if (clen != sizeof(AuthResponse)) {
        seaf_warning ("Invalid auth respnose length %d.\n", clen);
        client->info->result = BLOCK_CLIENT_FAILED;
        return -1;
    }

    rsp = (AuthResponse *)content;
    rsp->status = ntohl (rsp->status);

    if (rsp->status == STATUS_OK) {
        seaf_debug ("Auth OK.\n");

        if (!client->info->transfer_once) {
            int rsp = BLOCK_CLIENT_READY;
            pipewrite (client->info->done_pipe[1], &rsp, sizeof(rsp));
        }

        /* If in interactive mode, wait for TRANSFER command to start transfer. */
        if (client->info->transfer_once)
            return transfer_next_block (client);
    } else if (rsp->status == STATUS_ACCESS_DENIED) {
        seaf_warning ("Authentication failed.\n");
        /* this is a hard error. */
        client->info->result = BLOCK_CLIENT_FAILED;
        return -1;
    } else if (rsp->status == STATUS_INTERNAL_SERVER_ERROR) {
        seaf_warning ("Server error when handling auth.\n");
        client->info->result = BLOCK_CLIENT_SERVER_ERROR;
        return -1;
    } else {
        seaf_warning ("Bad status code %d in handshake.\n", rsp->status);
        client->info->result = BLOCK_CLIENT_FAILED;
        return -1;
    }

    return 0;
}
Exemplo n.º 14
0
Arquivo: file.c Projeto: hosanli/os4
// Write to file f.  Addr is kernel address.
int
filewrite(struct file *f, char *addr, int n)
{
//	cprintf(" -- filewrite -- f-type %d\n", f->type);
  int r;

  if(f->writable == 0)
    return -1;
  if(f->type == FD_PIPE)
    return pipewrite(f->pipe, addr, n);
  if(f->type == FD_INODE){
    ilock(f->ip);
    if((r = writei(f->ip, addr, f->off, n)) > 0)
      f->off += r;
    iunlock(f->ip);
//	cprintf(" -- filewrite -- after iunlock \n");
    return r;
  }
  panic("filewrite");
}
Exemplo n.º 15
0
// Write to file f.  Addr is kernel address.
int
filewrite(struct file *f, char *addr, int n)
{
	//cprintf("filewrite...\n");
  int r;
  //verified
  if(f->writable == 0)
    return -1;
  if(f->type == FD_PIPE)
    return pipewrite(f->pipe, addr, n);
  if(f->type == FD_INODE){
    ilock(f->ip);
    if((r = writei(f->ip, addr, f->off, n)) > 0)
      f->off += r;
    iunlock(f->ip);
		//cprintf("filwrite: r(%d)\n");
    return r;
  }
  panic("filewrite");
}
Exemplo n.º 16
0
int wait_until_received(const int mtype) { 
    if (mtype > 0 && mtype <= MSG_TYPES_NUMBER) {
		if (pipewrite(Pdesc2[1], Pdesc[0], &mtype, sizeof(int)) == FAIL)
			return FAIL;
        if (mtype == RESPONSE) {
			if (piperead(Pdesc2[1], Pdesc[0], &response_data.response_type, sizeof(int)) == FAIL ||
			piperead(Pdesc2[1], Pdesc[0], response_data.content, RESPONSE_LENGTH) == FAIL) {
				return FAIL;
			}
        }
		else if (mtype == USERS || mtype == ROOMS || mtype == ROOM_USERS_LIST) {
			int j = 0;
			while (piperead(Pdesc2[1], Pdesc[0], request_response_data->content[j], USER_NAME_MAX_LENGTH) > FAIL)
				++j;
			if (j < MAX_SERVERS_NUMBER * MAX_USERS_NUMBER)
				request_response_data->content[j][0] = '\0';
		}
		return 0;
	}
    return FAIL;
}
Exemplo n.º 17
0
int writePipe(int fd, void *buff, int buffsize)
{
	int   s   = 0;
	int	  res = 0;
retry:
	res = pipewrite(fd, (char *)buff + s, buffsize - s);
	if ( res >= 0 ) {
		s += res;
		if ( buffsize - s > 0 ) {
			goto retry;
		}
		return s;
	}
	else if ( res == -1 && (errno == EAGAIN || errno == EINTR)) {
		goto retry;
	}

	write_log("writePipe got write() error , fd %d, (errno %d)", fd, errno);

	return -1;
}
Exemplo n.º 18
0
Arquivo: pty.c Projeto: aunali1/exopc
static int
pty_write(struct file *filp, char *buffer, int nbyte, int blocking) {
  struct pty *pty;
  struct pipe *pipeb;
  int master,total = 0, final = 0;
  demand(filp, bogus filp);
  DPRINTF(CLU_LEVEL,
	  ("pty_write: filp: %08x offset: %qd nbyte: %d\n",
	   (int)filp, filp->f_pos, nbyte));
  pty = GETPTYP(filp);
  master = filp->f_pos;

  demand (master == 1 || master == 0,master flag set improperly);

  pipeb = &(pty->pipe[1 - master]);

  if (pipeb->length == 0 && CHECKNB(filp)) {
    errno = EWOULDBLOCK;
    return -1;
  }

  while(nbyte > 0) {
    if (!(PTY_BUSY(1 - master,pty))) {
      /* signal(getpid(),SIGPIPE); */
      return -1;
    }
    if (pipeb->length != 0) {
      int len;
      len = MIN(nbyte,pipeb->length);

      lock_pipepty(pipeb); 
      total = pipewrite(pipeb,buffer,len);
      final += total;
      buffer += total;
      unlock_pipepty(pipeb); 
      nbyte -= total;
    } else {
Exemplo n.º 19
0
static void
BaseBackup(void)
{
	PGresult   *res;
	char	   *sysidentifier;
	uint32		timeline;
	char		current_path[MAXPGPATH];
	char		escaped_label[MAXPGPATH];
	int			i;
	char		xlogstart[64];
	char		xlogend[64];

	/*
	 * Connect in replication mode to the server
	 */
	conn = GetConnection();

	/*
	 * Run IDENTIFY_SYSTEM so we can get the timeline
	 */
	res = PQexec(conn, "IDENTIFY_SYSTEM");
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
	{
		fprintf(stderr, _("%s: could not identify system: %s\n"),
				progname, PQerrorMessage(conn));
		disconnect_and_exit(1);
	}
	if (PQntuples(res) != 1)
	{
		fprintf(stderr, _("%s: could not identify system, got %i rows\n"),
				progname, PQntuples(res));
		disconnect_and_exit(1);
	}
	sysidentifier = strdup(PQgetvalue(res, 0, 0));
	timeline = atoi(PQgetvalue(res, 0, 1));
	PQclear(res);

	/*
	 * Start the actual backup
	 */
	PQescapeStringConn(conn, escaped_label, label, sizeof(escaped_label), &i);
	snprintf(current_path, sizeof(current_path), "BASE_BACKUP LABEL '%s' %s %s %s %s",
			 escaped_label,
			 showprogress ? "PROGRESS" : "",
			 includewal && !streamwal ? "WAL" : "",
			 fastcheckpoint ? "FAST" : "",
			 includewal ? "NOWAIT" : "");

	if (PQsendQuery(conn, current_path) == 0)
	{
		fprintf(stderr, _("%s: could not send base backup command: %s"),
				progname, PQerrorMessage(conn));
		disconnect_and_exit(1);
	}

	/*
	 * Get the starting xlog position
	 */
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
	{
		fprintf(stderr, _("%s: could not initiate base backup: %s"),
				progname, PQerrorMessage(conn));
		disconnect_and_exit(1);
	}
	if (PQntuples(res) != 1)
	{
		fprintf(stderr, _("%s: no start point returned from server\n"),
				progname);
		disconnect_and_exit(1);
	}
	strcpy(xlogstart, PQgetvalue(res, 0, 0));
	if (verbose && includewal)
		fprintf(stderr, "xlog start point: %s\n", xlogstart);
	PQclear(res);
	MemSet(xlogend, 0, sizeof(xlogend));

	/*
	 * Get the header
	 */
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
	{
		fprintf(stderr, _("%s: could not get backup header: %s"),
				progname, PQerrorMessage(conn));
		disconnect_and_exit(1);
	}
	if (PQntuples(res) < 1)
	{
		fprintf(stderr, _("%s: no data returned from server\n"), progname);
		disconnect_and_exit(1);
	}

	/*
	 * Sum up the total size, for progress reporting
	 */
	totalsize = totaldone = 0;
	tablespacecount = PQntuples(res);
	for (i = 0; i < PQntuples(res); i++)
	{
		if (showprogress)
			totalsize += atol(PQgetvalue(res, i, 2));

		/*
		 * Verify tablespace directories are empty. Don't bother with the
		 * first once since it can be relocated, and it will be checked before
		 * we do anything anyway.
		 */
		if (format == 'p' && !PQgetisnull(res, i, 1))
			verify_dir_is_empty_or_create(PQgetvalue(res, i, 1));
	}

	/*
	 * When writing to stdout, require a single tablespace
	 */
	if (format == 't' && strcmp(basedir, "-") == 0 && PQntuples(res) > 1)
	{
		fprintf(stderr, _("%s: can only write single tablespace to stdout, database has %d\n"),
				progname, PQntuples(res));
		disconnect_and_exit(1);
	}

	/*
	 * If we're streaming WAL, start the streaming session before we start
	 * receiving the actual data chunks.
	 */
	if (streamwal)
	{
		if (verbose)
			fprintf(stderr, _("%s: starting background WAL receiver\n"),
					progname);
		StartLogStreamer(xlogstart, timeline, sysidentifier);
	}

	/*
	 * Start receiving chunks
	 */
	for (i = 0; i < PQntuples(res); i++)
	{
		if (format == 't')
			ReceiveTarFile(conn, res, i);
		else
			ReceiveAndUnpackTarFile(conn, res, i);
	}							/* Loop over all tablespaces */

	if (showprogress)
	{
		progress_report(PQntuples(res), NULL);
		fprintf(stderr, "\n");	/* Need to move to next line */
	}
	PQclear(res);

	/*
	 * Get the stop position
	 */
	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_TUPLES_OK)
	{
		fprintf(stderr, _("%s: could not get WAL end position from server\n"),
				progname);
		disconnect_and_exit(1);
	}
	if (PQntuples(res) != 1)
	{
		fprintf(stderr, _("%s: no WAL end position returned from server\n"),
				progname);
		disconnect_and_exit(1);
	}
	strcpy(xlogend, PQgetvalue(res, 0, 0));
	if (verbose && includewal)
		fprintf(stderr, "xlog end point: %s\n", xlogend);
	PQclear(res);

	res = PQgetResult(conn);
	if (PQresultStatus(res) != PGRES_COMMAND_OK)
	{
		fprintf(stderr, _("%s: final receive failed: %s"),
				progname, PQerrorMessage(conn));
		disconnect_and_exit(1);
	}

	if (bgchild > 0)
	{
		int			status;

#ifndef WIN32
		int			r;
#endif

		if (verbose)
			fprintf(stderr, _("%s: waiting for background process to finish streaming...\n"), progname);

#ifndef WIN32
		if (pipewrite(bgpipe[1], xlogend, strlen(xlogend)) != strlen(xlogend))
		{
			fprintf(stderr, _("%s: could not send command to background pipe: %s\n"),
					progname, strerror(errno));
			disconnect_and_exit(1);
		}

		/* Just wait for the background process to exit */
		r = waitpid(bgchild, &status, 0);
		if (r == -1)
		{
			fprintf(stderr, _("%s: could not wait for child process: %s\n"),
					progname, strerror(errno));
			disconnect_and_exit(1);
		}
		if (r != bgchild)
		{
			fprintf(stderr, _("%s: child %i died, expected %i\n"),
					progname, r, bgchild);
			disconnect_and_exit(1);
		}
		if (!WIFEXITED(status))
		{
			fprintf(stderr, _("%s: child process did not exit normally\n"),
					progname);
			disconnect_and_exit(1);
		}
		if (WEXITSTATUS(status) != 0)
		{
			fprintf(stderr, _("%s: child process exited with error %i\n"),
					progname, WEXITSTATUS(status));
			disconnect_and_exit(1);
		}
		/* Exited normally, we're happy! */
#else							/* WIN32 */

		/*
		 * On Windows, since we are in the same process, we can just store the
		 * value directly in the variable, and then set the flag that says
		 * it's there.
		 */
		if (sscanf(xlogend, "%X/%X", &xlogendptr.xlogid, &xlogendptr.xrecoff) != 2)
		{
			fprintf(stderr, _("%s: could not parse xlog end position \"%s\"\n"),
					progname, xlogend);
			exit(1);
		}
		InterlockedIncrement(&has_xlogendptr);

		/* First wait for the thread to exit */
		if (WaitForSingleObjectEx((HANDLE) bgchild, INFINITE, FALSE) != WAIT_OBJECT_0)
		{
			_dosmaperr(GetLastError());
			fprintf(stderr, _("%s: could not wait for child thread: %s\n"),
					progname, strerror(errno));
			disconnect_and_exit(1);
		}
		if (GetExitCodeThread((HANDLE) bgchild, &status) == 0)
		{
			_dosmaperr(GetLastError());
			fprintf(stderr, _("%s: could not get child thread exit status: %s\n"),
					progname, strerror(errno));
			disconnect_and_exit(1);
		}
		if (status != 0)
		{
			fprintf(stderr, _("%s: child thread exited with error %u\n"),
					progname, status);
			disconnect_and_exit(1);
		}
		/* Exited normally, we're happy */
#endif
	}

	/*
	 * End of copy data. Final result is already checked inside the loop.
	 */
	PQfinish(conn);

	if (verbose)
		fprintf(stderr, "%s: base backup completed\n", progname);
}
Exemplo n.º 20
0
void
block_tx_client_run_command (BlockTxInfo *info, int command)
{
    pipewrite (info->cmd_pipe[1], &command, sizeof(int));
}
Exemplo n.º 21
0
		char *rackname = GET_SEGINFO_GRMRACKNAME(&(segres->Stat->Info));
		uint32_t preferredLen = sizeof(preferredLen) + sizeof(num_containers) + sizeof(flag) +
								__SIZE_ALIGN64((strlen(hostname) + 1 + strlen(rackname) + 1));
		appendSMBVar(&sendBuffer, preferredLen);
		appendSMBVar(&sendBuffer, num_containers);
		appendSMBVar(&sendBuffer, flag);
		appendSMBStr(&sendBuffer, hostname);
		appendSMBStr(&sendBuffer, rackname);
		appendSelfMaintainBufferTill64bitAligned(&sendBuffer);
		elog(LOG, "YARN mode resource broker build a preferred request."
				  "host:%s, rack:%s, container number:%d",
				  hostname, rackname, num_containers);
	}

	int piperes = pipewrite(ResBrokerRequestPipe[1],
				   	   	    sendBuffer.Buffer,
							sendBuffer.Cursor + 1);
	if ( piperes != sendBuffer.Cursor + 1 )
	{
		elog(WARNING, "YARN mode resource broker failed to write resource "
					  "allocation request to resource broker process. errno %d.",
					  errno);
		res = RESBROK_PIPE_ERROR;
	}

	elog(DEBUG3, "LIBYARN mode resource broker wrote %d bytes out.", sendBuffer.Cursor+1);

	destroySelfMaintainBuffer(&sendBuffer);
	elog(LOG, "YARN mode resource broker wrote resource allocation request to "
			  "resource broker process.");
	PipeReceivePending = res == FUNC_RETURN_OK;
Exemplo n.º 22
0
static gboolean
handle_command (BlockTxClient *client, int command)
{
    gboolean ret = FALSE;
    int rsp;

    switch (command) {
    case BLOCK_CLIENT_CMD_TRANSFER:
        /* Ignore TRANSFER command if client has been shutdown. */
        if (client->recv_state == RECV_STATE_DONE) {
            seaf_debug ("Client was shutdown, ignore transfer command.\n");
            break;
        }

        if (transfer_next_block (client) < 0) {
            rsp = client->info->result;
            pipewrite (client->info->done_pipe[1], &rsp, sizeof(rsp));

            shutdown_client (client);

            client->break_loop = FALSE;
        }
        break;
    case BLOCK_CLIENT_CMD_CANCEL:
        if (client->recv_state == RECV_STATE_DONE) {
            seaf_debug ("Client was shutdown, ignore cancel command.\n");
            break;
        }

        seaf_debug ("Canceled command received.\n");
        client->info->result = BLOCK_CLIENT_CANCELED;

        if (client->info->transfer_once) {
            shutdown_client (client);
            ret = TRUE;
        } else {
            rsp = client->info->result;
            pipewrite (client->info->done_pipe[1], &rsp, sizeof(rsp));

            shutdown_client (client);

            client->break_loop = FALSE;

            ret = FALSE;
        }

        break;
    case BLOCK_CLIENT_CMD_END:
        client->info->result = BLOCK_CLIENT_ENDED;

        rsp = client->info->result;
        pipewrite (client->info->done_pipe[1], &rsp, sizeof(rsp));

        /* Don't need to shutdown_client() if it's already called. */
        if (client->recv_state != RECV_STATE_DONE)
            shutdown_client (client);

        client->break_loop = FALSE;

        ret = TRUE;
        break;
    }

    return ret;
}