RCP cliente/servidor

O código e a execução do RCP .

Figura 1: telas dos códigos do cliente e servidor.

Figura 2: telas de execução do cliente e do servidor.

Servidor

#********************************************************************
# Autor:        ubiratã uaatsim itza I.
# Data:         07/03/2014
# Hora:         17:40:06
#*********************************************************************
# Arquivo:      servidorchavevalor9.py
#
# Descrição:    O arquivo servidorchavevalor4.py executou bem apareceu
#               os métodos porém, não realiza nunhuma operação sem dar
#               erro.
#
# Uso:          from servidorchavevalor9 import ServidorChaveValor
#               s = ServidorChaveValor
#               s.      --> aparecem os métodos e atributos disponíveis.
#
# Em 27/02/2014:
# 1- no janelas funciona até aparecer os métodos e atributos disponíveis.
# 2- no Ubuntu indica erros básicos.
#*********************************************************************

#!/usr/bin/env python
#-*- coding:utf-8 -*-

from xmlrpc.server import SimpleXMLRPCServer
from xmlrpc.server import SimpleXMLRPCRequestHandler

class RequestHandler(SimpleXMLRPCRequestHandler):
    rpc_paths = ()

# Restringe para um particular caminho.
#class RequestHandler(SimpleXMLRPCRequestHandler):
#    rpc_paths = ('/RPC2',)

v_dicionario = {'tan':88}
v_acesso = {'técnico':77,'administrador':66,'komum':33}
v_conectado = [1,2]

# Cria o servidor, pode ser "127.0.0.1" ou 'localhost'
servilo = SimpleXMLRPCServer(("127.0.0.1", 15000), allow_none = True, requestHandler=RequestHandler)
servilo.register_introspection_functions()

class ServidorChaveValor():
       
        def __init__(self):
            self.nome = 't'

        def acesso(nome_terminal):
            """Gerencia o acesso ao terminal.
            """
            v_conectado[0] = nome_terminal
            if nome_terminal == v_acesso['técnico']:
                    print('Conectado:', v_acesso['técnico'])
            elif nome_terminal == v_acesso['administrador']:
                    print('Conectado:', v_acesso['administrador'])
            elif nome_terminal == v_acesso['komum']:
                    print('Conectado:', v_acesso['komum'])
            else:
                    print('Acesso negado! Não conectado.')
        servilo.register_function(acesso, 'acesso')
       
        def versao():
            """Exibe a versão do RPC.
            """
            print('RPC Versão 9.')
        servilo.register_function(versao, 'versao')
           
        def busca(v_chave):
            """Retorna o valor através da chave.
            """
            if v_conectado[0] == v_acesso['administrador']:
                    print('Busca com sucesso!')
                    return v_dicionario[v_chave]
            else:
                    print('Acesso negado! Não buscado.')
        servilo.register_function(busca, 'busca')

        def insere(v_chave, v_valor):
            """Inseri uma chave/valor no dicionário.
            """
            if v_conectado[0] == v_acesso['administrador']:
                    v_dicionario[v_chave] = v_valor
                    print('Dado inserido com sucesso!')
            else:
                    print('Acesso negado! Não inserido.')
        servilo.register_function(insere, 'insere')

        def apaga(v_chave):
            """Apaga uma chave.
            """
            if v_conectado[0] == v_acesso['administrador']:
                    del v_dicionario[v_chave]
                    print('Dado removido com sucesso!')
            else:
                    print('Acesso negado! Não apagado.')
        servilo.register_function(apaga, 'apaga')

        def mostra():
            """Mostra o dicionário.
            """
            if v_conectado[0] == v_acesso['técnico']:
                     print(v_dicionario.keys())
            else:
                    print('Acesso negado! Não mostrado.')
                    return -1
        servilo.register_function(mostra, 'mostra')

        def executa():
            """Executa o servidor infinitamente!
            """
            if v_conectado[0] == v_acesso['administrador']:
                    try:
                            servilo.server_close()
                            print ('Use "Control-C" para encerrar o servidor 2.')
                            servilo.serve_forever()
                    except KeyboardInterrupt:
                            servilo.server_close()
                            print ('Saída 2!')
            else:
                    print('Acesso negado! Não executado.')
        servilo.register_function(executa, 'executa')

        def fecha():
                servilo.server_close()
        servilo.register_function(fecha,'fecha')


servilo.register_instance(ServidorChaveValor())


if __name__ == '__main__':
     try:
        print ('Use "Control-C" para encerrar o servidor 1.')
        servilo.serve_forever()
     except KeyboardInterrupt:
             servilo.server_close()
             print ('Saída 1!')
#************************************************************************

Cliente
#********************************************************************
# Autor:        ubiratã uaatsim itza I.
# Data:         07/03/2014
# Hora:         17:45:06
#*********************************************************************
# Arquivo:      clienteRCP9.py
#
# Descrição:    O arquivo servidorchavevalor9.py executou bem apareceu
#               os métodos porém, não realiza nunhuma operação sem dar
#               erro.
#
# Uso:          import xmlrpc.client
#               s = xmlrpc.client.ServerProxy('http://localhost:15000')
#               s.      --> aparecem os métodos e atributos disponíveis.
#
# Em 27/02/2014:
# 1- no janelas funciona até aparecer os métodos e atributos disponíveis.
# 2- no Ubuntu indica erros básicos.
#*********************************************************************

#!/usr/bin/env python
#-*- coding:utf-8 -*-

import xmlrpc.client
#from xmlrpc.client import ServerProxy

s = xmlrpc.client.ServerProxy('http://localhost:15000')
#s = ServerProxy('http://127.0.0.1', allow_none = True) # pode ser "127.0.0.1" ou 'localhost'

s.acesso(66)            # conecta-se ao sistema como usuário administrador.
s.versao()              # verifica a versão do sistema.
print(s.busca('tan'))   # faz uma busca do valor pela chave.
s.insere('x',12)        # insere um elemento.

print(s.busca('x'))     # faz uma busca do valor pela chave.
s.acesso(77)            # conecta-se ao sistema como usuário técnico.

print(s.mostra())       # mostra todo o dicionário.
s.acesso(66)            # conecta-se ao sistema como usuário administrador.
s.apaga('x')            # apaga um item do dicionário pela chave.
s.acesso(77)            # conecta-se ao sistema como usuário técnico.

print(s.mostra())       # mostra todo o dicionário.
s.acesso(66)            # conecta-se ao sistema como usuário administrador.
#s.executa()             # executa o RPC infinitamente.

print(s.system.listMethods())
#*********************************************************************
.

Mera cópia

Mera cópia do link python.org a fim de testar o código na minha máquina e nas minhas condições.

Figura 1: telas dos códigos e das execuções do RPC.

Deu tudo certo executou e realizou as funções perfeitamente. Um bom código para começo de programas mais complexos!

Fonte: Python.org
.

Cópia: cliente/servidor

Executou com perfeição suas funções.

Figura 1: telas dos códigos e execuções do RPC.

Veja mais em: python.org

.

RPC com Python.

RPC é a comunicação entre processos veja mais em wikipedia. Atente para os detalhes de versões do S.O. e do Python, muitas mudanças no código podem ser necessárias em função das versões.

Figura 1: Ambiente de desenvolvimento.

Este código foi testado e foi comprovado a sua execução dentro dos requisitos das versões.

Figura 2: Programa no editor.

#*********************************************************************
#!/usr/bin/env python
#-*- coding:utf-8 -*-
#
# arquivo: servidorchavevalor8.py
#*********************************************************************
from xmlrpc.server import SimpleXMLRPCServer, list_public_methods
"""
Servidor RPC dos métodos: versão, busca, salva, apaga, sai, chave e executa.
"""

v_dicionario = {'tan':83}
v_acesso = {'tekniko':77,'administranto':66,'komum':33} # privilégios pré definidos.

servilo = SimpleXMLRPCServer(('localhost', 15000), allow_none = True)
servilo.register_introspection_functions()

class ServidorChaveValor():
       
        def __init__(self):
            self.nome = 't'

        def acesso(nome_terminal):
            """Gerencia o acesso ao terminal.
            """
            if nome_terminal == v_acesso['tekniko']:
                    print(v_acesso['tekniko'])
            elif nome_terminal == v_acesso['administranto']:
                    print(v_acesso['administranto'])
            elif nome_terminal == v_acesso['komum']:
                    print(v_acesso['komum'])
            else:
                    print('Acesso negado!')
       
        def versao():
            """Exibe a versão do RPC.
            """
            print('RPC Versão 8.')
           
        def busca(v_chave):
            """Retorna o valor com base na chave do dicionário.
            """
            if v_conectado[0] == v_acesso['administranto']:  # Verificar privilégio de acesso.
                    print('Busca com sucesso!')
                    return v_dicionario[v_chave]
            else:
                    print('Acesso negado! Não buscado.')

        def insere(v_chave, v_valor):
            """Inseri um valor com base na chave do dicionário.
            """
            v_dicionario[v_chave] = v_valor

        def apaga(v_chave):
            """Apaga um dado com base na chave do dicionário.
            """
            del v_dicionario[v_chave]

        def executa():
            """Executa o servidor infinitamente!
            """
            try:
                print ('Use "Control-C" para encerrar o servidor 2.')
                servilo.serve_forever()
            except KeyboardInterrupt:
                print ('Saída 2!')

servilo.register_instance(ServidorChaveValor()) # Registra todos os métodos como público.


if __name__ == '__main__':
     try:
        print ('Use "Control-C" para encerrar o servidor 1.')
        servilo.serve_forever()
     except KeyboardInterrupt:
             print ('Saída 1!')
#************************************************************************

A interação com o utilizador é muito boa e o melhor é que as mensagens apresentados na edição durante a execução esta no controle do programador.

Figura 3: Interação com o utilizador.

Usando o RCP.
#************************************************************************

from servidorchavevalor8 import ServidorChaveValor # biblioteca.
s = ServidorChaveValor  # instância a classe.

s.acesso(66)            # conecta-se ao sistema como usuário administrador.
s.versao()              # verifica a versão do sistema.
print(s.busca('tan'))   # faz uma busca do valor pela chave.
s.insere('x',12)        # insere um elemento.
print(s.busca('x'))     # faz uma busca do valor pela chave.

s.acesso(77)            # conecta-se ao sistema como usuário técnico.
print(s.mostra())       # mostra todo o dicionário.

s.acesso(66)            # conecta-se ao sistema como usuário administrador.
s.apaga('x')            # apaga um item do dicionário pela chave.

s.acesso(77)            # conecta-se ao sistema como usuário técnico.
print(s.mostra())       # mostra todo o dicionário.

s.acesso(66)            # conecta-se ao sistema como usuário administrador.
s.executa()             # executa o RPC infinitamente.

#************************************************************************

Figura 4: Execução do RPC versão 8.

Daí para frente é só implementar mais alguns métodos com funcionalidades práticas.