def process(self, data):
(oid, block_id, version, serverid, ip,
port) = (data.oid, data.block_id, data.version, data.serverid,
data.ip, data.port)
client = hydra_client_api.HydraClientAPI(None)
client.set_primary_mdserver(self.cfg.CURR_MD_IP, self.cfg.CURR_MD_PORT)
client.set_mdservers(self.cfg.mdservers)
dest = os.path.join(self.app.get_storage_path(oid, block_id),
'__%s__%s' % (oid, block_id))
data.ip = self.cfg.IP
data.port = self.cfg.PORT
data.serverid = self.cfg.SERVER_ID
block = fs_objects.FSBlock(oid, block_id, version, 0, 0)
buf = client.get_block(block, ip, port)
file = open(dest, 'wb')
file.write(buf)
file.close()
self.fs.add(oid, block_id, version)
# print "Successfully replicated oid %s, block_id %s (version %s)" % (oid, block_id, version)
#tell metadata that we have now replicated this block
mds = network_services.NetworkTransport()
mds.open(self.cfg.CURR_MD_IP, self.cfg.CURR_MD_PORT)
mds.write(self.pb.build(packet_types.FS_REPLICATE_DONE, data))
mds.close()
def process(self, data):
data = self.pb.extract_stream(self.fp)
#if we are done then don't process any more incoming sync packets
if data.type == packet_types.CHK_DONE:
print "Sync done"
return None
oid = data.oid
block_id = data.block_id
block = self.fs.get_block(oid,block_id)
#if the block has been deleted, tell the data server to delete the block too
if not block:
print "Block deleted"
data = packet_builder.Data(params={'oid':oid,'block_id':block_id})
try:
out = network_services.NetworkTransport()
out.open(self.serverip,self.serverport)
out.write(self.pb.build(packet_types.FS_DELETE_BLOCK,data))
out.close()
except Exception,e:
print e
self.app.serverList.remove_address(self.serverip,self.serverport)
return None
def __init__(self, ip, port):
try:
self.net = network_services.NetworkTransport()
self.net.open(ip, port)
except Exception, e:
print e
self.net.close()
self.net = None
def process(self,data):
global fs
#client wants a file
print "Client wants to delete %s" % (data.path)
file = self.fs.get_file(path=data.path)
#if there is no such file tell the client so
if not file:
data = packet_builder.Data()
self.net.write(self.pb.build(packet_types.FS_ERR_PATH_NOT_FOUND, data))
return None
#get current replicas of this file
reps = self.fs.get_replicas(file.oid)
#if the file is currently in use, tell the client so
file_has_locks = self.app.serverList.file_has_locks(file.oid)
if not file_has_locks:
data = packet_builder.Data(params={'oid':file.oid,'version':file.version})
self.net.write(self.pb.build(packet_types.FS_ERR_LOCK_DENIED,data))
return None
#delete everything we have on that file
self.fs.delete_file(file.oid)
#tell the client the file is gone
data = packet_builder.Data(params={'oid':file.oid})
self.net.write(self.pb.build(packet_types.FS_DELETE_DONE,data))
self.net.close()
if reps:
#get a list of ip & ports of online servers that have such replica
servers = map(self.app.serverList.get_server, reps.replicas.keys())
for server in servers:
try:
print "Trying %s..." % str(server)
out = network_services.NetworkTransport()
out.open(server[0],server[1])
out.write(self.pb.build(packet_types.FS_DELETE_OID,data))
out.close()
except Exception,e:
print e
def replicate_block(self,
oid,
block_id,
version,
original_serverid,
force=False):
block = self.fs_db.get_block(oid, block_id)
reps = self.fs_db.get_block_replicas(oid, block_id)
#make sure the block we are replicating is the most current version
if block.version != version:
print "This version has expired! (%s) %s" % (version, block)
return
#replicate the file
done = False
while 1:
if len(reps.replicas.keys()) > self.cfg.REPLICAS and not force:
return None
#see if we need to do any more replicas
rep = self.serverList.select_new_replica_server(reps.replicas)
server = self.serverList.get_server(original_serverid)
if rep:
# print "REPLICATE FILE: server: %s replica %s" % (server, rep)
try:
(ip, port, serverid) = rep
data = packet_builder.Data(
params={
'oid': oid,
'block_id': block_id,
'version': version,
'serverid': original_serverid,
'ip': server[0],
'port': server[1]
})
net = network_services.NetworkTransport()
net.open(ip, port)
net.write(
self.pb.build(packet_types.FS_REPLICATE_BLOCK, data))
net.close()
done = True
except network_services.NetworkError, e:
print "OOOOOOOOOOO: %s" % e.value
#if the dataserver didn't work remove it from the active server list
self.serverList.remove(serverid)
print e
os._exit(1)
if done or not rep:
break
def update_file_replicas(self, oid, block_id, version, original_serverid):
"""Updates all replicas of oid, where the new version is in original_serverid"""
reps = self.fs_db.get_block_replicas(oid, block_id)
server = self.serverList.get_server(original_serverid)
if not server:
return
reps_done = 0
for rep in reps.replicas.keys():
dest = self.serverList.get_server(rep)
# print version
# print reps.replicas[rep]
# print dest
if not dest or reps.replicas[rep] >= version:
continue
try:
print "UPDATE REPLICA: server: %s replica %s" % (server, dest)
data = packet_builder.Data(
params={
'oid': oid,
'block_id': block_id,
'version': version,
'serverid': original_serverid,
'ip': server[0],
'port': server[1]
})
net = network_services.NetworkTransport()
net.open(dest[0], dest[1])
net.write(self.pb.build(packet_types.FS_REPLICATE_BLOCK, data))
net.close()
reps_done += 1
except network_services.NetworkError, e:
print "OOOOOOOOOOO: %s" % e.value
#if the dataserver didn't work remove it from the active server list
self.serverList.remove(str(rep))
def run(self):
"""Takes care of the incoming packet, and sends it to the class that will handle it"""
global lock
net = network_services.NetworkTransport(self.fd)
format = '!IIII'
packet_size = struct.calcsize(format)
while 1:
try:
data = net.read(packet_size)
(t, obj, arg, ver) = struct.unpack(format, data)
print "t=%s obj=%s arg=%s ver=%s" % (t, obj, arg, ver)
lock.acquire()
if t == 0: #server
if arg == 0: #server up
self.mon.serverdisplay.set_active(obj)
elif arg == 1: #server used
self.mon.serverdisplay.set_last(obj)
self.mon.statdisplay.server_transaction(obj)
elif arg == 2: #server down
self.mon.serverdisplay.set_error(obj)
elif arg == 3: #server inactive
self.mon.serverdisplay.set_inactive(obj)
elif t == 1: #oid
self.mon.update_version(obj, arg, ver)
lock.release()
except Exception, e:
self.close()
sys.exc_info()
v1, v2 = GetExceptionData()
Log("Exception within connection", v1, v2)
lock.release()
break
def process(self, data):
try:
#open the file, read the data from the network and store it in the filesystem
fout = open(
os.path.join(
self.app.get_storage_path(self.oid, self.block_id),
'__%s__%s' % (self.oid, self.block_id)), "wb")
# print "Trying to read %s bytes" % self.length
remaining = self.length
buf_size = 60000
l = 0
while remaining > 0:
if buf_size > remaining:
buf_size = remaining
buf = self.net.read_buffered(buf_size)
fout.write(buf)
l += len(buf)
remaining -= len(buf)
fout.close()
data = packet_builder.Data(
params={
'oid': self.oid,
'block_id': self.block_id,
'length': l,
'version': self.version,
'serverid': self.cfg.SERVER_ID,
'offset': self.file_offset
})
#store the replica information in the data server's local database
self.fs.add(self.oid, self.block_id, self.version)
#tell metadata server we have the file now
mds = network_services.NetworkTransport()
mds.open(self.cfg.CURR_MD_IP, self.cfg.CURR_MD_PORT)
mds.write(self.pb.build(packet_types.FS_BLOCK_STORED, data))
mds_reply = self.pb.extract_stream(mds.sock)
mds.close()
# print 'MDSERVER REPLY: %s' % mds_reply
if mds_reply.type == packet_types.ACK:
#tell client everything went ok
self.net.write(
self.pb.build(packet_types.FS_BLOCK_STORED, data))
return STATE_STORE_BLOCK_INFO()
except socket.timeout:
print "Socket timed out. File transfer failed for %s:%s." % (
self.oid, self.block_id)
self.rollback(fout)
#TODO: tell metadata that the client crashed on this operation
return None
except IOError:
print "Error while creating file __%s__%s." % (self.oid,
self.block_id)
data = Data()
data.oid = self.oid
data.block_id = self.block_id
#Notify client there was an error creating this file
self.net.write(pb.build(packet_types.FS_ERR_STORE, data))
return None
def process(self, data):
try:
#open the file, read the data from the network and store it in the filesystem
if self.offset == -1:
fout = open(
os.path.join(
self.app.get_storage_path(self.oid, self.block_id),
'__%s__%s' % (self.oid, self.block_id)), "ab+")
else:
fout = open(
os.path.join(
self.app.get_storage_path(self.oid, self.block_id),
'__%s__%s' % (self.oid, self.block_id)), "r+w")
fout.seek(self.offset)
# print "Trying to get and write %s bytes at %s" % (self.length, self.offset)
l = 0
remaining = self.length
buf_size = 64000
while remaining > 0:
if buf_size > remaining:
buf_size = remaining
buf = self.net.read_buffered(buf_size)
l += len(buf)
remaining -= len(buf)
fout.write(buf)
fout.close()
#get the new size of the block
block_size = os.path.getsize(
os.path.join(
self.app.get_storage_path(self.oid, self.block_id),
'__%s__%s' % (self.oid, self.block_id)))
# print "Update block: %s:%s" % (self.oid, self.block_id)
data = packet_builder.Data(
params={
'oid': self.oid,
'block_id': self.block_id,
'length': l,
'version': self.version,
'serverid': self.cfg.SERVER_ID,
'offset': self.offset,
'block_size': block_size
})
#tell metadata server we succesfully modified the block
mds = network_services.NetworkTransport()
mds.open(self.cfg.CURR_MD_IP, self.cfg.CURR_MD_PORT)
mds.write(self.pb.build(packet_types.FS_MODIFY_DONE, data))
mds_reply = self.pb.extract_stream(mds.sock)
print 'MDSERVER REPLY: %s' % mds_reply
if mds_reply.type == packet_types.FS_MODIFY_ACK:
#store the replica information in the data server's local database
self.fs.add(mds_reply.oid, mds_reply.block_id,
mds_reply.version)
mds.write(
self.pb.build(packet_types.FS_VERSION_UPDATED, mds_reply))
data.version = mds_reply.version
#tell client everything went ok
self.net.write(self.pb.build(packet_types.FS_MODIFY_DONE,
data))
else:
self.rollback(None)
mds.close()
return STATE_STORE_BLOCK_INFO()
except socket.timeout:
print "Socket timed out. File transfer failed for %s." % self.oid
self.rollback(fout)
return None
except IOError:
print "Error while creating file __%s." % self.oid
data = Data()
data.oid = self.oid
#Notify client there was an error creating this file
self.net.write(pb.build(packet_types.FS_ERR_STORE, data))
self.rollback(fout)
return None
