Python jsonrpclib.Server类代码示例

def nlp_parse(text):
    """
    pass the text to the stanford NLP core server and get the parsed data
    """
    server = Server("http://localhost:8080")
    parsed_data = loads(server.parse(text))
    return parsed_data

def main():
  
    argument_spec = dict( 
        vlan_id=dict(required=True), 
        vlan_name=dict(),
        host=dict(),
        username=dict(required=True),
        password=dict(required=True), 
        port=dict(required=False),
        transport=dict(choices=['http', 'https'],required=False)
    )

    module = AnsibleModule(argument_spec=argument_spec, supports_check_mode=True)
    
    vlan_id = module.params['vlan_id']
    vlan_name = module.params['vlan_name']
    host = str(module.params['host'])
    username = module.params['username']
    password = module.params['password']
    port = int(module.params['port'])
    transport = module.params['transport']

    conn = Server("https://%s:%[email protected]%s/command-api" %(username, password, host))
    
    list_cmds = [ "enable", "configure" ] 

    list_cmds.append("vlan %s" %(vlan_id))
    list_cmds.append("name %s" %(vlan_name))

    conn.runCmds(1, list_cmds, "json")

    module.exit_json(msg="Vlan created successfully")

def main():
    parser = argparse.ArgumentParser(description='Location,Ipaddress')
    parser.add_argument('-location', choices=['dc1','dc2'],
    help='Enter the colo location dc1|dc2')
    parser.add_argument('-ip', help='Enter switch ip address')
    args = parser.parse_args()
    if args.location == 'dc1':
         hostlist = arista_devices_dc1()
    elif args.location == 'dc2':
         hostlist = arista_devices_dc2()
    disable_https_cert()
    #----------------------------------------------------------------
    # Configuration section
    #----------------------------------------------------------------
    #-------------------Configuration - MUST Set ------------------------
    EAPI_USERNAME = os.getenv("USER")
    EAPI_PASSWORD = get_user_info()
    # http or https method
    EAPI_METHOD = 'https'

    for host in hostlist:
        switch = Server( '%s://%s:%[email protected]%s/command-api' %
                       ( EAPI_METHOD, EAPI_USERNAME, EAPI_PASSWORD, host ) )
        rc = switch.runCmds( 1, [ 'enable',
                        'configure',
                        'interface Vxlan1',
                        'vxlan flood vtep add %s' % args.ip  ] )
        print( 'Host configured: %s' % ( host ) )

def get_hostname(ip_list):
    ip_to_hostname = {}
    for ip in ip_list:
        switch_cli = Server( "http://admin:[email protected]"+ip+"/command-api" )
        response_hostname = switch_cli.runCmds( 1, ["show hostname"])
        ip_to_hostname[ip] = response_hostname[0]["hostname"]
    return ip_to_hostname

 def execute(self, cleanup=True):
     """
     Execute the bugger
     :return:
     """
     res = None
     try:
         res = self._server.execute(self._pdict, cleanup)
     except KeyboardInterrupt:
         self.monitor.stop()
         server2 = Server(self.url)
         server2.kill()
     except socket.error:
         self.log.error("Server was interrupted")
         exit(1)
     finally:
         self.monitor.stop()
     if res is None:
         raise ValueError("Run failed")
     resstr = "%s\t%s\t %s\t %s\t %s\t %s\t %s" % (str(datetime.datetime.utcnow()), self.message, 
                                                   self._pdict["cpuRangeVal"], self._pdict["outputDir"],
                                                   res["Wallclock"], res["peak"]/1024.**3, res["avg"]/1024**3)
     self.log.info("date \t\t\t message \t\t cpu \t outputdir \t time \t peak_mem \t avg_mem")
     self.log.info(resstr)
     with open(os.path.expanduser("~/result.dat"), "a") as out:
         out.write(resstr+"\n")

def eApiShowInterfaces():
    switch = Server(commandApiUrl)
    response = switch.runCmds( 1, ["show interfaces"])
    if (request.query.callback):
        return directFlowJsonp(request)
    else:
        return json.dumps(eApiDirectFlow(), indent=4, sort_keys=True)

def main(args):
    ''' main '''
    parser = OptionParser()
    parser.add_option('-u', '--username', default='eapi', help='username')
    parser.add_option('-p', '--password', default='', help='password')
    parser.add_option('-P', '--port', default='8543', help='port')
    parser.add_option('-D', '--debug', action='store_true', help='debug')
    options, args = parser.parse_args()

    for switch in args:
        url = "https://{0}:{1}@{2}:{3}/command-api".format(
            options.username, options.password, switch, options.port
        )
        request = Server(url)
        response = request.runCmds(1, ["show interfaces"] )
        if options.debug:
            print json.dumps(response, indent=4, sort_keys=True)
        interfaces = sorted(response[0]['interfaces'].keys())
        print "Switch {0} interfaces:".format(switch)
        print "{:20} {:<20} {:<20}".format("Interface", "inOctets", "outOctets")
        for inf in interfaces:
            data = response[0]['interfaces'][inf]
            if 'interfaceCounters' in data:
                print "{:20} {:<20} {:<20}".format(
                    inf, data['interfaceCounters']['inOctets'], data['interfaceCounters']['outOctets']
                )
        print

 def ControlPlayer(self, action='', percent=''):
     xbmc = Server(self.url('/jsonrpc', True))
     player = xbmc.Player.GetActivePlayers()
     if action == 'SetMute':
         return xbmc.Application.SetMute(mute='toggle')
     elif action == 'Back':
         return xbmc.Input.Back()
     elif action == 'Down':
         return xbmc.Input.Down()
     elif action == 'Home':
         return xbmc.Input.Home()
     elif action == 'Left':
         return xbmc.Input.Left()
     elif action == 'Right':
         return xbmc.Input.Right()
     elif action == 'Select':
         return xbmc.Input.Select()
     elif action == 'Up':
         return xbmc.Input.Up()
     elif action == 'MoveLeft':
         return xbmc.Input.Left()
     elif action == 'MoveRight':
         return xbmc.Input.Right()
     elif action == 'Seek':
         try:
             percent = float(percent)
             return xbmc.Player.Seek(playerid=player[0][u'playerid'], value=percent)
         except:
             return
     elif action:
         try:
             method = 'Player.'+action
             return xbmc._request(methodname=method, params={'playerid' : player[0][u'playerid']})
         except:
             return

    def test_get_device_status_good(self):
        """ Test get_device_status happy path
        """
        from mock import MagicMock
        from jsonrpclib import Server
        device = dict(self.device)
        sh_ver = dict(self.sh_ver)

        # Arbitrary test valuse
        model = "Monkey-bot"
        timestamp = 1408034881.09

        sh_ver['modelName'] = model
        sh_ver['bootupTimestamp'] = timestamp
        response = []
        response.append(sh_ver)

        device['eapi_obj'] = Server('https://arista:[email protected]:443/command-api')
        device['eapi_obj'].runCmds = MagicMock(return_value=response)

        #response = []
        #response.append({})
        #response[0][u'interfaceStatuses'] = self.int_status

        app.get_device_status(device)
        self.assertEqual(device['modelName'], model)
        self.assertEqual(device['bootupTimestamp'], timestamp)

def add_vlans():
    for switch in switches:
    	for vlanlist in vlans:
    		urlString = "http://{}:{}@{}/command-api".format(switchusername, switchpassword, switch)
    		switchReq = Server( urlString )
    		response = switchReq.runCmds( 1, ["enable", "configure", "vlan" +" "+ str(vlanlist)] )
    		print "adding vlans %s" % (vlanlist)

def show_vlans():
    for switch in switches:
        urlString = "http://{}:{}@{}/command-api".format(switchusername, switchpassword, switch)
        switchReq = Server( urlString )
        response = switchReq.runCmds( 1, ["show vlan"] )
        print "Showing the vlans on %s" % (switch)
        print json.dumps(response, indent=4)

def push(item, remote_addr, trg_queue, protocol=u'jsonrpc'):
    ''' Enqueue an FSQWorkItem at a remote queue '''
    if protocol == u'jsonrpc':
        try:
            server = Server(remote_addr, encoding=_c.FSQ_CHARSET)
            return server.enqueue(item.id, trg_queue, item.item.read())
        except Exception, e:
            raise FSQPushError(e)

 def ControlPlayer(self, action='', percent=''):
     """ Various commands to control XBMC Player """
     self.logger.debug("Sending control to XBMC: " + action)
     xbmc = Server(self.url('/jsonrpc', True))
     player = xbmc.Player.GetActivePlayers()
     if action == 'SetMute':
         return xbmc.Application.SetMute(mute='toggle')
     elif action == 'Back':
         return xbmc.Input.Back()
     elif action == 'Down':
         return xbmc.Input.Down()
     elif action == 'Home':
         return xbmc.Input.Home()
     elif action == 'Left':
         return xbmc.Input.Left()
     elif action == 'Right':
         return xbmc.Input.Right()
     elif action == 'Select':
         return xbmc.Input.Select()
     elif action == 'Up':
         return xbmc.Input.Up()
     elif action == 'MoveLeft':
         return xbmc.Input.Left()
     elif action == 'MoveRight':
         return xbmc.Input.Right()
     elif action == 'PlayNext':
         try:
             return xbmc.Player.GoTo(playerid=player[0][u'playerid'], to='next')
         except:
             self.logger.error("Unable to control XBMC with action: " + action)
             return
     elif action == 'PlayPrev':
         try:
             return xbmc.Player.GoTo(playerid=player[0][u'playerid'], to='previous')
         except:
             self.logger.error("Unable to control XBMC with action: " + action)
             return
     elif action == 'JumpItem':
         try:
             return xbmc.Player.GoTo(playerid=player[0][u'playerid'], to=int(percent))
         except:
             self.logger.error("Unable to control XBMC with action: " + action)
             return
     elif action == 'Seek':
         try:
             percent = float(percent)
             return xbmc.Player.Seek(playerid=player[0][u'playerid'], value=percent)
         except:
             self.logger.error("Unable to control XBMC with action: " + action)
             return
     elif action:
         try:
             method = 'Player.' + action
             return xbmc._request(methodname=method, params={'playerid': player[0][u'playerid']})
         except:
             self.logger.error("Unable to control XBMC with action: " + action)
             return

def main():
    args = parser.parse_args()
    config = get_rpc_string(os.path.expanduser('~/.namecoin/namecoin.conf'))
    rpc = Server(config)

    try:
        entry = rpc.name_filter('^%s/%s$' % (PREFIX, args.key), 0)[0]
        print(entry['value'])
    except IndexError:
        print('Key not found', file=sys.stderr)

def remove_acl(ip_list):
    adjacency_list = find_topology(ip_list)
    for ip in adjacency_list.keys():
        switch_cli = Server( "http://admin:[email protected]"+ip+"/command-api" )
        configure_acl_response = switch_cli.runCmds( 1, ["enable","configure terminal","no ip access-list trace",])
        for interface in adjacency_list[ip].values():
            configure_acl_interface_response = switch_cli.runCmds( 1, ["enable","configure terminal",
            "interface "+interface,
            "no ip access-group trace in",
            "end"])