def __init__(self):
DEVICE.__init__(self)
self.sreader = asyncio.StreamReader(self.uart)
self.swriter = asyncio.StreamWriter(self.uart, {})
self.data = b''
self.prompt_timeout = self.config['Ctd']['Prompt_Timeout']
self.warmup_interval = self.config['Warmup_Interval']
def __init__(self):
DEVICE.__init__(self)
self.sreader = asyncio.StreamReader(self.uart)
self.swriter = asyncio.StreamWriter(self.uart, {})
self.data = b''
self.warmup_interval = self.config['Warmup_Interval']
self.fix = None
self.fixed = timesync
self.displacement = 0
def __init__(self):
DEVICE.__init__(self)
self.sreader = asyncio.StreamReader(self.uart)
self.swriter = asyncio.StreamWriter(self.uart, {})
self.data = b''
self.break_timeout = self.config['Adcp']['Break_Timeout']
self.instrument_config = self.config['Adcp']['Instrument_Config']
self.deployment_config = self.config['Adcp']['Deployment_Config']
self.deployment_delay = self.config['Adcp']['Deployment_Delay']
def __init__(self):
DEVICE.__init__(self)
self.sreader = asyncio.StreamReader(self.uart)
self.swriter = asyncio.StreamWriter(self.uart, {})
self.data = b''
self.warmup_interval = self.config['Warmup_Interval']
self.data_length = self.config['Data_Length']
self.string_label = self.config['String_Label']
self.records = 0
def __init__(self, *args, **kwargs):
self.config_file = __name__ + "." + constants.CONFIG_TYPE
DEVICE.__init__(self, *args, **kwargs)
data_tasks = ["log"]
if "tasks" in kwargs:
if any(elem in data_tasks for elem in kwargs["tasks"]):
if self.main():
for task in kwargs["tasks"]:
eval("self." + task + "()", {"self": self})
else:
for task in kwargs["tasks"]:
eval("self." + task + "()", {"self": self})
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE()
self._device.register(self._ets)
self._device.weave(self._ets)
if printGroat:
Logger().info(self._ets.getGrOAT("gad"))
Logger().info(self._ets.getGrOAT("go"))
self._device.init()
def get_interface_list(_id: str = "",
name: str = "",
dynamic: str = "",
include: str = "",
exclude: str = "",
builtin: str = "",
comment: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"dynamic": dynamic,
"include": include,
"exclude": exclude,
"builtin": builtin,
"comment": comment
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "list")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_bridge_vlan(_id: str = "",
bridge: str = "",
vlan_ids: str = "",
tagged: str = "",
untagged: str = "",
current_tagged: str = "",
current_untagged: str = "",
dynamic: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"bridge": bridge,
"vlan-ids": vlan_ids,
"tagged": tagged,
"untagged": untagged,
"current-tagged": current_tagged,
"current-untagged": current_untagged,
"dynamic": dynamic,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bridge", "vlan")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_bridge_msti(_id: str = "",
identifier: str = "",
bridge: str = "",
priority: str = "",
vlan_mapping: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"identifier": identifier,
"bridge": bridge,
"priority": priority,
"vlan-mapping": vlan_mapping,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bridge", "msti")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface(_id: str = "",
name: str = "",
default_name: str = "",
_type: str = "",
mtu: str = "",
actual_mtu: str = "",
l2mtu: str = "",
max_l2mtu: str = "",
mac_address: str = "",
last_link_up_time: str = "",
link_downs: str = "",
rx_byte: str = "",
tx_byte: str = "",
rx_packet: str = "",
tx_packet: str = "",
tx_queue_drop: str = "",
fp_rx_byte: str = "",
fp_tx_byte: str = "",
fp_rx_packet: str = "",
fp_tx_packet: str = "",
running: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"default-name": default_name,
"type": _type,
"mtu": mtu,
"actual-mtu": actual_mtu,
"l2mtu": l2mtu,
"max-l2mtu": max_l2mtu,
"mac-address": mac_address,
"last-link-up-time": last_link_up_time,
"link-downs": link_downs,
"rx-byte": rx_byte,
"tx-byte": tx_byte,
"rx-packet": rx_packet,
"tx-packet": tx_packet,
"tx-queue-drop": tx_queue_drop,
"fp-rx-byte": fp_rx_byte,
"fp-tx-byte": fp_tx_byte,
"fp-rx-packet": fp_rx_packet,
"fp-tx-packet": fp_tx_packet,
"running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def startAllDevices():
print 'Starting DEVICE Mapping..'
tenant_deviceIdsList = TENANT().getDevicesIds(BASE_URL, session)
deviceInstanceList = []
# Instantiate device objects then set device credentials
for i in range(0, len(tenant_deviceIdsList)):
deviceInstance = DEVICE(BASE_URL, session, tenant_deviceIdsList[i])
deviceInstanceList.append(deviceInstance)
print 'Device ' + str(i + 1) + ' mapped.'
print 'Finished mapping devices.'
return deviceInstanceList
def get_interface_bonding(_id: str = "",
name: str = "",
mtu: str = "",
mac_address: str = "",
arp: str = "",
arp_timeout: str = "",
slaves: str = "",
mode: str = "",
primary: str = "",
link_monitoring: str = "",
arp_interval: str = "",
arp_ip_targets: str = "",
mii_interval: str = "",
down_delay: str = "",
up_delay: str = "",
lacp_rate: str = "",
transmit_hash_policy: str = "",
min_links: str = "",
running: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"mtu": mtu,
"mac-address": mac_address,
"arp": arp,
"arp-timeout": arp_timeout,
"slaves": slaves,
"mode": mode,
"primary": primary,
"link-monitoring": link_monitoring,
"arp-interval": arp_interval,
"arp-ip-targets": arp_ip_targets,
"mii-interval": mii_interval,
"down-delay": down_delay,
"up-delay": up_delay,
"lacp-rate": lacp_rate,
"transmit-hash-policy": transmit_hash_policy,
"min-links": min_links,
"running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bonding")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE(self.ets, self._deviceIndAddr)
self.ets.register(self._device)
if printGroat:
logger.info(ets.getGrOAT(self._device, "gad"))
logger.info(ets.getGrOAT(self._device, "go"))
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE(self._deviceIndAddr)
ETS().register(self._device)
ETS().weave(self._device)
if printGroat:
Logger().info(ETS().getGrOAT(self._device, "gad"))
Logger().info(ETS().getGrOAT(self._device, "go"))
def __init__(self):
DEVICE.__init__(self)
self.sreader = asyncio.StreamReader(self.uart)
self.swriter = asyncio.StreamWriter(self.uart, {})
self.data = b''
self.semaphore = Semaphore() # Data/Sms semaphore.
self.disconnect = disconnect
self.at_timeout = self.config['Modem']['At_Timeout']
self.init_ats = self.config['Modem']['Init_Ats']
self.init_timeout = self.config['Modem']['Init_Timeout']
self.call_ats = self.config['Modem']['Call_Ats']
self.hangup_ats = self.config['Modem']['Hangup_Ats']
self.at_delay = self.config['Modem']['At_Delay']
self.call_attempt = self.config['Modem']['Call_Attempt']
self.call_delay = self.config['Modem']['Call_Delay']
self.call_timeout = self.config['Modem']['Call_Timeout']
self.ymodem_delay = self.config['Modem']['Ymodem_Delay']
self.keep_alive = self.config['Modem']['Keep_Alive']
self.sms_ats1 = self.config['Modem']['Sms_Ats1']
self.sms_ats2 = self.config['Modem']['Sms_Ats2']
self.sms_timeout = self.config['Modem']['Sms_Timeout']
self.trigger = trigger
YMODEM.__init__(self, self.agetc, self.aputc)
def get_interface_vrrp(_id: str = "",
name: str = "",
mtu: str = "",
mac_address: str = "",
arp: str = "",
arp_timeout: str = "",
interface: str = "",
vrid: str = "",
priority: str = "",
interval: str = "",
preemption_mode: str = "",
authentication: str = "",
password: str = "",
on_backup: str = "",
on_master: str = "",
version: str = "",
v3_protocol: str = "",
invalid: str = "",
running: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"mtu": mtu,
"mac-address": mac_address,
"arp": arp,
"arp-timeout": arp_timeout,
"interface": interface,
"vrid": vrid,
"priority": priority,
"interval": interval,
"preemption-mode": preemption_mode,
"v3-protocol": v3_protocol,
"invalid": invalid,
"running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "vrrp")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE()
self._device.register(self._ets)
self._device.weave(self._ets)
if printGroat:
Logger().info(self._ets.getGrOAT("gad"))
Logger().info(self._ets.getGrOAT("go"))
self._device.init()
def get_interface_bridge(_id: str = "",
name: str = "",
mtu: str = "",
actual_mtu: str = "",
l2mtu: str = "",
arp: str = "",
arp_timeout: str = "",
mac_address: str = "",
protocol_mode: str = "",
fast_forward: str = "",
igmp_snooping: str = "",
auto_mac: str = "",
ageing_time: str = "",
vlan_filtering: str = "",
dhcp_snooping: str = "",
running: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"mtu": mtu,
"actual-mtu": actual_mtu,
"l2mtu": l2mtu,
"arp": arp,
"arp-timeout": arp_timeout,
"mac-address": mac_address,
"protocol-mode": protocol_mode,
"fast-forward": fast_forward,
"igmp-snooping": igmp_snooping,
"auto-mac": auto_mac,
"ageing-time": ageing_time,
"vlan-filtering": vlan_filtering,
"dhcp-snooping": dhcp_snooping,
"running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bridge")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_wireless_access_list(_id: str = "",
mac_address: str = "",
interface: str = "",
signal_range: str = "",
allow_signal_out_of_range: str = "",
authentication: str = "",
forwarding: str = "",
ap_tx_limit: str = "",
client_tx_limit: str = "",
private_algo: str = "",
private_key: str = "",
private_pre_shared_key: str = "",
management_protection_key: str = "",
vlan_mode: str = "",
vlan_id: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"mac-address": mac_address,
"interface": interface,
"signal-range": signal_range,
"allow-signal-out-of-range": allow_signal_out_of_range,
"authentication": authentication,
"forwarding": forwarding,
"ap-tx-limit": ap_tx_limit,
"client-tx-limit": client_tx_limit,
"private-algo": private_algo,
"private-key": private_key,
"private-pre-shared-key": private_pre_shared_key,
"management-protection-key": management_protection_key,
"vlan-mode": vlan_mode,
"vlan-id": vlan_id,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "wireless", "access-list")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
class MODEM(DEVICE, YMODEM):
def __init__(self, , *args, **kwargs):
self.config_file = __name__ + "." + constants.CONFIG_TYPE
DEVICE.__init__(self, *args, **kwargs)
self.sending = False
self.connected = False
self.sent = False
self.received = False
self.timeout = 1
self.file_paths = []
self.unsent_files = utils.unsent_files
self.pre_ats = self.config["Modem"]["Pre_Ats"]
self.post_ats = self.config["Modem"]["Post_Ats"]
self.ats_delay = self.config["Modem"]["Ats_Delay"]
self.call_attempt = self.config["Modem"]["Call_Attempt"]
self.call_delay = self.config["Modem"]["Call_Delay"]
self.call_timeout = self.config["Modem"]["Call_Timeout"]
YMODEM.__init__(self, self._getc, self._putc, mode="Ymodem1k")
def get_interface_bridge_host(
_id: str = "", mac_address: str = "", interface: str = "", bridge: str = "", on_interface: str = "",
age: str = "", invalid: str = "", dynamic: str = "", local: str = "", external: str = "", disabled: str = ""
):
try:
filters_dict = {
".id": _id, "mac-address": mac_address, "interface": interface, "bridge": bridge,
"on-interface": on_interface, "age": age, "invalid": invalid, "dynamic": dynamic, "local": local,
"external": external, "disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bridge", "host")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_ipip(_id: str = "",
name: str = "",
mtu: str = "",
actual_mtu: str = "",
local_address: str = "",
remote_address: str = "",
current_remote_address: str = "",
keepalive: str = "",
dscp: str = "",
clamp_tcp_mss: str = "",
dont_fragment: str = "",
allow_fast_path: str = "",
running: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"name": name,
"mtu": mtu,
"actual-mtu": actual_mtu,
"local-address": local_address,
"remote-address": remote_address,
"current-remote-address": current_remote_address,
"keepalive": keepalive,
"dscp": dscp,
"clamp-tcp-mss": clamp_tcp_mss,
"dont-fragment": dont_fragment,
"allow-fast-path": allow_fast_path,
"running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "ipip")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_wireless_registration_table(
_id: str = "", interface: str = "", radio_name: str = "", mac_address: str = "", ap: str = "", wds: str = "",
bridge: str = "", rx_rate: str = "", tx_rate: str = "", packets: str = "", bytes: str = "", frames: str = "",
frame_bytes: str = "", hw_frames: str = "", hw_frame_bytes: str = "", tx_frames_timed_out: str = "",
uptime: str = "", last_activity: str = "", signal_strength: str = "", signal_to_noise: str = "",
signal_strength_ch0: str = "", signal_strength_ch1: str = "", tx_signal_strength_ch0: str = "",
tx_signal_strength_ch1: str = "", strength_at_rates: str = "", tx_signal_strength: str = "", tx_ccq: str = "",
rx_ccq: str = "", p_throughput: str = "", nstreme: str = "", framing_mode: str = "", routeros_version: str = "",
last_ip: str = "", ap_tx_limit: str = "", client_tx_limit: str = "", _802_1x_port_enabled: str = "",
authentication_type: str = "", encryption: str = "", group_encryption: str = "", management_protection: str = "",
compression: str = "", wmm_enabled: str = "", tx_rate_set: str = ""
):
try:
filters_dict = {
".id": _id, "interface": interface, "radio-name": radio_name, "mac-address": mac_address, "ap": ap, "wds": wds,
"bridge": bridge, "rx-rate": rx_rate, "tx-rate": tx_rate, "packets": packets, "bytes": bytes, "frames": frames,
"frame-bytes": frame_bytes, "hw-frames": hw_frames, "hw-frame-bytes": hw_frame_bytes,
"tx-frames-timed-out": tx_frames_timed_out, "uptime": uptime, "last-activity": last_activity,
"signal-strength": signal_strength, "signal-to-noise": signal_to_noise,
"signal-strength-ch0": signal_strength_ch0, "signal-strength-ch1": signal_strength_ch1,
"tx-signal-strength-ch0": tx_signal_strength_ch0, "tx-signal-strength-ch1": tx_signal_strength_ch1,
"strength-at-rates": strength_at_rates, "tx-signal-strength": tx_signal_strength,
"tx-ccq": tx_ccq, "rx-ccq": rx_ccq, "p-throughput": p_throughput, "nstreme": nstreme, "framing-mode": framing_mode,
"routeros-version": routeros_version, "last-ip": last_ip, "ap-tx-limit": ap_tx_limit,
"client-tx-limit": client_tx_limit, "802.1x-port-enabled": _802_1x_port_enabled,
"authentication-type": authentication_type, "encryption": encryption, "group-encryption": group_encryption,
"management-protection": management_protection, "compression": compression, "wmm-enabled": wmm_enabled,
"tx-rate-set": tx_rate_set
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "wireless", "registration-table")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def get_interface_list_member(_id: str = "",
_list: str = "",
interface: str = "",
dynamic: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
"list": _list,
"interface": interface,
"dynamic": dynamic,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "list", "member")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
class DeviceRunner(object):
"""
"""
def __init__(self, loggerLevel, devicePath, mapPath):
"""
"""
super(DeviceRunner, self).__init__()
sys.path.insert(0, devicePath)
# Load user 'settings' module
from settings import DEVICE_NAME, DEVICE_IND_ADDR
# Init the logger
# DO NOT USE LOGGER BEFORE THIS POINT!
if loggerLevel is not None:
config.LOGGER_LEVEL = loggerLevel
Logger("%s-%s" % (DEVICE_NAME, DEVICE_IND_ADDR), config.LOGGER_LEVEL)
Logger().info("Logger level is '%s'" % config.LOGGER_LEVEL)
Logger().info("Device path is '%s'" % devicePath)
Logger().info("Device name is '%s'" % DEVICE_NAME)
deviceIndAddr = DEVICE_IND_ADDR
if not isinstance(deviceIndAddr, IndividualAddress):
deviceIndAddr = IndividualAddress(deviceIndAddr)
if deviceIndAddr.isNull:
Logger().warning("Device Individual Address is null")
else:
Logger().info("Device Individual Address is '%s'" % DEVICE_IND_ADDR)
# Retreive 'map' module
GAD_MAP = {}
if mapPath != "$PKNYX_MAP_PATH":
if os.path.exists(mapPath):
# Load 'map' module from mapPath
try:
fp, pathname, description = imp.find_module('map', mapPath)
except ImportError:
Logger().critical("Can't find 'map' module in %s" % mapPath)
sys.exit(1)
try:
mapModule = imp.load_module("map", fp, pathname, description)
finally:
if fp:
fp.close()
GAD_MAP = mapModule.GAD_MAP
else:
Logger().warning("Specified map path does not exists (%s)" % mapPath)
# Create KNX stack
self._stack = Stack(DEVICE_IND_ADDR)
self._ets = ETS(self._stack, gadMap=GAD_MAP)
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE()
self._device.register(self._ets)
self._device.weave(self._ets)
if printGroat:
Logger().info(self._ets.getGrOAT("gad"))
Logger().info(self._ets.getGrOAT("go"))
self._device.init()
def run(self, detach):
"""
"""
Logger().trace("Device.run()")
self.check()
Logger().info("Detaching is '%s'" % detach)
Scheduler().start()
self._stack.mainLoop() # blocking call
Scheduler().stop()
self._device.shutdown()
class DeviceRunner(object):
"""
"""
def __init__(self, loggerLevel, devicePath, gadMapPath):
"""
"""
super(DeviceRunner, self).__init__()
sys.path.insert(0, devicePath)
# Load user 'settings' module
from settings import DEVICE_NAME, DEVICE_IND_ADDR
# Init the logger
if loggerLevel is not None:
config.LOGGER_LEVEL = loggerLevel
# DO NOT USE LOGGER BEFORE THIS POINT!
Logger("%s-%s" % (DEVICE_NAME, DEVICE_IND_ADDR))
Logger().info("Logger level is '%s'" % config.LOGGER_LEVEL)
Logger().info("Device path is '%s'" % devicePath)
Logger().info("Device name is '%s'" % DEVICE_NAME)
self._deviceIndAddr = DEVICE_IND_ADDR
if not isinstance(self._deviceIndAddr, IndividualAddress):
self._deviceIndAddr = IndividualAddress(self._deviceIndAddr)
if self._deviceIndAddr.isNull:
Logger().warning("Device Individual Address is null")
else:
Logger().info("Device Individual Address is '%s'" % self._deviceIndAddr)
# Load GAD map table
mapper = GroupAddressTableMapper()
mapper.loadFrom(gadMapPath)
def _doubleFork(self):
""" Double fork.
"""
if os.fork() != 0: # launch child and ...
os._exit(0) # kill off parent
os.setsid()
os.chdir("/")
os.umask(0)
if os.fork() != 0: # fork again so we are not a session leader
os._exit(0)
# Close stdxxx
sys.stdin.close()
sys.__stdin__ = sys.stdin
sys.stdout.close()
sys.stdout = sys.__stdout__ = _NullDevice()
sys.stderr.close()
sys.stderr = sys.__stderr__ = _NullDevice()
# ??? does not work if enable
#for fd in xrange(4, 1024):
#try:
#os.close(fd)
#except OSError:
#pass
def check(self, printGroat=False):
"""
"""
# Create device from user 'device' module
from device import DEVICE
self._device = DEVICE(self._deviceIndAddr)
ETS().register(self._device)
ETS().weave(self._device)
if printGroat:
Logger().info(ETS().getGrOAT(self._device, "gad"))
Logger().info(ETS().getGrOAT(self._device, "go"))
def run(self, dameon=False):
"""
"""
Logger().trace("Device.run()")
self.check()
if dameon:
Logger().info("Run process as daemon...")
self._doubleFork()
self._device.start()
Scheduler().start()
time.sleep(1) # wait for things to start
try:
self._device.mainLoop()
except KeyboardInterrupt:
Logger().warning("Device execution canceled (SIGTERM)")
except:
Logger().exception("deviceRunner.run()")
finally:
Scheduler().stop()
self._device.stop()
self._device.shutdown()
def get_interface_wireless(
_id: str = "", default_name: str = "", name: str = "", mtu: str = "", l2mtu: str = "", mac_address: str = "",
arp: str = "", arp_timeout: str = "", disable_running_check: str = "", interface_type: str = "",
radio_name: str = "", mode: str = "", ssid: str = "", area: str = "", frequency_mode: str = "",
country: str = "", installation: str = "", antenna_gain: str = "", frequency: str = "", band: str = "",
channel_width: str = "", secondary_channel: str = "", scan_list: str = "", wireless_protocol: str = "",
rate_set: str = "", supported_rates_ag: str = "", max_station_count: str = "", distance: str = "",
tx_power_mode: str = "", noise_floor_threshold: str = "", nv2_noise_floor_offset: str = "",
vlan_mode: str = "", vlan_id: str = "", wds_mode: str = "", wds_default_bridge: str = "",
wds_default_cost: str = "", wds_cost_range: str = "", wds_ignore_ssid: str = "",
update_stats_interval: str = "", bridge_mode: str = "", default_authentication: str = "",
default_forwarding: str = "", default_ap_tx_limit: str = "", default_client_tx_limit: str = "",
wmm_support: str = "", hide_ssid: str = "", security_profile: str = "", interworking_profile: str = "",
wps_mode: str = "", station_roaming: str = "", disconnect_timeout: str = "", on_fail_retry_time: str = "",
preamble_mode: str = "", compression: str = "", allow_sharedkey: str = "", station_bridge_clone_mac: str = "",
ampdu_priorities: str = "", guard_interval: str = "", ht_supported_mcs: str = "", ht_basic_mcs: str = "",
tx_chains: str = "", rx_chains: str = "", amsdu_limit: str = "", amsdu_threshold: str = "",
tdma_period_size: str = "", nv2_queue_count: str = "", nv2_qos: str = "", nv2_cell_radius: str = "",
nv2_security: str = "", nv2_preshared_key: str = "", nv2_mode: str = "", nv2_downlink_ratio: str = "",
nv2_sync_secret: str = "", hw_retries: str = "", frame_lifetime: str = "", adaptive_noise_immunity: str = "",
hw_fragmentation_threshold: str = "", hw_protection_mode: str = "", hw_protection_threshold: str = "",
frequency_offset: str = "", rate_selection: str = "", multicast_helper: str = "", multicast_buffering: str = "",
keepalive_frames: str = "", skip_dfs_channels: str = "", running: str = "", disabled: str = ""
):
try:
filters_dict = {
".id": _id, "default-name": default_name, "name": name, "mtu": mtu, "l2mtu": l2mtu,
"mac-address": mac_address, "arp": arp, "arp-timeout": arp_timeout,
"disable-running-check": disable_running_check, "interface-type": interface_type,
"radio-name": radio_name, "mode": mode, "ssid": ssid, "frequency-mode": frequency_mode,
"country": country, "installation": installation, "antenna-gain": antenna_gain, "frequency": frequency,
"band": band, "channel-width": channel_width, "secondary-channel": secondary_channel,
"scan-list": scan_list, "wireless-protocol": wireless_protocol, "rate-set": rate_set,
"supported-rates-a/g": supported_rates_ag, "max-station-count": max_station_count,
"distance": distance, "tx-power-mode": tx_power_mode, "noise-floor-threshold": noise_floor_threshold,
"nv2-noise-floor-offset": nv2_noise_floor_offset, "vlan-mode": vlan_mode, "vlan-id": vlan_id,
"wds-mode": wds_mode, "wds-default-bridge": wds_default_bridge, "wds-default-cost": wds_default_cost,
"wds-cost-range": wds_cost_range, "wds-ignore-ssid": wds_ignore_ssid,
"update-stats-interval": update_stats_interval, "bridge-mode": bridge_mode,
"default-authentication": default_authentication, "default-forwarding": default_forwarding,
"default-ap-tx-limit": default_ap_tx_limit, "default-client-tx-limit": default_client_tx_limit,
"wmm-support": wmm_support, "hide-ssid": hide_ssid, "security-profile": security_profile,
"interworking-profile": interworking_profile, "wps-mode": wps_mode, "station-roaming": station_roaming,
"disconnect-timeout": disconnect_timeout, "on-fail-retry-time": on_fail_retry_time,
"preamble-mode": preamble_mode, "compression": compression, "allow-sharedkey": allow_sharedkey,
"station-bridge-clone-mac": station_bridge_clone_mac, "ampdu-priorities": ampdu_priorities,
"guard-interval": guard_interval, "ht-supported-mcs": ht_supported_mcs, "ht-basic-mcs": ht_basic_mcs,
"tx-chains": tx_chains, "rx-chains": rx_chains, "amsdu-limit": amsdu_limit, "amsdu-threshold": amsdu_threshold,
"tdma-period-size": tdma_period_size, "nv2-queue-count": nv2_queue_count, "nv2-qos": nv2_qos,
"nv2-cell-radius": nv2_cell_radius, "nv2-security": nv2_security, "nv2-preshared-key": nv2_preshared_key,
"nv2-mode": nv2_mode, "nv2-downlink-ratio": nv2_downlink_ratio, "nv2-sync-secret": nv2_sync_secret,
"hw-retries": hw_retries, "frame-lifetime": frame_lifetime, "adaptive-noise-immunity": adaptive_noise_immunity,
"hw-fragentation-threshold": hw_fragmentation_threshold, "hw-protection-mode": hw_protection_mode,
"hw-protection-threshold": hw_protection_threshold, "frequency-offset": frequency_offset,
"rate-selection": rate_selection, "multicast-helper": multicast_helper, "multicast-buffering": multicast_buffering,
"keepalive-frames": keepalive_frames, "skip-dfs-channels": skip_dfs_channels, "running": running,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "wireless")
#data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def startDeviceInstance(deviceID):
print 'Starting DEVICE Mapping..'
# Instantiate device object by ID and then set device credentials
deviceInstance = DEVICE(BASE_URL, session, deviceID)
print 'Finished mapping device.'
return deviceInstance
def get_interface_bridge_port(_id: str = "",
nextid: str = "",
interface: str = "",
bridge: str = "",
priority: str = "",
path_cost: str = "",
internal_path_cost: str = "",
edge: str = "",
point_to_point: str = "",
learn: str = "",
horizon: str = "",
auto_isolate: str = "",
restricted_role: str = "",
restricted_tcn: str = "",
pvid: str = "",
frame_types: str = "",
ingress_filtering: str = "",
unknown_unicast_flood: str = "",
unknown_multicast_flood: str = "",
broadcast_flood: str = "",
tag_stacking: str = "",
bpdu_guard: str = "",
trusted: str = "",
multicast_router: str = "",
fast_leave: str = "",
status: str = "",
port_number: str = "",
role: str = "",
edge_port: str = "",
edge_port_discovery: str = "",
point_to_point_port: str = "",
external_fdb_status: str = "",
sending_rstp: str = "",
learning: str = "",
forwarding: str = "",
debug_info: str = "",
inactive: str = "",
dynamic: str = "",
disabled: str = ""):
try:
filters_dict = {
".id": _id,
".nextid": nextid,
"interface": interface,
"bridge": bridge,
"priority": priority,
"path-cost": path_cost,
"internal-path-cost": internal_path_cost,
"edge": edge,
"point-to-point": point_to_point,
"learn": learn,
"frame-types": frame_types,
"ingress-filtering": ingress_filtering,
"unknown-unicast-flood": unknown_unicast_flood,
"unknown-multicast-flood": unknown_multicast_flood,
"broadcast-flood": broadcast_flood,
"tag-stacking": tag_stacking,
"bpdu-guard": bpdu_guard,
"trusted": trusted,
"multicast-router": multicast_router,
"fast-leave": fast_leave,
"status": status,
"port-number": port_number,
"role": role,
"edge-port": edge_port,
"edge-port-discovery": edge_port_discovery,
"point-to-point-port": point_to_point_port,
"external-fdb-status": external_fdb_status,
"sending-rstp": sending_rstp,
"learning": learning,
"forwarding": forwarding,
"debug-info": debug_info,
"inactive": inactive,
"dynamic": dynamic,
"disabled": disabled
}
filters_list = get_filters_list(filters_dict=filters_dict)
data = DEVICE.path("interface", "bridge", "port")
data = data.select(*filters_dict.keys()).where(*filters_list)
return tuple(data)
except Exception as e:
return {"error": e}
def __init__(self):
DEVICE.__init__(self)