def replication(self, filename, to_addr):
to_channel = channel.DRDFSChannel()
to_channel.connect(to_addr, conf.dataport)
f = open(os.path.join(self.rootpath, filename), 'r')
f_size = os.fstat(f.fileno()).st_size
senddata = ['recv_repl', filename, f_size]
to_channel._send_header(senddata)
send_size = 0
while send_size < f_size:
buf = f.read(conf.blsize)
print len(buf)
to_channel.sock.sendall(buf)
send_size += len(buf)
assert (send_size == f_size)
print "finish send data of file"
(ans, dist_filename) = to_channel.recv_header()
print "recv answer"
if ans == 0:
ans = (0, dist_filename, f_size)
self.c_channel.send_header(ans)
to_channel.brk_channel()
def __init__(self, metaaddr, rootpath, dddfs_dir):
"""initialize DDDFS's data server daemon
"""
self.metaaddr = metaaddr
self.rootpath = os.path.abspath(rootpath)
self.dddfs_dir = dddfs_dir
"""Check directory for data files.
"""
assert os.access(self.rootpath, os.R_OK and os.W_OK and os.X_OK)
"""Initialize Log
"""
DRDFSLog.init("data", DRDFSLog.DEBUG)
"""At first, connect to metadata server and send request to attend.
"""
mchannel = channel.DRDFSChannel()
mchannel.connect(self.metaaddr, conf.metaport)
DRDFSLog.debug("Success in creating connection to metadata server")
senddata = ['dataadd', self.rootpath]
ans = mchannel.send_recv_flow(senddata)
if ans == -1:
e = system.DDDFSSystemError()
raise e
mchannel.brk_channel()
DRDFSLog.debug("Init complete!!")
def send_delete_request(self, IP, files):
senddata = ['filedel', files]
ch = channel.DRDFSChannel()
ch.connect(IP, conf.dataport)
ans = ch.send_recv_flow(senddata)
senddata = ['close']
ch.send_header(senddata)
ch.brk_channel()
def finalize(self, ):
"""remove myself from data servers' list
"""
mchannel = channel.DRDFSChannel()
mchannel.connect(self.metaaddr, conf.metaport)
senddata = ['datadel']
mchannel.send_header(senddata)
mchannel.brk_channel()
def __init__(self, path, flags, *mode):
DRDFSLog.debug("** open ** path = %s, flag = %s, mode = %s" %
(path, str(flags), str(mode)))
senddata = ['open', path, flags, mode]
ans = m_channel.send_recv_flow(senddata)
DRDFSLog.debug("open ans (from meta)" + str(ans))
self.dist = ans[1]
self.metafd = ans[2]
self.path = path
self.size = ans[3]
path_data = ans[4]
self.created = ans[5]
DRDFSLog.debug("This file size is %d bytes" % (self.size, ))
self.d_channel = channel.DRDFSChannel()
self.d_channel.connect(self.dist, conf.dataport)
senddata = ['open', path_data, flags, mode]
ans = self.d_channel.send_recv_flow(senddata)
DRDFSLog.debug("open ans (from data)" + str(ans))
if ans[0] != 0:
print "open error!!"
e = IOError()
e.errno = ans[0]
raise e
self.datafd = ans[1]
"""Initialize the write buffer
"""
self.r_buflock = threading.Lock()
self.w_buflock = threading.Lock()
self.writelist = []
self.writedata = cStringIO.StringIO()
self.writelen = 0
self.blnum = self.size / conf.blsize
if self.size % conf.blsize != 0:
self.blnum += 1
if self.size == 0:
self.bldata = tuple([tips.DRDFSBlock()])
else:
self.bldata = tuple(
[tips.DRDFSBlock() for i in range(self.blnum + 1)])
DRDFSLog.debug("len of bldata = %d" % (len(self.bldata)))
DRDFSLog.debug("create bldata 0-%d block" % (len(self.bldata) - 1))
def run(self, ):
while True:
# check tasks of replication
try:
(rep_from, rep_filename, rep_to,
org_filename) = self.repq.get(timeout=1)
rep_ch = channel.DRDFSChannel()
rep_ch.connect(rep_from, conf.dataport)
senddata = ['do_repl', rep_filename, rep_to]
rep_ch.send_header(senddata)
self.sock_list.append(rep_ch.sock.fileno())
self.sock_dict[rep_ch.sock.fileno()] = (rep_ch,
org_filename,
rep_from, rep_to)
except Queue.Empty:
pass
# check messages of replication ends
ch_list = select.select(self.sock_list, [], [], 1)[0]
for socknum in ch_list:
ch = self.sock_dict[socknum][0]
org_filename = self.sock_dict[socknum][1]
org_dist = self.sock_dict[socknum][2]
new_dist = self.sock_dict[socknum][3]
(ans, dist_filename, size) = ch.recv_header()
if ans == 0:
# add new location of the file
f = open(self.rootpath + org_filename, 'a')
buf = "%s,%s,%d,%s\n" % (new_dist, dist_filename, size,
org_dist)
f.write(buf)
f.close()
print "*** add replication ****"
self.access_info.add_dest(org_filename, new_dist)
self.sock_list.remove(ch.sock.fileno())
del self.sock_dict[ch.sock.fileno()]
senddata = [
'close',
]
ch.send_header(senddata)
ch.brk_channel()
def truncate(self, path, len):
senddata = ['truncate', path, len]
DRDFSLog.debug('*** truncate ***' + path + str(len))
ans = m_channel.send_recv_flow(senddata)
if ans[0] != 0:
return -ans[0]
ans[1] = filedist_info_list
DRDFSLog.debug("send request to data server: path=%s, len=%d" %
(path, len))
for filedist_info in filedist_info_list:
dist = filedist_info[0]
filename = filedist_info[1]
senddata = ['truncate', filename, len]
ch = channel.DRDFSChannel()
ch.connect(dist, conf.dataport)
ans = ch.send_recv_flow(senddata)
ch.brk_channel()
if ans != 0:
return -ans
return 0
def run(self, ):
"""Connected from clients
"""
self.lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.lsock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.lsock.bind(("0.0.0.0", conf.dataport))
self.lsock.listen(10)
daemons = []
collector_thread = self.thread_collector(daemons)
collector_thread.start()
threads_count = 0
while True:
(csock, address) = self.lsock.accept()
c_channel = channel.DRDFSChannel()
c_channel.set_channel_from_sock(csock)
datad = self.handler(c_channel, self.rootpath)
datad.name = "D%d" % (threads_count)
threads_count += 1
datad.start()
daemons.append(datad)
def run(self, ):
"""Connected from a client
"""
self.lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.lsock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
self.lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.lsock.bind(("0.0.0.0", conf.metaport))
self.lsock.listen(10)
DRDFSLog.debug("Listening at the port " + str(conf.metaport))
daemons = []
collector_thread = self.thread_collector(daemons)
collector_thread.start()
threads_count = 0
delete_files_thread = self.delete_files(self.delfiles_q)
delete_files_thread.start()
replicator_thread = self.replicator(self.repq, self.access_info,
self.rootpath)
replicator_thread.start()
delete_replica_thread = self.del_repl(self.repl_info, self.delfiles_q,
self.rootpath)
delete_replica_thread.start()
while True:
(csock, address) = self.lsock.accept()
c_channel = channel.DRDFSChannel()
c_channel.set_channel_from_sock(csock)
DRDFSLog.debug("accept connnect from %s" % (str(address[0])))
metad = self.handler(c_channel, self.rootpath, self.delfiles_q,
self.datalist, self.repq, self.repl_info,
self.access_info, self.cluster_info)
threads_count += 1
metad.start()
daemons.append(metad)
DRDFSLog.debug("Created thread name = " + metad.getName())
fuse.fuse_python_api = (0, 2)
import os, sys, os.path
sys.path.append(os.pardir)
from conf import conf
from libs import channel, dbmng, system, tips
from libs.system import DRDFSLog
import stat, errno, re
import socket, cPickle
import cStringIO, threading
import string, time, select
m_channel = channel.DRDFSChannel()
daemons = []
class DRDFS(Fuse):
"""Class for DRDFS's clients
"""
def __init__(self, meta_server, *args, **kw):
Fuse.__init__(self, *args, **kw)
self.meta_server = meta_server
self.parse(errex=1)
m_channel.connect(self.meta_server, conf.metaport)
def fsinit(self):
"""Called before fs.main() called.
"""
