COUCH_EXE = os.environ.get('COUCHDB')
if not COUCH_EXE:
    for x in os.environ['PATH'].split(':'):
        if os.path.exists(os.path.join(x, 'couchdb')):
            COUCH_EXE = os.path.join(x, 'couchdb')
if not COUCH_EXE:
    raise ImportError("Could not find couchdb")

def run_couchdb(ctx=local_files.DEFAULT_CONTEXT):
    """Actually start the CouchDB process.  Return its PID."""
    pid = read_pidfile(ctx)
    if pid is not None and not process_is_couchdb(pid):
        print "Removing stale, deceptive pid file."
        os.remove(ctx.file_pid)
    local_exec = ctx.couch_exec_command + ['-b']
    try:
        # subprocess is buggy.  Chad patched, but that takes time to propagate.
        proc = subprocess.Popen(local_exec)
        while True:
            try:
                retcode = proc.wait()
                break
            except OSError, e:
                if e.errno == errno.EINTR:
                    continue
                raise
        if retcode < 0:
            print >> sys.stderr, "Child was terminated by signal", -retcode
        elif retcode > 0:
            print >> sys.stderr, "Child returned", retcode
    except OSError, e:
        print >> sys.stderr, "Execution failed: %s: %s" % (e, local_exec)
        exit(1)
 
    # give the process a chance to start
    for timeout in (0.4, 0.1, 0.1, 0.2, 0.5, 1, 3, 5):
        pid = read_pidfile(ctx=ctx)
        if pid is not None and process_is_couchdb(pid):
            break
        time.sleep(timeout)
 
    # Loop for a number of times until the port has been found, this
    # has to be done because there's a slice of time between PID being written
    # and the listening port being active.
    for timeout in (0.1, 0.1, 0.2, 0.5, 1, 3, 5, 8):
        try:
            port = desktopcouch.find_port(pid=pid, ctx=ctx) # only returns valid port
            break
        except RuntimeError, e:
            pass
        time.sleep(timeout)
 
    ctx.ensure_files_not_readable()
    return pid, port

using System.Runtime.Serialization;
using System.ServiceModel;
 
namespace DesktopcouchServie
{
	/// <summary>
	/// Basic service contract that provides a number of methods that client applications can execute to query the information 
	/// of the couchdb instance of the current user.
	/// </summary>
	[ServiceContract]
	public interface IDesktopcouchService
	{
		/// <summary>
		/// This method allow a client application to query the port in which the couchdb instance is executing. 
		/// </summary>
		/// <returns>The post in which the couchdb instance can be found.</returns>
		[OperationContract]
		string GetCouchdbPort();
 
		/// <summary>
		/// This method allows a client to starta couchdb instance for the current user. It is recommended to just allow the
                /// desktopcouch python
		/// library to take care of the start of the instance.
		/// </summary>
		/// <param name="startUpData">The data to be used to start the couchdb instance.</param>
		/// <returns>A boolean value that communicates the client that the couchdb instace was started.</returns>
		[OperationContract]
		bool StartCouchdbInstance(CouchdbInstanceStartUpData startUpData);
 
		/// <summary>
		/// This method allows a client to stop the current instance of couchdb. It is recommended to just 
                /// allow the desktopcouch python library 
		/// to take care os stoping the couchdb instance.
		/// </summary>
		/// <returns>A boolean value that communicates the client that the couchdb instance was stopped.</returns>
		[OperationContract]
		bool StopCouchdbInstance();
 
	}
 
	// Use a data contract as illustrated in the sample below to add composite types to service operations
	[DataContract]
	public class CouchdbInstanceStartUpData
	{
		#region Properties
 
		/// <summary>
		/// Gets and sets the full path of the ini file to be use to start the couchdb instance.
		/// </summary>
		[DataMember]
		public string IniFile { get; set; }
 
		/// <summary>
		/// Gets and sets the full path of the file that will be used by the stdout of the couchdb instance.
		/// </summary>
		[DataMember]
		public string OutputFile { get; set; }
 
		/// <summary>
		/// Gets and sets the full path of the file that will be used by the stderr of the couchdb instance.
		/// </summary>
		[DataMember]
		public string ErrorFile { get; set; }
 
		/// <summary>
		/// Gets and sets the full path of the file that will be used to write the logs of the couchdb instance.
		/// </summary>
		[DataMember]
		public string LogFile { get; set; }
 
		#endregion
 
	}
}

		#region Get port from PID
 
		#region Structures
 
		/// <summary>
		/// Enumerator that is used to list the different class for the TCP table.
		/// </summary>
		public enum TCP_TABLE_CLASS
		{
			TCP_TABLE_BASIC_LISTENER,
			TCP_TABLE_BASIC_CONNECTIONS,
			TCP_TABLE_BASIC_ALL,
			TCP_TABLE_OWNER_PID_LISTENER,
			TCP_TABLE_OWNER_PID_CONNECTIONS,
			TCP_TABLE_OWNER_PID_ALL,
			TCP_TABLE_OWNER_MODULE_LISTENER,
			TCP_TABLE_OWNER_MODULE_CONNECTIONS,
			TCP_TABLE_OWNER_MODULE_ALL,
		}
 
		/// <summary>
		/// Struct used to show the information of the woner of a TCP connection.
		/// </summary>
		[StructLayout(LayoutKind.Sequential)]
		public struct MIB_TCPROW_OWNER_PID
		{
			public uint State;
			public uint LocalAddr;
			public byte LocalPort1;
			public byte LocalPort2;
			public byte LocalPort3;
			public byte LocalPort4;
			public uint RemoteAddr;
			public byte RemotePort1;
			public byte RemotePort2;
			public byte RemotePort3;
			public byte RemotePort4;
			public int OwningPid;
		}
 
 
		[StructLayout(LayoutKind.Sequential)]
		public struct MIB_TCPTABLE_OWNER_PID
		{
			public uint dwNumEntries;
			MIB_TCPROW_OWNER_PID table;
		}
 
		#endregion
 
		// We use the funtion from the iphlapi dll to get the talbe f tcp connections.
		[DllImport("iphlpapi.dll", SetLastError = true)]
		static extern uint GetExtendedTcpTable(IntPtr pTcpTable, ref int dwOutBufLen, bool sort, int ipVersion, TCP_TABLE_CLASS tblClass, int reserved);
 
 
		// Returns an array with the rwos with the dta of the different connecitons.
		private static MIB_TCPROW_OWNER_PID[] GetAllTcpConnections()
		{
			MIB_TCPROW_OWNER_PID[] tTable;
			// IP_v4
			var AF_INET = 2;    
			var buffSize = 0;
 
			// how much memory do we need?
			var ret = GetExtendedTcpTable(IntPtr.Zero, ref buffSize, true, AF_INET, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL, 0);
			var buffTable = Marshal.AllocHGlobal(buffSize);
 
			try
			{
				ret = GetExtendedTcpTable(buffTable, ref buffSize, true, AF_INET, TCP_TABLE_CLASS.TCP_TABLE_OWNER_PID_ALL, 0);
				if (ret != 0)
				{
					return null;
				}
 
				// get the number of entries in the table
				var tab = (MIB_TCPTABLE_OWNER_PID) Marshal.PtrToStructure(buffTable, typeof(MIB_TCPTABLE_OWNER_PID));
				var rowPtr = (IntPtr) ((long) buffTable + Marshal.SizeOf(tab.dwNumEntries));
 
				// buffer we will be returning
				tTable = new MIB_TCPROW_OWNER_PID[tab.dwNumEntries];
 
				for (var index = 0; index < tab.dwNumEntries; index++)
				{
					var tcpRow = (MIB_TCPROW_OWNER_PID) Marshal.PtrToStructure(rowPtr, typeof(MIB_TCPROW_OWNER_PID));
					tTable[index] = tcpRow;
					rowPtr = (IntPtr) ((long) rowPtr + Marshal.SizeOf(tcpRow));
				}
 
			}
			finally
			{
				// Free the Memory
				Marshal.FreeHGlobal(buffTable);
			}
 
			return tTable;
		}
 
		#endregion

def rpc_handler(request):
	"""
	the actual handler:
	if you setup your urls.py properly, all calls to the xml-rpc service
	should be routed through here.
	If post data is defined, it assumes it's XML-RPC and tries to process as such
	Empty post assumes you're viewing from a browser and tells you about the service.
	"""
 
	response = HttpResponse()
	if len(request.POST):
		response.write(dispatcher._marshaled_dispatch(request.raw_post_data))
	else:
		response.write("<b>This is an XML-RPC Service.</b><br>")
		response.write("You need to invoke it using an XML-RPC Client!<br>")
		response.write("The following methods are available:<ul>")
		methods = dispatcher.system_listMethods()
 
		for method in methods:
			# right now, my version of SimpleXMLRPCDispatcher always
			# returns "signatures not supported"... :(
			# but, in an ideal world it will tell users what args are expected
			sig = dispatcher.system_methodSignature(method)
 
			# this just reads your docblock, so fill it in!
			help =  dispatcher.system_methodHelp(method)
 
			response.write("<li><b>%s</b>: [%s] %s" % (method, sig, help))
 
		response.write("</ul>")
 
	response['Content-length'] = str(len(response.content))
	return response

response = HttpResponse(mimetype="application/xml")
response.write(dispatcher._marshaled_dispatch(request.raw_post_data))