sidekick-client 0.2.1 → 0.2.2

data/lib/ext/eventmachine-0.12.10/ext/pipe.cpp

@@ -1,349 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     pipe.cpp
-Date:     30May07
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-#include "project.h"
-
-
-#ifdef OS_UNIX
-// THIS ENTIRE FILE IS ONLY COMPILED ON UNIX-LIKE SYSTEMS.
-
-/******************************
-PipeDescriptor::PipeDescriptor
-******************************/
-
-PipeDescriptor::PipeDescriptor (int fd, pid_t subpid, EventMachine_t *parent_em):
-	EventableDescriptor (fd, parent_em),
-	bReadAttemptedAfterClose (false),
-	LastIo (gCurrentLoopTime),
-	InactivityTimeout (0),
-	OutboundDataSize (0),
-	SubprocessPid (subpid)
-{
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = EPOLLIN;
-	#endif
-	#ifdef HAVE_KQUEUE
-	MyEventMachine->ArmKqueueReader (this);
-	#endif
-}
-
-
-/*******************************
-PipeDescriptor::~PipeDescriptor
-*******************************/
-
-PipeDescriptor::~PipeDescriptor()
-{
-	// Run down any stranded outbound data.
-	for (size_t i=0; i < OutboundPages.size(); i++)
-		OutboundPages[i].Free();
-
-	/* As a virtual destructor, we come here before the base-class
-	 * destructor that closes our file-descriptor.
-	 * We have to make sure the subprocess goes down (if it's not
-	 * already down) and we have to reap the zombie.
-	 *
-	 * This implementation is PROVISIONAL and will surely be improved.
-	 * The intention here is that we never block, hence the highly
-	 * undesirable sleeps. But if we can't reap the subprocess even
-	 * after sending it SIGKILL, then something is wrong and we
-	 * throw a fatal exception, which is also not something we should
-	 * be doing.
-	 *
-	 * Eventually the right thing to do will be to have the reactor
-	 * core respond to SIGCHLD by chaining a handler on top of the
-	 * one Ruby may have installed, and dealing with a list of dead
-	 * children that are pending cleanup.
-	 *
-	 * Since we want to have a signal processor integrated into the
-	 * client-visible API, let's wait until that is done before cleaning
-	 * this up.
-	 *
-	 * Added a very ugly hack to support passing the subprocess's exit
-	 * status to the user. It only makes logical sense for user code to access
-	 * the subprocess exit status in the unbind callback. But unbind is called
-	 * back during the EventableDescriptor destructor. So by that time there's
-	 * no way to call back this object through an object binding, because it's
-	 * already been cleaned up. We might have added a parameter to the unbind
-	 * callback, but that would probably break a huge amount of existing code.
-	 * So the hack-solution is to define an instance variable in the EventMachine
-	 * object and stick the exit status in there, where it can easily be accessed
-	 * with an accessor visible to user code.
-	 * User code should ONLY access the exit status from within the unbind callback.
-	 * Otherwise there's no guarantee it'll be valid.
-	 * This hack won't make it impossible to run multiple EventMachines in a single
-	 * process, but it will make it impossible to reliably nest unbind calls
-	 * within other unbind calls. (Not sure if that's even possible.)
-	 */
-
-	assert (MyEventMachine);
-
-	/* Another hack to make the SubprocessPid available to get_subprocess_status */
-	MyEventMachine->SubprocessPid = SubprocessPid;
-
-	/* 01Mar09: Updated to use a small nanosleep in a loop. When nanosleep is interrupted by SIGCHLD,
-	 * it resumes the system call after processing the signal (resulting in unnecessary latency).
-	 * Calling nanosleep in a loop avoids this problem.
-	 */
-	struct timespec req = {0, 50000000}; // 0.05s
-	int n;
-
-	// wait 0.25s for the process to die
-	for (n=0; n<5; n++) {
-		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
-		nanosleep (&req, NULL);
-	}
-
-	// send SIGTERM and wait another 0.5s
-	kill (SubprocessPid, SIGTERM);
-	for (n=0; n<10; n++) {
-		nanosleep (&req, NULL);
-		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
-	}
-
-	// send SIGKILL and wait another 1s
-	kill (SubprocessPid, SIGKILL);
-	for (n=0; n<20; n++) {
-		nanosleep (&req, NULL);
-		if (waitpid (SubprocessPid, &(MyEventMachine->SubprocessExitStatus), WNOHANG) != 0) return;
-	}
-
-	// still not dead, give up!
-	throw std::runtime_error ("unable to reap subprocess");
-}
-
-
-
-/********************
-PipeDescriptor::Read
-********************/
-
-void PipeDescriptor::Read()
-{
-	int sd = GetSocket();
-	if (sd == INVALID_SOCKET) {
-		assert (!bReadAttemptedAfterClose);
-		bReadAttemptedAfterClose = true;
-		return;
-	}
-
-	LastIo = gCurrentLoopTime;
-
-	int total_bytes_read = 0;
-	char readbuffer [16 * 1024];
-
-	for (int i=0; i < 10; i++) {
-		// Don't read just one buffer and then move on. This is faster
-		// if there is a lot of incoming.
-		// But don't read indefinitely. Give other sockets a chance to run.
-		// NOTICE, we're reading one less than the buffer size.
-		// That's so we can put a guard byte at the end of what we send
-		// to user code.
-		// Use read instead of recv, which on Linux gives a "socket operation
-		// on nonsocket" error.
-		
-
-		int r = read (sd, readbuffer, sizeof(readbuffer) - 1);
-		//cerr << "<R:" << r << ">";
-
-		if (r > 0) {
-			total_bytes_read += r;
-
-			// Add a null-terminator at the the end of the buffer
-			// that we will send to the callback.
-			// DO NOT EVER CHANGE THIS. We want to explicitly allow users
-			// to be able to depend on this behavior, so they will have
-			// the option to do some things faster. Additionally it's
-			// a security guard against buffer overflows.
-			readbuffer [r] = 0;
-			_GenericInboundDispatch(readbuffer, r);
-			}
-		else if (r == 0) {
-			break;
-		}
-		else {
-			// Basically a would-block, meaning we've read everything there is to read.
-			break;
-		}
-
-	}
-
-
-	if (total_bytes_read == 0) {
-		// If we read no data on a socket that selected readable,
-		// it generally means the other end closed the connection gracefully.
-		ScheduleClose (false);
-		//bCloseNow = true;
-	}
-
-}
-
-/*********************
-PipeDescriptor::Write
-*********************/
-
-void PipeDescriptor::Write()
-{
-	int sd = GetSocket();
-	assert (sd != INVALID_SOCKET);
-
-	LastIo = gCurrentLoopTime;
-	char output_buffer [16 * 1024];
-	size_t nbytes = 0;
-
-	while ((OutboundPages.size() > 0) && (nbytes < sizeof(output_buffer))) {
-		OutboundPage *op = &(OutboundPages[0]);
-		if ((nbytes + op->Length - op->Offset) < sizeof (output_buffer)) {
-			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, op->Length - op->Offset);
-			nbytes += (op->Length - op->Offset);
-			op->Free();
-			OutboundPages.pop_front();
-		}
-		else {
-			int len = sizeof(output_buffer) - nbytes;
-			memcpy (output_buffer + nbytes, op->Buffer + op->Offset, len);
-			op->Offset += len;
-			nbytes += len;
-		}
-	}
-
-	// We should never have gotten here if there were no data to write,
-	// so assert that as a sanity check.
-	// Don't bother to make sure nbytes is less than output_buffer because
-	// if it were we probably would have crashed already.
-	assert (nbytes > 0);
-
-	assert (GetSocket() != INVALID_SOCKET);
-	int bytes_written = write (GetSocket(), output_buffer, nbytes);
-
-	if (bytes_written > 0) {
-		OutboundDataSize -= bytes_written;
-		if ((size_t)bytes_written < nbytes) {
-			int len = nbytes - bytes_written;
-			char *buffer = (char*) malloc (len + 1);
-			if (!buffer)
-				throw std::runtime_error ("bad alloc throwing back data");
-			memcpy (buffer, output_buffer + bytes_written, len);
-			buffer [len] = 0;
-			OutboundPages.push_front (OutboundPage (buffer, len));
-		}
-		#ifdef HAVE_EPOLL
-		EpollEvent.events = (EPOLLIN | (SelectForWrite() ? EPOLLOUT : 0));
-		assert (MyEventMachine);
-		MyEventMachine->Modify (this);
-		#endif
-	}
-	else {
-		#ifdef OS_UNIX
-		if ((errno != EINPROGRESS) && (errno != EWOULDBLOCK) && (errno != EINTR))
-		#endif
-		#ifdef OS_WIN32
-		if ((errno != WSAEINPROGRESS) && (errno != WSAEWOULDBLOCK))
-		#endif
-			Close();
-	}
-}
-
-
-/*************************
-PipeDescriptor::Heartbeat
-*************************/
-
-void PipeDescriptor::Heartbeat()
-{
-	// If an inactivity timeout is defined, then check for it.
-	if (InactivityTimeout && ((gCurrentLoopTime - LastIo) >= InactivityTimeout))
-		ScheduleClose (false);
-		//bCloseNow = true;
-}
-
-
-/*****************************
-PipeDescriptor::SelectForRead
-*****************************/
-
-bool PipeDescriptor::SelectForRead()
-{
-	/* Pipe descriptors, being local by definition, don't have
-	 * a pending state, so this is simpler than for the
-	 * ConnectionDescriptor object.
-	 */
-	return true;
-}
-
-/******************************
-PipeDescriptor::SelectForWrite
-******************************/
-
-bool PipeDescriptor::SelectForWrite()
-{
-	/* Pipe descriptors, being local by definition, don't have
-	 * a pending state, so this is simpler than for the
-	 * ConnectionDescriptor object.
-	 */
-	return (GetOutboundDataSize() > 0);
-}
-
-
-
-
-/********************************
-PipeDescriptor::SendOutboundData
-********************************/
-
-int PipeDescriptor::SendOutboundData (const char *data, int length)
-{
-	//if (bCloseNow || bCloseAfterWriting)
-	if (IsCloseScheduled())
-		return 0;
-
-	if (!data && (length > 0))
-		throw std::runtime_error ("bad outbound data");
-	char *buffer = (char *) malloc (length + 1);
-	if (!buffer)
-		throw std::runtime_error ("no allocation for outbound data");
-	memcpy (buffer, data, length);
-	buffer [length] = 0;
-	OutboundPages.push_back (OutboundPage (buffer, length));
-	OutboundDataSize += length;
-	#ifdef HAVE_EPOLL
-	EpollEvent.events = (EPOLLIN | EPOLLOUT);
-	assert (MyEventMachine);
-	MyEventMachine->Modify (this);
-	#endif
-	return length;
-}
-
-/********************************
-PipeDescriptor::GetSubprocessPid
-********************************/
-
-bool PipeDescriptor::GetSubprocessPid (pid_t *pid)
-{
-	bool ok = false;
-	if (pid && (SubprocessPid > 0)) {
-		*pid = SubprocessPid;
-		ok = true;
-	}
-	return ok;
-}
-
-
-#endif // OS_UNIX
-

data/lib/ext/eventmachine-0.12.10/ext/project.h

@@ -1,151 +0,0 @@
-/*****************************************************************************
-
-$Id$
-
-File:     project.h
-Date:     06Apr06
-
-Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
-Gmail: blackhedd
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of either: 1) the GNU General Public License
-as published by the Free Software Foundation; either version 2 of the
-License, or (at your option) any later version; or 2) Ruby's License.
-
-See the file COPYING for complete licensing information.
-
-*****************************************************************************/
-
-
-#ifndef __Project__H_
-#define __Project__H_
-
-
-#ifdef OS_WIN32
-#pragma warning(disable:4786)
-#endif
-
-#include <iostream>
-#include <map>
-#include <set>
-#include <vector>
-#include <deque>
-#include <string>
-#include <sstream>
-#include <stdexcept>
-
-
-#ifdef OS_UNIX
-#include <signal.h>
-#include <netdb.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <sys/resource.h>
-#include <sys/wait.h>
-#include <assert.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <pwd.h>
-typedef int SOCKET;
-#define closesocket close
-#define INVALID_SOCKET -1
-#define SOCKET_ERROR -1
-#ifdef OS_SOLARIS8
-#include <strings.h>
-#include <sys/un.h>
-#ifndef AF_LOCAL
-#define AF_LOCAL AF_UNIX
-#endif
-// INADDR_NONE is undefined on Solaris < 8. Thanks to Brett Eisenberg and Tim Pease.
-#ifndef INADDR_NONE
-#define INADDR_NONE ((unsigned long)-1)
-#endif
-#endif /* OS_SOLARIS8 */
-
-#ifdef _AIX
-#include <strings.h>
-#ifndef AF_LOCAL
-#define AF_LOCAL AF_UNIX
-#endif
-#endif /* _AIX */
-
-#endif /* OS_UNIX */
-
-#ifdef OS_WIN32
-// 21Sep09: windows limits select() to 64 sockets by default, we increase it to 1024 here (before including winsock2.h)
-#define FD_SETSIZE 1024
-
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#include <rpc.h>
-#include <fcntl.h>
-#include <assert.h>
-
-typedef int socklen_t;
-typedef int pid_t;
-#endif
-
-
-using namespace std;
-
-#ifdef WITH_SSL
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#endif
-
-#ifdef HAVE_EPOLL
-#include <sys/epoll.h>
-#endif
-
-#ifdef HAVE_KQUEUE
-#include <sys/event.h>
-#include <sys/queue.h>
-#endif
-
-#ifdef HAVE_INOTIFY
-#include <sys/inotify.h>
-#endif
-
-#ifdef HAVE_OLD_INOTIFY
-#include <sys/syscall.h>
-#include <linux/inotify.h>
-static inline int inotify_init (void) { return syscall (__NR_inotify_init); }
-static inline int inotify_add_watch (int fd, const char *name, __u32 mask) { return syscall (__NR_inotify_add_watch, fd, name, mask); }
-static inline int inotify_rm_watch (int fd, __u32 wd) { return syscall (__NR_inotify_rm_watch, fd, wd); }
-#define HAVE_INOTIFY 1
-#endif
-
-#ifdef HAVE_INOTIFY
-#define INOTIFY_EVENT_SIZE  (sizeof(struct inotify_event))
-#endif
-
-#ifdef HAVE_WRITEV
-#include <sys/uio.h>
-#endif
-
-#include "binder.h"
-#include "em.h"
-#include "epoll.h"
-#include "sigs.h"
-#include "ed.h"
-#include "files.h"
-#include "page.h"
-#include "ssl.h"
-#include "eventmachine.h"
-#include "eventmachine_cpp.h"
-
-
-
-
-#endif // __Project__H_