def validate_community_list(value):
if not isinstance(value, list):
raise SchemaError('snmp community is not a list')
def validate_clients_list(value):
if not isinstance(value, list):
raise SchemaError('snmp clients is not a list')
snmp_clients_schema = Schema({
"name": str,
Optional("restrict"): bool
})
# Validate each dictionary in list
for item in value:
snmp_clients_schema.validate(item)
return value
snmp_community_schema = Schema({
"name": str,
"authorization": str,
"clients": Use(validate_clients_list),
})
# Validate each dictionary in list
for item in value:
snmp_community_schema.validate(item)
return value
def validate_neighbor_list(value):
if not isinstance(value, list):
raise SchemaError('RSVP Neighbor not a list')
rsvp_neighbor_list = Schema({
"rsvp-neighbor-address": str,
Optional("rsvp-neighbor-interface"): str,
"rsvp-neighbor-status": str,
Optional("rsvp-neighbor-node"): bool,
"last-changed-time": str,
"neighbor-idle": str,
"neighbor-up-count": str,
"neighbor-down-count": str,
"messages-received": str,
"hello-interval": str,
"hellos-sent": str,
"hellos-received": str,
"rsvp-neighbor-remote-instance": str,
"rsvp-neighbor-local-instance": str,
"rsvp-refresh-reduct-status": str,
"rsvp-refresh-reduct-remote-status": str,
"rsvp-refresh-reduct-ack-status": str,
"rsvp-nbr-enh-local-protection": {
"rsvp-nbr-enh-lp-status": str,
Optional("rsvp-nbr-enh-lp-total-lsp-count"): str,
Optional("rsvp-nbr-enh-lp-phop-lsp-count"): str,
Optional("rsvp-nbr-enh-lp-pphop-lsp-count"): str,
Optional("rsvp-nbr-enh-lp-nhop-lsp-count"): str,
Optional("rsvp-nbr-enh-lp-nnhop-lsp-count"): str,
}
})
for item in value:
rsvp_neighbor_list.validate(item)
return value
def validate_ddos_instance_list(value):
# Pass ddos instance list
if not isinstance(value, list):
raise SchemaError('ddos-instance is not a list')
ddos_instance_schema = Schema({
Optional("@junos:style"): str,
"ddos-instance-parameters": {
Optional("@junos:style"): str,
Optional("hostbound-queue"): str,
"policer-bandwidth": str,
Optional("policer-bandwidth-scale"): str,
"policer-burst": str,
Optional("policer-burst-scale"): str,
Optional("policer-enable"): str
},
"ddos-instance-statistics": {
Optional("@junos:style"): str,
"packet-arrival-rate": str,
"packet-arrival-rate-max": str,
"packet-dropped": str,
"packet-received": str
},
"protocol-states-locale": str
})
# Validate each dictionary in list
for item in value:
ddos_instance_schema.validate(item)
return value
def validate_route_table_data(value):
if not isinstance(value, list):
raise SchemaError('validate_route_table_data is not a list')
entry_schema = Schema({'index': str, 'routes': str, 'size': str})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
def validate_ldp_binding(value):
if not isinstance(value, list):
raise SchemaError('LDP binding is not a list')
ldp_binding = Schema({"ldp-label": str, "ldp-prefix": str})
for item in value:
ldp_binding.validate(item)
return value
def validate_krt_queue_list(value):
# Pass ospf3-interface list as value
if not isinstance(value, list):
raise SchemaError('ospf-interface is not a list')
krt_queue_schema = Schema({"krtq-queue-length": str, "krtq-type": str})
# Validate each dictionary in list
for item in value:
krt_queue_schema.validate(item)
return value
def validate_explicit_route(value):
if not isinstance(value, list):
raise SchemaError('Explicit route is not a list')
explicit_route = Schema({
"address": str,
})
for item in value:
explicit_route.validate(item)
return value
def validate_categories_or_targets_list(value):
if not isinstance(value, list):
raise SchemaError('snmp categories is not a list')
snmp_categories_or_targets_schema = Schema({
"name": str,
})
# Validate each dictionary in list
for item in value:
snmp_categories_or_targets_schema.validate(item)
return value
def validate_record_route(value):
if not isinstance(value, list):
raise SchemaError('Record route is not a list')
record_route = Schema({
"address": str,
})
for item in value:
record_route.validate(item)
return value
def validate_server_list(value):
# Pass server list of dict in value
if not isinstance(value, list):
raise SchemaError('server list is not a list')
# Create server list Schema
servers = Schema({
'name': str,
})
# Validate each dictionary in list
for item in value:
servers.validate(item)
return value
def validate_path_list_schema(value):
if not isinstance(value, list):
raise SchemaError('path list schema is not a list')
path_list_schema = Schema({
'name': str,
'type': str,
})
for item in value:
path_list_schema.validate(item)
return value
def validate_package_information_list(value):
# Pass ospf3-interface list as value
if not isinstance(value, list):
raise SchemaError('package_information is not a list')
package_information_schema = Schema({
"comment": str,
"name": str
})
# Validate each dictionary in list
for item in value:
package_information_schema.validate(item)
return value
def validate_counter_list(value):
# Pass firmware list as value
if not isinstance(value, list):
raise SchemaError('counter is not a list')
counter_inner_schema = Schema({
"byte-count": str,
"counter-name": str,
"packet-count": str
})
# Validate each dictionary in list
for item in value:
counter_inner_schema.validate(item)
return value
def validate_snmp_object_list(value):
if not isinstance(value, list):
raise SchemaError('snmp-object is not a list')
snmp_object_schema = Schema({
"name": str,
"object-value": str,
Optional("object-value-type"): str,
Optional("oid"): str
})
# Validate each dictionary in list
for item in value:
snmp_object_schema.validate(item)
return value
def validate_lag_lacp_protocol_list(value):
if not isinstance(value, list):
raise SchemaError('lag-lacp-protocol is not a list')
entry_schema = Schema({
"lacp-mux-state": str,
"lacp-receive-state": str,
"lacp-transmit-state": str,
"name": str
})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
def lag_lacp_statistics_list(value):
if not isinstance(value, list):
raise SchemaError('lag-lacp-statistics is not a list')
entry_schema = Schema({
"illegal-rx-packets": str,
"lacp-rx-packets": str,
"lacp-tx-packets": str,
"name": str,
"unknown-rx-packets": str,
})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
def validate_ldp_neighbor(value):
if not isinstance(value, list):
raise SchemaError('LDP neighbor is not a list')
ldp_neighbor = Schema({
"interface-name": str,
"ldp-label-space-id": str,
"ldp-neighbor-address": str,
"ldp-remaining-time": str
})
for item in value:
ldp_neighbor.validate(item)
return value
def validate_usage_information(value):
if not isinstance(value, list):
raise SchemaError('Usage information is not a list')
usage_information = Schema({
"interface-name": str,
"uptime": str,
"inttime": str,
"five-second-load": str,
"one-minute-load": str,
})
for item in value:
usage_information.validate(item)
return value
def validate_ldp_session(value):
if not isinstance(value, list):
raise SchemaError('LDP Session not a list')
ldp_session = Schema({
"ldp-neighbor-address": str,
"ldp-session-state": str,
"ldp-connection-state": str,
"ldp-remaining-time": str,
Optional("ldp-session-adv-mode"): str,
})
for item in value:
ldp_session.validate(item)
return value
def validate_filter_information_list(value):
if not isinstance(value, list):
raise SchemaError('filter-information is not a list')
filter_schema = Schema({
Optional("counter"): Use(ShowFirewall.validate_counter_list),
"filter-name": str,
Optional("policer"): {
"byte-count": str,
"packet-count": str,
"policer-name": str
}
})
for item in value:
filter_schema.validate(item)
return value
def validate_arp_table_entry_list(value):
# Pass arp-entry list of dict in value
if not isinstance(value, list):
raise SchemaError('arp-table-entry is not a list')
# Create Arp Entry Schema
entry_schema = Schema({
"arp-table-entry-flags": str,
"interface-name": str,
"ip-address": str,
"mac-address": str
})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
def validate_hops_list(value):
# Pass hops list of dict in value
if not isinstance(value, list):
raise SchemaError('hops is not a list')
# Create hop Schema
hop_schema = Schema({
"hop-number": str,
Optional("router-name"): str,
"address": str,
"round-trip-time": str
})
# Validate each dictionary in list
for item in value:
hop_schema.validate(item)
return value
def validate_log_information_list(value):
if not isinstance(value, list):
raise SchemaError('log-information is not a list')
log_schema = Schema({
"action-name": str,
"destination-address": str,
"filter-name": str,
"interface-name": str,
"protocol-name": str,
"source-address": str,
"time": str
})
for item in value:
log_schema.validate(item)
return value
def validate_error_information(value):
if not isinstance(value, list):
raise SchemaError('Error information is not a list')
error_information = Schema({
"interface-name": str,
"service-set-dropped": str,
"active-timeout-failures": str,
"export-packet-failures": str,
"flow-creation-failures": str,
"memory-overload": str,
})
for item in value:
error_information.validate(item)
return value
def validate_bfd_session(value):
if not isinstance(value, list):
raise SchemaError('BFD Session not a list')
bfd_session = Schema({
"session-neighbor": str,
"session-state": str,
Optional("session-interface"): str,
"session-detection-time": str,
"session-transmission-interval": str,
"session-adaptive-multiplier": str,
})
for item in value:
bfd_session.validate(item)
return value
def validate_ted_link(val):
''' Validates each value in ted link '''
if not isinstance(val, list):
raise SchemaError('ted link is not a list')
ted_link_schema = Schema({
"ted-link-local-address": str,
"ted-link-local-ifindex": str,
"ted-link-protocol": str,
"ted-link-remote-address": str,
"ted-link-remote-ifindex": str,
"ted-link-to": str
})
for item in val:
ted_link_schema.validate(item)
return val
def validate_memory_information(value):
if not isinstance(value, list):
raise SchemaError('Memory information is not a list')
memory_information = Schema({
"interface-name": str,
"allocation-count": str,
"free-count": str,
"allocations-per-second": str,
"frees-per-second": str,
"memory-used": str,
"memory-free": str,
"v9-memory-used": str,
})
for item in value:
memory_information.validate(item)
return value
def validate_ipv6_entry_list(value):
# Pass arp-entry list of dict in value
if not isinstance(value, list):
raise SchemaError('ipv6-entry is not a list')
# Create Arp Entry Schema
entry_schema = Schema({
"ipv6-nd-expire": str,
"ipv6-nd-interface-name": str,
"ipv6-nd-isrouter": str,
"ipv6-nd-issecure": str,
"ipv6-nd-neighbor-address": str,
"ipv6-nd-neighbor-l2-address": str,
"ipv6-nd-state": str
})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
def validate_status_information(value):
if not isinstance(value, list):
raise SchemaError('Status information is not a list')
status_information = Schema({
"interface-name": str,
"status-export-format": str,
"status-route-record-count": str,
"status-ifl-snmp-map-count": str,
"status-as-count": str,
"status-monitor-config-set": str,
"status-monitor-route-record-set": str,
"status-monitor-ifl-snmp-set": str,
})
for item in value:
status_information.validate(item)
return value
def validate_lag_lacp_state_list(value):
if not isinstance(value, list):
raise SchemaError('lag-lacp-state is not a list')
entry_schema = Schema({
"lacp-activity": str,
"lacp-aggregation": str,
"lacp-collecting": str,
"lacp-defaulted": str,
"lacp-distributing": str,
"lacp-expired": str,
"lacp-role": str,
"lacp-synchronization": str,
"lacp-timeout": str,
"name": str
})
# Validate each dictionary in list
for item in value:
entry_schema.validate(item)
return value
