def _build_yp_establish_subscription_shell(self, datastore, datastore_subtree_filter, datastore_xpath_filter): es_nsmap = {'yp': 'urn:ietf:params:xml:ns:yang:ietf-yang-push'} root = etree.Element( 'establish-subscription', nsmap=es_nsmap, attrib={ 'xmlns': 'urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications' }) datastore_leaf = util.leaf_elm('yp:datastore', f'ds:{datastore}') root.append(datastore_leaf) if datastore_subtree_filter: selection_filter = util.elm('yp:datastore-subtree-filter') if isinstance(datastore_subtree_filter, etree.Element): selection_filter.append(datastore_subtree_filter) else: selection_filter.text = datastore_subtree_filter elif datastore_xpath_filter: selection_filter = util.leaf_elm('yp:datastore-xpath-filter', datastore_xpath_filter) else: raise ValueError("Missing selection filter") root.append(selection_filter) return root
def rpc_full_itu_scan (self, unused_session, rpc, *params): # No input values yet try: if len(params) > 2: raise ncerror.RPCSvrInvalidValue(rpc, message="Too many parameters") # XXX Should be able to use "j:high-resolution" but it fails hires = self._rpc_param_get_boolean(rpc, "high-resolution", False, params) power_only = not self._rpc_param_get_boolean(rpc, "detect-presence", False, params) if power_only: points = self._run_device_method(rpc, self.device.get_itu_power_scan, hires) else: points = self._run_device_method(rpc, self.device.get_itu_scan, hires) result = ncutil.elm("data") for tup in points: ptelm = ncutil.subelm(result, "j:point") ptelm.append(ncutil.leaf_elm("j:frequency", tup[0])) if power_only: ptelm.append(ncutil.leaf_elm("j:power", "{:.2f}".format(tup[1].dBm))) else: ptelm.append(ncutil.leaf_elm("j:power", "{:.2f}".format(tup[2].dBm))) ptelm.append(ncutil.leaf_elm("j:channel-presence", tup[1])) return result except jerror.OCMError as ocmerr: logger.error("Got OCM error in full itu scan: %s: %s", str(ocmerr), traceback.format_exc()) except Exception as err: logger.error("Got error in full itu scan: %s: %s", str(err), traceback.format_exc()) raise
def rpc_get_config(self, session, rpc, source_elm, filter_or_none): # pylint: disable=W0613 assert source_elm is not None if source_elm.find("nc:running", namespaces=NSMAP) is None: # Really this should be a different error its a bad value for source not missing raise ncerror.MissingElementProtoError(rpc, ncutil.qname("nc:running")) data = ncutil.elm("data") cont = ncutil.subelm(data, "interfaces") listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "Ethernet0/0")) listval.append(ncutil.leaf_elm("shutdown", "true")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "Ethernet0/1")) listval.append(ncutil.leaf_elm("shutdown", "false")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "FastEthernet1/0")) listval.append(ncutil.leaf_elm("shutdown", "false")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "FastEthernet1/1")) listval.append(ncutil.leaf_elm("shutdown", "false")) # Missing from operational listval.append(ncutil.leaf_elm("name", "GigabitEthernet2/0")) listval.append(ncutil.leaf_elm("shutdown", "false")) return ncutil.filter_results(rpc, data, filter_or_none)
def main(): parser = Parser(__file__) args = parser.parse_args() session = NetconfSSHSession(args.host, args.port, args.user, args.password) es_nsmap = {'yp': 'urn:ietf:params:xml:ns:yang:ietf-yang-push'} root = lxml.etree.Element( 'establish-subscription', nsmap=es_nsmap, attrib={ 'xmlns': 'urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications' }) datastore = util.leaf_elm('yp:datastore', 'ds:operational') root.append(datastore) datastore_xpath_filter = util.leaf_elm('yp:datastore-xpath-filter', args.xpath) root.append(datastore_xpath_filter) periodic = util.subelm(root, 'yp:periodic') period = util.leaf_elm("yp:period", args.period) periodic.append(period) res = session.send_rpc(root) while True: tree, notif, msg = session.get_notification() print(etree.tounicode(notif, pretty_print=True), end="\n\n")
def rpc_get(self, session, rpc, filter_or_none): # pylint: disable=W0613 """ Retrieve all or part of specified configuration. :param session: the server session with the client :type session: NetconfServerSession :param rpc: the topmost element in the received message :type rpc: lxml.Element :param filter_or_none: the filter element if present :type filter_or_none: lxml.Element or None :return: "nc:data" type containing the requested state :rtype: lxml.Element """ logger.debug("GET") try: # extract bn, En and eq from running configuration datastore using pyangbind format eq = str(self.configuration.DRoF_configuration.equalization) bn, En = self.extract_bn_and_En(self.configuration) # DAC/OSC setup result = self.ac.dac_setup(bn, En, eq) # modify SNR and BER in running configuration datastore SNR = result[0] BER = result[1] self.modify_SNR_and_BER(BER, SNR) logger.info(pybindJSON.dumps(self.configuration)) # get new SNR and BER from running configuration datastore data = etree.XML(pybindIETFXMLEncoder.serialise( self.configuration)) monitor = data.findall( ".//xmlns:monitor", namespaces={'xmlns': "urn:blueSPACE-DRoF-configuration"}) ber = data.find( ".//xmlns:BER", namespaces={'xmlns': "urn:blueSPACE-DRoF-configuration"}) # create NETCONF rpc-reply message with the new SNR and BER from running configuration datastore data_reply = util.elm("data") top = util.subelm( data_reply, "{urn:blueSPACE-DRoF-configuration}DRoF-configuration") for value in monitor: m = util.subelm(top, 'monitor') m.append(util.leaf_elm('subcarrier-id', str(value[0].text))) m.append(util.leaf_elm('SNR', str(value[1].text))) top.append(util.leaf_elm('BER', str(ber.text))) return util.filter_results(rpc, data_reply, filter_or_none) except Exception as e: logger.error("GET, error: {}".format(e)) raise e
def _add_config(self, data): sysc = util.subelm(data, "sys:system") # System Identification sysc.append(util.leaf_elm("sys:hostname", socket.gethostname())) # System Clock clockc = util.subelm(sysc, "sys:clock") tzname = time.tzname[time.localtime().tm_isdst] clockc.append( util.leaf_elm("sys:timezone-utc-offset", int(time.timezone / 100)))
def rpc_get_config(self, session, rpc, source_elm, filter_or_none): # pylint: disable=W0613 """Passed the source element""" data = util.elm("nc:data") sysc = util.subelm(data, "sys:system") sysc.append(util.leaf_elm("sys:hostname", socket.gethostname())) # Clock clockc = util.subelm(sysc, "sys:clock") # tzname = time.tzname[time.localtime().tm_isdst] clockc.append(util.leaf_elm("sys:timezone-utc-offset", int(time.timezone / 100))) return util.filter_results(rpc, data, filter_or_none)
def _send_yp_establish_subscription_periodic(self, root, period, anchor_time=None): periodic = util.subelm(root, 'yp:periodic') period_leaf = util.leaf_elm("yp:period", period) periodic.append(period_leaf) if anchor_time: anchor_time_leaf = util.leaf_elm("yp:anchor-time", anchor_time) periodic.append(anchor_time_leaf) return self.send_rpc(root)
def rpc_get(self, unused_session, unused_rpc, filter_elm): data = ncutil.elm("data") get_data_methods = { ncutil.qname("j:ocm-type").text: self.device.get_device_type, ncutil.qname("j:oper-mode").text: self.device.get_oper_mode, ncutil.qname("j:ident-data").text: self.device.get_idn_string, ncutil.qname("j:device-info").text: self.device.get_module_info, ncutil.qname("j:application-version").text: self.device.get_app_version, ncutil.qname("j:temp").text: self.device.get_temp_int, } if not self.device.get_device_type().startswith("tf"): get_data_methods[ncutil.qname( "j:safe-version").text] = self.device.get_safe_version infonode = ncutil.elm("j:info") # infonode = etree.Element(ncutil.qname("j:info"), nsmap={ 'j': NSMAP['j'] }) # Get filter children children = [] if filter_elm is not None: children = filter_elm.getchildren( ) if filter_elm is not None else [] def get_all_values(): leaf_elms = [] for key, valuef in get_data_methods.items(): leaf_elms.append(ncutil.leaf_elm(key, valuef())) return leaf_elms # No filter children return info only if not children: ncutil.filter_leaf_values(None, infonode, get_all_values(), data) return data # Look for info filter. finfo = filter_elm.find("info") or filter_elm.find("j:info", namespaces=NSMAP) if finfo is not None: children = finfo.getchildren() if not children: leaf_elms = get_all_values() else: leaf_elms = [] for felm in children: tag = felm.tag if tag in get_data_methods: leaf_elms.append( ncutil.leaf_elm(tag, get_data_methods[tag]())) rv = ncutil.filter_leaf_values(finfo, infonode, leaf_elms, data) # Some selector doesn't match return empty. if rv is False: logger.error("XXX returning False") return data return data
def rpc_my_cool_rpc(self, session, rpc, *params): data = ncutil.elm("nc:data") #data = ncutil.elm("data") #data.append(ncutil.leaf_elm("pfx:result", "RPC result string")) data.append(ncutil.leaf_elm("result", "RPC result string")) #print (type(data), data.tag, data.attrib) print(etree.tounicode(rpc)) print(session, params) return data
def _rpc_full_scan (self, method, rpc, *params): # No input values yet if params: logging.error("%s: _rpc_full_scan got unexpected params", str(self)) raise ncerror.RPCSvrErrBadMsg(rpc) rv = self._run_device_method(rpc, method) result = ncutil.elm("data") for port, points in rv: portelm = ncutil.elm("j:port") result.append(portelm) portelm.append(ncutil.leaf_elm("j:port-index", port)) for freq, power in points: ptelm = ncutil.subelm(portelm, "j:point") ptelm.append(ncutil.leaf_elm("j:frequency", freq)) ptelm.append(ncutil.leaf_elm("j:power", "{:.2f}".format(power.dBm))) return result
def _rpc_full_scan(self, method, rpc, *params): # No input values yet if params: logging.error("%s: _rpc_full_scan got unexpected params", str(self)) raise ncerror.RPCSvrErrBadMsg(rpc) rv = self._run_device_method(rpc, method) result = ncutil.elm("data") for port, points in rv: portelm = ncutil.elm("j:port") result.append(portelm) portelm.append(ncutil.leaf_elm("j:port-index", port)) for freq, power in points: ptelm = ncutil.subelm(portelm, "j:point") ptelm.append(ncutil.leaf_elm("j:frequency", freq)) ptelm.append( ncutil.leaf_elm("j:power", "{:.2f}".format(power.dBm))) return result
def rpc_frequency_power (self, unused, rpc, *params): if len(params) > 1: # XXX need a function to look for unknown elements and raise exc for those. # XXX really need a better error for not handled params raise ncerror.RPCSvrInvalidValue(rpc, message="Too many parameter") freq = self._rpc_param_get_frequency(rpc, params) power = self._run_device_method(rpc, self.device.get_freq_power, freq) result = ncutil.elm("data") result.append(ncutil.leaf_elm("j:power", "{:.2f}".format(power.dBm))) return result
def rpc_frequency_power(self, unused, rpc, *params): if len(params) > 1: # XXX need a function to look for unknown elements and raise exc for those. # XXX really need a better error for not handled params raise ncerror.RPCSvrInvalidValue(rpc, message="Too many parameter") freq = self._rpc_param_get_frequency(rpc, params) power = self._run_device_method(rpc, self.device.get_freq_power, freq) result = ncutil.elm("data") result.append(ncutil.leaf_elm("j:power", "{:.2f}".format(power.dBm))) return result
def rpc_get_config(self, unused_session, rpc, source_elm, unused_filter_elm): assert source_elm is not None if source_elm.find("nc:running", namespaces=NSMAP) is None: raise ncerror.RPCSvrMissingElement(rpc, ncutil.elm("nc:running")) config = ncutil.elm("data") if self.is_tfm: profile_elm = ncutil.elm("j:scan-profile") config.append(profile_elm) profile_elm.append( ncutil.leaf_elm("j:channel-spacing", self.device.get_channel_spacing())) profile_elm.append( ncutil.leaf_elm("j:frequency-start", self.device.get_start_freq())) profile_elm.append( ncutil.leaf_elm("j:frequency-end", self.device.get_stop_freq())) else: for idx in range(1, 17): profile_elm = ncutil.elm("j:channel-profile") config.append(profile_elm) profile_elm.append(ncutil.leaf_elm("j:profile-index", idx)) channels = self.device.get_channel_profile(idx) for freqs, freqe in channels: channel_elm = ncutil.subelm(profile_elm, "j:channel") range_elm = ncutil.subelm(channel_elm, "j:range") range_elm.append( ncutil.leaf_elm("j:frequency-start", freqs)) range_elm.append(ncutil.leaf_elm("j:frequency-end", freqe)) return config
def rpc_get(self, session, rpc, filter_or_none): # pylint: disable=W0613 """Passed the filter element or None if not present""" data = util.elm("nc:data") # if False: # If NMDA # sysc = util.subelm(data, "system") # sysc.append(util.leaf_elm("hostname", socket.gethostname())) # # Clock # clockc = util.subelm(sysc, "clock") # tzname = time.tzname[time.localtime().tm_isdst] # clockc.append(util.leaf_elm("timezone-utc-offset", int(time.timezone / 100))) sysc = util.subelm(data, "sys:system-state") platc = util.subelm(sysc, "sys:system") platc.append(util.leaf_elm("sys:os-name", platform.system())) platc.append(util.leaf_elm("sys:os-release", platform.release())) platc.append(util.leaf_elm("sys:os-version", platform.version())) platc.append(util.leaf_elm("sys:machine", platform.machine())) # Clock clockc = util.subelm(sysc, "sys:clock") now = datetime.datetime.now() clockc.append(util.leaf_elm("sys:current-datetime", date_time_string(now))) if os.path.exists("/proc/uptime"): with open('/proc/uptime', 'r') as f: uptime_seconds = float(f.readline().split()[0]) boottime = time.time() - uptime_seconds boottime = datetime.datetime.fromtimestamp(boottime) clockc.append(util.leaf_elm("sys:boot-datetime", date_time_string(boottime))) return util.filter_results(rpc, data, filter_or_none, self.server.debug)
def rpc_get(self, session, rpc, filter_or_none): # pylint: disable=W0613 """Passed the filter element or None if not present""" data = util.elm("nc:data") self._add_config(data) # # State Data # sysd = util.subelm(data, "sys:system-state") # System Identification platc = util.subelm(sysd, "sys:platform") platc.append(util.leaf_elm("sys:os-name", platform.system())) platc.append(util.leaf_elm("sys:os-release", platform.release())) platc.append(util.leaf_elm("sys:os-version", platform.version())) platc.append(util.leaf_elm("sys:machine", platform.machine())) # System Clock clockc = util.subelm(sysd, "sys:clock") now = datetime.datetime.now() clockc.append( util.leaf_elm("sys:current-datetime", date_time_string(now))) if os.path.exists("/proc/uptime"): with open('/proc/uptime', 'r') as f: uptime_seconds = float(f.readline().split()[0]) boottime = time.time() - uptime_seconds boottime = datetime.datetime.fromtimestamp(boottime) clockc.append( util.leaf_elm("sys:boot-datetime", date_time_string(boottime))) return util.filter_results(rpc, data, filter_or_none, self.server.debug)
def rpc_get_config (self, unused_session, rpc, source_elm, unused_filter_elm): assert source_elm is not None if source_elm.find("nc:running", namespaces=NSMAP) is None: raise ncerror.RPCSvrMissingElement(rpc, ncutil.elm("nc:running")) config = ncutil.elm("data") if self.is_tfm: profile_elm = ncutil.elm("j:scan-profile") config.append(profile_elm) profile_elm.append(ncutil.leaf_elm("j:channel-spacing", self.device.get_channel_spacing())) profile_elm.append(ncutil.leaf_elm("j:frequency-start", self.device.get_start_freq())) profile_elm.append(ncutil.leaf_elm("j:frequency-end", self.device.get_stop_freq())) else: for idx in range(1, 17): profile_elm = ncutil.elm("j:channel-profile") config.append(profile_elm) profile_elm.append(ncutil.leaf_elm("j:profile-index", idx)) channels = self.device.get_channel_profile(idx) for freqs, freqe in channels: channel_elm = ncutil.subelm(profile_elm, "j:channel") range_elm = ncutil.subelm(channel_elm, "j:range") range_elm.append(ncutil.leaf_elm("j:frequency-start", freqs)) range_elm.append(ncutil.leaf_elm("j:frequency-end", freqe)) return config
def rpc_get (self, unused_session, unused_rpc, filter_elm): data = ncutil.elm("data") get_data_methods = { ncutil.qname("j:ocm-type").text: self.device.get_device_type, ncutil.qname("j:oper-mode").text: self.device.get_oper_mode, ncutil.qname("j:ident-data").text: self.device.get_idn_string, ncutil.qname("j:device-info").text: self.device.get_module_info, ncutil.qname("j:application-version").text: self.device.get_app_version, ncutil.qname("j:temp").text: self.device.get_temp_int, } if not self.device.get_device_type().startswith("tf"): get_data_methods[ncutil.qname("j:safe-version").text] = self.device.get_safe_version infonode = ncutil.elm("j:info") # infonode = etree.Element(ncutil.qname("j:info"), nsmap={ 'j': NSMAP['j'] }) # Get filter children children = [] if filter_elm is not None: children = filter_elm.getchildren() if filter_elm is not None else [] def get_all_values (): leaf_elms = [] for key, valuef in get_data_methods.items(): leaf_elms.append(ncutil.leaf_elm(key, valuef())) return leaf_elms # No filter children return info only if not children: ncutil.filter_leaf_values(None, infonode, get_all_values(), data) return data # Look for info filter. finfo = filter_elm.find("info") or filter_elm.find("j:info", namespaces=NSMAP) if finfo is not None: children = finfo.getchildren() if not children: leaf_elms = get_all_values() else: leaf_elms = [] for felm in children: tag = felm.tag if tag in get_data_methods: leaf_elms.append(ncutil.leaf_elm(tag, get_data_methods[tag]())) rv = ncutil.filter_leaf_values(finfo, infonode, leaf_elms, data) # Some selector doesn't match return empty. if rv is False: logger.error("XXX returning False") return data return data
def rpc_full_itu_scan(self, unused_session, rpc, *params): # No input values yet try: if len(params) > 2: raise ncerror.RPCSvrInvalidValue(rpc, message="Too many parameters") # XXX Should be able to use "j:high-resolution" but it fails hires = self._rpc_param_get_boolean(rpc, "high-resolution", False, params) power_only = not self._rpc_param_get_boolean( rpc, "detect-presence", False, params) if power_only: points = self._run_device_method( rpc, self.device.get_itu_power_scan, hires) else: points = self._run_device_method(rpc, self.device.get_itu_scan, hires) result = ncutil.elm("data") for tup in points: ptelm = ncutil.subelm(result, "j:point") ptelm.append(ncutil.leaf_elm("j:frequency", tup[0])) if power_only: ptelm.append( ncutil.leaf_elm("j:power", "{:.2f}".format(tup[1].dBm))) else: ptelm.append( ncutil.leaf_elm("j:power", "{:.2f}".format(tup[2].dBm))) ptelm.append(ncutil.leaf_elm("j:channel-presence", tup[1])) return result except jerror.OCMError as ocmerr: logger.error("Got OCM error in full itu scan: %s: %s", str(ocmerr), traceback.format_exc()) except Exception as err: logger.error("Got error in full itu scan: %s: %s", str(err), traceback.format_exc()) raise
def send_hello(self, caplist, session_id=None): msg = ncutil.elm("hello", attrib={'xmlns': NSMAP['nc']}) caps = ncutil.elm("capabilities") for cap in caplist: ncutil.subelm(caps, "capability").text = str(cap) if session_id is not None: assert hasattr(self, "methods") self.methods.nc_append_capabilities(caps) # pylint: disable=E1101 msg.append(caps) if self.debug: logger.debug("%s: Sending HELLO", str(self)) if session_id is not None: msg.append(ncutil.leaf_elm("session-id", str(session_id))) msg = etree.tostring(msg) self.send_message(msg.decode('utf-8'))
def send_notification(self, data, *params): msg = etree.Element("{{{}}}notification".format(NSMAP['ncEvent'])) node_event_time = util.leaf_elm( 'eventTime', date_time_string(datetime.datetime.now())) msg.append(node_event_time) msg.append(data) msg_unicode = etree.tounicode(msg, pretty_print=True) logger.debug("notification msg is:\n%s", str(msg_unicode)) for socket in self.server.sockets: if socket.running is False: continue for session in socket.sessions: if session.session_open is False: continue logger.debug( "Sending to client, session id: %d, ip:%s, port:%d", session.session_id, socket.client_addr[0], socket.client_addr[1]) session.send_message(msg_unicode) return
def rpc_ownership(self, session, rpc, *params): """Passed the filter element or None if not present""" data = util.elm("nc:data") data.append(util.leaf_elm("result", "RPC result string")) xPathResult = rpc.xpath( "//nc:ownership/nc:ownerCertificate/nc:certificate", namespaces=NSMAP) if not xPathResult: print("no cert found") else: certString = xPathResult[0].text temp_ownerCert = OpenSSL.crypto.load_certificate( OpenSSL.crypto.FILETYPE_PEM, certString) #print(OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_TEXT, ownerCert).decode("utf-8")) xPathResult = rpc.xpath( "//nc:ownership/nc:ownerCertificate/nc:certificateSignature", namespaces=NSMAP) #if there is no signature at all, just accecpt the unsigned ownerCertificate if not xPathResult: print("no siganture found") self.ownerCertificate = temp_ownerCert #if there is a signature, check the signed ownerCertificate and accept it else: signature_base64 = xPathResult[0].text signature = base64.b64decode(signature_base64) #print(certString) if verifyString(self.manufacturerCert, signature, certString.encode('ascii'), "sha256"): self.ownerCertificate = temp_ownerCert #print(result) #print(OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_TEXT, self.ownerCertificate).decode("utf-8")) return util.filter_results(rpc, data, None)
def get_all_values (): leaf_elms = [] for key, valuef in get_data_methods.items(): leaf_elms.append(ncutil.leaf_elm(key, valuef())) return leaf_elms
def rpc_establish_subscription(self, session, rpc, *params): """ Source https://tools.ietf.org/id/draft-ietf-netconf-yang-push-19.html +---x establish-subscription | +---w input | | ... | | +---w (target) | | | +--:(stream) | | | | ... | | | +--:(yp:datastore) | | | +---w yp:datastore identityref | | | +---w (yp:selection-filter)? | | | +--:(yp:by-reference) | | | | +---w yp:selection-filter-ref | | | | selection-filter-ref | | | +--:(yp:within-subscription) | | | +---w (yp:filter-spec)? | | | +--:(yp:datastore-subtree-filter) | | | | +---w yp:datastore-subtree-filter? | | | | <anydata> {sn:subtree}? | | | +--:(yp:datastore-xpath-filter) | | | +---w yp:datastore-xpath-filter? | | | yang:xpath1.0 {sn:xpath}? | | | ... | | +---w (yp:update-trigger) | | +--:(yp:periodic) | | | +---w yp:periodic! | | | +---w yp:period yang:timeticks | | | +---w yp:anchor-time? yang:date-and-time | | +--:(yp:on-change) {on-change}? | | +---w yp:on-change! | | +---w yp:dampening-period? yang:timeticks | | +---w yp:sync-on-start? boolean | | +---w yp:excluded-change* change-type | +--ro output | +--ro id subscription-id | +--ro replay-start-time-revision? yang:date-and-time | {replay}? """ # We have recieved an establish-subscription rpc # TODO validate more fields from the RPC logger.info("Received establish-subscription RPC") sub_type = None sid: int = -1 sub = None root = rpc[0] nsmap = rpc[0].nsmap periodic_elm = root.find('yp:periodic', nsmap) on_change_elm = root.find('yp:on-change', nsmap) datastore_elm = root.find('yp:datastore', nsmap) datastore_xpath_filter_elm = root.find('yp:datastore-xpath-filter', nsmap) if periodic_elm is not None: period_elm = periodic_elm.find('yp:period', nsmap) period = int(period_elm.text) sub_type = Subscription.PERIODIC anchor_time_elm = periodic_elm.find('yp:anchor-time', nsmap) anchor_time = None if anchor_time_elm is not None: anchor_time = anchor_time_elm.text elif on_change_elm is not None: sub_type = Subscription.ON_CHANGE else: # Malformed request return ncutil.leaf_elm( 'error', 'Neither periodic nor on change found in establish-subscription request' ) xpath_filter = datastore_xpath_filter_elm.text datastore = datastore_elm.text if sub_type == Subscription.PERIODIC: sid = self.get_next_sub_id() sub = Subscription(sid, sub_type, datastore, period=period, datastore_xpath_filter=xpath_filter, raw=etree.tostring( rpc, pretty_print=True).decode('utf8'), anchor_time=anchor_time) self.subscriptions[sid] = sub # Generate response res_map = { None: 'urn:ietf:params:xml:ns:yang:ietf-subscribed-notifications' } # id tag containing the subscription id res = etree.Element('id', nsmap=res_map) res.text = str(sid) logger.debug(etree.tostring(rpc, pretty_print=True).decode('utf8')) logger.debug(etree.tostring(res, pretty_print=True).decode('utf8')) if not self.datasource.xpath_exists(sub.datastore_xpath_filter): raise ValueError("XPath does not correspond to any data") PeriodicNotificationThread(sub, self.datasource, session) return res
def rpc_my_cool_rpc(self, session, rpc, *params): data = ncutil.elm("data") data.append(ncutil.leaf_elm("pfx:result", "RPC result string")) return data
def get_all_values(): leaf_elms = [] for key, valuef in get_data_methods.items(): leaf_elms.append(ncutil.leaf_elm(key, valuef())) return leaf_elms
def main(args): if not args: return #print(type(args)) #return #TODO: check if args is a valid IP nsmap_add("sys", "urn:ietf:params:xml:ns:yang:ietf-system") MODEL_NS = "urn:my-urn:my-model" nsmap_add('pfx', MODEL_NS) keyFileToSend = "python/cwCA/intermediate/certs/www.ap.controlware.com.cert.pem" privateKeyFile = "/usr/src/app/python/vendorCA/intermediate/private/www.ownership.vendor1.com.key.pem" fileString = getCertStringfromFile(keyFileToSend) sign = signString(privateKeyFile, b"password", fileString.encode('ascii'), "sha256") #Encode signature so it can be send as a string sign_base64 = base64.b64encode(sign) utf8Signature = sign_base64.decode('utf-8') ownershipRPC = util.elm("ownership") cert = OpenSSL.crypto.load_certificate( OpenSSL.crypto.FILETYPE_PEM, getCertStringfromFile( '/usr/src/app/python/vendorCA/intermediate/certs/www.ownership.vendor1.com.cert.pem' )) #if verifyString(cert, sign, fileString.encode('ascii'),"sha256"): if verifyString( '/usr/src/app/python/vendorCA/intermediate/certs/www.ownership.vendor1.com.cert.pem', sign, fileString.encode('ascii'), "sha256"): ownerCertificate = util.subelm(ownershipRPC, "ownerCertificate") ownerCertificate.append(util.leaf_elm("certificate", fileString)) #ownerCertificate.append(util.leaf_elm("certificateSignature", sign_base64)) ownerCertificate.append( util.leaf_elm("certificateSignature", utf8Signature)) bootstrapRPC = util.elm("bootstrap") bootInfo = util.subelm(bootstrapRPC, "bootInfo") #bootInfo_base64 = base64.b64encode(asnString) bytebootstrapArtifact = buildbootstrapArtifact() bootInfo_base64 = base64.b64encode(bytebootstrapArtifact) utf8BootInfo = bootInfo_base64.decode('utf-8') privateKeyFile = "/usr/src/app/python/cwCA/intermediate/private/www.ap.controlware.com.key.pem" sign = signString(privateKeyFile, b"password", utf8BootInfo.encode('ascii'), "sha256") sign_base64 = base64.b64encode(sign) utf8Signature = sign_base64.decode('utf-8') bootInfo.append(util.leaf_elm("bootInfoASN", utf8BootInfo)) if verifyString( '/usr/src/app/python/cwCA/intermediate/certs/www.ap.controlware.com.cert.pem', sign, utf8BootInfo.encode('ascii'), "sha256"): bootInfo.append(util.leaf_elm("bootInfoSignature", utf8Signature)) #TODO: not hardcode session = NetconfSSHSession(args, "8300", "admin", "admin", debug=True) root, reply, replystring = session.send_rpc(ownershipRPC) root, reply, replystring = session.send_rpc(bootstrapRPC) session.close() dataElem = reply.find("nc:data", namespaces=NSMAP) x = dataElem.find("nc:result", namespaces=NSMAP) if x is not None: print(x.text) else: print("not found")
def rpc_get(self, session, rpc, filter_or_none): # pylint: disable=W0613 data = ncutil.elm("data") cont = ncutil.subelm(data, "interfaces") listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "Ethernet0/0")) listval.append(ncutil.leaf_elm("shutdown", "true")) listval.append(ncutil.leaf_elm("state", "down")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "Ethernet0/1")) listval.append(ncutil.leaf_elm("shutdown", "false")) listval.append(ncutil.leaf_elm("state", "down")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "FastEthernet1/0")) listval.append(ncutil.leaf_elm("shutdown", "false")) listval.append(ncutil.leaf_elm("state", "up")) listval = ncutil.subelm(cont, "interface") listval.append(ncutil.leaf_elm("name", "FastEthernet1/1")) listval.append(ncutil.leaf_elm("shutdown", "false")) listval.append(ncutil.leaf_elm("state", "down")) return ncutil.filter_results(rpc, data, filter_or_none)
from netconf.client import NetconfSSHSession from lxml import etree import netconf.util as util from netconf import nsmap_add, nsmap_update from netconf import NSMAP import re nsmap_add("sys", "urn:ietf:params:xml:ns:yang:ietf-system") MODEL_NS = "urn:my-urn:my-model" nsmap_add('pfx', MODEL_NS) #nsmap_update({'pfx': MODEL_NS}) data = util.elm("bootstrap") redirect = util.subelm(data, "redirect-information") boots_server = util.subelm(redirect, "bootstrap-server") boots_server.append(util.leaf_elm("address", "172.17.0.1")) boots_server.append(util.leaf_elm("port", "8300")) boots_server.append(util.leaf_elm("trust_anchor", "undefined")) onboard = util.subelm(data, "onboarding-information") boot_img = util.subelm(onboard, "boot-image") boot_img.append(util.leaf_elm("os-name", "IOS")) boot_img.append(util.leaf_elm("os-version", "16.8")) boot_img.append(util.leaf_elm("download-uri", "tftp://10.0.0.1/files")) img_verification = util.subelm(boot_img, "image-verification") img_verification.append(util.leaf_elm("hash-algorithm", "md5")) img_verification.append(util.leaf_elm("hash-value", "12345678")) onboard.append(util.leaf_elm("configuration-handling", "append")) onboard.append(util.leaf_elm("pre-configuration-script", "pre.py")) onboard.append(util.leaf_elm("configuration", "tbd"))