def blockingCallFromThread(reactor, f, *a, **kw):
"""
Run a function in the reactor from a thread, and wait for the result
synchronously, i.e. until the callback chain returned by the function
get a result.
@param reactor: The L{IReactorThreads} provider which will be used to
schedule the function call.
@param f: the callable to run in the reactor thread
@type f: any callable.
@param a: the arguments to pass to C{f}.
@param kw: the keyword arguments to pass to C{f}.
@return: the result of the callback chain.
@raise: any error raised during the callback chain.
"""
queue = Queue.Queue()
def _callFromThread():
result = defer.maybeDeferred(f, *a, **kw)
result.addBoth(queue.put)
reactor.callFromThread(_callFromThread)
result = queue.get()
if isinstance(result, failure.Failure):
result.raiseException()
return result
def _create_derivative_resource_async(self, docid, pdfname):
self._derivs[docid] = PdfDerivatives(
os.path.join(self.dbpath, docid, pdfname),
os.path.join(CACHEROOT, self.dbname, docid))
reactor.callFromThread(
self._with_derivative_resource_sync, docid)
def mineThread(self):
for data in self.qr:
for i in range(data.iterations):
offset = (unpack('I', data.base[i])[0],) if self.GOFFSET else None
self.kernel.search(
self.commandQueue, (data.size, ), (self.WORKSIZE, ),
data.state[0], data.state[1], data.state[2], data.state[3],
data.state[4], data.state[5], data.state[6], data.state[7],
data.state2[1], data.state2[2], data.state2[3],
data.state2[5], data.state2[6], data.state2[7],
data.base[i],
data.f[0], data.f[1], data.f[2], data.f[3],
data.f[4], data.f[5], data.f[6], data.f[7],
self.output_buf, global_offset=offset)
cl.enqueue_read_buffer(self.commandQueue, self.output_buf,
self.output, is_blocking=False)
self.commandQueue.finish()
# The OpenCL code will flag the last item in the output buffer
# when it finds a valid nonce. If that's the case, send it to
# the main thread for postprocessing and clean the buffer
# for the next pass.
if self.output[self.WORKSIZE]:
reactor.callFromThread(self.postprocess,
self.output.copy(), data.nr)
self.output.fill(0)
cl.enqueue_write_buffer(self.commandQueue, self.output_buf,
self.output, is_blocking=False)
def run(self):
while True:
self.userv.wi_available.acquire()
while len(self.userv.wi) == 0:
self.userv.wi_available.wait()
wi = self.userv.wi.pop(0)
if wi == None:
# Shutdown request, relay it further
self.userv.wi.append(None)
self.userv.wi_available.notify()
self.userv.wi_available.release()
if wi == None:
break
command, result_callback, callback_parameters = wi
try:
data, rtpc_delay = self.send_raw(command)
if len(data) == 0:
data, rtpc_delay = None, None
except Exception as e:
print(e)
data, rtpc_delay = None, None
if result_callback != None:
reactor.callFromThread(self.dispatch, result_callback, data, callback_parameters)
if rtpc_delay != None:
reactor.callFromThread(self.userv.register_delay, rtpc_delay)
def onSettingsChange(self, plugin_name, data):
"""
The plugin has been changed by the frontend
:param plugin_name: Name of plugin that changed
:type plugin_name: str
:param data: Complete data (changed and unchanged)
:type data: dict
:rtype: None
"""
logger.info(u"onSettingsChange: {}".format(data))
if not plugin_name:
logger.error("Missing plugin name")
return
if not data:
logger.error("Missing data")
return
logger.info(u"Sending data {}".format(data))
reactor.callFromThread(self._sendJSON, {
'msg': "plugin_data_set",
'plugin_name': plugin_name,
'data': data
})
# trigger db update
reactor.callFromThread(self._sendJSON, {
'msg': "plugin_data_get",
'plugin_name': plugin_name
})
def connect(self, reflect=True, existing_metadata=None):
""" Connect to the database.
When a connection has been established, the
`on_connection_established` is invoked with the metadata.
If connecting fails, the `on_connection_failed` is invoked
with the failure.
:param reflect: If true, reflects the tables and their relations.
:param existing_metadata: If provided, use this existing
metadata instead of creating a metadata instance.
:param reconnect_on_failure: If true, keeps reconnecting if the initial
attempt fails.
"""
if self.is_connected:
return
self._should_reflect = reflect
self._configure_driver()
self._make_metadata(existing_metadata)
try:
self._try_connecting()
except sa.exc.SQLAlchemyError, e:
log.error('Could not connect to database "%s": %s' % (self.database_name, e))
reactor.callFromThread(self.on_connection_failed, failure.Failure())
raise
def _new_fragment(self, hlssink):
self.log("hlsink created a new fragment")
try:
fragment = hlssink.get_property('fragment')
except:
fragment = hlssink.emit('pull-fragment')
reactor.callFromThread(self._process_fragment, fragment)
def blockingCallFromMainThread(f, *a, **kw):
"""
Modified version of twisted.internet.threads.blockingCallFromThread
which waits 30s for results and otherwise assumes the system to be shut down.
This is an ugly workaround for a twisted-internal deadlock.
Please keep the look intact in case someone comes up with a way
to reliably detect from the outside if twisted is currently shutting
down.
"""
queue = Queue.Queue()
def _callFromThread():
result = defer.maybeDeferred(f, *a, **kw)
result.addBoth(queue.put)
reactor.callFromThread(_callFromThread)
result = None
while True:
try:
result = queue.get(True, config.plugins.autotimer.timeout.value*60)
except Queue.Empty as qe:
if True: #not reactor.running: # reactor.running is only False AFTER shutdown, we are during.
doLog("[AutoTimer] Reactor no longer active, aborting.")
else:
break
if isinstance(result, failure.Failure):
result.raiseException()
return result
def disconnect(self):
""" Disconnect from the database.
This closes all active connections in the underlying
connection pool, and calls the `on_connection_lost`. """
self.metadata.bind.dispose()
reactor.callFromThread(self.on_connection_lost)
def check_response(resp):
failed = False
response = resp.content
if resp.status_code == requests.codes.ok:
sha1_regex = re.compile(r'<sha1checksum>([^<]+)<\/sha1checksum>')
sha1_match = sha1_regex.search(response)
if sha1_match is None:
log.err('dshield ERROR: Could not find sha1checksum in response')
failed = True
sha1_local = hashlib.sha1()
sha1_local.update(log_output)
if sha1_match.group(1) != sha1_local.hexdigest():
log.err('dshield ERROR: SHA1 Mismatch {0} {1} .'.format(sha1_match.group(1), sha1_local.hexdigest()))
failed = True
md5_regex = re.compile(r'<md5checksum>([^<]+)<\/md5checksum>')
md5_match = md5_regex.search(response)
if md5_match is None:
log.err('dshield ERROR: Could not find md5checksum in response')
failed = True
md5_local = hashlib.md5()
md5_local.update(log_output)
if md5_match.group(1) != md5_local.hexdigest():
log.err('dshield ERROR: MD5 Mismatch {0} {1} .'.format(md5_match.group(1), md5_local.hexdigest()))
failed = True
log.msg('dshield SUCCESS: Sent {0} bytes worth of data to secure.dshield.org'.format(len(log_output)))
else:
log.err('dshield ERROR: error {0}.'.format(resp.status_code))
log.err('Response was {0}'.format(response))
failed = True
if failed:
# Something went wrong, we need to add them to batch.
reactor.callFromThread(self.transmission_error, batch)
def test(self):
crawler = mock.MagicMock()
crawler.settings = CrawlerSettings()
crawler.settings.overrides['USER_AGENT'] = 'CustomAgent'
self.assertRaises(NotConfigured, RobotsTxtMiddleware, crawler)
crawler.settings.overrides['ROBOTSTXT_OBEY'] = True
crawler.engine.download = mock.MagicMock()
ROBOTS = re.sub(r'^\s+(?m)', '', '''
User-Agent: *
Disallow: /admin/
Disallow: /static/
''')
response = Response('http://site.local/robots.txt', body=ROBOTS)
def return_response(request, spider):
deferred = Deferred()
reactor.callFromThread(deferred.callback, response)
return deferred
crawler.engine.download.side_effect = return_response
middleware = RobotsTxtMiddleware(crawler)
spider = None # not actually used
# There is a bit of neglect in robotstxt.py: robots.txt is fetched asynchronously,
# and it is actually fetched only *after* first process_request completes.
# So, first process_request will always succeed.
# We defer test() because otherwise robots.txt download mock will be called after assertRaises failure.
self.assertIsNone(middleware.process_request(Request('http://site.local'), spider)) # not affected by robots.txt
def test(r):
self.assertIsNone(middleware.process_request(Request('http://site.local/allowed'), spider))
self.assertRaises(IgnoreRequest, middleware.process_request, Request('http://site.local/admin/main'), spider)
self.assertRaises(IgnoreRequest, middleware.process_request, Request('http://site.local/static/'), spider)
deferred = Deferred()
deferred.addCallback(test)
reactor.callFromThread(deferred.callback, None)
return deferred
def do_list(self, line):
"""List data about a room.
"list members <roomid> [query]" - List all the members in this room.
"list messages <roomid> [query]" - List all the messages in this room.
Where [query] will be directly applied as query parameters, allowing
you to use the pagination API. E.g. the last 3 messages in this room:
"list messages <roomid> from=END&to=START&limit=3"
"""
args = self._parse(line, ["type", "roomid", "qp"])
if not "type" in args or not "roomid" in args:
print "Must specify type and room ID."
return
if args["type"] not in ["members", "messages"]:
print "Unrecognised type: %s" % args["type"]
return
room_id = args["roomid"]
path = "/rooms/%s/%s" % (urllib.quote(room_id), args["type"])
qp = {"access_token": self._tok()}
if "qp" in args:
for key_value_str in args["qp"].split("&"):
try:
key_value = key_value_str.split("=")
qp[key_value[0]] = key_value[1]
except:
print "Bad query param: %s" % key_value
return
reactor.callFromThread(self._run_and_pprint, "GET", path,
query_params=qp)
def _send_receipt(self, event, feedback_type):
path = ("/rooms/%s/messages/%s/%s/feedback/%s/%s" %
(urllib.quote(event["room_id"]), event["user_id"], event["msg_id"],
self._usr(), feedback_type))
data = {}
reactor.callFromThread(self._run_and_pprint, "PUT", path, data=data,
alt_text="Sent receipt for %s" % event["msg_id"])
def do_joinalias(self, line):
try:
args = self._parse(line, ["roomname"], force_keys=True)
path = "/join/%s" % urllib.quote(args["roomname"])
reactor.callFromThread(self._run_and_pprint, "POST", path, {})
except Exception as e:
print e
def do_topic(self, line):
""""topic [set|get] <roomid> [<newtopic>]"
Set the topic for a room: topic set <roomid> <newtopic>
Get the topic for a room: topic get <roomid>
"""
try:
args = self._parse(line, ["action", "roomid", "topic"])
if "action" not in args or "roomid" not in args:
print "Must specify set|get and a room ID."
return
if args["action"].lower() not in ["set", "get"]:
print "Must specify set|get, not %s" % args["action"]
return
path = "/rooms/%s/topic" % urllib.quote(args["roomid"])
if args["action"].lower() == "set":
if "topic" not in args:
print "Must specify a new topic."
return
body = {
"topic": args["topic"]
}
reactor.callFromThread(self._run_and_pprint, "PUT", path, body)
elif args["action"].lower() == "get":
reactor.callFromThread(self._run_and_pprint, "GET", path)
except Exception as e:
print e
def negotiateSession(self, username, tryNext=False):
"""
Negotiate through the instant messaging layer a direct peer-to-peer connection
with the user that has the given username. Note the username in question must
represent another SubliminalCollaborator Negotiator instance used by another
user.
If the user identified by the given username is not in the C{Array} returned
by listUsers(), the expectation is that successful execution of this function
will result in the given username being added to the list of known users.
"""
if (not username in self.peerUsers) and (not username in self.unverifiedUsers):
self.addUserToLists(username)
if not tryNext:
self.hostAddressToTryQueue = socket.gethostbyname_ex(socket.gethostname())[2]
if len(self.hostAddressToTryQueue) == 0:
status_bar.status_message('failed to share with %s' % username)
logger.warn('Unable to connect to peer %s, all host addresses tried and failed!' % username)
# TODO error reporting in UI
self.msg(username, 'NO-GOOD-HOST-IP')
return
ipaddress = self.hostAddressToTryQueue.pop()
session = base.BasePeer(username)
port = session.hostConnect()
status_bar.status_message('trying to share with %s@%s' % (username, ipaddress))
logger.debug('Negotiating collab session with %s with ip address %s on port %d' % (username, ipaddress, port))
reactor.callFromThread(self.ctcpMakeQuery, username, [('DCC CHAT', 'collaborate %s %d' % (ipaddress, port))])
self.negotiateCallback(session)
def do_register(self, line):
"""Registers for a new account: "register <userid> <noupdate>"
<userid> : The desired user ID
<noupdate> : Do not automatically clobber config values.
"""
args = self._parse(line, ["userid", "noupdate"])
password = None
pwd = None
pwd2 = "_"
while pwd != pwd2:
pwd = getpass.getpass("Type a password for this user: "******"Retype the password: "******"Password mismatch."
pwd = None
else:
password = pwd
body = {
"type": "m.login.password"
}
if "userid" in args:
body["user"] = args["userid"]
if password:
body["password"] = password
reactor.callFromThread(self._do_register, body,
"noupdate" not in args)
def run(self):
while self.port_agent.keep_going:
if not self.port_agent._pause:
reactor.callFromThread(self.port_agent.router.got_data, get_one(self.orb))
time.sleep(.0001)
else:
time.sleep(.001)
def blockingCallFromThread(reactor, f, *a, **kw):
"""
Run a function in the reactor from a thread, and wait for the result
synchronously. If the function returns a L{Deferred}, wait for its
result and return that.
@param reactor: The L{IReactorThreads} provider which will be used to
schedule the function call.
@param f: the callable to run in the reactor thread
@type f: any callable.
@param a: the arguments to pass to C{f}.
@param kw: the keyword arguments to pass to C{f}.
@return: the result of the L{Deferred} returned by C{f}, or the result
of C{f} if it returns anything other than a L{Deferred}.
@raise: If C{f} raises a synchronous exception,
C{blockingCallFromThread} will raise that exception. If C{f}
returns a L{Deferred} which fires with a L{Failure},
C{blockingCallFromThread} will raise that failure's exception (see
L{Failure.raiseException}).
"""
queue = Queue.Queue()
def _callFromThread():
result = defer.maybeDeferred(f, *a, **kw)
result.addBoth(queue.put)
reactor.callFromThread(_callFromThread)
result = queue.get()
if isinstance(result, failure.Failure):
result.raiseException()
return result
def _signal_kill(self, signum, _):
signame = signal_names[signum]
log.msg('Received %s twice, forcing unclean shutdown' % signame, \
level=log.INFO)
log.log_level = log.SILENT # disable logging of confusing tracebacks
reactor.callFromThread(self.engine.kill)
install_shutdown_handlers(signal.SIG_IGN)
def processDone(self, view, protocol, client,
account, request):
if __debug__:
trace("processDone")
if self.shuttingDown:
return None
# request
# 0: cmd
# 1: client
# 2: accountUUID
dt = self.getDownloadTracker(account)
if dt.totalDownloaded > 0:
# This is a PyICU.ChoiceFormat class
txt = constants.DOWNLOAD_CHANDLER_MESSAGES.format(dt.totalDownloaded)
setStatusMessage(txt % \
{'accountName': account.displayName,
'numberTotal': dt.totalDownloaded,
'numberNew': dt.totalNewDownloaded,
'numberUpdates': dt.totalUpdateDownloaded,
'numberDuplicates': dt.totalIgnoreDownloaded,
'numberErrors': dt.totalErrorDownloaded})
else:
setStatusMessage(constants.DOWNLOAD_NO_MESSAGES % \
{'accountName': account.displayName})
self._resetWorker(account)
# Post a notification to the Mail Protocol Client
# That the requested actions are finished.
reactor.callFromThread(client.requestsComplete)
def intermediateWrite(self, timers, conflicting, similar, skipped):
returnlist = []
extend = returnlist.extend
for (name, begin, end, serviceref, autotimername, message) in timers:
ref = ServiceReference(str(serviceref))
extend(
(
"<e2simulatedtimer>\n" " <e2servicereference>",
stringToXML(serviceref),
"</e2servicereference>\n",
" <e2servicename>",
stringToXML(ref.getServiceName().replace("\xc2\x86", "").replace("\xc2\x87", "")),
"</e2servicename>\n",
" <e2name>",
stringToXML(name),
"</e2name>\n",
" <e2timebegin>",
str(begin),
"</e2timebegin>\n",
" <e2timeend>",
str(end),
"</e2timeend>\n",
" <e2autotimername>",
stringToXML(autotimername),
"</e2autotimername>\n" "</e2simulatedtimer>\n",
)
)
if self._stillAlive:
reactor.callFromThread(lambda: self._req.write("".join(returnlist)))
def wrapper(*args, **kargs):
q = Queue()
def callback(value):
q.put(None)
def errback(failure):
# Retrieve and save full exception info
try:
failure.raiseException()
except:
q.put(sys.exc_info())
def g():
try:
d = func(*args, **kargs)
try:
d.addCallbacks(callback, errback)
# Check for a common mistake and display a nice error
# message
except AttributeError:
raise TypeError("you must return a twisted Deferred "
"from your test case!")
# Catch exceptions raised in the test body (from the
# Twisted thread)
except:
q.put(sys.exc_info())
reactor.callFromThread(g)
try:
error = q.get(timeout=timeout)
except Empty:
raise TimeExpired("timeout expired before end of test (%f s.)"
% timeout)
# Re-raise all exceptions
if error is not None:
exc_type, exc_value, tb = error
raise exc_type(exc_value).with_traceback(tb)
def run(self):
maxemptydata = 100
while True:
try:
data, address = self.userv.skt.recvfrom(8192)
if not data:
# Ugly hack to detect socket being closed under us on Linux.
# The problem is that even call on non-closed socket can
# sometimes return empty data buffer, making AsyncReceiver
# to exit prematurely.
maxemptydata -= 1
if maxemptydata == 0:
break
continue
else:
maxemptydata = 100
except Exception, why:
if isinstance(why, socket.error) and why[0] in (ECONNRESET, ENOTCONN, ESHUTDOWN):
break
if isinstance(why, socket.error) and why[0] in (EINTR,):
continue
else:
print datetime.now(), 'Udp_server: unhandled exception when receiving incoming data'
print '-' * 70
traceback.print_exc(file = sys.stdout)
print '-' * 70
sys.stdout.flush()
sleep(1)
continue
rtime = MonoTime()
if self.userv.uopts.family == socket.AF_INET6:
address = ('[%s]' % address[0], address[1])
reactor.callFromThread(self.userv.handle_read, data, address, rtime)
def runTestFunc():
no_errors = False
try:
func(*clients)
no_errors = True
finally:
reactor.callFromThread(superviseFunc, connections, no_errors)
def _signal_kill(self, signum, _):
install_shutdown_handlers(signal.SIG_IGN)
signame = signal_names[signum]
log.msg(format='Received %(signame)s twice, forcing unclean shutdown',
level=log.INFO, signame=signame)
self._stop_logging()
reactor.callFromThread(self._stop_reactor)
def _client_removed_cb(self, element, arg0, client_status):
# treat as error if we were removed because of GST_CLIENT_STATUS_ERROR
# FIXME: can we use the symbol instead of a numeric constant ?
if client_status == 4:
# since we get called from the streaming thread, hand off handling
# to the reactor's thread
reactor.callFromThread(self._client_error_cb)
def writeResponse(message):
global processing, queue
self.transport.write(message + "\r\n")
if queue.empty() == False:
reactor.callFromThread(self.lineReceived, queue.get())
print "Processing message in Queue"
processing = False
def next(self):
"""Since QueueReader is iterable, this is the function that runs the
for-loop and dispatches work to the thread.
This should be the only thread that executes outside of the Twisted
main thread.
"""
# If we just completed a range, we should tell the main thread.
now = time()
if self.currentData:
dt = now - self.startedAt
# self.currentData[1] is the un-preprocessed NonceRange.
reactor.callFromThread(self._ranExecution, dt, self.currentData[1])
self.startedAt = now
# Block for more data from the main thread. In 99% of cases, though,
# there should already be something here.
# Note that this comes back with either a tuple, or a StopIteration()
self.currentData = self.dataQueue.get(True)
# Does the main thread want us to shut down, or pass some more data?
if isinstance(self.currentData, StopIteration):
raise self.currentData
# We just took the only item in the queue. It needs to be restocked.
reactor.callFromThread(self._requestMore)
# currentData is actually a tuple, with item 0 intended for the kernel.
return self.currentData[0]
def run(self):
req = self._req
if self._stillAlive:
req.setResponseCode(http.OK)
req.setHeader("Content-type", "application/xhtml+xml")
req.setHeader("charset", "UTF-8")
reactor.callFromThread(
lambda: req.write(
'<?xml version="1.0" encoding="UTF-8" ?>\n<e2autotimersimulate api_version="'
+ str(API_VERSION)
+ '">\n'
)
)
def finishRequest():
req.write("</e2autotimersimulate>")
req.finish()
id = req.args.get("id")
if id:
self.id = int(id[0])
else:
self.id = None
try:
autotimer.parseEPG(simulateOnly=True, uniqueId=self.id, callback=self.intermediateWrite)
except Exception as e:
def finishRequest():
req.write("<exception>" + str(e) + "</exception><|PURPOSEFULLYBROKENXML<")
req.finish()
if self._stillAlive:
reactor.callFromThread(finishRequest)
def main(args, net, datadir_path, merged_urls, worker_endpoint):
try:
print 'p2pool (version %s)' % (p2pool.__version__, )
print
@defer.inlineCallbacks
def connect_p2p():
# connect to bitcoind over bitcoin-p2p
print '''Testing bitcoind P2P connection to '%s:%s'...''' % (
args.bitcoind_address, args.bitcoind_p2p_port)
factory = bitcoin_p2p.ClientFactory(net.PARENT)
reactor.connectTCP(args.bitcoind_address, args.bitcoind_p2p_port,
factory)
yield factory.getProtocol() # waits until handshake is successful
print ' ...success!'
print
defer.returnValue(factory)
if args.testnet: # establish p2p connection first if testnet so bitcoind can work without connections
factory = yield connect_p2p()
# connect to bitcoind over JSON-RPC and do initial getmemorypool
url = '%s://%s:%i/' % ('https' if args.bitcoind_rpc_ssl else 'http',
args.bitcoind_address, args.bitcoind_rpc_port)
print '''Testing bitcoind RPC connection to '%s' with username '%s'...''' % (
url, args.bitcoind_rpc_username)
bitcoind = jsonrpc.Proxy(
url,
dict(Authorization='Basic ' +
base64.b64encode(args.bitcoind_rpc_username + ':' +
args.bitcoind_rpc_password)),
timeout=30)
yield helper.check(bitcoind, net)
temp_work = yield helper.getwork(bitcoind)
bitcoind_warning_var = variable.Variable(None)
@defer.inlineCallbacks
def poll_warnings():
errors = (yield
deferral.retry('Error while calling getmininginfo:')(
bitcoind.rpc_getmininginfo)())['errors']
bitcoind_warning_var.set(errors if errors != '' else None)
yield poll_warnings()
task.LoopingCall(poll_warnings).start(20 * 60)
print ' ...success!'
print ' Current block hash: %x' % (temp_work['previous_block'], )
print ' Current block height: %i' % (temp_work['height'] - 1, )
print
if not args.testnet:
factory = yield connect_p2p()
print 'Determining payout address...'
if args.pubkey_hash is None:
address_path = os.path.join(datadir_path, 'cached_payout_address')
if os.path.exists(address_path):
with open(address_path, 'rb') as f:
address = f.read().strip('\r\n')
print ' Loaded cached address: %s...' % (address, )
else:
address = None
if address is not None:
res = yield deferral.retry(
'Error validating cached address:',
5)(lambda: bitcoind.rpc_validateaddress(address))()
if not res['isvalid'] or not res['ismine']:
print ' Cached address is either invalid or not controlled by local bitcoind!'
address = None
if address is None:
print ' Getting payout address from bitcoind...'
address = yield deferral.retry(
'Error getting payout address from bitcoind:',
5)(lambda: bitcoind.rpc_getaccountaddress('p2pool'))()
with open(address_path, 'wb') as f:
f.write(address)
my_pubkey_hash = bitcoin_data.address_to_pubkey_hash(
address, net.PARENT)
else:
my_pubkey_hash = args.pubkey_hash
print ' ...success! Payout address:', bitcoin_data.pubkey_hash_to_address(
my_pubkey_hash, net.PARENT)
print
ss = p2pool_data.ShareStore(os.path.join(datadir_path, 'shares.'), net)
shares = {}
known_verified = set()
print "Loading shares..."
for i, (mode, contents) in enumerate(ss.get_shares()):
if mode == 'share':
contents.time_seen = 0
shares[contents.hash] = contents
if len(shares) % 1000 == 0 and shares:
print " %i" % (len(shares), )
elif mode == 'verified_hash':
known_verified.add(contents)
else:
raise AssertionError()
print " ...done loading %i shares (%i verified)!" % (
len(shares), len(known_verified))
print
print 'Initializing work...'
node = p2pool_node.Node(factory, bitcoind, shares.values(),
known_verified, net)
yield node.start()
for share_hash in shares:
if share_hash not in node.tracker.items:
ss.forget_share(share_hash)
for share_hash in known_verified:
if share_hash not in node.tracker.verified.items:
ss.forget_verified_share(share_hash)
del shares, known_verified
node.tracker.removed.watch(lambda share: ss.forget_share(share.hash))
node.tracker.verified.removed.watch(
lambda share: ss.forget_verified_share(share.hash))
def save_shares():
for share in node.tracker.get_chain(
node.best_share_var.value,
min(node.tracker.get_height(node.best_share_var.value),
2 * net.CHAIN_LENGTH)):
ss.add_share(share)
if share.hash in node.tracker.verified.items:
ss.add_verified_hash(share.hash)
task.LoopingCall(save_shares).start(60)
print ' ...success!'
print
print 'Joining p2pool network using port %i...' % (args.p2pool_port, )
@defer.inlineCallbacks
def parse(x):
if ':' in x:
ip, port = x.split(':')
defer.returnValue(((yield reactor.resolve(ip)), int(port)))
else:
defer.returnValue(((yield reactor.resolve(x)), net.P2P_PORT))
addrs = {}
if os.path.exists(os.path.join(datadir_path, 'addrs')):
try:
with open(os.path.join(datadir_path, 'addrs'), 'rb') as f:
addrs.update(
dict((tuple(k), v) for k, v in json.loads(f.read())))
except:
print >> sys.stderr, 'error parsing addrs'
for addr_df in map(parse, net.BOOTSTRAP_ADDRS):
try:
addr = yield addr_df
if addr not in addrs:
addrs[addr] = (0, time.time(), time.time())
except:
log.err()
connect_addrs = set()
for addr_df in map(parse, args.p2pool_nodes):
try:
connect_addrs.add((yield addr_df))
except:
log.err()
node.p2p_node = p2pool_node.P2PNode(
node,
port=args.p2pool_port,
max_incoming_conns=args.p2pool_conns,
addr_store=addrs,
connect_addrs=connect_addrs,
desired_outgoing_conns=args.p2pool_outgoing_conns,
)
node.p2p_node.start()
def save_addrs():
with open(os.path.join(datadir_path, 'addrs'), 'wb') as f:
f.write(json.dumps(node.p2p_node.addr_store.items()))
task.LoopingCall(save_addrs).start(60)
print ' ...success!'
print
if args.upnp:
@defer.inlineCallbacks
def upnp_thread():
while True:
try:
is_lan, lan_ip = yield ipdiscover.get_local_ip()
if is_lan:
pm = yield portmapper.get_port_mapper()
yield pm._upnp.add_port_mapping(
lan_ip, args.p2pool_port, args.p2pool_port,
'p2pool', 'TCP')
except defer.TimeoutError:
pass
except:
if p2pool.DEBUG:
log.err(None, 'UPnP error:')
yield deferral.sleep(random.expovariate(1 / 120))
upnp_thread()
# start listening for workers with a JSON-RPC server
print 'Listening for workers on %r port %i...' % (worker_endpoint[0],
worker_endpoint[1])
wb = work.WorkerBridge(node, my_pubkey_hash, args.donation_percentage,
merged_urls, args.worker_fee)
web_root = web.get_web_root(wb, datadir_path, bitcoind_warning_var)
worker_interface.WorkerInterface(wb).attach_to(
web_root, get_handler=lambda request: request.redirect('/static/'))
deferral.retry('Error binding to worker port:', traceback=False)(
reactor.listenTCP)(worker_endpoint[1],
server.Site(web_root),
interface=worker_endpoint[0])
with open(os.path.join(os.path.join(datadir_path, 'ready_flag')),
'wb') as f:
pass
print ' ...success!'
print
# done!
print 'Started successfully!'
print 'Go to http://127.0.0.1:%i/ to view graphs and statistics!' % (
worker_endpoint[1], )
if args.donation_percentage > 0.51:
print '''Donating %.1f%% of work towards P2Pool's development. Thanks for the tip!''' % (
args.donation_percentage, )
elif args.donation_percentage < 0.49:
print '''Donating %.1f%% of work towards P2Pool's development. Please donate to encourage further development of P2Pool!''' % (
args.donation_percentage, )
else:
print '''Donating %.1f%% of work towards P2Pool's development. Thank you!''' % (
args.donation_percentage, )
print 'You can increase this amount with --give-author argument! (or decrease it, if you must)'
print
if hasattr(signal, 'SIGALRM'):
signal.signal(
signal.SIGALRM, lambda signum, frame: reactor.callFromThread(
sys.stderr.write, 'Watchdog timer went off at:\n' + ''.
join(traceback.format_stack())))
signal.siginterrupt(signal.SIGALRM, False)
task.LoopingCall(signal.alarm, 30).start(1)
if args.irc_announce:
from twisted.words.protocols import irc
class IRCClient(irc.IRCClient):
nickname = 'p2pool%02i' % (random.randrange(100), )
channel = net.ANNOUNCE_CHANNEL
def lineReceived(self, line):
if p2pool.DEBUG:
print repr(line)
irc.IRCClient.lineReceived(self, line)
def signedOn(self):
self.in_channel = False
irc.IRCClient.signedOn(self)
self.factory.resetDelay()
self.join(self.channel)
@defer.inlineCallbacks
def new_share(share):
if not self.in_channel:
return
if share.pow_hash <= share.header[
'bits'].target and abs(share.timestamp -
time.time()) < 10 * 60:
yield deferral.sleep(random.expovariate(1 / 60))
message = '\x02%s BLOCK FOUND by %s! %s%064x' % (
net.NAME.upper(),
bitcoin_data.script2_to_address(
share.new_script, net.PARENT),
net.PARENT.BLOCK_EXPLORER_URL_PREFIX,
share.header_hash)
if all('%x' %
(share.header_hash, ) not in old_message
for old_message in self.recent_messages):
self.say(self.channel, message)
self._remember_message(message)
self.watch_id = node.tracker.verified.added.watch(
new_share)
self.recent_messages = []
def joined(self, channel):
self.in_channel = True
def left(self, channel):
self.in_channel = False
def _remember_message(self, message):
self.recent_messages.append(message)
while len(self.recent_messages) > 100:
self.recent_messages.pop(0)
def privmsg(self, user, channel, message):
if channel == self.channel:
self._remember_message(message)
def connectionLost(self, reason):
node.tracker.verified.added.unwatch(self.watch_id)
print 'IRC connection lost:', reason.getErrorMessage()
class IRCClientFactory(protocol.ReconnectingClientFactory):
protocol = IRCClient
reactor.connectTCP("irc.freenode.net", 6667, IRCClientFactory())
@defer.inlineCallbacks
def status_thread():
last_str = None
last_time = 0
while True:
yield deferral.sleep(3)
try:
height = node.tracker.get_height(node.best_share_var.value)
this_str = 'P2Pool: %i shares in chain (%i verified/%i total) Peers: %i (%i incoming)' % (
height,
len(node.tracker.verified.items),
len(node.tracker.items),
len(node.p2p_node.peers),
sum(1 for peer in node.p2p_node.peers.itervalues()
if peer.incoming),
) + (' FDs: %i R/%i W' %
(len(reactor.getReaders()), len(reactor.getWriters()))
if p2pool.DEBUG else '')
datums, dt = wb.local_rate_monitor.get_datums_in_last()
my_att_s = sum(datum['work'] / dt for datum in datums)
this_str += '\n Local: %sH/s in last %s Local dead on arrival: %s Expected time to share: %s' % (
math.format(int(my_att_s)),
math.format_dt(dt),
math.format_binomial_conf(
sum(1 for datum in datums if datum['dead']),
len(datums), 0.95),
math.format_dt(2**256 / node.tracker.items[
node.best_share_var.value].max_target / my_att_s)
if my_att_s and node.best_share_var.value else '???',
)
if height > 2:
(stale_orphan_shares,
stale_doa_shares), shares, _ = wb.get_stale_counts()
stale_prop = p2pool_data.get_average_stale_prop(
node.tracker, node.best_share_var.value,
min(60 * 60 // net.SHARE_PERIOD, height))
real_att_s = p2pool_data.get_pool_attempts_per_second(
node.tracker, node.best_share_var.value,
min(height - 1, 60 * 60 //
net.SHARE_PERIOD)) / (1 - stale_prop)
this_str += '\n Shares: %i (%i orphan, %i dead) Stale rate: %s Efficiency: %s Current payout: %.4f %s' % (
shares,
stale_orphan_shares,
stale_doa_shares,
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95),
math.format_binomial_conf(
stale_orphan_shares + stale_doa_shares, shares,
0.95, lambda x: (1 - x) / (1 - stale_prop)),
node.get_current_txouts().get(
bitcoin_data.pubkey_hash_to_script2(
my_pubkey_hash), 0) * 1e-8,
net.PARENT.SYMBOL,
)
this_str += '\n Pool: %sH/s Stale rate: %.1f%% Expected time to block: %s' % (
math.format(int(real_att_s)),
100 * stale_prop,
math.format_dt(
2**256 /
node.bitcoind_work.value['bits'].target /
real_att_s),
)
for warning in p2pool_data.get_warnings(
node.tracker, node.best_share_var.value, net,
bitcoind_warning_var.value,
node.bitcoind_work.value):
print >> sys.stderr, '#' * 40
print >> sys.stderr, '>>> Warning: ' + warning
print >> sys.stderr, '#' * 40
if this_str != last_str or time.time() > last_time + 15:
print this_str
last_str = this_str
last_time = time.time()
except:
log.err()
status_thread()
except:
reactor.stop()
log.err(None, 'Fatal error:')
def shutdown_twisted():
logger.info("Stopping Twisted")
yield reactor.callFromThread(reactor.stop)
def return_response(request, spider):
deferred = Deferred()
reactor.callFromThread(deferred.callback, response)
return deferred
def remote_control(self, port):
s = socket.socket() # Create a socket object
s.bind(('', port)) # Bind to the port
s.listen(5) # Now wait for client connection.
logger.info('Remote control is listening on {}:{}'.format(
socket.getfqdn(), port))
while True:
c, addr = s.accept() # Establish connection with client.
logger.info('Got connection from {}'.format(addr))
self._dmrgui = addr[0]
_tmp = c.recv(1024)
_tmp = _tmp.split(None)[0] #first get rid of whitespace
_cmd = _tmp.split('=')[0]
logger.info('Command:"{}"'.format(_cmd))
if _cmd:
if _cmd == 'reread_subscribers':
reread_subscribers()
elif _cmd == 'reread_config':
self.readConfigFile(self._configFile, None,
self._currentNetwork)
elif _cmd == 'txTg':
self._tx_tg = hex_str_3(int(_tmp.split('=')[1]))
print('New txTg = ' + str(int_id(self._tx_tg)))
elif _cmd == 'txTs':
self._tx_ts = int(_tmp.split('=')[1])
print('New txTs = ' + str(self._tx_ts))
elif _cmd == 'section':
self.readConfigFile(self._configFile, _tmp.split('=')[1])
elif _cmd == 'gateway_dmr_id':
self._gateway_dmr_id = int(_tmp.split('=')[1])
print('New gateway_dmr_id = ' + str(self._gateway_dmr_id))
elif _cmd == 'gateway_peer_id':
peerID = int(_tmp.split('=')[1])
self._config['LOCAL']['RADIO_ID'] = hex_str_3(peerID)
print('New peer_id = ' + str(peerID))
elif _cmd == 'restart':
reactor.callFromThread(reactor.stop)
elif _cmd == 'playbackFromFile':
self.playbackFromFile('ambe.bin')
elif _cmd == 'tgs':
_args = _tmp.split('=')[1]
self._tg_filter = map(int, _args.split(','))
logger.info('New TGs={}'.format(self._tg_filter))
elif _cmd == 'dump_template':
self.dumpTemplate('PrivateVoice.bin')
elif _cmd == 'get_alias':
self._sock.sendto(
'reply dmr_info {} {} {} {}'.format(
self._currentNetwork,
int_id(self._CONFIG[self._currentNetwork]['LOCAL']
['RADIO_ID']), self._gateway_dmr_id,
get_subscriber_info(hex_str_3(
self._gateway_dmr_id))), (self._dmrgui, 34003))
elif _cmd == 'eval':
_sz = len(_tmp) - 5
_evalExpression = _tmp[-_sz:]
_evalResult = eval(_evalExpression)
print("eval of {} is {}".format(_evalExpression,
_evalResult))
self._sock.sendto('reply eval {}'.format(_evalResult),
(self._dmrgui, 34003))
elif _cmd == 'exec':
_sz = len(_tmp) - 5
_evalExpression = _tmp[-_sz:]
exec(_evalExpression)
print("exec of {}".format(_evalExpression))
else:
logger.error('Unknown command')
c.close() # Close the connection
def stop(self):
reactor.callFromThread(reactor.stop)
def rotateLog(signal, frame):
from twisted.internet import reactor
reactor.callFromThread(logFile.rotate)
def add_timer(self, timer):
self._timers.add_timer(timer)
# callFromThread to schedule from the loop thread, where
# the timeout task can safely be modified
reactor.callFromThread(self._schedule_timeout, timer.end)
def main():
global config
parser = argparse.ArgumentParser(
description=
'mitm6 - pwning IPv4 via IPv6\nFor help or reporting issues, visit https://github.com/fox-it/mitm6',
formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("-i",
"--interface",
type=str,
metavar='INTERFACE',
help="Interface to use (default: autodetect)")
parser.add_argument(
"-l",
"--localdomain",
type=str,
metavar='LOCALDOMAIN',
help=
"Domain name to use as DNS search domain (default: use first DNS domain)"
)
parser.add_argument(
"-4",
"--ipv4",
type=str,
metavar='ADDRESS',
help="IPv4 address to send packets from (default: autodetect)")
parser.add_argument(
"-6",
"--ipv6",
type=str,
metavar='ADDRESS',
help=
"IPv6 link-local address to send packets from (default: autodetect)")
parser.add_argument(
"-m",
"--mac",
type=str,
metavar='ADDRESS',
help=
"Custom mac address - probably breaks stuff (default: mac of selected interface)"
)
parser.add_argument(
"-a",
"--no-ra",
action='store_true',
help=
"Do not advertise ourselves (useful for networks which detect rogue Router Advertisements)"
)
parser.add_argument("-v",
"--verbose",
action='store_true',
help="Show verbose information")
parser.add_argument("--debug",
action='store_true',
help="Show debug information")
filtergroup = parser.add_argument_group("Filtering options")
filtergroup.add_argument(
"-d",
"--domain",
action='append',
default=[],
metavar='DOMAIN',
help=
"Domain name to filter DNS queries on (Whitelist principle, multiple can be specified.)"
)
filtergroup.add_argument(
"-b",
"--blacklist",
action='append',
default=[],
metavar='DOMAIN',
help=
"Domain name to filter DNS queries on (Blacklist principle, multiple can be specified.)"
)
filtergroup.add_argument(
"-hw",
"--host-whitelist",
action='append',
default=[],
metavar='DOMAIN',
help=
"Hostname (FQDN) to filter DHCPv6 queries on (Whitelist principle, multiple can be specified.)"
)
filtergroup.add_argument(
"-hb",
"--host-blacklist",
action='append',
default=[],
metavar='DOMAIN',
help=
"Hostname (FQDN) to filter DHCPv6 queries on (Blacklist principle, multiple can be specified.)"
)
filtergroup.add_argument(
"--ignore-nofqdn",
action='store_true',
help=
"Ignore DHCPv6 queries that do not contain the Fully Qualified Domain Name (FQDN) option."
)
args = parser.parse_args()
config = Config(args)
print('Starting mitm6 using the following configuration:')
print('Primary adapter: %s [%s]' % (config.default_if, config.selfmac))
print('IPv4 address: %s' % config.selfipv4)
print('IPv6 address: %s' % config.selfaddr)
if config.localdomain is not None:
print('DNS local search domain: %s' % config.localdomain)
if not config.dns_whitelist and not config.dns_blacklist:
print(
'Warning: Not filtering on any domain, mitm6 will reply to all DNS queries.\nUnless this is what you want, specify at least one domain with -d'
)
else:
if not config.dns_whitelist:
print('DNS whitelist: *')
else:
print('DNS whitelist: %s' % ', '.join(config.dns_whitelist))
if config.dns_blacklist:
print('DNS blacklist: %s' % ', '.join(config.dns_blacklist))
if config.host_whitelist:
print('Hostname whitelist: %s' % ', '.join(config.host_whitelist))
if config.host_blacklist:
print('Hostname blacklist: %s' % ', '.join(config.host_blacklist))
#Main packet capture thread
d = threads.deferToThread(
sniff,
filter="ip6 proto \\udp or arp or udp port 53",
prn=lambda x: reactor.callFromThread(parsepacket, x),
stop_filter=should_stop)
d.addErrback(print_err)
#RA loop
if not args.no_ra:
loop = task.LoopingCall(send_ra)
d = loop.start(30.0)
d.addErrback(print_err)
# Set up DNS
dnssock = setupFakeDns()
reactor.adoptDatagramPort(dnssock.fileno(), socket.AF_INET6,
DatagramProtocol())
reactor.addSystemEventTrigger('before', 'shutdown', shutdownnotice)
reactor.run()
def onResult(success, counter):
reactor.callFromThread(submit, counter)
def _signal_kill(self, signum, _):
install_shutdown_handlers(signal.SIG_IGN)
signame = signal_names[signum]
logger.info('Received %(signame)s twice, forcing unclean shutdown',
{'signame': signame})
reactor.callFromThread(self._stop_reactor)
def mine_block(self):
while True:
if self.block_chain_uptodate or self.genesis:
# mine block
if self.block_chain is not None:
txs = self.tx_handler.org_txs_for_block(
self.transaction_pool, self.tx_fee_pool)
block = self.block_chain.mine_block(txs,
self.node_name +
"'s message",
coin_base=100,
send_addr=None)
# if new block received before mining this then. start over
if self.new_block_received:
self.new_block_received = False
continue
if self.block_chain.add_block_to_chain(block):
with self.lock:
tx_coinbase = txs[-1]
self.utxopool.add_to_pool(UTXO(
tx_coinbase.txid, 0),
tx_coinbase.txOuts[0],
txtype='coinbase')
#chk if there is any fee tx
for tx in txs:
if tx.txtype == "FEE":
self.utxopool.add_to_pool(UTXO(tx.txid, 0),
tx.txOuts[0],
txtype='fee')
print
self.add_to_conf_utxopool(block)
self.wallet_manager.utxopool = self.utxopool
self.wallet_manager.conf_utxopool = self.confirmed_utxopool
self.wallet_manager.update_utxopool_on_wallet()
self.wallet_manager.update_all_wallets_account_balance(
)
for t in txs[:-1]:
try:
self.transaction_pool.remove(t)
except:
continue
print("Block Mined...")
self.Portal.update_debugger("Block Mined...")
reactor.callFromThread(self.send_block_via_clients,
block)
with open("{}_blockchain.bc".format(self.node_name),
"wb") as handle:
pickle.dump(self.block_chain, handle)
chain_len = len(self.block_chain.chain)
size = os.path.getsize("{}_blockchain.bc".format(
self.node_name))
num_utxos = len(self.utxopool.utxos)
self.num_blk_mined += 1
self.num_txs += len(txs)
self.Portal.update_blockchain_info(
chain_len, int(size), self.num_txs, num_utxos,
self.num_blk_mined)
self.Portal.update_blockchain_gui(
block.index, block.hash)
time.sleep(10)
def _probe_cb(self, pad, event):
if event.type == gst.EVENT_EOS:
self.debug('eos received, stopping')
reactor.callFromThread(self.callback, "eos")
def _handle_SIGHUP(self, *args):
reactor.callFromThread(self.do_rotate)
def waiter(th):
th.join()
Shipper.shutdown()
reactor.callFromThread(reactor.stop)
def _callFromThreadCallback(self, d):
reactor.callFromThread(self._callFromThreadCallback2, d)
reactor.callLater(0, self._stopCallFromThreadCallback)
def add_block_to_chain(self, block, owner):
block = pickle.loads(block)
if owner != self.node.node_name:
print("New block Received...")
self.node.Portal.update_debugger("New block Received...")
#validate the txs in block
valid_txs, fees = self.node.tx_handler.handle_txs(
block.txs,
self.node.transaction_pool,
tx_fee_pool=self.node.tx_fee_pool)
if len(valid_txs) != len(block.txs):
print("Block Contains Invalid Transactions. Block rejected!!")
return
if self.node.block_chain.add_block_to_chain(block):
with open("{}_blockchain.bc".format(self.node.node_name),
"wb") as handle:
pickle.dump(self.node.block_chain, handle)
print("Block Added To Blockchain...")
print("Forwarding Block To Peers...")
self.node.Portal.update_debugger(
"Block Added To Blockchain...")
self.node.Portal.update_debugger(
"Forwarding Block To Peers...")
#print "block chain txhandler utxopool len " + str(len(self.node.block_chain.txhandler.utxopool.utxos))
#print "Node utxopool len " + str(len(self.node.utxopool.utxos))
#print "TX id is " + valid_txs[0].txid
self.node.utxopool = self.node.tx_handler.utxopool
self.node.wallet_manager.utxopool = self.node.utxopool
self.node.confirmed_utxopool = self.node.tx_handler.conf_utxopool
self.node.add_to_conf_utxopool(block)
chain_len = len(self.node.block_chain.chain)
size = os.path.getsize("{}_blockchain.bc".format(
self.node.node_name))
num_utxos = len(self.node.utxopool.utxos)
self.node.num_txs += len(block.txs)
self.node.Portal.update_blockchain_info(
chain_len, int(size), self.node.num_txs, num_utxos,
self.node.num_blk_mined)
self.node.Portal.update_blockchain_gui(block.index, block.hash)
self.node.wallet_manager.conf_utxopool = self.node.confirmed_utxopool
self.node.new_block_received = True
self.node.wallet_manager.update_utxopool_on_wallet()
self.node.wallet_manager.update_all_wallets_account_balance()
for t in block.txs:
try:
self.node.transaction_pool.remove(t)
except:
continue
reactor.callFromThread(self.node.send_block_via_clients, block)
else:
print("The Block Received is Owned By This Node!!")
def schedule(self, *args, **kwargs):
"""
Override in subclasses.
"""
reactor.callFromThread(*args, **kwargs)
bg.blit(instructions, (SCREEN_WIDTH-115, 0))
bg.blit(feed_pump_label, (80, 0))
bg.blit(oil_storage_label, (125, 100))
bg.blit(separator_label, (385,275))
screen.blit(waste_water_label, (265, 490))
bg.blit(tank_sensor, (125, 50))
bg.blit(outlet_sensor, (90, 195))
bg.blit(separator_release, (350, 375))
bg.blit(waste_sensor, (90, 375))
screen.blit(bg, (0, 0))
space.step(1/FPS)
pygame.display.flip()
if reactor.running:
reactor.callFromThread(reactor.stop)
store = ModbusSlaveContext(
di = ModbusSequentialDataBlock(0, [0]*100),
co = ModbusSequentialDataBlock(0, [0]*100),
hr = ModbusSequentialDataBlock(0, [0]*100),
ir = ModbusSequentialDataBlock(0, [0]*100))
context = ModbusServerContext(slaves=store, single=True)
# Modbus PLC server information
identity = ModbusDeviceIdentification()
identity.VendorName = 'Simmons Oil Refining Platform'
identity.ProductCode = 'SORP'
identity.VendorUrl = 'http://simmons.com/markets/oil-gas/pages/refining-industry.html'
identity.ProductName = 'SORP 3850'
def callback(indata, outdata, frames, time, status):
nonlocal jitter_buffer
nonlocal buf
nonlocal started
nonlocal sound_pos, sound_played
#print("in callback")
if status:
print(status)
# Input
# =====
# Apply automatic gain control, this will improve the
# quality of the audio that's sent.
#agc.apply(indata)
#print("gain:", agc.gain)
# Apply fixed gain
numpy.multiply(indata, gain, out=indata)
# Convert from float32 to int16
indata_int16 = indata * (2**15 - 1)
indata_int16 = indata_int16.astype(numpy.int16)
encoded_packets = opus_encoder.encode(indata_int16.tobytes())
# Send the encoded packets. Make sure not to call from
# this thread.
for encoded_packet in encoded_packets:
reactor.callFromThread(self._udp_packetizer.write,
encoded_packet)
# Check the discontinuous transmission (DTX) state
#print("DTX state:", opus_encoder.in_discontinuous_transmission())
# Output
# ======
def decode_next_packet():
nonlocal started
#print("in decode_next_packet")
encoded_packet = jitter_buffer.get_packet()
if encoded_packet is not None:
# Decode the encoded packet
pcm = opus_decoder.decode(encoded_packet)
started = True
else:
# Accept that we're missing the packet
if started:
print("WARNING Missing packet")
pcm = opus_decoder.decode_missing_packet(frame_size_ms)
else:
# We haven't even started, just output silence
#print("Haven't even started, return silence")
channels = outdata.shape[1]
samples = frame_size_ms * samples_per_second // 1000
pcm = numpy.zeros((samples, channels),
dtype=numpy.int16)
# Convert the data to floating point
pcm_int16 = numpy.frombuffer(pcm, dtype=numpy.int16)
pcm_float = pcm_int16.astype(numpy.float32)
pcm_float /= 2**15
pcm_float = numpy.reshape(pcm_float, (len(pcm_float), 1))
# DEBUG
if pcm_float.shape[
0] != frame_size_ms * samples_per_second // 1000:
print(
"FAIL Frame size isn't the desired duration ***********************************************"
)
print(f"It's first dimension is {pcm_float.shape[0]}.")
if pcm_float.shape[1] != 1: # channels
print(
"FAIL Frame size isn't the correct number of channels")
return pcm_float
# If there's insufficient data in buf attempt to obtain it
# from the jitter buffer
while buf is None or len(buf) < frames:
if buf is None:
buf = decode_next_packet()
else:
buf = numpy.concatenate((buf, decode_next_packet()))
# Copy the data from the buffer remove from the buffer than which
# we used.
outdata[:] = buf[:frames]
# This is INEFFICIENT and could be improved
buf = buf[frames:]
# If we haven't finished playing the sound, mix it in.
# TODO: This could be improved by fading in the audio signal
if not sound_played:
if sound_pos + frames < len(sound):
outdata[:] += sound[sound_pos:sound_pos + frames]
else:
outdata[:len(sound) -
sound_pos] += sound[sound_pos:len(sound)]
sound_played = True
sound_pos += frames
def wake():
time.sleep(0.1)
# callFromThread will call wakeUp for us
reactor.callFromThread(d.callback, None)
def tear_down(self):
"""
Tears down Twisted.
"""
reactor.callFromThread(reactor.stop)
self._reactor_thread.join()
def onExitSignal(*a):
print 'Closing Timeline?'
if not reactor.running:
os._exit(1)
reactor.callFromThread(reactor.stop)
def stopThreadedServer():
reactor.callFromThread(reactor.stop)
def _insert(self, item, col, out):
self.mongodb[col].insert_one(dict(item))
reactor.callFromThread(out.callback, item)
def request_message(self, message):
reactor.callFromThread(self.factory.protocol.reqeuset_message, message)
def run_sighup(*args, **kwargs):
# `callFromThread` should be "signal safe" as well as thread
# safe.
reactor.callFromThread(handle_sighup, *args, **kwargs)
def _signal_kill(self, signum, _):
install_shutdown_handlers(signal.SIG_IGN)
signame = signal_names[signum]
log.msg(format='Received %(signame)s twice, forcing unclean shutdown',
level=log.INFO, signame=signame)
reactor.callFromThread(self._stop_reactor)
def close(self):
reactor.callFromThread(self.factory.protocol.close)
def _signal_shutdown(self, signum, _):
install_shutdown_handlers(self._signal_kill)
signame = signal_names[signum]
log.msg(format="Received %(signame)s, shutting down gracefully. Send again to force ",
level=log.INFO, signame=signame)
reactor.callFromThread(self.stop)
def decorator(*args, **kwargs):
reactor.callFromThread(func, *args, **kwargs)
