Python ServerProxy.fetch方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    '''
    A text-based client interface.
    '''
    prompt = '>'
    
    def __init__(self, url, dirname, urlfile):
        '''
        Initialize the node and start the Node server in a seperate thread.
        '''
        Cmd.__init__(self)
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            self.server.hello(line.strip())

    def do_fetch(self, arg):
        '''
        Fetch the specified file.
        '''
        try:
            self.server.fetch(arg, self.secret)
        except Fault, f:
            if f.faultCode !=UNHANDLED:
                raise
            print 'Could not find ', arg

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    """
    Node类的简单的基于文本的界面。
    """
    prompt = '>'

    def __init__(self, url, dirname, urlfile):
        """
        设定url、dirname和urlfile,并且在单独的线程中启动Node服务器。
        """
        Cmd.__init__(self)
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target = n._start)
        t.setDaemon(1)
        t.start()

        #让服务器先启动。
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)

    def do_fetch(self, arg):
        "调用服务器的fetch方法"
        try:
            self.server.fetch(arg, self.secret)
        except Fault, f:
            if f.faultCode != UNHANDLED: raise
            print "Counldn't find the file", arg

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    """
    A simple text-based interface to the Node class.
    """

    prompt = '> '


    def __init__(self, url, dirname, urlfile):
        """
        Sets the url, dirname, and urlfile, and starts the Node
        Server in a separate thread.
        """
        Cmd.__init__(self)
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        # Give the server a head start:
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)

    def do_fetch(self, arg):
        "Call the fetch method of the Server."
        try:
            self.server.fetch(arg, self.secret)
        except Fault, f:
            if f.faultCode != UNHANDLED: raise
            print "Couldn't find the file", arg

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    prompt = '>'
    def __init__(self, url, dirname, urlfile):
        Cmd.__init__(self)
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)

    def do_fetch(self, arg):
        try:
            self.server.fetch(arg, self.secret)
        except Fault as f:
            if f.faultCode != UNHANDLED:
                raise
            print "Couldn't find the file", arg, f

    def do_exit(self, arg):
        print
        sys.exit()

    do_EOF = do_exit

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
    """
    主Client类，用于设定GUI，启动为文件服务的Node。
    """
    def __inif__(self, url, dirname, urlfile):
        """
        创建一个随机的密码，使用这个密码实例化Node。利用Node的_start方法（确保Thread是个无交互的后台程序，
        这样他会随着程序退出而退出）启动Thread，读取URL文件中的所有URL，并且将Node介绍给这些URL。
        """
        super(Client, self).__init__()
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()

        #让服务器先启动。
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)

    def OnInit(self):
        """
        设置GUI。创建窗体、文本框和按钮，并且进行布局。将提交按钮绑定到self.fetchHandler上。
        """
        win = wx.Frame(None, title="File Sharing Client", size=(400,45))

        bkg = wx.Panel(win)

        self.input = input = wx.TextCtrl(bkg)

        submit = wx.Button(bkg, label="Fetch", size=(80, 25))
        submit.Bind(wx.EVT_BUTTON, self.fetchHandler)

        hbox = wx.BoxSizer()
        hbox.Add(input, proportion=1, flag=wx.ALL|wx.EXPAND, border=10)
        hbox.Add(submit, flag=wx.TOP|wx.BOTTON|wx.RIGHT, border=10)

        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(hbox, proportion=0, flag=wx.EXPAND)

        bkg.SetSizer(vbox)

        win.Show()

        return True

    def fetchHandler(self, event):
        """
        在用户点击‘Fetch’按钮时调用，读取文本框中的查询，调用服务器Node的fetch方法。
        如果查询没有被处理则打印错误信息。
        """
        query = self.input.getValue()
        try:
            self.server.fetch(query, self.secret)
        except Fault, f:
            if f.faultCode != UNHANDLED: raise
            print "Couldn't find the file", query

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    """
    Interface based on text of Node class
    """
    prompt = '> '

    def __init__(self, url, dirname, urlfile):
        """
        set url, dirname and urlfile.
        start Node server in single thread.
        """
        Cmd.__init__(self)
        self.secret = randomString(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        # server start first
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)

    def do_fetch(self, arg):
        "call fetch method from server"
        try:
            self.server.fetch(arg, self.secret)
        except Fault, f:
            if f.faultCode != UNHANDLED: 
                raise
            print "couldn't find the file", arg

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
    def __init__(self, url, dirname, urlfile):
        #创建一个随机密码，使用这个密码实例化ListableNode,利用它的start方法(确保Thread是个无交互的后台程序，这样它会随着程序退出而退出)启动一个Thread,读取URL文件中的所有URL，并且将Node
        #介绍给这些URL，最后设置GUI
        self.secret = randomString(SECRET_LENGTH)
        n = ListableNode(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        #先启动服务器
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)
        #运行GUI
        super(Client,self).__init__()

    #使用从服务器 Node中获取文件名更新列表框
    def updateList(self):
        self.files.Set(self.server.list())

    #设置GUI,创建窗体，文本框和按钮，并且进行布局。将提交按钮绑定到self.fetchHandler上
    def OnInit(self):
        win = wx.Frame(None, title="File Sharing Client",size=(400,300))

        bkg = wx.Panel(win)

        self.input = input = wx.TextCtrl(bkg)

        submit = wx.Button(bkg, label="FETCH", size=(400,300))
        submit.Bind(wx.EVT_BUTTON, self.fetchHandler)

        hbox = wx.BoxSizer()

        hbox.Add(input, proportion=1, flag=wx.ALL | wx.EXPAND, border=10)
        hbox.Add(submit, flag=wx.TOP | wx.BOTTOM | wx.RIGHT,border=10)

        self.files = files = wx.ListBox(bkg)
        self.updateList()

        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(hbox, proportion=1, flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, border=10)

        bkg.SetSizer(vbox)

        win.Show()

        return True

    #在用户点击'Fetch'按钮时调用，读取文件中的查询，调用服务器Node的fetch方法，处理查询之后调用Updatelist。如果请求没有被处理则打印错误信息
    def fetchHandler(self, event):
        query = self.input.GetValue()
        try:
            self.server.fetch(query, self.secret)
            self.updateList()
        except Fault,f:
            if f.faultCode != UNHANDLED:raise
            print "Couldn't find the file",query

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
	"""docstring for Client"""
	def __init__(self, url, dirname, urlfile):
	
		self.secret=randomString(SECRET_LENGTH)
		n=ListableNode(url,dirname,self.secret)
		t=Thread(target=n._start)
		t.setDaemon(1)
		t.start()

		sleep(HEAD_START)
		self.server=ServerProxy(url)
		for line in open(urlfile):
			line=line.strip()
			self.server.hello(line)

		super(Client,self).__init__()

	def updateList(self):
		self.files.Set(self.server.list())

	def OnInit(self):
		win=wx.Frame(None, title="File Sharing Client", size=(400,300))

		bkg=wx.Panel(Win)

		self.input=input=wx.TextCtrl(bkg)

		submit=wx.Button(bkg,lable="Fetch",size=(80,25))
		submit=Bind(wx.EVT_BUTTON, self.fetchHandler)

		hbox=wx.BoxSizer()

		hbox.Add(input,proportion=1,flag=wx.ALL|wx.EXOAND, border=10)
		hbox.Add(submit,flag=wx.TOP|wx.BOTTOM|wx.RIGHT,border=10)

		self.files=files=wx.ListBox(bkg)
		self.updateList()

		vbox=wx.BoxSizer(wx.VERTICAL)
		vbox=Add(hbox,proportion=0,flag=wx.EXOAND)
		vbox=Add(files,proportion=1,flag=wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM,border=10)

		bkg=SetSizer(vbox)

		win.Show()

		return True

	def fetchHandler(self,event):
	
		query=self.input.GetValue()
		try:
			self.server.fetch(query,self.secret)
		except Fault, f:
			if f.faultCode!=UNHANDLED:
				raise
			print "Couldn't find the file",query

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(Cmd):
    '''
    a text-based interface to the Node class, using cmd to
    create the Command line interface.
    '''
    prompt = 'Node > '

    def __init__(self, url, dirname, urlfile):
        
        Cmd.__init__(self)
        self.secret = GenPassword(SECRET_LENGTH)
        n = Node(url, dirname, self.secret)
        p = Process(target = n._start_server, name = 'rpc-xml_server')
        p.daemon = True
        p.start()
        time.sleep(HEAD_START)

        self.server = ServerProxy(url)

    def do_fetch(self, arg):
        print 'the fetch result: ', self.server.fetch(arg, self.secret)
        '''
        try:
            self.server.fetch(arg, self.secret)
        except:
            print 'failed to fetch ' + arg
        '''
    
    def do_exit(self, arg):
        sys.exit()

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
def send_request():
    mypeer = ServerProxy('http://localhost:4242')
    code, data = mypeer.query('test.txt')
    print code
    print data
    
    otherpeer = ServerProxy('http://localhost:4243')
    code, data = otherpeer.query('test.txt')
    print code
    print data
    
    mypeer.hello('http://localhost:4243')
    code, data = mypeer.query('test.txt')
    print code
    print data
    
    mypeer.fetch('test.txt', 'secret1')

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
    def _broadcast(self, query, history):
        '''
        handle the query search fro other known URLs
        '''
        for URL in self.known.copy(): ## to delete URL without any response, so a copy is needed
            if URL in history: continue
            try:
                s = ServerProxy(URL)
                ## fetch is the only registered function
                code, data = s.fetch(query, self.secret, history)
                if code == self.OK: return code, data
            except:
                self.known.remove(URL)

        return self.FAIL, self.EMPTY

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
    """
    The main client class, which takes care of setting up the GUI and
    starts a Node for serving files.
    """
    def __init__(self, url, dirname, urlfile):
        """
        Creates a random secret, instantiates a ListableNode with that secret,
        starts a Thread with the ListableNode's _start method (making sure the
        Thread is a daemon so it will quit when the application quits),
        reads all the URLs from the URL file and introduces the Node to
        them. Finally, sets up the GUI.
        """
        # Give the server a head start:
        try:
            sleep(HEAD_START)
            self.server = ServerProxy(url)
            super(Client, self).__init__()
            self.secret = randomString(SECRET_LENGTH)
            n = ListableNode(url, dirname, self.secret)
            t = Thread(target=n._start)
            t.setDaemon(1)
            t.start()
            for line in open(urlfile):
                line = line.strip()
                self.server.hello(line)

        except:
            print "init fail"
            exit(1)

    def updateList(self):
        """
        Updates the list box with the names of the files available
        from the server Node.
        """
        self.files.Set(self.server.list())

    def OnInit(self):
        """
        Sets up the GUI. Creates a window, a text field, a button, and
        a list box, and lays them out. Binds the submit button to
        self.fetchHandler.
        """
        win = wx.Frame(None, title="File Sharing Client", size=(400, 300))
        bkg = wx.Panel(win)
        self.input = input = wx.TextCtrl(bkg)
        submit = wx.Button(bkg, label="Fetch", size=(80, 25))
        submit.Bind(wx.EVT_BUTTON, self.fetchHandler)
        hbox = wx.BoxSizer()
        hbox.Add(input, proportion=1, flag=wx.ALL | wx.EXPAND, border=10)
        hbox.Add(submit, flag=wx.TOP | wx.BOTTOM | wx.RIGHT, border=10)
        self.files = files = wx.ListBox(bkg)
        self.updateList()
        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(hbox, proportion=0, flag=wx.EXPAND)
        vbox.Add(files, proportion=1, flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, border=10)
        bkg.SetSizer(vbox)
        win.Show()
        return True

    def fetchHandler(self, event):
        """
        Called when the user clicks the 'Fetch' button. Reads the
        query from the text field, and calls the fetch method of the
        server Node. After handling the query, updateList is called.
        If the query is not handled, an error message is printed.
        """
        query = self.input.GetValue()
        try:
            self.server.fetch(query, self.secret)
            self.updateList()

        except Fault, f:
            if f.faultCode != UNHANDLED:
                raise

            print "Couldn't find the file", query

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
    """
    主client类，用于设定GUI，启动为文件服务的Node
    """
    def __init__(self, url, dirname, urlfile):
        """
        创建一个随机密码，使用这个密码实例化Node。
        利用Node的_start方法启动Thread
        (确保Thread是个无交互的后台程序，随程序退出而退出)
        读取URL文件的所有URL，并将Node介绍给这些URL
        """
        self.secret = randomString(SECRET_LENGTH)
        n = ListableNode(url, dirname, self.secret)
        t = Thread(target=n._start)
        t.setDaemon(1)
        t.start()
        # server start first
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)
        # 运行GUI
        super(Client, self).__init__()
    
    def updateList(self):
        """
        使用从服务器Node获得的文件名更新列表框
        """
        self.files.Set(self.server.list())

    def OnInit(self):
        """
        设置GUI。创建窗体、文本框和按钮，并进行布局。
        将提交按钮绑定到self.fetchHandler上
        """
        win = wx.Frame(None, title="File Sharing Client", size=(400,300))
        bkg = wx.Panel(win)

        self.input = input = wx.TextCtrl(bkg)
        
        submit = wx.Button(bkg, label="Fetch", size=(80, 25))
        submit.Bind(wx.EVT_BUTTON, self.fetchHandler)

        hbox = wx.BoxSizer()
        hbox.Add(input, proportion=1, flag=wx.ALL|wx.EXPAND, border=10)
        hbox.Add(submit, flag=wx.TOP|wx.BOTTOM|wx.RIGHT, border=10)

        self.files = files = wx.ListBox(bkg)
        self.updateList()

        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(hbox, proportion=0, flag=wx.EXPAND)
        vbox.Add(files, proportion=1, flag=wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, border=10)

        bkg.SetSizer(vbox)
        win.Show()
        
        return True

    def fetchHandler(self, event):
        """
        在用户点击'Fetch'按钮时调用。
        读取文本框中的查询，调用服务器Node的fetch方法。
        处理查询后，调用updateList.
        如果查询没有被处理则打印错误信息。
        """
        query = self.input.GetValue()
        try:
            self.server.fetch(query, self.secret)
            self.updateList()
        except Fault,f:
            if f.faultCode != UNHANDLED: 
                raise
            print "couldn't find the file", query

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class Client(wx.App):
    
    def __init__(self, url, dirname, urlfile):
        self.secret = randomString(SECRET_LENGTH)
        node = ListableNode(url, dirname, self.secret)
        thread = Thread(target=node._start)
        thread.setDaemon(1)
        thread.start()
        sleep(HEAD_START)
        self.server = ServerProxy(url)
        for line in open(urlfile):
            line = line.strip()
            self.server.hello(line)
        super(Client, self).__init__()
        
    def updateList(self):
        self.files.Set(self.server.list())
        
    def OnInit(self):
        """
        Sets up the GUI. Creates a window, a text field, and a button, and lays them out.
        Binds the submit button to self.fetchHandler
        """
        win = wx.Frame(None, title="File Sharing Client", size=(400, 300))
        bkg = wx.Panel(win)
        
        self.input = input = wx.TextCtrl(bkg)
        submit = wx.Button(bkg, label="Fetch", size=(80, 25))
        submit.Bind(wx.EVT_BUTTON, self.fetchHandler)
        
        hbox = wx.BoxSizer()
        hbox.Add(input, proportion=1, flag=wx.ALL | wx.EXPAND, border=10)
        hbox.Add(submit, flag=wx.TOP | wx.BOTTOM | wx.RIGHT, border=10)
        
        self.peer = peer = wx.TextCtrl(bkg)
        add = wx.Button(bkg, label="Add a Peer", size=(80, 25))
        add.Bind(wx.EVT_BUTTON, self.helloHandler)
        
        peerbox = wx.BoxSizer()
        peerbox.Add(peer, proportion=1, flag=wx.ALL | wx.EXPAND, border=10)
        peerbox.Add(add, flag=wx.TOP | wx.BOTTOM | wx.RIGHT, border=10)
        
        self.files = files =wx.ListBox(bkg)
        self.updateList()
        
        vbox = wx.BoxSizer(wx.VERTICAL)
        vbox.Add(hbox, proportion=0, flag=wx.EXPAND)
        vbox.Add(peerbox, proportion=0, flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, border=10)
        vbox.Add(files, proportion=1, flag=wx.EXPAND | wx.LEFT | wx.RIGHT | wx.BOTTOM, border=10)
        
        bkg.SetSizer(vbox)
        
        win.Show()
        
        return True
            
    def fetchHandler(self, event):
    
        query = self.input.GetValue()
        try:
            self.server.fetch(query, self.secret)
            self.updateList()
        except Fault as f:
            if f.faultCode != UNHANDLED:
                raise
            print("Couldn't find the file %s" % query)
            
    def helloHandler(self, event):
        url = self.peer.GetValue()
        self.server.hello(url)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import fetch [as 别名]
class NodeService():
	"""
	node service: start stop list listall fetch 
	"""	
	def __init__(self,url,dirname,ipsfile):
		self.url = url
		self.dirname = dirname
		self.secret = random_string(SECRET_LENGTH)
		self.ipsfile = ipsfile
		# indicate whether node server is running
		self.event_running= Event() # flag is false by default

		# server thread instance
		self.server_thread = NodeServerThread('Thread-SERVER',self.url,self.dirname,self.secret,self.ipsfile,self.event_running)
		# node server proxy for client use
		self.server = None

	def get_filepath(self,query):
		"""
		query like  './share/11.txt' or '11.txt'
		"""
		if query.startswith(self.dirname):
			return query
		else:
			return join(self.dirname,query)

	def start(self):
		"""
		start NodeServerThread in child thread,and connect to server in main thread 
		"""
		mylogger.info('[start]: NodeService starting...')
		# 1)start node server in child thread
		self.server_thread.start()
		# block current thread until node server is started
		if not self.event_running.wait(3):
			sys.exit()
		mylogger.info('[start]: NodeServerThread started') 
		# 2) connect to server in main thread
		self.server = ServerProxy(self.url,allow_none=True)
		mylogger.info('[start]: NodeService started')

	def stop(self):
		mylogger.info('[stop]: NodeService stopping...')
		# 1) stop node server in child thread
		self.server_thread.stop()
		mylogger.info('[stop]: NodeService stopped')

	"""
	node server methods
	"""
	def fetch(self,query):
		# fetch file from available node
		filepath = self.get_filepath(query)
		return self.server.fetch(filepath,self.secret)

	def get_local_files(self):
		# return local_files
		return self.server.get_local_files()

	def get_remote_files(self):
		# return remote_files
		return self.server.get_remote_files()
		
	def update_local_list(self):
		# update local_files 
		self.server.update_local_list()

	def update_remote_list(self):
		# update remote_files 
		self.server.update_remote_list()
	
	def get_url(self):
		# get url of local node
		return self.url

	def get_remote_urls(self):
		# get remote urls 
		return self.server.get_remote_urls()

	def is_local_updated(self):
		# whether local updated
		return self.server.is_local_updated()

	def is_remote_updated(self):
		# whether remote updated
		return self.server.is_remote_updated()

	def clear_local_update(self):
		# clear local update and set to false
		self.server.clear_local_update()

	def clear_remote_update(self):
		# clear remote update and set to false
		self.server.clear_remote_update()