from __future__ import division
-import struct
-import socket
-import random
-import cStringIO as StringIO
import hashlib
+import random
+import StringIO
+import socket
+import struct
import time
import traceback
-from twisted.internet import protocol, reactor, defer
+from twisted.internet import defer, protocol, reactor
import util
from __future__ import division
import argparse
-import subprocess
import os
+import random
+import sqlite3
+import subprocess
import sys
import traceback
-import random
-import gdbm
-from twisted.internet import reactor, defer
+from twisted.internet import defer, reactor
from twisted.web import server
-import jsonrpc
-import conv
-import worker_interface
-import util
import bitcoin_p2p
-import p2p
+import conv
+import db
import expiring_dict
+import jsonrpc
+import p2p
import p2pool
+import util
+import worker_interface
class Chain(object):
def __init__(self, chain_id_data):
self.last_p2pool_block_hash = p2pool.chain_id_type.unpack(chain_id_data)['last_p2pool_block_hash']
self.share2s = {} # hash -> share2
- self.highest = util.Variable(None)
+ self.highest = util.Variable(None) # hash
self.requesting = set()
self.request_map = {}
def main(args):
try:
net = p2pool.Testnet if args.testnet else p2pool.Main
- #sqlite3.connect(args.config, isolation_level=None)
-
+
print name
print
# information affecting work that should not trigger a long-polling update
current_work2 = util.Variable(None)
- share_dbs = [gdbm.open(filename, 'cs') for filename in args.store_shares]
+ share_dbs = [db.SQLiteDict(sqlite3.connect(filename, isolation_level=None), 'shares') for filename in args.store_shares]
@defer.inlineCallbacks
def set_real_work():
res = chain.accept(share, net)
if res == 'good':
share2 = chain.share2s[share.hash]
+
hash_data = bitcoin_p2p.HashType().pack(share.hash)
share1_data = p2pool.share1.pack(share.as_share1())
for share_db in share_dbs:
share_db[hash_data] = share1_data
- share_db.sync()
+
if chain is current_work.value['current_chain']:
print 'Accepted share, passing to peers. Hash: %x' % (share.hash,)
share_share2(share2, peer)
current_work=current_work,
port=args.p2pool_port,
testnet=args.testnet,
- addr_store=gdbm.open(os.path.join(os.path.dirname(__file__), 'peers.dat'), 'cs'),
+ addr_store=db.SQLiteDict(sqlite3.connect(os.path.join(os.path.dirname(__file__), 'addrs.dat'), isolation_level=None), 'addrs'),
mode=0 if args.low_bandwidth else 1,
preferred_addrs=map(parse, args.p2pool_nodes) + nodes,
)
import time
import traceback
-from twisted.internet import defer, reactor, protocol, task
+from twisted.internet import defer, protocol, reactor, task
import bitcoin_p2p
import conv
-import util
import p2pool
+import util
# mode
# 0: send hash first (high latency, low bandwidth)
# 1: send entire share (low latency, high bandwidth)
-if 0:
- import pygame
- d = pygame.display.set_mode((512, 512))
- task.LoopingCall(pygame.display.update).start(.1)
- def draw_circle(id, color=(255,0,0)):
- id = repr(id)
- pygame.draw.circle(d, (255, 0, 0), (hash(id)%512, hash(id)//512%512), 4)
- def draw_line(id, id2, color):
- id = repr(id)
- pygame.draw.line(d, color, (hash(id)%512, hash(id)//512%512), (hash(id2)%512, hash(id2)//512%512))
-else:
- draw_circle = draw_line = lambda *args, **kwargs: None
-
class Protocol(bitcoin_p2p.BaseProtocol):
version = 0
sub_version = ""
def connectionMade(self):
bitcoin_p2p.BaseProtocol.connectionMade(self)
- if isinstance(self.factory, ClientFactory):
- draw_line(self.node.port, self.transport.getPeer().port, (128, 128, 128))
chain = self.node.current_work.value['current_chain']
highest_share2 = chain.get_highest_share2()
chain_id=state['chain_id'],
hashes=[state['highest']['hash']],
)])
-
- if isinstance(self.factory, ClientFactory):
- draw_line(self.node.port, self.transport.getPeer().port, (0, 255, 0))
def handle_set_mode(self, mode):
self.other_mode_var.set(mode)
if self.connected2:
self.node.lost_conn(self)
-
- if isinstance(self.factory, ClientFactory):
- draw_line(self.node.port, self.transport.getPeer().port, (255, 0, 0))
class ServerFactory(protocol.ServerFactory):
def __init__(self, node):
self.attempts = {}
self.peers = {}
self.running = False
-
- draw_circle(self.port)
def start(self):
if self.running:
from __future__ import division
-import random
import collections
import hashlib
import itertools
+import random
from twisted.internet import defer, reactor
from twisted.python import failure
-from twisted.web import server, resource
+from twisted.web import resource, server
class DeferredResource(resource.Resource):
def render(self, request):
from twisted.internet import defer
+import json
import jsonrpc
import util
-import json
class LongPollingWorkerInterface(util.DeferredResource):
def __init__(self, work, compute):