def get(self, block=True, timeout=None):
try:
item = Queue.Queue.get(self, block, timeout)
except Queue.Empty as e:
raise Queue.Empty()
with self.sizeLock:
self.curSize -= len(item[1])
return item
def get(self, timeout):
item = self.collection.find_and_modify(sort=[('priority',
pymongo.ASCENDING)],
remove=True)
if item is None:
raise Queue.Empty()
else:
return pickle.loads(item['task'])
def setUp(self):
request = getTurbiniaRequest()
self.kombu = celery.TurbiniaKombu('fake_topic')
result = mock.MagicMock()
result.payload = request.to_json()
self.kombu.queue = mock.MagicMock()
self.kombu.queue.__len__.return_value = 1
self.kombu.queue.get.side_effect = [result, Queue.Empty('Empty Queue')]
def get_new_msgs(self):
msgs = []
while not self._msg_queue.empty():
try:
msg = self._msg_queue.get(block=False)
msgs.append(msg)
except queue.Empty():
return msgs
return msgs
def create_libdoc_in_separate_process(libname,
format,
python_paths,
class_paths,
timeout_duration=30):
import os
import subprocess
import threading
import time
try:
import Queue as queue
except:
import queue
global INTERPRETER_PATH
command = [INTERPRETER_PATH]
command.append(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'red_libraries.py'))
command.append(libname)
command.append(format)
command.append(';'.join(python_paths))
if class_paths:
command.append(';'.join(class_paths))
def get_output(process, q_stdout, q_stderr):
out, err = process.communicate()
q_stdout.put(out)
q_stderr.put(err)
encoded_command = __encode_unicode_if_needed(command)
process = subprocess.Popen(encoded_command,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.PIPE)
q_stdout = queue.Queue()
q_stderr = queue.Queue()
thread = threading.Thread(target=get_output,
args=(process, q_stdout, q_stderr))
thread.daemon = True
thread.start()
try:
out = q_stdout.get(timeout=timeout_duration)
err = q_stderr.get()
if out:
return next(line[8:].rstrip().decode('UTF-8')
for line in out.splitlines()
if line.startswith(b'Libdoc >'))
else:
raise Exception(err.decode('UTF-8', 'replace'))
except queue.Empty:
process.kill()
raise queue.Empty('Libdoc not generated due to timeout')
def get(self):
item = self.collection.find_one_and_delete(
{'schedule_time': {
'$lt': datetime.utcnow()
}},
sort=[('priority', pymongo.ASCENDING)])
if item is None:
raise queue.Empty()
else:
return pickle.loads(item['task'])
def getJob(self):
try:
if self.output.empty():
raise Queue.Empty()
job = self.output.get(True, 1)
self.output.task_done()
except Queue.Empty as e:
job = {'waiting': True}
finally:
return job
def loop_insert(flag_queue, task_queue, res_queue, db_info):
global loop_insert, loop_get
logger.info('Starting: loop_insert() => %s' % (cfg['vddb-async-url']))
select_todo_sql = db_info['sqls']['select-todo']
select_limit = db_info['select-limit']
todo_conn = gen_db_conn(db_info['todo-db'])
while not should_die(flag_queue):
try:
while not res_queue.empty():
ok = res_queue.get()
rows = execute_sql(todo_conn,
select_todo_sql, (select_limit, ),
fetch=True)
for record in rows:
logger.info('Deleted mysql %d' % record[0])
task_queue.put(record)
time.sleep(1)
results = []
results_ok = 0
rows_len = len(rows)
for i in range(rows_len):
try:
ok = res_queue.get(timeout=5)
except Queue.Empty():
ok = False
if ok:
results_ok += 1
results.append(ok)
if rows_len == 0:
time.sleep(db_info['select-interval'])
logger.info('One turn: (%d/%d), %r' %
(results_ok, rows_len, results))
except KeyboardInterrupt:
break
except Exception:
todo_conn.close()
todo_conn = gen_db_conn(db_info['todo-db'])
logger.error('loop_insert Exception: %r' % traceback.format_exc())
time.sleep(0.5)
todo_conn.close()
logger.warning('@@@ Exit: loop_insert()')
def test_perform_write_empty_queue(context):
('XMPPConnection.perform_write() should do '
'nothing when has an empty write queue')
conn = XMPPConnection('capulet.com', 5222)
conn.write_queue = Mock(name='write_queue')
conn.write_queue.get.side_effect = Queue.Empty('dang!')
write = EventHandlerMock('on_write')
conn.on.write(write)
socket = Mock(name='socket')
conn.perform_write(socket)
socket.sendall.called.should.be.false
write.called.should.be.false
def nextByte(self):
"""Get next 8 bits as a byte, tail-padded with zeroes if queue has fewer than 8 bits"""
# We could just call nextBit() 8 times and glue them all together, but this is faster
if not len(self.data) and self.currentbyte is None:
if self.currentinputbyte:
output = chr(
int(
self.currentinputbyte + "0" *
(8 - len(self.currentinputbyte)), 2))
self.currentinputbyte = ""
return output
else:
raise Queue.Empty()
if self.currentbyte is None:
self.currentbyte = self.data[0]
self.data = self.data[1:]
bitmask = (2 << self.bitposition) - 1
bits = ord(self.currentbyte) & bitmask
bits <<= 7 - self.bitposition
if self.bitposition < 7:
if self.data:
self.currentbyte = self.data[0]
self.data = self.data[1:]
bitmask = (
(2 <<
(7 - self.bitposition)) - 1) << (self.bitposition + 1)
bits2 = ord(self.currentbyte) & bitmask
bits |= bits2 >> (self.bitposition + 1)
elif self.currentinputbyte:
self.currentinputbyte += "0" * (7 - self.bitposition -
len(self.currentinputbyte))
bits2 = int(self.currentinputbyte[:7 - self.bitposition], 2)
bits |= bits2
self.currentinputbyte = self.currentinputbyte[7 - self.
bitposition:]
self.bitposition = 7
self.currentbyte = None
else:
self.bitposition = 7
self.currentbyte = None
else:
self.currentbyte = None
self.bitposition = 7
return chr(bits)
def write(self):
''' Create a list of instructions '''
try:
old, new = self.instructions.get_nowait()
# 1. Find the line with 'old' on it
for line, string in enumerate(self.widget.read().split("\n")):
if old in string:
line += 1
break
else:
raise Queue.Empty()
# 2. Replace
self.widget.replace(line, old, new)
index = str(line) + ".0"
# 3. Execute
self.widget.exec_line(event=None, insert=index)
# Recall
self.widget.root.after(50, self.write)
except Queue.Empty:
if self.running == True:
self.widget.root.after(choice([2000, 3000, 4000, 5000]),
self.act)
return
def nextBit(self):
"""Get next bit."""
if not len(self.data) and self.currentbyte is None:
if self.currentinputbyte:
output = int(self.currentinputbyte[0])
self.currentinputbyte = self.currentinputbyte[1:]
return output
else:
raise Queue.Empty()
if self.currentbyte is None:
self.currentbyte = self.data[0]
self.data = self.data[1:]
bitmask = 1 << self.bitposition
bit = ord(self.currentbyte) & bitmask
bit >>= self.bitposition
self.bitposition -= 1
if self.bitposition < 0:
self.bitposition = 7
self.currentbyte = None
return bit
def testHttp(self):
serverEnabled, serverPort, serverUser, serverPassword = getWebserverInfo(
)
if serverEnabled:
self.task = taskdict['http']['class']
taskKwargs = {
'http': 'http://localhost:%s/jsonrpc' % str(serverPort),
'user': serverUser,
'pass': serverPassword,
'type': 'http',
'request-type': 'GET',
'notify': False
}
userargs = '?request={"jsonrpc":%__"2.0"%_%__"id": 1%_%__"method":"Application.Setmute"%_%__"params":{"mute":"toggle"}}'
tm = TaskManager(self.task,
1,
None,
-1,
taskid='T1',
userargs=userargs,
**taskKwargs)
tm.returnHandler = self.returnHandler
topic = Topic('onPlaybackStarted')
runKwargs = events['onPlayBackStarted']['expArgs']
self.clear_q()
tm.start(topic, **runKwargs)
try:
tr = self.q.get(timeout=1)
except Queue.Empty:
raise Queue.Empty(_('testHttp never returned'))
else:
tm.start(topic, **runKwargs) # Toggle Mute again
if tr.iserror is True:
log(loglevel=xbmc.LOGERROR,
msg=_('testHttp returned with an error: %s') % tr.msg)
if '{"id":1,"jsonrpc":"2.0","result":' not in tr.msg:
raise AssertionError(_('Http test failed'))
else:
raise AssertionError(
'Http test cannot be run because webserver not enabled')
def test_get_new_task_empty_queue(self):
# prepare mock queues
for queue in self.queue_map.values():
queue.get.side_effect = threadqueue.Empty()
exc = scheduler.Executor("a", self.conn, self.queue_map, timeout=1)
self.assertEqual(exc._get_new_task(), None)
def get(self):
task = self.queue_object.pop()
if task is None:
raise queue.Empty()
else:
return pickle.loads(task[0])
def side_effect(*args, **kwds):
raise Queue.Empty()
def peek(self):
if len(self.__heap) == 0:
raise Queue.Empty()
return self.__heap[0]
def get(self, block=True, timeout=None):
return self._failOrWait(block, timeout, Queue.Empty())
def get_message_from_unpublished_stack(self, seconds):
if len(self.messages) == 0:
raise queue.Empty()
else:
return self.messages.pop()
def pop(self):
if len(self.__heap) == 0:
raise Queue.Empty()
return heapq.heappop(self.__heap)
def testBadCheckMessages(self):
result = mock.MagicMock()
result.payload = 'non-json-data'
self.kombu.queue.get.side_effect = [result, Queue.Empty('Empty Queue')]
self.assertListEqual(self.kombu.check_messages(), [])
def get_result(self, timeout=0):
if self.result != None:
return self.result
tmp_result = []
missed_key = []
if (timeout > 0):
start_time = time.time()
end_time = start_tume + timeout
for a in self.ops:
curr_time = time.time()
remain_time = end_time - curr_time
if remain_time < 0:
raise Queue.Empty()
ret, miss = a.get_result(remain_time)
tmp_result.append(ret)
missed_key += miss
else:
for a in self.ops:
ret, miss = a.get_result()
tmp_result.append(ret)
missed_key += miss
if self.cmd == 'bop mget':
result = {}
for a in tmp_result:
result.update(a)
else: # bop smget
length = len(tmp_result)
# empty
if length <= 0:
return []
# merge sort
result = []
while True:
# remove empty list
while len(tmp_result[0]) == 0:
tmp_result.pop(0)
if len(tmp_result) == 0: # all done
if self.result == None and self.invalid == True:
raise ArcusNodeConnectionException(
'current async result is unavailable because Arcus node is disconnected now'
)
missed_key.sort()
self.result = result
self.missed_key = missed_key
return self.result
min = tmp_result[0][0]
idx = 0
for i in xrange(0, len(tmp_result)):
if len(tmp_result[i]) and tmp_result[i][0] < min:
min = tmp_result[i][0]
idx = i
result.append(tmp_result[idx].pop(0))
if self.result == None and self.invalid == True:
raise ArcusNodeConnectionException(
'current async result is unavailable because Arcus node is disconnected now'
)
missed_key.sort()
self.result = result
self.missed_key = missed_key
return self.result
def get(self, timeout=None):
if timeout:
raise Queue.Empty()
def get(self):
with self._lock:
if len(self.queue) == 0:
raise Queue.Empty()
return copy.deepcopy(self.queue[0])
def get_nowait(self):
with self.__lock:
if len(self.__queue) == 0:
raise Queue.Empty()
return self.__queue.popleft()
def get(self, timeout):
task = self.queue_object.pop()
if task is None:
raise Queue.Empty()
else:
return task
def get(qSelf, timeout=1):
qSelf.getCallCount += 1
raise Queue.Empty("MOCK")
