Python ExecutorService.execute_rpc方法代码示例

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    infra_bridge_new_root = xr_snmp_test_trap_act.InfraBridgeNewRoot()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, infra_bridge_new_root)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
class SanityTest(unittest.TestCase):

    @classmethod
    def setUpClass(self):
        self.csp = CodecServiceProvider(type=EncodingFormat.XML)
        self.es = ExecutorService()
        self.cs = CodecService()

    def setUp(self):
        # start a brand new session for every single test case
        # so test_close_session_rpc will not interfere with other test cases
        # self.ncc = NetconfServiceProvider('127.0.0.1', 'admin', 'admin', 12022)
        self.ncc = NetconfServiceProvider(
            self.hostname,
            self.username,
            self.password,
            self.port,
            self.protocol,
            self.on_demand,
            self.common_cache,
            self.timeout)
        from ydk.services import CRUDService
        crud = CRUDService()
        runner = ysanity.Runner()
        crud.delete(self.ncc, runner)

    def tearDown(self):
        # close session by close session rpc
        try:
            rpc = ietf_netconf.CloseSession()
            self.es.execute_rpc(self.ncc, rpc)
        except YError:
            pass
        del self.ncc

    @unittest.skip('Issues in confd')
    def test_close_session_rpc(self):
        rpc = ietf_netconf.CloseSession()

        reply = self.es.execute_rpc(self.ncc, rpc)
        self.assertIsNone(reply)

    def test_commit_rpc(self):
        rpc = ietf_netconf.Commit()
        rpc.input.confirmed = Empty()
        rpc.input.confirm_timeout = 5

        reply = self.es.execute_rpc(self.ncc, rpc)
        self.assertIsNone(reply)

    def test_copy_config_rpc(self):
        rpc = ietf_netconf.CopyConfig()
        rpc.input.target.candidate = Empty()
        rpc.input.source.running = Empty()

        reply = self.es.execute_rpc(self.ncc, rpc)
        self.assertIsNone(reply)

    @unittest.skip('Issues in netsim')
    def test_delete_config_rpc(self):
        rpc = ietf_netconf.DeleteConfig()
        rpc.input.target.url = "http://test"

        reply = self.es.execute_rpc(self.ncc, rpc)
        self.assertIsNone(reply)

    def test_discard_changes_rpc(self):
        rpc = ietf_netconf.DiscardChanges()
        reply = self.es.execute_rpc(self.ncc, rpc)
        self.assertIsNone(reply)

    # test edit config, get config, and get rpcs
    def test_edit_config_rpc(self):
        runner = ysanity.Runner()
        runner.ydktest_sanity_one.number = 1
        runner.ydktest_sanity_one.name = 'runner:one:name'

        runner_xml = self.cs.encode(self.csp, runner)
        filter_xml = self.cs.encode(self.csp, ysanity.Runner())

        # Edit Config
        edit_rpc = ietf_netconf.EditConfig()
        edit_rpc.input.target.candidate = Empty()
        edit_rpc.input.config = runner_xml
        reply = self.es.execute_rpc(self.ncc, edit_rpc)
        self.assertIsNone(reply)

        # Get Config
        get_config_rpc = ietf_netconf.GetConfig()
        get_config_rpc.input.source.candidate = Empty()
        get_config_rpc.input.filter = filter_xml
        reply = self.es.execute_rpc(self.ncc, get_config_rpc, runner)
        self.assertIsNotNone(reply)
        self.assertEqual(reply, runner)

        # Commit
        commit_rpc = ietf_netconf.Commit()
        reply = self.es.execute_rpc(self.ncc, commit_rpc)
        self.assertIsNone(reply)

#.........这里部分代码省略.........

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    roll_back_configuration_to = xr_cfgmgr_rollback_act.RollBackConfigurationTo()  # create object
    prepare_roll_back_configuration_to(roll_back_configuration_to)  # add RPC input

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, roll_back_configuration_to)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    routing_mpls_tunnel_re_routed = xr_snmp_test_trap_act.RoutingMplsTunnelReRouted()  # create object
    prepare_routing_mpls_tunnel_re_routed(routing_mpls_tunnel_re_routed)  # add RPC input

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, routing_mpls_tunnel_re_routed)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    entity_sensor_threshold_notification = xr_snmp_test_trap_act.EntitySensorThresholdNotification()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, entity_sensor_threshold_notification)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    sonet_line_status = xr_snmp_test_trap_act.SonetLineStatus()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, sonet_line_status)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    routing_ospf_neighbor_state_change = xr_snmp_test_trap_act.RoutingOspfNeighborStateChange()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, routing_ospf_neighbor_state_change)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    infra_bridge_topology_change = xr_snmp_test_trap_act.InfraBridgeTopologyChange()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, infra_bridge_topology_change)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    infra_flash_device_inserted = xr_snmp_test_trap_act.InfraFlashDeviceInserted()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, infra_flash_device_inserted)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    infra_redundancy_progression = xr_snmp_test_trap_act.InfraRedundancyProgression()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, infra_redundancy_progression)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    get_schema = ietf_netconf_monitoring.GetSchema()  # create object
    prepare_get_schema(get_schema)  # add RPC input

    # execute RPC on NETCONF device
    print(executor.execute_rpc(provider, get_schema))

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    platform_hfr_plane_state = xr_snmp_test_trap_act.PlatformHfrPlaneState()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, platform_hfr_plane_state)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    entity_fru_fan_tray_inserted = xr_snmp_test_trap_act.EntityFruFanTrayInserted()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, entity_fru_fan_tray_inserted)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    all = xr_snmp_test_trap_act.All()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, all)

    exit()
# End of script

# 需要导入模块: from ydk.services import ExecutorService [as 别名]
# 或者: from ydk.services.ExecutorService import execute_rpc [as 别名]
                        help="NETCONF device (ssh://user:[email protected]:port)")
    args = parser.parse_args()
    device = urlparse(args.device)

    # log debug messages if verbose argument specified
    if args.verbose:
        logger = logging.getLogger("ydk")
        logger.setLevel(logging.INFO)
        handler = logging.StreamHandler()
        formatter = logging.Formatter(("%(asctime)s - %(name)s - "
                                      "%(levelname)s - %(message)s"))
        handler.setFormatter(formatter)
        logger.addHandler(handler)

    # create NETCONF provider
    provider = NetconfServiceProvider(address=device.hostname,
                                      port=device.port,
                                      username=device.username,
                                      password=device.password,
                                      protocol=device.scheme)
    # create executor service
    executor = ExecutorService()

    sonet_path_status = xr_snmp_test_trap_act.SonetPathStatus()  # create object

    # execute RPC on NETCONF device
    executor.execute_rpc(provider, sonet_path_status)

    exit()
# End of script