import time, struct, sys, stat, logging
import ping, ping_disk, ping_reporter
log = ping_reporter.setup_log('PingFileSystem')
"""
PingFS_File
[00: 4] size
[04: 4] type
[08: 2] uid
[0a: 2] gid
[0c: 2] mode
[0e: 2] reserved
[10:__] data
PingFS_Directory(PingFS_File)
[10: 4] entry count
[14:__] entries
PingFS_DirEntry
[00: 2] name length
[02:__] name
"""
def makePingNode(data):
pnode = PingNode()
pnode.deserialize(data)
return pnode
def makePingFile(data):
pfile = PingFile()
import os,sys,socket,struct,select,time,binascii,logging
import ping_reporter
ping_count = 0
ping_bandwidth = 0
log = ping_reporter.setup_log('Ping')
server_list = ['www.google.com','172.16.2.1','10.44.0.1']
def select_server(log,max_timeout=1):
server = ''
log.notice('selecting server')
maxw = len(max(server_list, key=len))
min_delay = max_timeout * 1000 # seconds -> ms
for x in server_list:
delay = min_delay + 1
try: delay = single_ping(x,max_timeout)
finally:
if delay == None: log.notice('%-*s: timed out'%(maxw,x))
else: log.notice('%-*s: %05.02fms'%(maxw,x,delay*1000))
if delay != None and delay < min_delay:
min_delay = delay
server = x
log.info('selected server: %s (%.02fms)'%(server,min_delay*1000))
return server
def carry_add(a, b):
c = a + b
return (c & 0xFFFF) + (c >> 16)
def checksum(msg):
s = 0
import ping, threading, time, socket, select, sys, struct, Queue
import binascii, collections, math, random, logging
import ping_reporter
log = ping_reporter.setup_log("PingServer")
class PingTimer(threading.Thread): # helper class for PingServer to manage timeouts
def __init__(self, event):
self.queue = Queue.PriorityQueue()
threading.Thread.__init__(self)
self.running = False
self.event = event
def stop(self):
log.debug("PingTimeout terminating")
self.running = False
self.event.set()
def run(self):
self.running = True
log.debug("PingTimeout starting")
while self.running:
timeout = None
self.event.clear()
timeout = self.process()
self.event.wait(timeout)
def process(self):
while self.queue.qsize() > 0:
try:
import ping, threading, time, socket, select, sys, struct, Queue
import binascii, collections, math, random, logging
import ping_reporter
log = ping_reporter.setup_log('PingServer')
class PingTimer(threading.Thread
): # helper class for PingServer to manage timeouts
def __init__(self, event):
self.queue = Queue.PriorityQueue()
threading.Thread.__init__(self)
self.running = False
self.event = event
def stop(self):
log.debug('PingTimeout terminating')
self.running = False
self.event.set()
def run(self):
self.running = True
log.debug('PingTimeout starting')
while self.running:
timeout = None
self.event.clear()
timeout = self.process()
self.event.wait(timeout)
def process(self):
while self.queue.qsize() > 0:
#!/usr/bin/python
import os, sys, stat, errno, posix, logging, time, fuse
import ping, ping_reporter, ping_filesystem
from time import time
fuse.fuse_python_api = (0,2)
log = ping_reporter.setup_log('PingFuse')
class PingFuse(fuse.Fuse):
def __init__(self, server):
self.FS = ping_filesystem.PingFS(server)
#ping.drop_privileges()
fuse.Fuse.__init__(self)
log.notice('ping::fuse: initialized (%d-byte blocks)'%self.FS.disk.block_size())
def fsinit(self):
self.reporter = ping_reporter.PingReporter(log,'',90)
self.reporter.start()
def getattr(self, path):
"""
- st_mode (protection bits)
- st_ino (inode number)
- st_dev (device)
- st_nlink (number of hard links)
- st_uid (user ID of owner)
- st_gid (group ID of owner)
- st_size (size of file, in bytes)
- st_atime (time of most recent access)
import ping, threading, time, socket, select, sys, struct, Queue
import binascii, collections, math, random, logging
import ping_reporter
log = ping_reporter.setup_log('PingServer')
class PingTimer(threading.Thread): # helper class for PingServer to manage timeouts
def __init__(self, event):
self.queue = Queue.PriorityQueue()
threading.Thread.__init__(self)
self.running = False
self.event = event
def stop(self):
log.debug('PingTimeout terminating')
self.running = False
self.event.set()
def run(self):
self.running = True
log.debug('PingTimeout starting')
while self.running:
timeout = None
self.event.clear()
timeout = self.process()
self.event.wait(timeout)
#time.sleep(0.1)
def process(self):
while self.queue.qsize() > 0:
try: expire,event,callback,cb_args = item = self.queue.get_nowait()
import ping, threading, time, socket, select, sys, struct, logging
import binascii, threading, collections, math, random
import ping, ping_server, ping_reporter
log = ping_reporter.setup_log('PingDisk')
class PingDisk():
def __init__(self, d_addr, block_size=1024, timeout=2):
#self.server = ping_server.PingServerInterface(d_addr,block_size,timeout)
self.server = ping_server.PingServer(d_addr,block_size,timeout)
self.server.setup()
self.server.start()
def stop(self):
self.server.stop()
def size(self):
return self.server.block_size * (1<<28)
def block_size(self):
return self.server.block_size
def region_size(self):
return max(2,4096/self.block_size())
def read_block(self, ID, datastore, blocking=False):
event = self.server.read_block(ID, self.__read_callback, datastore, False)
if not blocking: return event
event.wait()
def read_block_sync(self, ID):
import os, sys, socket, struct, select, time, binascii, logging
import ping_reporter
ping_count = 0
ping_bandwidth = 0
log = ping_reporter.setup_log('Ping')
server_list = ['www.google.com', '172.16.2.1', '10.44.0.1']
def select_server(log, max_timeout=1):
server = ''
log.notice('selecting server')
maxw = len(max(server_list, key=len))
min_delay = max_timeout * 1000 # seconds -> ms
for x in server_list:
delay = min_delay + 1
try:
delay = single_ping(x, max_timeout)
finally:
if delay == None: log.notice('%-*s: timed out' % (maxw, x))
else: log.notice('%-*s: %05.02fms' % (maxw, x, delay * 1000))
if delay != None and delay < min_delay:
min_delay = delay
server = x
log.info('selected server: %s (%.02fms)' % (server, min_delay * 1000))
return server
def carry_add(a, b):
c = a + b
return (c & 0xFFFF) + (c >> 16)
import ping, threading, time, socket, select, sys, struct, logging
import binascii, threading, collections, math, random
import ping, ping_server, ping_disk, ping_reporter
import random
log = ping_reporter.setup_log('PingRaid')
class PingRaid():
def __init__(self, servers):
self.disks = []
for host in servers:
try:
disk = ping_disk.PingDisk(host)
except:
log.error('failed setup: %s' % host)
continue
self.disks.append(disk)
if len(self.disks) == 0:
raise Exception('PingRaid: no valid servers registered')
def stop(self):
for disk in self.disks:
disk.stop()
def size(self):
return min([x.size() for x in self.disks])
def block_size(self):
return min([x.block_size() for x in self.disks])
import ping, threading, time, socket, select, sys, struct, logging
import binascii, threading, collections, math, random
import ping, ping_server, ping_reporter
log = ping_reporter.setup_log('PingDisk')
class PingDisk():
def __init__(self, d_addr, block_size=1024, timeout=2):
#self.server = ping_server.PingServerInterface(d_addr,block_size,timeout)
self.server = ping_server.PingServer(d_addr, block_size, timeout)
self.server.setup()
self.server.start()
def stop(self):
self.server.stop()
def size(self):
return self.server.block_size * (1 << 28)
def block_size(self):
return self.server.block_size
def region_size(self):
return max(2, 4096 / self.block_size())
def read_block(self, ID, datastore, blocking=False):
event = self.server.read_block(ID, self.__read_callback, datastore,
False)
if not blocking: return event
event.wait()
#!/usr/bin/python
import os, sys, stat, errno, posix, logging, time, fuse
import ping, ping_reporter, ping_filesystem
from time import time
fuse.fuse_python_api = (0, 2)
log = ping_reporter.setup_log('PingFuse')
class PingFuse(fuse.Fuse):
def __init__(self, server):
self.FS = ping_filesystem.PingFS(server)
#ping.drop_privileges()
fuse.Fuse.__init__(self)
log.notice('ping::fuse: initialized (%d-byte blocks)' %
self.FS.disk.block_size())
def fsinit(self):
self.reporter = ping_reporter.PingReporter(log, '', 90)
self.reporter.start()
def getattr(self, path):
"""
- st_mode (protection bits)
- st_ino (inode number)
- st_dev (device)
- st_nlink (number of hard links)
- st_uid (user ID of owner)
- st_gid (group ID of owner)
import ping, threading, time, socket, select, sys, struct, logging
import binascii, threading, collections, math, random
import ping, ping_server, ping_disk, ping_reporter
import random
log = ping_reporter.setup_log('PingRaid')
class PingRaid():
def __init__(self, servers):
self.disks = []
for host in servers:
try:
disk = ping_disk.PingDisk(host)
except:
log.error('failed setup: %s'%host)
continue
self.disks.append(disk)
if len(self.disks) == 0:
raise Exception('PingRaid: no valid servers registered')
def stop(self):
for disk in self.disks:
disk.stop()
def size(self): return min([x.size() for x in self.disks])
def block_size(self): return min([x.block_size() for x in self.disks])
def region_size(self): return min([x.region_size() for x in self.disks])
def get_disk(self): return random.choice(self.disks)
def get_region(self, size):
return self.get_disk().get_region(size)
import time, struct, sys, stat, logging
import ping, ping_disk, ping_reporter
log = ping_reporter.setup_log('PingFileSystem')
"""
PingFS_File
[00: 4] size
[04: 4] type
[08: 2] uid
[0a: 2] gid
[0c: 2] mode
[0e: 2] reserved
[10:__] data
PingFS_Directory(PingFS_File)
[10: 4] entry count
[14:__] entries
PingFS_DirEntry
[00: 2] name length
[02:__] name
"""
def makePingNode(data):
pnode = PingNode()
pnode.deserialize(data)
return pnode
def makePingFile(data):
