from twisted.internet import defer
from twisted.internet import reactor
from twisted.names import client
import random
import time
from stratum.services import GenericService, signature, synchronous
import stratum.pubsub as pubsub
import stratum.logger as logger
log = logger.get_logger('example')
class ExampleService(GenericService):
service_type = 'example'
service_vendor = 'Stratum'
is_default = True
def hello_world(self):
return "Hello world!"
hello_world.help_text = "Returns string 'Hello world!'"
hello_world.params = []
@signature
def ping(self, payload):
return payload
ping.help_text = "Returns signed message with the payload given by the client."
ping.params = [('payload', 'mixed', 'This payload will be sent back to the client.'),]
@synchronous
def synchronous(self, how_long):
'''This can use blocking calls, because it runs in separate thread'''
from twisted.internet import defer
from stratum import settings
import stratum.logger as logger # Python3
log = logger.get_logger('proxy') # Python3
class Job(object):
def __init__(self):
self.params = ''
@classmethod
def build_from_pool(cls, getWorkParams):
'''Build job object from Stratum server broadcast'''
job = Job()
job.params = getWorkParams
return job
class JobRegistry(object):
def __init__(self, f, f1, f2, f3):
self.f = f
self.f1 = f1
self.f2 = f2
self.f3 = f3
self.jobs = None
# stop mining after 6 minutes if internet disconnected
if settings.COIN == "ETH":
self.coinTimeout = 360
else:
self.coinTimeout = 900 # For expanse 15 minutes waiting for new job
from twisted.internet.protocol import ServerFactory
from twisted.internet.protocol import ReconnectingClientFactory
from twisted.internet import reactor, defer, endpoints
import stratum.socksclient as socksclient # Python3
import stratum.custom_exceptions # Python3
from stratum.protocol import Protocol, ClientProtocol # Python3
from stratum.event_handler import GenericEventHandler # Python3
import stratum.logger as logger # Python3
log = logger.get_logger('socket_transport')
def sockswrapper(proxy, dest):
endpoint = endpoints.TCP4ClientEndpoint(reactor, dest[0], dest[1])
return socksclient.SOCKSWrapper(reactor, proxy[0], proxy[1], endpoint)
class SocketTransportFactory(ServerFactory):
def __init__(self,
debug=False,
signing_key=None,
signing_id=None,
event_handler=GenericEventHandler,
tcp_proxy_protocol_enable=False):
self.debug = debug
self.signing_key = signing_key
self.signing_id = signing_id
self.event_handler = event_handler
self.protocol = Protocol
from twisted.internet import reactor
from stratum.event_handler import GenericEventHandler
from mining_libs.jobs import Job
import stratum.version as _version
from stratum import logger
log = logger.get_logger('proxy')
class ClientMiningService(GenericEventHandler):
job_registry = None # Reference to JobRegistry instance
timeout = None # Reference to IReactorTime object
@classmethod
def reset_timeout(cls):
if cls.timeout != None:
if not cls.timeout.called:
cls.timeout.cancel()
cls.timeout = None
cls.timeout = reactor.callLater(180, cls.on_timeout)
@classmethod
def on_timeout(cls):
'''
Try to reconnect to the pool after 3 minutes of no activity on the connection.
It will also drop all Stratum connections to sub-miners
to indicate connection issues.
'''
log.error("Connection to upstream pool timed out")
cls.reset_timeout()
from twisted.web.resource import Resource
from twisted.web.server import Request, Session, NOT_DONE_YET
from twisted.internet import defer
from twisted.python.failure import Failure
import hashlib
import json
import string
import helpers
import semaphore
from protocol import Protocol, RequestCounter
from event_handler import GenericEventHandler
import settings
import stratum.logger as logger # Python3
log = logger.get_logger('http_transport')
class Transport(object):
def __init__(self, session_id, lock):
self.buffer = []
self.session_id = session_id
self.lock = lock
self.push_url = None # None or full URL for HTTP Push
self.peer = None
# For compatibility with generic transport, not used in HTTP transport
self.disconnecting = False
def getPeer(self):
return self.peer
import socket
import traceback
from twisted.protocols.basic import LineOnlyReceiver
from twisted.internet import defer, reactor, error
from twisted.python.failure import Failure
#import services
import stratum.stats as stats
import stratum.signature as signature
import stratum.custom_exceptions as custom_exceptions
import stratum.connection_registry as connection_registry
import stratum.settings as settings
import stratum.logger as logger
log = logger.get_logger('protocol')
class RequestCounter(object):
def __init__(self):
self.on_finish = defer.Deferred()
self.counter = 0
def set_count(self, cnt):
self.counter = cnt
def decrease(self):
self.counter -= 1
if self.counter <= 0:
self.finish()
from twisted.words.protocols import irc
from twisted.internet import reactor, protocol
import random
import string
import stratum.custom_exceptions as custom_exceptions
import stratum.logger as logger
log = logger.get_logger('irc')
# Reference to open IRC connection
_connection = None
def get_connection():
if _connection:
return _connection
raise custom_exceptions.IrcClientException("IRC not connected")
class IrcLurker(irc.IRCClient):
def connectionMade(self):
irc.IRCClient.connectionMade(self)
self.peers = {}
global _connection
_connection = self
def get_peers(self):
return self.peers.values()
import time
from stratum import logger
log = logger.get_logger('stats')
class PeerStats(object):
'''Stub for server statistics'''
counter = 0
changes = 0
@classmethod
def client_connected(cls, ip):
cls.counter += 1
cls.changes += 1
cls.print_stats()
@classmethod
def client_disconnected(cls, ip):
cls.counter -= 1
cls.changes += 1
cls.print_stats()
@classmethod
def print_stats(cls):
if cls.counter and float(cls.changes) / cls.counter < 0.05:
# Print connection stats only when more than
# 5% connections change to avoid log spam
return
import time
from twisted.internet import defer
from stratum import settings
import stratum.logger as logger
log = logger.get_logger('BasicShareLimiter')
# import DBInterface
# dbi = DBInterface.DBInterface()
# dbi.clear_worker_diff()
''' This is just a customized ring buffer '''
class SpeedBuffer:
def __init__(self, size_max):
self.max = size_max
self.data = []
self.cur = 0
def append(self, x):
self.data.append(x)
self.cur += 1
if len(self.data) == self.max:
self.cur = 0
self.__class__ = SpeedBufferFull
def avg(self):
return sum(self.data) / self.cur
def pos(self):