def __init__(self, directory, sha=None, clone=False):
self.directory = os.path.abspath(directory)
self.clone = clone
self.peers = []
self.dampen = {}
self.aka = {} # mapping of addr's to peer-ids
self.loops = {}
self.closed = False
if self.clone:
self.git = None
self.sha = sha
else:
self.git = Git(self.directory)
self.sha = self.git.root
self.short_sha = self.sha[:7]
if self.index.has_key(self.sha):
raise Exception("Swarm already exists for %s" % self.directory)
self.index[self.sha] = self
EventLoop.register(self)
print timestamp(), self, "Registered", self.sha
lpd.LPD.update()
def __init__(self, host, port, listen_port):
if [ x for x in self.index if x.host == host and x.port == port ]:
raise Exception("Tracker already exists for %s:%d" % (host, port))
self.closed = False
self.host = host # Tracker's hostname
self.port = port # Tracker's port
self.listen_port = listen_port # Our port, to announce
self.swarms = {} # Map of Swarm objects to announcement expire times
self.transaction_id = random.randint(0, 2**32)
self.key = random.randint(0, 2**32)
self.state = STATE_SOCK
self.sock = None
self.sock_next_attempt = 0
self.current_swarm = None
self.conn_id = None
self.conn_id_expires = 0
self.conn_id_next_attempt = 0
self.conn_id_retry = 0
self.announce_next_attempt = 0
self.announce_retry = 0
self.unmute_time = 0
self.index.append(self)
EventLoop.register(self)
print timestamp(), self, "Registered"
def __init__(self, addr, backlog=5):
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(addr)
sock.listen(backlog)
sock.setblocking(False)
self.sock = sock
self.addr = sock.getsockname()
EventLoop.register(self)
print timestamp(), self, "Listening"
def __init__(self, port, announce_time=600, sock_attempt_time=5):
if self.index:
raise Exception("An instance already exists?")
self.port = port
self.announce_time = announce_time
self.sock_attempt_time = sock_attempt_time
self.last_sock_attempt = 0
self.sock = None
self.open_socket()
self.index.append(self)
EventLoop.register(self)
def __init__(self, peer, tag, cmd):
self.tag = tag
self.peer = peer
self.cmd = cmd
self.popen = Popen(cmd, stdout=PIPE, stderr=STDOUT, preexec_fn=os.setsid)
self.pid = self.popen.pid
self.fd = self.popen.stdout
self.eof = False
self.closed = False
# Set non-blocking
flags = fcntl.fcntl(self.fd, fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(self.fd, fcntl.F_SETFL, flags)
print timestamp(), self, "Running", repr(' '.join(cmd))
EventLoop.register(self)
def __init__(self, listener, sock, addr, peer):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024*128)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024*128)
self.listener = listener
self.auth = listener.auth
self.sock = sock
self.addr = addr
self.peer = peer
self.readbuf = ''
self.bytes_read = 0
self.request = ''
self.idle_timeout = time.time()
self.sent_header = False
self.eof = False
self.closed = False
self.id_ = None
self.filename = None
#print timestamp(), self, "Incomming connection from", self.addr
EventLoop.register(self)
def __init__(self, peer, sock, addr):
if sock is None:
# No sock argument means outbound connection
sock = socket.socket()
sock.setblocking(False)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1024*128)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1024*128)
self.connected = False
else:
self.connected = True
self.peer = peer
self.sock = sock
self.addr = addr
self.host = addr[0]
self.port = addr[1]
self.readbuf = ''
self.parse_state = STATE_START
self.parse_len = 0
self.helo = False
self.last_read_time = time.time()
self.last_ping_time = time.time()
self.closed = False
if not self.connected:
print timestamp(), self, "Connecting to", self.addr
try:
self.sock.connect(self.addr)
except socket.error as e:
if e.errno != errno.EINPROGRESS:
raise
else:
print timestamp(), self, "Connected immediately?"
self.on_connect()
EventLoop.register(self)
def __init__(self, peer, port=0, backlog=4):
sock = socket.socket()
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.bind(('127.0.0.1', port))
sock.listen(backlog)
sock.setblocking(False)
self.peer = peer
self.sock = sock
self.addr = sock.getsockname()
self.closed = False
# Generate a random username and password for authentication. We're
# binding to localhost, but this prevents another user on the system
# from hijacking our connection.
self.auth = '%s:%s' % (base64.b32encode(os.urandom(10)), base64.b32encode(os.urandom(10)))
self.url = 'http://%s@%s:%d/' % (self.auth, self.addr[0], self.addr[1])
self.children = []
self.set_env()
EventLoop.register(self)
print timestamp(), self, "Proxy URL", self.url
