Set the _returncode attribute, so close() doesn't try to terminate the process.

Create the protocol on a separated line for readability and ease debugging.

…seEventLoop)

Ignore pipes for which the protocol is not set yet (still equal to None).

…is closed

Close the transport if the creation of the transport (if the waiter) gets an
exception.

Skip SSL tests on the ProactorEventLoop if ssl.MemoryIO is missing

Sort also imports in windows_utils.

StreamWriter now raises an exception if it is closed: write(), writelines(),
write_eof(), can_write_eof(), get_extra_info(), drain().

Don't call immediatly self._process_write_backlog() but schedule the call using
call_soon(). _on_handshake_complete() can be called indirectly from
_process_write_backlog(), and _process_write_backlog() is not reentrant.

transport at subprocess exit.

Clear also its reference to the transport.

Do nothing if the transport is already closed. Before it was not possible to
close the transport twice.

Check if the _sock attribute is None to check if the transport is closed.

Set the _read_fut attribute to None after cancelling it.

This change should fix a race condition with
_ProactorWritePipeTransport._pipe_closed().

* Use test_utils.run_briefly() to execute pending calls to really close
  transports
* sslproto: mock also _SSLPipe.shutdown(), it's need to close the transport
* pipe test: the test doesn't close explicitly the PipeHandle, so ignore
  the warning instead
* test_popen: use the context manager ("with p:") to explicitly close pipes

StreamWriter: close() now clears the reference to the transport

StreamWriter now raises an exception if it is closed: write(), writelines(),
write_eof(), can_write_eof(), get_extra_info(), drain().

Override the connect_read_pipe() method of the loop to mock immediatly
pause_reading() and resume_reading() methods.

The test failed randomly on FreeBSD 9 buildbot and on Windows using trollius.

Remove the exc variable, it's not used.

* Handle correctly CancelledError: just exit
* On error, log the exception and exit

Don't try to close the event loop, it is probably running and so it cannot be
closed.

This change fixes a race conditon related to _WaitHandleFuture.cancel() leading
to Python crash or "GetQueuedCompletionStatus() returned an unexpected event"
logs. Before, the overlapped object was destroyed too early, it was possible
that the wait completed whereas the overlapped object was already destroyed.
Sometimes, a different overlapped was allocated at the same address, leading to
unexpected completition.

_WaitHandleFuture.cancel() now waits until the wait is cancelled to clear its
reference to the overlapped object. To wait until the cancellation is done,
UnregisterWaitEx() is used with an event instead of UnregisterWait().

To wait for this event, a new _WaitCancelFuture class was added. It's a
simplified version of _WaitCancelFuture. For example, its cancel() method calls
UnregisterWait(), not UnregisterWaitEx(). _WaitCancelFuture should not be
cancelled.

The overlapped object is kept alive in _WaitHandleFuture until the wait is
unregistered.

Other changes:

* Add _overlapped.UnregisterWaitEx()
* Remove fast-path in IocpProactor.wait_for_handle() to immediatly set the
  result if the wait already completed. I'm not sure that it's safe to
  call immediatly UnregisterWaitEx() before the completion was signaled.
* Add IocpProactor._unregistered() to forget an overlapped which may never be
  signaled, but may be signaled for the next loop iteration. It avoids to
  block forever IocpProactor.close() if a wait was cancelled, and it may also
  avoid some "... unexpected event ..." warnings.

…t only

Exception

_WaitCancelFuture futures

Add _overlapped.ConnectPipe() which tries to connect to the pipe for
asynchronous I/O (overlapped): call CreateFile() in a loop until it doesn't
fail with ERROR_PIPE_BUSY. Use an increasing delay between 1 ms and 100 ms.

Remove Overlapped.WaitNamedPipeAndConnect() which is no more used.

Overlapped.ConnectNamedPipe() now returns a boolean: True if the pipe is
connected (if ConnectNamedPipe() failed with ERROR_PIPE_CONNECTED), False if
the connection is in progress.

This change removes multiple hacks in IocpProactor.

Fix create_datagram_endpoint(), connect_read_pipe() and connect_write_pipe():
close the transport if the task is cancelled or on error.

The special case for connect_pipe() is not more needed. connect_pipe() doesn't
use overlapped operations anymore.

Fixing some comments. The server listens on 12345 and client connects
on 12345, but the comments state 1234. Patch written by bryan.neff.

To more closely match the standard Queue, asyncio.Queue has "join" and
"task_done". JoinableQueue is deleted.

In debug mode, BaseEventLoop._run_once() now sets the
BaseEventLoop._current_handle attribute to the handle currently executed.
In release mode or when no handle is executed, the attribute is None.

BaseEventLoop.default_exception_handler() displays the traceback of the current
handle if available.

If a client connected before the server was closed: drop the client (close the
pipe) and exit

Use a coroutine with asyncio.sleep() instead of call_later() to ensure that the
schedule call is cancelled.

Add also a unit test cancelling connect_pipe().

If UnregisterWaitEx() fais with ERROR_IO_PENDING, it doesn't mean that the wait
is unregistered yet. We still have to wait until the wait is cancelled.

If ReadFile() fails with ERROR_BROKEN_PIPE, the operation is not pending: don't
register the overlapped.

I don't know if WSARecv() can fail with ERROR_BROKEN_PIPE. Since
Overlapped.WSARecv() already handled ERROR_BROKEN_PIPE, let me guess that it
has the same behaviour than ReadFile().

already know the traceback of the source.

The handle may be more revelant, but having 3 tracebacks (handle, source,
exception) becomes more difficult to read. The handle may be preferred later
but it requires more work to make this choice.

Wake-up the waiter if it is not done yet.

* Rephrase also the comment explaining why the waiter is not awaken immediatly.
* SSLProtocol.eof_received() doesn't instanciate ConnectionResetError exception
  directly, it will be done by Future.set_exception(). The exception is not
  used if the waiter was cancelled or if there is no waiter.

Only start reading when connection_made() has been called:
protocol.data_received() must not be called before protocol.connection_made().

close() closes pipes, which is not None yet by _kill_wait().

Only start reading after connection_made() has been called.

Don't call protocol.connection_lost() if protocol.connection_made() was not
called yet: if the SSL handshake failed or is still in progress.

The close() method can be called if the creation of the connection is
cancelled, by a timeout for example.

attribute

Only start reading when connection_made() has been called.

* Close the transport on error
* In debug mode, log errors using call_exception_handler()

…when an

event loop or a transport is not explicitly closed

Changes on BaseSubprocessTransport:

* Add a wait() method to wait until the child process exit
* The constructor now accepts an optional waiter parameter. The _post_init()
  coroutine must not be called explicitly anymore. It makes subprocess
  transports closer to other transports, and it gives more freedom if we want
  later to change completly how subprocess transports are created.
* close() now kills the process instead of kindly terminate it: the child
  process may ignore SIGTERM and continue to run. Call explicitly terminate()
  and wait() if you want to kindly terminate the child process.
* close() now logs a warning in debug mode if the process is still running and
  needs to be killed
* _make_subprocess_transport() is now fully asynchronous again: if the creation
  of the transport failed, wait asynchronously for the process eixt. Before the
  wait was synchronous. This change requires close() to *kill*, and not
  terminate, the child process.
* Remove the _kill_wait() method, replaced with a more agressive close()
  method. It fixes _make_subprocess_transport() on error.
  BaseSubprocessTransport.close() calls the close() method of pipe transports,
  whereas _kill_wait() closed directly pipes of the subprocess.Popen object
  without unregistering file descriptors from the selector (which caused severe
  bugs).

These changes simplifies the code of subprocess.py.

BaseSubprocessTransport now check if the transport was closed and if the
process exited.

…f the

transport was closed. The check broken a Tulip example and this limitation is
arbitrary. Check if _proc is None should be enough.

Enhance also close(): do nothing when called the second time.

Kill the process on timeout: don't keep a running process in the backgroud!

Close the transport, not directly the pipe.

Don't use yield/yield-from in an except block of a generator. Store the
exception and handle it outside the except block.

Just try to be consistent: _debug was already used in some places, and always
used in BaseProactorEventLoop.

* _check_resolved_address() is implemented with getaddrinfo() which is slow
* If available, use socket.inet_pton() instead of socket.getaddrinfo(), because
  it is much faster

Microbenchmark (timeit) on Fedora 21 (Python 3.4, Linux 3.17, glibc 2.20) to
validate the IPV4 address "127.0.0.1" or the IPv6 address "::1":

* getaddrinfo() 10.4 usec per loop
* inet_pton(): 0.285 usec per loop

On glibc older than 2.14, getaddrinfo() always requests the list of all local
IP addresses to the kernel (using a NETLINK socket). getaddrinfo() has other
known issues, it's better to avoid it when it is possible.

… already

finished

…nning

…or Queue.

To more closely match the standard Queue, asyncio.Queue has "join" and "task_done".
JoinableQueue remains as a deprecated alias for Queue to avoid needlessly breaking
too much code that depended on it.

Patch written by Serhiy Storchaka <storchaka@gmail.com>.

Really kill the child process, don't mock completly the Popen.kill() method.

This change fix memory leaks and reference leaks.

Read process exit status to avoid the "Caught subprocess termination from
unknown pid" message.

…sTransport

Methods only raise NotImplementedError and are never used.

Replace "running" with "not started" and don't show the pid if the subprocess
didn't start yet.

…onnect()

again if the first call to connect() raises an InterruptedError.

When the C function connect() fails with EINTR, the connection runs in
background. We have to wait until the socket becomes writable to be notified
when the connection succeed or fails.

Rename README file to have rst render on Github

add in .gitignore pyvenv and PyCharm files

Update repo reference from google code to github

Issue python#222: Fix the @coroutine decorator for functions without __name__
attribute like functools.partial().

Enhance also the representation of a CoroWrapper if the coroutine
function is a functools.partial().