import StringIO
import json
import random
-import weakref
+import sys
from twisted.internet import defer
import p2pool
-from p2pool.bitcoin import getwork
-from p2pool.util import jsonrpc, variable
+from p2pool.bitcoin import data as bitcoin_data, getwork
+from p2pool.util import expiring_dict, jsonrpc, pack, variable
-class _Page(jsonrpc.Server):
+class _Provider(object):
def __init__(self, parent, long_poll):
- jsonrpc.Server.__init__(self)
self.parent = parent
self.long_poll = long_poll
def rpc_getwork(self, request, data=None):
return self.parent._getwork(request, data, long_poll=self.long_poll)
+
+class _GETableServer(jsonrpc.HTTPServer):
+ def __init__(self, provider, render_get_func):
+ jsonrpc.HTTPServer.__init__(self, provider)
+ self.render_GET = render_get_func
+
+class WorkerBridge(object):
+ def __init__(self):
+ self.new_work_event = variable.Event()
- def render_GET(self, request):
- request.content = StringIO.StringIO(json.dumps(dict(id=0, method='getwork')))
- return self.render_POST(request)
+ def preprocess_request(self, request):
+ return request, # *args to self.compute
+
+ def get_work(self, request):
+ raise NotImplementedError()
class WorkerInterface(object):
- def __init__(self, compute, response_callback, new_work_event=variable.Event()):
- self.compute = compute
- self.response_callback = response_callback
- self.new_work_event = new_work_event
+ def __init__(self, worker_bridge):
+ self.worker_bridge = worker_bridge
self.worker_views = {}
- self.work_cache = {} # username -> blockattempt
- watch_id = new_work_event.watch(lambda *args: self_ref().work_cache.clear())
- self_ref = weakref.ref(self, lambda _: new_work_event.unwatch(watch_id))
+ self.merkle_root_to_handler = expiring_dict.ExpiringDict(300)
- def attach_to(self, res):
- res.putChild('', _Page(self, long_poll=False))
- res.putChild('long-polling', _Page(self, long_poll=True))
+ def attach_to(self, res, get_handler=None):
+ res.putChild('', _GETableServer(_Provider(self, long_poll=False), get_handler))
+
+ def repost(request):
+ request.content = StringIO.StringIO(json.dumps(dict(id=0, method='getwork')))
+ return s.render_POST(request)
+ s = _GETableServer(_Provider(self, long_poll=True), repost)
+ res.putChild('long-polling', s)
@defer.inlineCallbacks
def _getwork(self, request, data, long_poll):
request.setHeader('X-Long-Polling', '/long-polling')
- request.setHeader('X-Roll-NTime', 'expire=10')
+ request.setHeader('X-Roll-NTime', 'expire=100')
+ request.setHeader('X-Is-P2Pool', 'true')
+ if request.getHeader('Host') is not None:
+ request.setHeader('X-Stratum', 'stratum+tcp://' + request.getHeader('Host'))
if data is not None:
- defer.returnValue(self.response_callback(getwork.decode_data(data), request))
+ header = getwork.decode_data(data)
+ if header['merkle_root'] not in self.merkle_root_to_handler:
+ print >>sys.stderr, '''Couldn't link returned work's merkle root with its handler. This should only happen if this process was recently restarted!'''
+ defer.returnValue(False)
+ defer.returnValue(self.merkle_root_to_handler[header['merkle_root']](header, request.getUser() if request.getUser() is not None else '', '\0'*self.worker_bridge.COINBASE_NONCE_LENGTH))
if p2pool.DEBUG:
id = random.randrange(1000, 10000)
- print 'POLL %i START long_poll=%r user_agent=%r x-work-identifier=%r user=%r' % (id, long_poll, request.getHeader('User-Agent'), request.getHeader('X-Work-Identifier'), request.getUser())
+ print 'POLL %i START is_long_poll=%r user_agent=%r user=%r' % (id, long_poll, request.getHeader('User-Agent'), request.getUser())
if long_poll:
request_id = request.getClientIP(), request.getHeader('Authorization')
- if self.worker_views.get(request_id, self.new_work_event.times) != self.new_work_event.times:
+ if self.worker_views.get(request_id, self.worker_bridge.new_work_event.times) != self.worker_bridge.new_work_event.times:
if p2pool.DEBUG:
- print 'POLL %i PUSH user=%r' % (id, request.getUser())
+ print 'POLL %i PUSH' % (id,)
else:
if p2pool.DEBUG:
- print 'POLL %i WAITING user=%r' % (id, request.getUser())
- yield self.new_work_event.get_deferred()
- self.worker_views[request_id] = self.new_work_event.times
+ print 'POLL %i WAITING' % (id,)
+ yield self.worker_bridge.new_work_event.get_deferred()
+ self.worker_views[request_id] = self.worker_bridge.new_work_event.times
- if request.getUser() in self.work_cache:
- res = self.work_cache[request.getUser()]
- else:
- res = self.compute(request.getUser())
+ x, handler = self.worker_bridge.get_work(*self.worker_bridge.preprocess_request(request.getUser() if request.getUser() is not None else ''))
+ res = getwork.BlockAttempt(
+ version=x['version'],
+ previous_block=x['previous_block'],
+ merkle_root=bitcoin_data.check_merkle_link(bitcoin_data.hash256(x['coinb1'] + '\0'*self.worker_bridge.COINBASE_NONCE_LENGTH + x['coinb2']), x['merkle_link']),
+ timestamp=x['timestamp'],
+ bits=x['bits'],
+ share_target=x['share_target'],
+ )
+ assert res.merkle_root not in self.merkle_root_to_handler
- self.work_cache[request.getUser()] = res.update(timestamp=res.timestamp + 12) # XXX doesn't bound timestamp
+ self.merkle_root_to_handler[res.merkle_root] = handler
if p2pool.DEBUG:
- print 'POLL %i END identifier=%i user=%r' % (id, self.new_work_event.times, request.getUser())
+ print 'POLL %i END identifier=%i' % (id, self.worker_bridge.new_work_event.times)
+
+ defer.returnValue(res.getwork(identifier=str(self.worker_bridge.new_work_event.times), submitold=True))
+
+class CachingWorkerBridge(object):
+ def __init__(self, inner):
+ self._inner = inner
+
+ self.COINBASE_NONCE_LENGTH = (inner.COINBASE_NONCE_LENGTH+1)//2
+ self.new_work_event = inner.new_work_event
+ self.preprocess_request = inner.preprocess_request
+
+ self._my_bits = (self._inner.COINBASE_NONCE_LENGTH - self.COINBASE_NONCE_LENGTH)*8
+
+ self._cache = {}
+ self._times = None
+
+ def get_work(self, *args):
+ if self._times != self.new_work_event.times:
+ self._cache = {}
+ self._times = self.new_work_event.times
+
+ if args not in self._cache:
+ x, handler = self._inner.get_work(*args)
+ self._cache[args] = x, handler, 0
+
+ x, handler, nonce = self._cache.pop(args)
+
+ res = (
+ dict(x, coinb1=x['coinb1'] + pack.IntType(self._my_bits).pack(nonce)),
+ lambda header, user, coinbase_nonce: handler(header, user, pack.IntType(self._my_bits).pack(nonce) + coinbase_nonce),
+ )
+
+ if nonce + 1 != 2**self._my_bits:
+ self._cache[args] = x, handler, nonce + 1
- defer.returnValue(res.getwork(identifier=str(self.new_work_event.times)))
+ return res
git://git.novaco.in / p2pool.git / blobdiff