Python ServerProxy.login方法代码示例

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def set_ip(domains, ip, user, password):
    """
    Override WebFaction's dns
    """
    try:
        server = ServerProxy(API)
        session_id = server.login(user, password)[0]

        overrides = server.list_dns_overrides(session_id)

        current = {domain:None for domain in domains}

        for override in overrides:
            if override['domain'] in domains:
                current[override['domain']] = override['a_ip']

        for domain in domains:
            if (not current[domain]) or (current[domain] != ip):
                print '%s => %s' % (domain, ip)

                if domain in current:
                    server.delete_dns_override(session_id, domain)

                server.create_dns_override(session_id, domain, ip)
            else:
                print '%s == %s' % (domain, ip)

    except Exception as e:
        print "ERROR: clearing password."
        keyring.set_password(NAMESPACE, user, '')
        raise e

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def login(request):
    """
    This method lets a user login to pyquiz
    """
    if unauthenticated_userid(request) != None and 'user' in request.session.keys():
        return HTTPFound(location='/index')
    message = ''
    login = ''
    password = ''
    if 'form.submitted' in request.params:
        username = request.params['login']
        password = request.params['password']
        server = ServerProxy(serverLocation, transport = trans)
        if server.login(username, password):
            user_info = server.get_user_info(username)
            userinfo = schooltool_login(username, password, user_info)
            request.session['user'] = userinfo
            headers = remember(request, userinfo['roles'][0])
            return HTTPFound(location='/index',
                             headers = headers)
        message = 'Failed login'

    return dict(
        message = message,
        url = request.application_url + '/',
        login = login,
        password = password,
        main = get_renderer('templates/master.pt').implementation(),
        )

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
class TinyXMLRPC:
  def __init__(self, username, password, database, base_url):
    self.username = username
    self.password = password
    self.database = database
    self.base_url = base_url

    self._connect()
    self._login()

  def _connect(self):

    # Since python 2.7.9 ssl check ca-cetificates thus we need to give
    # system's trusted certificates
    ssl_context = ssl.create_default_context(purpose=ssl.Purpose.CLIENT_AUTH)

    self._common_server = ServerProxy(os.path.join(self.base_url, "common"),
        context=ssl_context)
    self._object_server = ServerProxy(os.path.join(self.base_url, "object"),
        context=ssl_context)
    self._wizard_server = ServerProxy(os.path.join(self.base_url, "wizard"),
        context=ssl_context)

  def _login(self):
    self.user_id = self._common_server.login(self.database, self.username, self.password)

  def execute(self, *params):
    return self._object_server.execute(self.database, self.user_id, self.password, *params)

  def wizard(self, *params):
    return self._wizard_server.execute(self.database, self.user_id, self.password, *params)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def webfaction_login():
  print "Logging in to webfaction"
  from xmlrpclib import ServerProxy, Error
  wfapi = ServerProxy("https://api.webfaction.com/")
  print env.user
  wf_session_id, _account = wfapi.login(env.user, env.password)
  print "logged in", wf_session_id
  return wfapi, wf_session_id

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
 def check_login(self, login, password=False):
     """
     Checks the login
     If no password is provided, returns true if the login exists,
     false otherwise
     If a password is provided, returns true if the login/password
     are valid credentials, false otherwise
     """
     if not password:
         orm_user = request.env['res.users'].sudo()
         return bool(orm_user.search([('login', '=', login)]))
     else:
         server = ServerProxy('http://localhost:8069/xmlrpc/common')
         return server.login(request.db, login, password)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def magento_connect(self, cr, uid):
    try:
        ids = self.pool.get('sneldev.magento').search(cr, uid, [])
        export = self.pool.get('sneldev.magento').browse(cr, uid, [ids[0]])
        server_address = export[0]['url']
        if not server_address[-1:] == '/':
            server_address = server_address + "/"
        server_address = server_address + "index.php/api/xmlrpc/?wsdl"
        server = ServerProxy(server_address)
        session = server.login(export[0]['api_user'], export[0]['api_pwd'])
        return [True, server, session]
    except:
        traceback.print_exc()
        return [False, sys.exc_info()[0], False]

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
 def magento_openerp_syn(self, cr, uid):
     try:
         #To search magneto configuration id from openerp
         ids = self.pool.get('magento.configuration').search(cr, uid, [])
         #To create reference
         config_obj = self.pool.get('magento.configuration').browse(cr, uid, [ids[0]])
         #configured url for magneto
         server_address = config_obj[0]['url']
         if not server_address[-1:] == '/':
             server_address = server_address + "/"
         server_address = server_address + "index.php/api/xmlrpc/?wsdl"
         server = ServerProxy(server_address)
         #To login with magneto for configured API user
         session = server.login(config_obj[0]['api_user'], config_obj[0]['api_pwd'])
         return [True, server, session]
     except Exception,e:
         return [False, sys.exc_info()[0], False]

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def main():
    logging.basicConfig(level = logging.DEBUG,
                        format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
    proxy = ServerProxy("http://localhost:8080")
    logging.info("Logging in with team %s and password %s" % (team, password))
    session = proxy.login(team, password)
    logging.info("Initiated session %s" % (session))
    #session = "lgpb1yqve5tn0ggu3rxoktmt112uthvfbgemnou8"
    try:
        res = proxy.get_info(session)
        turn_num = res['turn_num']
        logging.info("Sending add_request()")
        res = proxy.add_request(session, turn_num, {"5": {ACTION_MOVE: MOVE_DOWN}, "4": {ACTION_SHOOT: (7, 3)}})
        logging.info("Response: %s" % (repr(res)))
    finally:
        logging.info("Logging out")
        res = proxy.logout(session)
        logging.info("Response: %s" % (repr(res)))
        logging.info("Finished!")

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def main():
    logging.basicConfig(level = logging.DEBUG,
                        format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
    proxy = ServerProxy("http://localhost:8080")
    logging.info("Logging in with team %s and password %s" % (team, password))
    session = proxy.login(team, password)
    logging.info("Initiated session %s" % (session))
    try:
        while True:
            #logging.info("Sending get_info()")
            res = proxy.get_info(session)
            #logging.info("Response: %s" % (repr(res)))
            turn_num = res['turn_num']
            simulator = Simulator.from_external_status(res['status'])
            print "TURN %d" % (turn_num)
            simulator.print_field()
            proxy.wait_for_simulation(session)
            print
    finally:
        logging.info("Logging out")
        res = proxy.logout(session)
        logging.info("Response: %s" % (repr(res)))
        logging.info("Finished!")

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
class TinyXMLRPC:
  def __init__(self, username, password, database, base_url):
    self.username = username
    self.password = password
    self.database = database
    self.base_url = base_url

    self._connect()
    self._login()

  def _connect(self):
    self._common_server = ServerProxy(os.path.join(self.base_url, "common"))
    self._object_server = ServerProxy(os.path.join(self.base_url, "object"))
    self._wizard_server = ServerProxy(os.path.join(self.base_url, "wizard"))

  def _login(self):
    self.user_id = self._common_server.login(self.database, self.username, self.password)

  def execute(self, *params):
    return self._object_server.execute(self.database, self.user_id, self.password, *params)

  def wizard(self, *params):
    return self._wizard_server.execute(self.database, self.user_id, self.password, *params)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
    def login(self, api_user=None, api_key=None):
        if api_user is None:
            if self.__xmlrpc_api_url_parsed.username is not None:
                api_user = self.__xmlrpc_api_url_parsed.username
            else:
                raise ValueError('missing api_user')

        if api_key is None:
            if self.__xmlrpc_api_url_parsed.password is not None:
                api_key = self.__xmlrpc_api_url_parsed.password
            else:
                raise ValueError('missing api_key')

        xmlrpc_proxy = \
            ServerProxy(
                self.__xmlrpc_api_url,
                allow_none=True,
                verbose=logging.getLevelName(logging.getLogger().getEffectiveLevel()) == 'DEBUG'
            )

        session_id = xmlrpc_proxy.login(api_user, api_key)

        return self.Session(session_id, xmlrpc_proxy)

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
#!/usr/bin/env python
from xmlrpclib import ServerProxy

SERVER = 'http://localhost:1200'
DATABASE = 'tph_etl'
USERNAME = 'admin'
PASSWORD = 'admin'

server = ServerProxy('http://localhost:1200/xmlrpc/common')
user_id = server.login(DATABASE, USERNAME, PASSWORD)

server = ServerProxy('http://localhost:1200/xmlrpc/object')
user_ids = server.execute(
    DATABASE, user_id, PASSWORD,
    'res.users', 'search', []
)

users = server.execute(
    DATABASE, user_id, PASSWORD,
    'res.users', 'read', user_ids, []
)

for user in users:
    print(user['id'], user['name'])

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
def jira_connect(url, user, password):
    '''Connect to JIRA, return proxy object and token.'''
    jira = ServerProxy(url).jira1
    token = jira.login(user, password)
    return jira, token

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
from xmlrpclib import ServerProxy
from tests.transport import SessionTransport

HOST = 'http://androidworld.staging.hub.nl/forum/mobiquo/mobiquo.php'
USERNAME = 'tapatalk'
PASSWORD = 'foobar'

t = SessionTransport()
server = ServerProxy(HOST, verbose=True, transport=t)

print server.login(USERNAME, PASSWORD)
latest_topics = server.get_latest_topic(0,2)
topics = latest_topics['topics']
server.reply_post(topics[0]['forum_id'], topics[0]['topic_id'], 'subject', 'body')

# 需要导入模块: from xmlrpclib import ServerProxy [as 别名]
# 或者: from xmlrpclib.ServerProxy import login [as 别名]
zendesk_url = sys.argv[1]
zendesk_url = (zendesk_url + "/api/v2/topics.json")
zendesk_username = sys.argv[2]
zendesk_password = sys.argv[3]
zendesk_forum_id = sys.argv[4]

# Setting Confluence server details. The confluence_server_url looks like https://YOURCONFLUENCEDOMAIN.com".
confluence_server_url = sys.argv[5]
conf_user = sys.argv[6]
conf_pwd = sys.argv[7]
conf_space = sys.argv[8]

# Access the Confluence site via XML-RPC to retrieve the list of all pages in the space (once-off)
s = Server(confluence_server_url + "/rpc/xmlrpc")
s = s.confluence1
confluence_token = s.login(conf_user,conf_pwd)
# this is a "dictionary" (spaceindex)
confluence_spaceindex = s.getPages(confluence_token, conf_space)
#print confluence_spaceindex #temporary debug point
#s.logout(confluence_token) 

#Set up Zendesk login credentials from command-line arguments
zendesk_auth = HTTPBasicAuth(zendesk_username,zendesk_password)

#Loop to create new pages in Zendesk from the list of pages in Confluence.
for page_summary in confluence_spaceindex:
    confluence_content_space = page_summary['space']
    confluence_content_url = page_summary['url']
    confluence_content_title = page_summary['title']
    confluence_content_version = page_summary['version']
    confluence_content_parent = page_summary['parentId']