def connect(self): try: self.omapi = Omapi(self.module.params['host'], self.module.params['port'], self.module.params['key_name'], self.module.params['key']) except socket.error: e = get_exception() self.module.fail_json(msg="Unable to connect to OMAPI server: %s" % e)
def __init__(self, omapi_key: str, ipv6: bool = False): self._omapi = Omapi( "127.0.0.1", 7912 if ipv6 else 7911, b"omapi_key", omapi_key.encode("ascii"), )
def connect(self): try: self.omapi = Omapi(self.module.params['host'], self.module.params['port'], self.module.params['key_name'], self.module.params['key']) except binascii.Error: self.module.fail_json(msg="Unable to open OMAPI connection. 'key' is not a valid base64 key.") except OmapiError as e: self.module.fail_json(msg="Unable to open OMAPI connection. Ensure 'host', 'port', 'key' and 'key_name' " "are valid. Exception was: %s" % to_native(e)) except socket.error as e: self.module.fail_json(msg="Unable to connect to OMAPI server: %s" % to_native(e))
def connect(self): try: self.omapi = Omapi(self.module.params['host'], self.module.params['port'], self.module.params['key_name'], self.module.params['key']) except binascii.Error: self.module.fail_json(msg="Unable to open OMAPI connection. 'key' is not a valid base64 key.") except OmapiError as e: self.module.fail_json(msg="Unable to open OMAPI connection. Ensure 'host', 'port', 'key' and 'key_name' " "are valid. Exception was: %s" % to_native(e)) except socket.error as e: self.module.fail_json(msg="Unable to connect to OMAPI server: %s" % to_native(e))
class OmapiClient: """Client for the DHCP OMAPI.""" def __init__(self, omapi_key: str, ipv6: bool = False): self._omapi = Omapi( "127.0.0.1", 7912 if ipv6 else 7911, b"omapi_key", omapi_key.encode("ascii"), ) def add_host(self, mac: str, ip: str): """Add a host mapping for a MAC.""" name = self._name_from_mac(mac) self._omapi.add_host_supersede(ip, mac, name) def del_host(self, mac: str): """Remove a host mapping for a MAC.""" self._omapi.del_host(mac) def update_host(self, mac: str, ip: str): """Update a host mapping for a MAC.""" name = self._name_from_mac(mac) msg = OmapiMessage.open(b"host") msg.update_object({b"name": name}) resp = self._omapi.query_server(msg) if resp.opcode != OMAPI_OP_UPDATE: raise OmapiError(f"Host not found: {name.decode('ascii')}") msg = OmapiMessage.update(resp.handle) msg.update_object({b"ip-address": pack_ip(ip)}) resp = self._omapi.query_server(msg) if resp.opcode != OMAPI_OP_STATUS: raise OmapiError( f"Updating IP for host {name.decode('ascii')} to {ip} failed" ) def _name_from_mac(self, mac: str) -> bytes: return mac.replace(":", "-").encode("ascii")
class OmapiHostManager: def __init__(self, module): self.module = module self.omapi = None self.connect() def connect(self): try: self.omapi = Omapi(self.module.params['host'], self.module.params['port'], self.module.params['key_name'], self.module.params['key']) except socket.error: e = get_exception() self.module.fail_json(msg="Unable to connect to OMAPI server: %s" % e) def get_host(self, macaddr): msg = OmapiMessage.open(to_bytes("host", errors='surrogate_or_strict')) msg.obj.append((to_bytes("hardware-address", errors='surrogate_or_strict'), pack_mac(macaddr))) msg.obj.append((to_bytes("hardware-type", errors='surrogate_or_strict'), struct.pack("!I", 1))) response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_UPDATE: return None return response @staticmethod def unpack_facts(obj): result = dict(obj) if 'hardware-address' in result: result['hardware-address'] = unpack_mac(result['hardware-address']) if 'ip-address' in result: result['ip-address'] = unpack_ip(result['ip-address']) if 'hardware-type' in result: result['hardware-type'] = struct.unpack("!I", result['hardware-type']) return result def setup_host(self): if self.module.params['hostname'] is None or len(self.module.params['hostname']) == 0: self.module.fail_json(msg="name attribute could not be empty when adding or modifying host.") msg = None host_response = self.get_host(self.module.params['macaddr']) # If host was not found using macaddr, add create message if host_response is None: msg = OmapiMessage.open(to_bytes('host', errors='surrogate_or_strict')) msg.message.append(('create', struct.pack('!I', 1))) msg.message.append(('exclusive', struct.pack('!I', 1))) msg.obj.append(('hardware-address', pack_mac(self.module.params['macaddr']))) msg.obj.append(('hardware-type', struct.pack('!I', 1))) msg.obj.append(('name', self.module.params['hostname'])) if self.module.params['ip'] is not None: msg.obj.append((to_bytes("ip-address", errors='surrogate_or_strict'), pack_ip(self.module.params['ip']))) stmt_join = "" if self.module.params['ddns']: stmt_join += 'ddns-hostname "{0}"; '.format(self.module.params['hostname']) try: if len(self.module.params['statements']) > 0: stmt_join += "; ".join(self.module.params['statements']) stmt_join += "; " except TypeError: e = get_exception() self.module.fail_json(msg="Invalid statements found: %s" % e) if len(stmt_join) > 0: msg.obj.append(('statements', stmt_join)) try: response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_UPDATE: self.module.fail_json(msg="Failed to add host, ensure authentication and host parameters " "are valid.") self.module.exit_json(changed=True, lease=self.unpack_facts(response.obj)) except OmapiError: e = get_exception() self.module.fail_json(msg="OMAPI error: %s" % e) # Forge update message else: response_obj = self.unpack_facts(host_response.obj) fields_to_update = {} if to_bytes('ip-address', errors='surrogate_or_strict') not in response_obj or \ unpack_ip(response_obj[to_bytes('ip-address', errors='surrogate_or_strict')]) != self.module.params['ip']: fields_to_update['ip-address'] = pack_ip(self.module.params['ip']) # Name cannot be changed if 'name' not in response_obj or response_obj['name'] != self.module.params['hostname']: self.module.fail_json(msg="Changing hostname is not supported. Old was %s, new is %s. " "Please delete host and add new." % (response_obj['name'], self.module.params['hostname'])) """ # It seems statements are not returned by OMAPI, then we cannot modify them at this moment. if 'statements' not in response_obj and len(self.module.params['statements']) > 0 or \ response_obj['statements'] != self.module.params['statements']: with open('/tmp/omapi', 'w') as fb: for (k,v) in iteritems(response_obj): fb.writelines('statements: %s %s\n' % (k, v)) """ if len(fields_to_update) == 0: self.module.exit_json(changed=False, lease=response_obj) else: msg = OmapiMessage.update(host_response.handle) msg.update_object(fields_to_update) try: response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_STATUS: self.module.fail_json(msg="Failed to modify host, ensure authentication and host parameters " "are valid.") self.module.exit_json(changed=True) except OmapiError: e = get_exception() self.module.fail_json(msg="OMAPI error: %s" % e) def remove_host(self): try: self.omapi.del_host(self.module.params['macaddr']) self.module.exit_json(changed=True) except OmapiErrorNotFound: self.module.exit_json() except OmapiError: e = get_exception() self.module.fail_json(msg="OMAPI error: %s" % e)
def post_init(self, **kwargs): # Get parameters from keyword arguments skip_modules = kwargs.get("skip_modules", False) skip_network = kwargs.get("skip_network", False) skip_ap = kwargs.get("skip_ap", False) # Extra options self.sdr_dev = kwargs.get("sdr_dev", "sdr0") # self.lan_ip = kwargs.get("lan_ip", "192.168.13.1") self.lan_ip = kwargs.get("lan_ip", "10.0.0.1") # gw_ip = kwargs.get("gw_ip", "134.226.55.211") gw_dev = kwargs.get("gw_dev", "eth0") ap_config_path = kwargs.get("ap_path", "/root/openwifi/hostapd-openwifi.conf") openwifi_path = kwargs.get("openwifi_path", "/root/openwifi") # Stop Network Manager bash("service network-manager stop") self._log("Stopped Network Manager") # If loading kernel modules if not skip_modules: fpga_dev_path = "/sys/bus/iio/devices/iio:device2" filter_file = "openwifi_ad9361_fir.ftr" # Load mac80211 kernel module bash("modprobe mac80211") self._log("Loaded 'mac80211' kernel module") # If the SDR kernel module is loaded if bool(bash("lsmod | grep sdr")): # Remove SDR kernel module bash("rmmod sdr") self._log("Removed 'sdr' kernel module") # List of custom kernel modules module_list = { "first_batch": ["xilinx_dma", "tx_intf", "ad9361_drv"], "second_batch": ["rx_intf", "openofdm_tx", "openofdm_rx", "xpu", "sdr"] } # Device configuration dictionary device_config = { "first_batch": { "in_voltage_rf_bandwidth": "17500000", "out_voltage_rf_bandwidth": "37500000", "in_voltage_sampling_frequency": "40000000", "out_voltage_sampling_frequency": "40000000", "out_altvoltage0_RX_LO_frequency": "5240000000", "out_altvoltage1_TX_LO_frequency": "5250000000" }, "second_batch": { "in_voltage_filter_fir_en": "1", "out_voltage_filter_fir_en": "0", "in_voltage0_gain_control_mode": "fast_attack", "in_voltage1_gain_control_mode": "fast_attack", "in_voltage0_hardwaregain": "70", "in_voltage1_hardwaregain": "70", "out_voltage0_hardwaregain": "89", "out_voltage1_hardwaregain": "0" } } # Iterate over the first batch for submodule in module_list['first_batch']: # Check whether the module is loaded if bool(bash("lsmod | grep {0}".format(submodule))): # Removing current version of the module bash("rmmod {0}".format(submodule)) # Installing new version of the module bash("insmod {0}/{1}.ko".format(openwifi_path, submodule)) # Check installation of kernel module sleep(1) if not bash("lsmod | grep {0}".format(submodule)).code: self._log("Loaded", submodule, "kernel module") else: self._log("Not loaded", submodule, "kernel module") # Iterate over the first batch of parameters for parameter in device_config["first_batch"].keys(): # Update the parameter value bash("echo {0} > {1}/{2}".format( device_config["first_batch"][parameter], fpga_dev_path, parameter)) bash("sync") sleep(0.5) # Filter file string filter_str = "cat {0}/{1} > {2}/filter_fir_config" # Load filter response values bash(filter_str.format(openwifi_path, filter_file, fpga_dev_path)) # Iterate over the second batch of parameters for parameter in device_config["second_batch"].keys(): # Update the parameter value bash("echo {0} > {1}/{2}".format( device_config["second_batch"][parameter], fpga_dev_path, parameter)) bash("sync") sleep(0.5) # Iterate over the second batch for submodule in module_list['second_batch']: # Check whether the module is loaded if bool(bash("lsmod | grep {0}".format(submodule))): # Removing current version of the module bash("rmmod {0}".format(submodule)) # Installing new version of the module bash("insmod {0}/{1}.ko".format(openwifi_path, submodule)) sleep(1) # Check installation of kernel module if not bash("lsmod | grep {0}".format(submodule)).code: self._log("Loaded", submodule, "kernel module") # Sleep for 10 seconds and log event self._log("Waiting for configurations to take effect") sleep(10) self._log("Configured kernel modules and FPGA") # If configuring routing and networking if not skip_network: # Configure the SDR interface's IP bash("ifconfig {0} {1} netmask 255.255.255.0".format( self.sdr_dev, self.lan_ip)) self._log("Set {0} interface IP's to: {1}".format( self.sdr_dev, self.lan_ip)) # Set the default route through eth0 # bash("ip route add default via {0} dev eth0".format(gw_ip)) bash("ip route add default dev {0}".format(gw_dev)) # self._log("Set default gateway to: {0}".format(gw_ip)) self._log("Set default gateway to: {0}".format(gw_dev)) # Sleep for 2 seconds and log event self._log("Configured routing and networking") # Stop DHCP server bash("service isc-dhcp-server stop") # Clear current leases bash("echo '' > /var/lib/dhcp/dhcpd.leases") # Start DHCP server bash("service isc-dhcp-server start") sleep(5) self._log("Restarted DHCP server") # Create a list of possible client IPs self.dhcp_pool = set(".".join(self.lan_ip.split(".")[:-1]) + "." + str(x) for x in range(110, 200)) # OMAPI Configuration parameters omapi_host = "127.0.0.1" omapi_port = 7911 omapi_keyname = b"defomapi" omapi_key = b"SmR3+XVX95vDQ3SaZD1B7xTXYTcwNg/AZn9DAsJS" + \ b"9oESudsTQ5bRMaSt bHPyOJchWlXF2Q6CuhSD70eTNl5hOg==" # Create OMAPI object self.omapi = Omapi(omapi_host, omapi_port, omapi_keyname, omapi_key) # If starting the access point if not skip_ap: # If there is a Host AP Daemon running in the background if bool(bash("ps -aux | grep [h]ostapd")): # Kill the process bash("killall hostapd") self._log("Stopped existing hostapd instances") # Run this 10 times or until hostapd starts for x in range(10): # Start Host AP Daemon in the background and log event apd = bash("hostapd -B {0}".format(ap_config_path)).code # If it worked if not apd: break self._log("Trying to start the AP, #", x + 1) sleep(1) # If we could not configure the AP if apd: raise Exception("Could not configure AP") # Log event self._log("Configured access point") # TODO This ought to change in the future # List of currently support RAN slices self.ran_slice_list = [ { "index": 0, "available": True }, { "index": 1, "available": True }, { "index": 2, "available": True }, { "index": 3, "available": True }, ] # Iterate over existing slices for ran_slice in self.ran_slice_list: # Set current slice index idx = bash("sdrctl dev {0} set slice_idx {1}".format( self.sdr_dev, ran_slice['index'])).code # Clear MAC addresses associated with slice cls = bash("sdrctl dev {0} set addr {1}".format( self.sdr_dev, "00000000")).code # Log event self._log("Failed clearing slice #" if cls else "Cleared slice #", ran_slice["index"]) # Sync all slices sync = bash("sdrctl dev {0} set slice_idx 4".format(self.sdr_dev)).code # Output status message and/or exit if not sync: self._log("Synchronised all RAN slices!") else: self._log("Failed synchronising RAN slices.") exit(10)
class opw_controller(base_controller): def post_init(self, **kwargs): # Get parameters from keyword arguments skip_modules = kwargs.get("skip_modules", False) skip_network = kwargs.get("skip_network", False) skip_ap = kwargs.get("skip_ap", False) # Extra options self.sdr_dev = kwargs.get("sdr_dev", "sdr0") # self.lan_ip = kwargs.get("lan_ip", "192.168.13.1") self.lan_ip = kwargs.get("lan_ip", "10.0.0.1") # gw_ip = kwargs.get("gw_ip", "134.226.55.211") gw_dev = kwargs.get("gw_dev", "eth0") ap_config_path = kwargs.get("ap_path", "/root/openwifi/hostapd-openwifi.conf") openwifi_path = kwargs.get("openwifi_path", "/root/openwifi") # Stop Network Manager bash("service network-manager stop") self._log("Stopped Network Manager") # If loading kernel modules if not skip_modules: fpga_dev_path = "/sys/bus/iio/devices/iio:device2" filter_file = "openwifi_ad9361_fir.ftr" # Load mac80211 kernel module bash("modprobe mac80211") self._log("Loaded 'mac80211' kernel module") # If the SDR kernel module is loaded if bool(bash("lsmod | grep sdr")): # Remove SDR kernel module bash("rmmod sdr") self._log("Removed 'sdr' kernel module") # List of custom kernel modules module_list = { "first_batch": ["xilinx_dma", "tx_intf", "ad9361_drv"], "second_batch": ["rx_intf", "openofdm_tx", "openofdm_rx", "xpu", "sdr"] } # Device configuration dictionary device_config = { "first_batch": { "in_voltage_rf_bandwidth": "17500000", "out_voltage_rf_bandwidth": "37500000", "in_voltage_sampling_frequency": "40000000", "out_voltage_sampling_frequency": "40000000", "out_altvoltage0_RX_LO_frequency": "5240000000", "out_altvoltage1_TX_LO_frequency": "5250000000" }, "second_batch": { "in_voltage_filter_fir_en": "1", "out_voltage_filter_fir_en": "0", "in_voltage0_gain_control_mode": "fast_attack", "in_voltage1_gain_control_mode": "fast_attack", "in_voltage0_hardwaregain": "70", "in_voltage1_hardwaregain": "70", "out_voltage0_hardwaregain": "89", "out_voltage1_hardwaregain": "0" } } # Iterate over the first batch for submodule in module_list['first_batch']: # Check whether the module is loaded if bool(bash("lsmod | grep {0}".format(submodule))): # Removing current version of the module bash("rmmod {0}".format(submodule)) # Installing new version of the module bash("insmod {0}/{1}.ko".format(openwifi_path, submodule)) # Check installation of kernel module sleep(1) if not bash("lsmod | grep {0}".format(submodule)).code: self._log("Loaded", submodule, "kernel module") else: self._log("Not loaded", submodule, "kernel module") # Iterate over the first batch of parameters for parameter in device_config["first_batch"].keys(): # Update the parameter value bash("echo {0} > {1}/{2}".format( device_config["first_batch"][parameter], fpga_dev_path, parameter)) bash("sync") sleep(0.5) # Filter file string filter_str = "cat {0}/{1} > {2}/filter_fir_config" # Load filter response values bash(filter_str.format(openwifi_path, filter_file, fpga_dev_path)) # Iterate over the second batch of parameters for parameter in device_config["second_batch"].keys(): # Update the parameter value bash("echo {0} > {1}/{2}".format( device_config["second_batch"][parameter], fpga_dev_path, parameter)) bash("sync") sleep(0.5) # Iterate over the second batch for submodule in module_list['second_batch']: # Check whether the module is loaded if bool(bash("lsmod | grep {0}".format(submodule))): # Removing current version of the module bash("rmmod {0}".format(submodule)) # Installing new version of the module bash("insmod {0}/{1}.ko".format(openwifi_path, submodule)) sleep(1) # Check installation of kernel module if not bash("lsmod | grep {0}".format(submodule)).code: self._log("Loaded", submodule, "kernel module") # Sleep for 10 seconds and log event self._log("Waiting for configurations to take effect") sleep(10) self._log("Configured kernel modules and FPGA") # If configuring routing and networking if not skip_network: # Configure the SDR interface's IP bash("ifconfig {0} {1} netmask 255.255.255.0".format( self.sdr_dev, self.lan_ip)) self._log("Set {0} interface IP's to: {1}".format( self.sdr_dev, self.lan_ip)) # Set the default route through eth0 # bash("ip route add default via {0} dev eth0".format(gw_ip)) bash("ip route add default dev {0}".format(gw_dev)) # self._log("Set default gateway to: {0}".format(gw_ip)) self._log("Set default gateway to: {0}".format(gw_dev)) # Sleep for 2 seconds and log event self._log("Configured routing and networking") # Stop DHCP server bash("service isc-dhcp-server stop") # Clear current leases bash("echo '' > /var/lib/dhcp/dhcpd.leases") # Start DHCP server bash("service isc-dhcp-server start") sleep(5) self._log("Restarted DHCP server") # Create a list of possible client IPs self.dhcp_pool = set(".".join(self.lan_ip.split(".")[:-1]) + "." + str(x) for x in range(110, 200)) # OMAPI Configuration parameters omapi_host = "127.0.0.1" omapi_port = 7911 omapi_keyname = b"defomapi" omapi_key = b"SmR3+XVX95vDQ3SaZD1B7xTXYTcwNg/AZn9DAsJS" + \ b"9oESudsTQ5bRMaSt bHPyOJchWlXF2Q6CuhSD70eTNl5hOg==" # Create OMAPI object self.omapi = Omapi(omapi_host, omapi_port, omapi_keyname, omapi_key) # If starting the access point if not skip_ap: # If there is a Host AP Daemon running in the background if bool(bash("ps -aux | grep [h]ostapd")): # Kill the process bash("killall hostapd") self._log("Stopped existing hostapd instances") # Run this 10 times or until hostapd starts for x in range(10): # Start Host AP Daemon in the background and log event apd = bash("hostapd -B {0}".format(ap_config_path)).code # If it worked if not apd: break self._log("Trying to start the AP, #", x + 1) sleep(1) # If we could not configure the AP if apd: raise Exception("Could not configure AP") # Log event self._log("Configured access point") # TODO This ought to change in the future # List of currently support RAN slices self.ran_slice_list = [ { "index": 0, "available": True }, { "index": 1, "available": True }, { "index": 2, "available": True }, { "index": 3, "available": True }, ] # Iterate over existing slices for ran_slice in self.ran_slice_list: # Set current slice index idx = bash("sdrctl dev {0} set slice_idx {1}".format( self.sdr_dev, ran_slice['index'])).code # Clear MAC addresses associated with slice cls = bash("sdrctl dev {0} set addr {1}".format( self.sdr_dev, "00000000")).code # Log event self._log("Failed clearing slice #" if cls else "Cleared slice #", ran_slice["index"]) # Sync all slices sync = bash("sdrctl dev {0} set slice_idx 4".format(self.sdr_dev)).code # Output status message and/or exit if not sync: self._log("Synchronised all RAN slices!") else: self._log("Failed synchronising RAN slices.") exit(10) def create_slice(self, **kwargs): # Extract parameters from keyword arguments s_id = str(kwargs.get('s_id', None)) s_mac = str(kwargs.get('s_mac', None)) i_sln = int(kwargs.get("slice", {}).get('number', 0)) # If the MAC address is invalid if not s_mac or s_mac is None: return False, "Malformatted MAC address:" + str(s_mac) # Iterate over the current slices for sid in self.s_ids: # Check whether the entered MAC address is already being used if self.s_ids[sid] and (s_mac == self.s_ids[sid]['mac']): # Return error return False, "MAC address already associated to slice: " + sid # Check whether the slice number is valid if i_sln not in [x['index'] for x in self.ran_slice_list]: # If not, return error return False, "Invalid slice number:" + str(i_sln) # Check whether there an available slice elif not self.ran_slice_list[i_sln]['available']: # If not, return error return False, "Slice #" + str(i_sln) + " is not available." # Check whether the given MAC address has a current DHCP lease try: # Try to check it self.omapi.lookup_by_host(mac=s_mac) # If it doesn't work, great except OmapiErrorNotFound: pass # Otherwise, clear it else: self.omapi.del_host(s_mac) # Get the first available IP address lease_ip = self.dhcp_pool.pop() # Add host to the DHCP subnet try: self.omapi.add_host(lease_ip, s_mac) # If if failed except OmapiError: # Report to the hyperstrator return False, "DHCP lease creation failed." # Log event self._log("Set", s_mac, "IP to:", lease_ip) # Get the slice configuration parameters i_start = int(kwargs.get("slice", {}).get('start', 0)) i_end = int(kwargs.get("slice", {}).get('end', 49999)) i_total = int(kwargs.get("slice", {}).get('total', 50000)) # Set the slice in question bash("sdrctl dev {0} set slice_idx {1}".format(self.sdr_dev, i_sln)) # Set the slice configuration bash("sdrctl dev {0} set slice_start {1}".format( self.sdr_dev, i_start)) bash("sdrctl dev {0} set slice_end {1}".format(self.sdr_dev, i_end)) bash("sdrctl dev {0} set slice_total {1}".format( self.sdr_dev, i_total)) # Sync all commands sync = bash("sdrctl dev {0} set slice_idx 4".format(self.sdr_dev)).code # Log event self._log("Set slice", i_sln, " start/end/total to", i_start, "/", i_end, "/", i_total) # Set the slice in question bash("sdrctl dev {0} set slice_idx {1}".format(self.sdr_dev, i_sln)) print(s_mac) # Get MAC address associated with service and map it to 32 bits s_mac_32 = s_mac.replace(":", "")[4:] print(s_mac_32) # Add MAC address to SDRCTL sla = bash("sdrctl dev {0} set addr {1}".format( self.sdr_dev, s_mac_32)).code # Sync all commands sync = bash("sdrctl dev {0} set slice_idx 4".format(self.sdr_dev)).code if sla or sync: return False, "Slice creation failed." # Iterate over the slice slice for i, x in enumerate(self.ran_slice_list): # If matching the slice number if x["index"] == i_sln: # Toggle flag self.ran_slice_list[i]['available'] = False # Create a slice entry self.s_ids[s_id] = { "mac": s_mac, "ip": lease_ip, "slice": { "number": i_sln, "start": i_start, "end": i_end, "total": i_total } } # Log event self._log("Created slice", s_id) return True, {"s_id": s_id, "destination": lease_ip} def request_slice(self, **kwargs): # Extract parameters from keyword arguments s_id = kwargs.get('s_id', None) # Container to told the requested information msg = {} # Iterate over all slices for virtual_radio in self.s_ids: # If requesting info about a specific S_ID but it is not a match if s_id and s_id != virtual_radio: continue # Log event self._log("Found virtual radio:", virtual_radio) # Append this information to the output dictionary msg[s_id] = { "mac": self.s_ids[virtual_radio]["mac"], "ip": self.s_ids[virtual_radio]["ip"], "slice": self.s_ids[virtual_radio]["slice"] } # Return flag and dictionary in case positive return (False, "Virtual radio missing") if \ (s_id and not msg) else (True, msg) def update_slice(self, **kwargs): # Extract parameters from keyword arguments s_id = kwargs.get('s_id', None) # Return state return True, "This is a stub" def delete_slice(self, **kwargs): # Extract parameters from keyword arguments s_id = kwargs.get('s_id', None) # Get the client's MAC address s_mac = self.s_ids[s_id]["mac"] # Get the slice number i_sln = self.s_ids[s_id]["slice"]["number"] # Remove host from the DHCP subnet self.omapi.del_host(s_mac) # Set the slice in question bash("sdrctl dev {0} set slice_idx {1}".format(self.sdr_dev, i_sln)) # Try to clear the slice cls = bash("sdrctl dev {0} set addr {1}".format( self.sdr_dev, "00000000")).code # If the last command failed if cls: return False, "Could not remove MAC from slice #" + str(i_lsn) # Set the default slice configuration s = bash("sdrctl dev {0} set slice_start {1}".format(self.sdr_dev, 0)).code e = bash("sdrctl dev {0} set slice_end {1}".format( self.sdr_dev, 49999)).code t = bash("sdrctl dev {0} set slice_total {1}".format( self.sdr_dev, 50000)).code # Sync all commands sync = bash("sdrctl dev {0} set slice_idx 4".format(self.sdr_dev)).code # If any of the precious commands failed if any([s, e, t, sync]): return False, "Failed reverting slice to default parameters." # Iterate over the slice slice for i, x in enumerate(self.ran_slice_list): # If matching the slice number if x["index"] == i_sln: # Toggle flag self.ran_slice_list[i]['available'] = True # Return state return True, {"s_id": s_id}
class OmapiHostManager: def __init__(self, module): self.module = module self.omapi = None self.connect() def connect(self): try: self.omapi = Omapi(self.module.params['host'], self.module.params['port'], self.module.params['key_name'], self.module.params['key']) except binascii.Error: self.module.fail_json(msg="Unable to open OMAPI connection. 'key' is not a valid base64 key.") except OmapiError as e: self.module.fail_json(msg="Unable to open OMAPI connection. Ensure 'host', 'port', 'key' and 'key_name' " "are valid. Exception was: %s" % to_native(e)) except socket.error as e: self.module.fail_json(msg="Unable to connect to OMAPI server: %s" % to_native(e)) def get_host(self, macaddr): msg = OmapiMessage.open(to_bytes("host", errors='surrogate_or_strict')) msg.obj.append((to_bytes("hardware-address", errors='surrogate_or_strict'), pack_mac(macaddr))) msg.obj.append((to_bytes("hardware-type", errors='surrogate_or_strict'), struct.pack("!I", 1))) response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_UPDATE: return None return response @staticmethod def unpack_facts(obj): result = dict(obj) if 'hardware-address' in result: result['hardware-address'] = unpack_mac(result['hardware-address']) if 'ip-address' in result: result['ip-address'] = unpack_ip(result['ip-address']) if 'hardware-type' in result: result['hardware-type'] = struct.unpack("!I", result['hardware-type']) return result def setup_host(self): if self.module.params['hostname'] is None or len(self.module.params['hostname']) == 0: self.module.fail_json(msg="name attribute could not be empty when adding or modifying host.") msg = None host_response = self.get_host(self.module.params['macaddr']) # If host was not found using macaddr, add create message if host_response is None: msg = OmapiMessage.open(to_bytes('host', errors='surrogate_or_strict')) msg.message.append(('create', struct.pack('!I', 1))) msg.message.append(('exclusive', struct.pack('!I', 1))) msg.obj.append(('hardware-address', pack_mac(self.module.params['macaddr']))) msg.obj.append(('hardware-type', struct.pack('!I', 1))) msg.obj.append(('name', self.module.params['hostname'])) if self.module.params['ip'] is not None: msg.obj.append((to_bytes("ip-address", errors='surrogate_or_strict'), pack_ip(self.module.params['ip']))) stmt_join = "" if self.module.params['ddns']: stmt_join += 'ddns-hostname "{0}"; '.format(self.module.params['hostname']) try: if len(self.module.params['statements']) > 0: stmt_join += "; ".join(self.module.params['statements']) stmt_join += "; " except TypeError as e: self.module.fail_json(msg="Invalid statements found: %s" % to_native(e), exception=traceback.format_exc()) if len(stmt_join) > 0: msg.obj.append(('statements', stmt_join)) try: response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_UPDATE: self.module.fail_json(msg="Failed to add host, ensure authentication and host parameters " "are valid.") self.module.exit_json(changed=True, lease=self.unpack_facts(response.obj)) except OmapiError as e: self.module.fail_json(msg="OMAPI error: %s" % to_native(e), exception=traceback.format_exc()) # Forge update message else: response_obj = self.unpack_facts(host_response.obj) fields_to_update = {} if to_bytes('ip-address', errors='surrogate_or_strict') not in response_obj or \ unpack_ip(response_obj[to_bytes('ip-address', errors='surrogate_or_strict')]) != self.module.params['ip']: fields_to_update['ip-address'] = pack_ip(self.module.params['ip']) # Name cannot be changed if 'name' not in response_obj or response_obj['name'] != self.module.params['hostname']: self.module.fail_json(msg="Changing hostname is not supported. Old was %s, new is %s. " "Please delete host and add new." % (response_obj['name'], self.module.params['hostname'])) """ # It seems statements are not returned by OMAPI, then we cannot modify them at this moment. if 'statements' not in response_obj and len(self.module.params['statements']) > 0 or \ response_obj['statements'] != self.module.params['statements']: with open('/tmp/omapi', 'w') as fb: for (k,v) in iteritems(response_obj): fb.writelines('statements: %s %s\n' % (k, v)) """ if len(fields_to_update) == 0: self.module.exit_json(changed=False, lease=response_obj) else: msg = OmapiMessage.update(host_response.handle) msg.update_object(fields_to_update) try: response = self.omapi.query_server(msg) if response.opcode != OMAPI_OP_STATUS: self.module.fail_json(msg="Failed to modify host, ensure authentication and host parameters " "are valid.") self.module.exit_json(changed=True) except OmapiError as e: self.module.fail_json(msg="OMAPI error: %s" % to_native(e), exception=traceback.format_exc()) def remove_host(self): try: self.omapi.del_host(self.module.params['macaddr']) self.module.exit_json(changed=True) except OmapiErrorNotFound: self.module.exit_json() except OmapiError as e: self.module.fail_json(msg="OMAPI error: %s" % to_native(e), exception=traceback.format_exc())
def close(self): NacOmapi.instance = None Omapi.close(self)