def basic_publish (self, payload, exchange='', routing_key='', mandatory=False, immediate=False, properties=None): if self.confirm_mode: self._next_delivery_tag += 1 dtag = self._next_delivery_tag assert dtag not in self._pending_published s = coro.inverted_semaphore(1) self._pending_published[dtag] = s #W('basic_publish pending >>> %d\n' % dtag); self._basic_publish(payload, exchange, routing_key, mandatory, immediate, properties) self._publish_cv.wake_one() s.block_till_zero() #W('basic_publish pending <<< %d\n' % dtag); else: self._basic_publish(payload, exchange, routing_key, mandatory, immediate, properties)
def test_isem_schedule_interrupt(self): """Test schedule then interrupt on inverted semaphore.""" s = coro.inverted_semaphore() s.acquire(1) self._resume_count = 0 threads = [] # Spawn some threads that will block and be interrupted. for unused in xrange(5): threads.append(coro.spawn(self._isem_block, s)) # Spawn a thread that we will not interrupt. no_interrupt_thread = coro.spawn(self._isem_block, s) coro.yield_slice() # Schedule all of the threads. s.release(1) # Now interrupt them. for t in threads: t.shutdown() coro.yield_slice() # Verify that it ran. self.assertEqual(self._resume_count, 1)
def __init__(self): self._worker_semaphore = coro.inverted_semaphore() self._writes_finished = 0 self._reads_finished = 0 self._bytes_written = 0 self._bytes_read = 0 self._start_time = 0 self._fd = -1 self._written = [] self._size = 0 self._num_live_writers = 0 self._write_cancel_success = 0 self._write_cancel_fail = 0 self._read_cancel_success = 0 self._read_cancel_fail = 0 self._assertion_errors = 0 self._write_locks = None self._read_locks = None self.main_thread_state = 'Not started.' self.writer_status = {} self.reader_status = {} self.lio_status = {}
# furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import coro l = coro.inverted_semaphore() def worker(sleep): global l print 'working starting' l.acquire() coro.sleep_relative(sleep) print 'worker done, releasing' l.release() def waiter(): global l print 'waiter' l.block_till_zero()
def capture_with_stderr(command, cwd=None, env=None, timeout=0, pgrp=0): """Run a program in the background and capture its output. stdout and stderr are captured independently. :Parameters: - `command`: The command to execute. If it is a string, it will be parsed for command-line arguments. Otherwise it assumes it is a sequence of arguments, with the first element being the command to execute. If the command does not contain a slash (/) it will search the PATH environment for the executable. - `cwd`: Change the working directory to this path if specified before executing the program. - `env`: The environment to use. If None, the environment is not changed. May be a dictionary or a list of 'NAME=VALUE' strings. - `timeout`: If specified, will use a coro timeout to ensure that the process returns within the specified length of time. If it does not, it is forcefully killed (with SIGKILL) and `ProcessTimeout` is raised. - `pgrp`: Set to -1 to keep process group unchanged, 0 to create a new job (default) and >0 to set process group to pgrp :Return: Returns a tuple ``(status, stdout_output, stderr_output)``. Status is an `ExitStatus` instance. The outputs are strings. :Exceptions: - `OSError`: Generic system error. - `ValueError`: The command value is invalid. - `ProcessTimeout`: The process did not return within `timeout` seconds. """ status = None stdout_result = [] stderr_result = [] finished_sem = coro.inverted_semaphore(2) p = spawn_job_bg(command, stdin=DEV_NULL, stdout=PIPE, stderr=PIPE, cwd=cwd, env=env, pgrp=pgrp) def do_read(s, result): while 1: block = s.read(1024) if block: result.append(block) else: break finished_sem.release() def do_work(): finished_sem.block_till_zero() return p.wait() try: coro.spawn(do_read, p.stdout, stdout_result) coro.spawn(do_read, p.stderr, stderr_result) if timeout: status = coro.with_timeout(timeout, do_work) else: status = do_work() except BaseException, e: try: p.killpg(signal.SIGKILL) except OSError, kill_exc: if kill_exc.errno != errno.ESRCH: raise
# furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import coro l = coro.inverted_semaphore() def worker(sleep): global l print 'working starting' l.acquire() coro.sleep_relative(sleep) print 'worker done, releasing' l.release() def waiter(): global l print 'waiter' l.block_till_zero() print 'waiter awoke' coro._exit = 1