diff --git a/software/ors-amarisoft/buildout.hash.cfg b/software/ors-amarisoft/buildout.hash.cfg index 0a9e67180f9c990a04b8a7a1d59e87775f34fed2..c6b21a019657584d18d5e5e2be3c1cd76812a726 100644 --- a/software/ors-amarisoft/buildout.hash.cfg +++ b/software/ors-amarisoft/buildout.hash.cfg @@ -16,7 +16,7 @@ [template] filename = instance.cfg -md5sum = 2e30c07c6436895ac0bc6c177cf7013d +md5sum = f096f3cbb414730a9f0d46b0c0f5eb22 [template-ors] filename = instance-ors.cfg @@ -24,7 +24,7 @@ md5sum = f5c76c3443b75569eb18503dce38e783 [slaplte.jinja2] _update_hash_filename_ = slaplte.jinja2 -md5sum = 871ade334f445e22d6cb473e4d4e3522 +md5sum = 27c49897c9a3e4c260105534bed0132d [ru_amarisoft-stats.jinja2.py] _update_hash_filename_ = ru/amarisoft-stats.jinja2.py @@ -36,44 +36,16 @@ md5sum = ab666fdfadbfc7d8a16ace38d295c883 [ru_libinstance.jinja2.cfg] _update_hash_filename_ = ru/libinstance.jinja2.cfg -md5sum = 2dda7713832be83d94522c7abb4901f9 +md5sum = 7613c4decd4468ab5d826421aef955f1 [ru_sdr_libinstance.jinja2.cfg] _update_hash_filename_ = ru/sdr/libinstance.jinja2.cfg md5sum = b7906ca3a6b17963f78f680fc0842b74 -[ru_lopcomm_libinstance.jinja2.cfg] -_update_hash_filename_ = ru/lopcomm/libinstance.jinja2.cfg -md5sum = c3bd882559ab9cd2a068519ea5d8c92e - [ru_sunwave_libinstance.jinja2.cfg] _update_hash_filename_ = ru/sunwave/libinstance.jinja2.cfg md5sum = bc5d82b8737b6990674b280ef2774be7 -[ru_lopcomm_ncclient_common.py] -_update_hash_filename_ = ru/lopcomm/ncclient_common.py -md5sum = 8dbe6a48fc0fca4f0cbd0c746be1aeda - -[ru_lopcomm_stats.jinja2.py] -_update_hash_filename_ = ru/lopcomm/stats.jinja2.py -md5sum = b7ec0025a92e0947e4ac6abc4b06bf19 - -[ru_lopcomm_config.jinja2.py] -_update_hash_filename_ = ru/lopcomm/config.jinja2.py -md5sum = 122726666d147447171dcae9ebf8d093 - -[ru_lopcomm_reset-info.jinja2.py] -_update_hash_filename_ = ru/lopcomm/reset-info.jinja2.py -md5sum = 3d78df1993211efaabd3dc6f2ec8de30 - -[ru_lopcomm_reset.jinja2.py] -_update_hash_filename_ = ru/lopcomm/reset.jinja2.py -md5sum = 9741fbc99aaf768e9cc3ab48925dfee5 - -[ru_lopcomm_software.jinja2.py] -_update_hash_filename_ = ru/lopcomm/software.jinja2.py -md5sum = 2b08bb666c5f3ab287cdddbfdb4c9249 - [ru_tapsplit] _update_hash_filename_ = ru/tapsplit md5sum = 700aab566289619fb83ac6f3b085d983 @@ -150,14 +122,6 @@ md5sum = f07c85916bcb7e4002c8edc3d087c1be filename = config/ue.jinja2.cfg md5sum = 62291a11fd36a42464901cdc81338687 -[ru_lopcomm_CreateProcessingEle.jinja2.xml] -_update_hash_filename_ = ru/lopcomm/CreateProcessingEle.jinja2.xml -md5sum = e435990eb0a0d4be41efa9bd16dce09b - -[ru_lopcomm_cu_config.jinja2.xml] -_update_hash_filename_ = ru/lopcomm/cu_config.jinja2.xml -md5sum = 346c911e1ac5e5001a39c8926b44c91e - [software.cfg.html] _update_hash_filename_ = gadget/software.cfg.html md5sum = 61a2f783fbf683a34aed3d13e00baca2 diff --git a/software/ors-amarisoft/cell/common.json b/software/ors-amarisoft/cell/common.json index 9dc656f99fcadd710ccfc944f6cec4fcaad53144..6d2a4110a54a2633bafc7db655f15b58a266e947 100644 --- a/software/ors-amarisoft/cell/common.json +++ b/software/ors-amarisoft/cell/common.json @@ -105,9 +105,6 @@ { "$ref": "../ru/sdr/input-schema.json" }, - { - "$ref": "../ru/lopcomm/input-schema.json" - }, { "$ref": "../ru/sunwave/input-schema.json" } diff --git a/software/ors-amarisoft/instance.cfg b/software/ors-amarisoft/instance.cfg index f319763940f2aa69508f113e11283b52a1920004..5289b5ea144bdd025ced3de7a67ccef764a2f6f3 100644 --- a/software/ors-amarisoft/instance.cfg +++ b/software/ors-amarisoft/instance.cfg @@ -46,7 +46,6 @@ import-list = rawfile slaplte.jinja2 ${slaplte.jinja2:target} rawfile ru_libinstance.jinja2.cfg ${ru_libinstance.jinja2.cfg:target} rawfile ru_sdr_libinstance.jinja2.cfg ${ru_sdr_libinstance.jinja2.cfg:target} - rawfile ru_lopcomm_libinstance.jinja2.cfg ${ru_lopcomm_libinstance.jinja2.cfg:target} rawfile ru_sunwave_libinstance.jinja2.cfg ${ru_sunwave_libinstance.jinja2.cfg:target} # activate eggs and modules used in jinja2 templates @@ -158,16 +157,6 @@ extra-context = raw sib23_template ${sib23.jinja2.asn:target} raw ru_amarisoft_stats_template ${ru_amarisoft-stats.jinja2.py:target} raw ru_amarisoft_rf_info_template ${ru_amarisoft-rf-info.jinja2.py:target} - raw ru_lopcomm_stats_template ${ru_lopcomm_stats.jinja2.py:target} - raw ru_lopcomm_config_template ${ru_lopcomm_config.jinja2.py:target} - raw ru_lopcomm_software_template ${ru_lopcomm_software.jinja2.py:target} - raw ru_lopcomm_reset_info_template ${ru_lopcomm_reset-info.jinja2.py:target} - raw ru_lopcomm_reset_template ${ru_lopcomm_reset.jinja2.py:target} - raw ru_lopcomm_CreateProcessingEle_template ${ru_lopcomm_CreateProcessingEle.jinja2.xml:target} - raw ru_lopcomm_cu_config_template ${ru_lopcomm_cu_config.jinja2.xml:target} - raw ru_lopcomm_cu_inactive_config_template ${ru_lopcomm_cu_config.jinja2.xml:target} - raw ru_lopcomm_firmware_path ${ru_lopcomm_firmware-dl:target} - raw ru_lopcomm_firmware_filename ${ru_lopcomm_firmware-dl:filename} raw ru_tapsplit ${ru_tapsplit:target} raw netcapdo ${netcapdo:exe} raw openssl_location ${openssl:location} @@ -217,16 +206,6 @@ extra-context = raw ru_amarisoft_stats_template ${ru_amarisoft-stats.jinja2.py:target} raw ru_amarisoft_rf_info_template ${ru_amarisoft-rf-info.jinja2.py:target} - raw ru_lopcomm_stats_template ${ru_lopcomm_stats.jinja2.py:target} - raw ru_lopcomm_config_template ${ru_lopcomm_config.jinja2.py:target} - raw ru_lopcomm_software_template ${ru_lopcomm_software.jinja2.py:target} - raw ru_lopcomm_reset_info_template ${ru_lopcomm_reset-info.jinja2.py:target} - raw ru_lopcomm_reset_template ${ru_lopcomm_reset.jinja2.py:target} - raw ru_lopcomm_CreateProcessingEle_template ${ru_lopcomm_CreateProcessingEle.jinja2.xml:target} - raw ru_lopcomm_cu_config_template ${ru_lopcomm_cu_config.jinja2.xml:target} - raw ru_lopcomm_cu_inactive_config_template ${ru_lopcomm_cu_config.jinja2.xml:target} - raw ru_lopcomm_firmware_path ${ru_lopcomm_firmware-dl:target} - raw ru_lopcomm_firmware_filename ${ru_lopcomm_firmware-dl:filename} raw ru_tapsplit ${ru_tapsplit:target} raw netcapdo ${netcapdo:exe} raw ru_dnsmasq_template ${ru_dnsmasq.jinja2.cfg:target} diff --git a/software/ors-amarisoft/ru/buildout.cfg b/software/ors-amarisoft/ru/buildout.cfg index 793d168913ea889241216b0b29ec739b8e390ba9..f5bc0c38d319624234e638bee9ef1217f67cf796 100644 --- a/software/ors-amarisoft/ru/buildout.cfg +++ b/software/ors-amarisoft/ru/buildout.cfg @@ -3,7 +3,6 @@ [buildout] extends = sdr/buildout.cfg - lopcomm/buildout.cfg sunwave/buildout.cfg parts += diff --git a/software/ors-amarisoft/ru/input-schema.json b/software/ors-amarisoft/ru/input-schema.json index e42c7887391710f2bc65d5135ef5eca3d8ad259b..3f29a450d94098021b7d2e808d9bd1399d3cce26 100644 --- a/software/ors-amarisoft/ru/input-schema.json +++ b/software/ors-amarisoft/ru/input-schema.json @@ -6,9 +6,6 @@ { "$ref": "sdr/input-schema.json" }, - { - "$ref": "lopcomm/input-schema.json" - }, { "$ref": "sunwave/input-schema.json" } diff --git a/software/ors-amarisoft/ru/libinstance.jinja2.cfg b/software/ors-amarisoft/ru/libinstance.jinja2.cfg index f458dc17f1a5495d7b677ee96d1152adb41cf638..dfb4d8240970ff3bf82012a87caffa59c480946b 100644 --- a/software/ors-amarisoft/ru/libinstance.jinja2.cfg +++ b/software/ors-amarisoft/ru/libinstance.jinja2.cfg @@ -53,10 +53,8 @@ config-stats-period = {{ slapparameter_dict.get("enb_stats_fetch_period", 60) }} {%- set jcell_ru_ref = slaplte.jcell_ru_ref %} {%- set ierror = slaplte.ierror %} {%- import 'ru_sdr_libinstance.jinja2.cfg' as rudrv_sdr with context %} -{%- import 'ru_lopcomm_libinstance.jinja2.cfg' as rudrv_lopcomm with context %} {%- import 'ru_sunwave_libinstance.jinja2.cfg' as rudrv_sunwave with context %} {%- set rudrv_dict = namespace(sdr=rudrv_sdr, - lopcomm=rudrv_lopcomm, sunwave=rudrv_sunwave) %} {%- set rudrv_init = {} %} diff --git a/software/ors-amarisoft/ru/lopcomm/CreateProcessingEle.jinja2.xml b/software/ors-amarisoft/ru/lopcomm/CreateProcessingEle.jinja2.xml deleted file mode 100644 index 380c700eaf7b92618464a9fe2a47d773941f09ed..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/CreateProcessingEle.jinja2.xml +++ /dev/null @@ -1,11 +0,0 @@ -<config xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"> - <processing-elements xmlns="urn:o-ran:processing-element:1.0"> - <transport-session-type>CPRI-INTERFACE</transport-session-type> - <ru-elements> - <name>PE0</name> - <transport-flow> - <interface-name>eth1</interface-name> - </transport-flow> - </ru-elements> - </processing-elements> -</config> \ No newline at end of file diff --git a/software/ors-amarisoft/ru/lopcomm/buildout.cfg b/software/ors-amarisoft/ru/lopcomm/buildout.cfg deleted file mode 100644 index bc6b3a2c7022fb8f97e791a1f1d7b1a6e2d1da0e..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/buildout.cfg +++ /dev/null @@ -1,39 +0,0 @@ -# ru/lopcomm/buildout.cfg provides software code for handling Lopcomm ORAN Radio Units. - -[buildout] -parts += - ru_lopcomm_ncclient_common.py - -[ru_lopcomm_libinstance.jinja2.cfg] -<= download-base - -[ru_lopcomm_config.jinja2.py] -<= download-base - -[ru_lopcomm_reset-info.jinja2.py] -<= download-base - -[ru_lopcomm_reset.jinja2.py] -<= download-base - -[ru_lopcomm_stats.jinja2.py] -<= download-base - -[ru_lopcomm_software.jinja2.py] -<= download-base - -[ru_lopcomm_ncclient_common.py] -<= download-base -destination = ${buildout:directory}/ncclient_common.py - -[ru_lopcomm_CreateProcessingEle.jinja2.xml] -<= download-base - -[ru_lopcomm_cu_config.jinja2.xml] -<= download-base - -[ru_lopcomm_firmware-dl] -recipe = slapos.recipe.build:download -url = https://lab.nexedi.com/nexedi/ors-utils/raw/master/lopcomm-firmware/${:filename} -filename = PR.PRM61C70V1005.005.tar.gz -md5sum = 62281d0be42feac94e843e1850ba6e09 diff --git a/software/ors-amarisoft/ru/lopcomm/config.jinja2.py b/software/ors-amarisoft/ru/lopcomm/config.jinja2.py deleted file mode 100644 index 639987ae0402e275b6e8a0316d1fbe69b578845e..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/config.jinja2.py +++ /dev/null @@ -1,19 +0,0 @@ -#!{{ python_path }} -import time -import sys -sys.path.append({{ repr(buildout_directory_path) }}) -from ncclient_common import LopcommNetconfClient - -if __name__ == '__main__': - nc = LopcommNetconfClient(log_file="{{ log_file }}") - while True: - try: - nc.connect("{{ netaddr.IPAddress(vtap.gateway) }}", 830, "oranuser", "oranpassword") - nc.edit_config(["{{ CreateProcessingEle_template }}", "{{ cu_inactive_config_template }}", "{{ cu_config_template }}"]) - break - except Exception as e: - nc.logger.debug('Got exception, waiting 10 seconds before reconnecting...') - nc.logger.debug(e) - time.sleep(10) - finally: - nc.close() diff --git a/software/ors-amarisoft/ru/lopcomm/cu_config.jinja2.xml b/software/ors-amarisoft/ru/lopcomm/cu_config.jinja2.xml deleted file mode 100644 index 9b0f180165f05b10e69ca9cd80bc8257de699915..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/cu_config.jinja2.xml +++ /dev/null @@ -1,132 +0,0 @@ -<xc:config xmlns:xc="urn:ietf:params:xml:ns:netconf:base:1.0"> - <user-plane-configuration xc:operation="replace" xmlns="urn:o-ran:uplane-conf-option8:1.0"> - <!-- TX path: eaxcid → TxEndpoint - ↘ - mod → static TxEndpoint → TxArray - ↗ - TxCarrier - - (static TxEndpoint, TxArray and their association are defined by RU itself) - --> -{%- set TxCarrier = 'TXA0CC00' %} -{%- for ant in range(ru.n_antenna_dl) %} -{%- set port = ant // 2 %} -{%- set chan = ant % 2 %} -{%- set txep = 'TXA0P%02dC%02d' % (port, chan) %} - - <!-- TxAntenna{{ ant }} --> - <tx-endpoints> - <name>{{ txep }}</name> - <e-axcid> - <o-du-port-bitmask>61440</o-du-port-bitmask> - <band-sector-bitmask>3968</band-sector-bitmask> - <ccid-bitmask>112</ccid-bitmask> - <ru-port-bitmask>15</ru-port-bitmask> - <eaxc-id>{{ ant }}</eaxc-id> - </e-axcid> - </tx-endpoints> - <tx-links> - <name>{{ txep }}</name> - <processing-element>PE0</processing-element> - <tx-array-carrier>{{ TxCarrier }}</tx-array-carrier> - <tx-endpoint>{{ txep }}</tx-endpoint> - </tx-links> -{%- endfor %} - - - <!-- - RX path: eaxcid ↠RxEndpoint - (data ∪ prach) - ↖ - demod ↠static RxEndpoint ↠RxArray - ↗ - RxCarrier - - (static RxEndpoint, RxArray and their association are defined by RU itself) - --> -{%- set RxCarrier = 'RXA0CC00' %} -{%- for ant in range(ru.n_antenna_ul) %} -{%- set port = ant // 2 %} -{%- set chan = ant % 2 %} -{%- set rxep = 'RXA0P%02dC%02d' % (port, chan) %} -{%- set prachep = 'PRACH0P%02dC%02d' % (port, chan) %} - - <!-- RxAntenna{{ ant }} --> - <rx-endpoints> - <name>{{ rxep }}</name> - <e-axcid> - <o-du-port-bitmask>61440</o-du-port-bitmask> - <band-sector-bitmask>3968</band-sector-bitmask> - <ccid-bitmask>112</ccid-bitmask> - <ru-port-bitmask>15</ru-port-bitmask> - <eaxc-id>{{ ant }}</eaxc-id> - </e-axcid> - </rx-endpoints> - <rx-endpoints> - <name>{{ prachep }}</name> - <e-axcid> - <o-du-port-bitmask>61440</o-du-port-bitmask> - <band-sector-bitmask>3968</band-sector-bitmask> - <ccid-bitmask>112</ccid-bitmask> - <ru-port-bitmask>15</ru-port-bitmask> - <eaxc-id>{{ 16*chan + 8 + port }}</eaxc-id> - </e-axcid> - </rx-endpoints> - <rx-links> - <name>{{ rxep }}</name> - <processing-element>PE0</processing-element> - <rx-array-carrier>{{ RxCarrier }}</rx-array-carrier> - <rx-endpoint>{{ rxep }}</rx-endpoint> - </rx-links> - <rx-links> - <name>{{ prachep }}</name> - <processing-element>PE0</processing-element> - <rx-array-carrier>{{ RxCarrier }}</rx-array-carrier> - <rx-endpoint>{{ prachep }}</rx-endpoint> - </rx-links> -{%- endfor %} - - - <!-- TX/RX carriers --> - <!-- TODO support multiple cells over 1 RU --> -{%- if cell.cell_type == 'lte' %} -{%- set dl_arfcn = cell.dl_earfcn %} -{%- set ul_arfcn = cell.ul_earfcn %} -{%- set dl_freq = int(xearfcn_module.frequency(dl_arfcn) * 1e6) %} -{%- set ul_freq = int(xearfcn_module.frequency(ul_arfcn) * 1e6) %} -{%- elif cell.cell_type == 'nr' %} -{%- set dl_arfcn = cell.dl_nr_arfcn %} -{%- set ul_arfcn = cell.ul_nr_arfcn %} -{%- set dl_freq = int(xnrarfcn_module.frequency(dl_arfcn) * 1e6) %} -{%- set ul_freq = int(xnrarfcn_module.frequency(ul_arfcn) * 1e6) %} -{%- else %} -{%- do bug('unreachable') %} -{%- endif %} -{%- set bw = int(cell.bandwidth * 1e6) %} - <tx-array-carriers> - <name>{{ TxCarrier }}</name> - <absolute-frequency-center>{{ dl_arfcn }}</absolute-frequency-center> - <center-of-channel-bandwidth>{{ dl_freq }}</center-of-channel-bandwidth> - <channel-bandwidth>{{ bw }}</channel-bandwidth> - <active>{{ ru.txrx_active }}</active> - <rw-type>{{ cell.cell_type | upper }}</rw-type> - <rw-duplex-scheme>{{ cell.rf_mode | upper }}</rw-duplex-scheme> - <gain>{{ ru.tx_gain }}</gain> - <downlink-radio-frame-offset>0</downlink-radio-frame-offset> - <downlink-sfn-offset>0</downlink-sfn-offset> - </tx-array-carriers> - <rx-array-carriers> - <name>{{ RxCarrier }}</name> - <absolute-frequency-center>{{ ul_arfcn }}</absolute-frequency-center> - <center-of-channel-bandwidth>{{ ul_freq }}</center-of-channel-bandwidth> - <channel-bandwidth>{{ bw }}</channel-bandwidth> - <active>{{ ru.txrx_active }}</active> - <downlink-radio-frame-offset>0</downlink-radio-frame-offset> - <downlink-sfn-offset>0</downlink-sfn-offset> - <!-- <gain>{{ ru.rx_gain }}</gain> --> - <!-- TODO(lu.xu): clarify with Lopcomm regaring rx gain --> - <gain-correction>0.0</gain-correction> - <n-ta-offset>0</n-ta-offset> - </rx-array-carriers> - </user-plane-configuration> -</xc:config> diff --git a/software/ors-amarisoft/ru/lopcomm/input-schema.json b/software/ors-amarisoft/ru/lopcomm/input-schema.json deleted file mode 100644 index 76a75e6b492187f0d56c87b1eb6f6c97514acc52..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/input-schema.json +++ /dev/null @@ -1,64 +0,0 @@ -{ - "$schema": "https://json-schema.org/draft/2020-12/schema", - "title": "Lopcomm ORAN", - "type": "object", - "required": [ - "ru_type", - "ru_link_type", - "n_antenna_dl", - "n_antenna_ul", - "tx_gain", - "rx_gain", - "cpri_link", - "mac_addr" - ], - "properties": { - "$ref": "../../ru/common.json#/properties", - "ru_type": { - "$ref": "#/properties/ru_type", - "const": "lopcomm" - }, - "ru_link_type": { - "$ref": "#/properties/ru_link_type", - "const": "cpri" - }, - "n_antenna_dl": { - "$ref": "#/properties/n_antenna_dl", - "default": 2 - }, - "n_antenna_ul": { - "$ref": "#/properties/n_antenna_ul", - "default": 2 - }, - "cpri_link": { - "$ref": "#/properties/cpri_link", - "properties": { - "$ref": "#/properties/cpri_link/properties", - "mapping": { - "$ref": "#/properties/cpri_link/properties/mapping", - "const": "hw", - "enum": [ - "hw" - ] - }, - "rx_delay": { - "$ref": "#/properties/cpri_link/properties/rx_delay", - "default": 25.11 - }, - "tx_delay": { - "$ref": "#/properties/cpri_link/properties/tx_delay", - "default": 14.71 - }, - "tx_dbm": { - "$ref": "#/properties/cpri_link/properties/tx_dbm", - "default": 63 - } - } - }, - "reset_schedule": { - "title": "Cron schedule for RRH reset", - "description": "Refer https://crontab.guru/ to make a reset schedule for RRH, for example, '0 1 * * *' means the RRH will reset every day at 1 am", - "type": "string" - } - } -} diff --git a/software/ors-amarisoft/ru/lopcomm/libinstance.jinja2.cfg b/software/ors-amarisoft/ru/lopcomm/libinstance.jinja2.cfg deleted file mode 100644 index 5c92f2980d0c5428d7c2c8205bd1a30cae50c05c..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/libinstance.jinja2.cfg +++ /dev/null @@ -1,314 +0,0 @@ -{#- Package ru/lopcomm/libinstance provides instance code for handling Lopcomm ORAN Radio Units. #} - -{%- macro buildout_iru(iru, icell_list) %} -{%- set ru_ref = J(jref_of_shared(iru)) %} -{%- set ru = iru['_'] %} -{%- set ns = namespace(inactive_ru=ru.copy()) %} -{%- do ns.inactive_ru.update({'txrx_active': 'INACTIVE'}) %} - -{%- if len(icell_list) != 1 %} -{%- do ierror(iru, 'ru/lopcomm supports only 1 cell ; requested %d' % len(icell_list)) %} -{%- endif %} -{%- set icell = icell_list[0] %} -{%- set cell = icell['_'] %} - -{#- indicate whether RU is listening for netconf #} - -{%- if not testing %} -{{ promise('%s-netconf-socket' % ru_ref) }} -promise = check_socket_listening -config-host = ${vtap.{{ru.cpri_link._tap}}:gateway} -config-port = 830 -{%- endif %} - - -{#- push firmware to RU #} - -{{ part('%s-software-template' % ru_ref) }} -recipe = slapos.recipe.template:jinja2 -extensions = jinja2.ext.do -_logbase = ${directory:var}/log/{{B('%s-software' % ru_ref)}} -log-output = ${:_logbase}.log -software-reply-json-log-output = ${:_logbase}-reply.json.log -remote-file-path = sftp://${user-info:pw-name}@[${sshd-service:ipv6}]:${sshd-service:port}{{ru_lopcomm_firmware_path}} -is_firmware_updated = ${directory:etc}/{{B('%s.is_firmware_updated' % ru_ref)}} -context = - section directory directory - section vtap vtap.{{ ru.cpri_link._tap }} - key slapparameter_dict myslap:parameter_dict - key log_file :log-output - key software_reply_json_log_file :software-reply-json-log-output - key remote_file_path :remote-file-path - raw testing {{ testing }} - raw python_path {{ buildout_directory}}/bin/pythonwitheggs - raw buildout_directory_path {{ buildout_directory }} - key is_firmware_updated :is_firmware_updated - raw firmware_name {{ru_lopcomm_firmware_filename}} - import netaddr netaddr -mode = 0775 -url = {{ ru_lopcomm_software_template }} -output = ${directory:script}/{{B('%s-software.py' % ru_ref)}} - -{%- if not testing %} -{{ promise('%s-firmware' % ru_ref) }} -promise = check_command_execute -config-command = [ -f ${ {{-B('%s-software-template' % ru_ref)}}:is_firmware_updated} ] -{%- endif %} - - -[{{ B('%s-cu-config' % ru_ref) }}] -<= config-base -url = {{ ru_lopcomm_cu_config_template }} -output = ${directory:etc}/{{B('%s-cu_config.xml' % ru_ref)}} -extra-context = - import xearfcn_module xlte.earfcn - import xnrarfcn_module xlte.nrarfcn - key ru :ru - key cell :cell -ru = {{ dumps(ru) }} -cell = {{ dumps(cell) }} - -[{{ B('%s-cu-inactive-config' % ru_ref) }}] -<= config-base -url = {{ ru_lopcomm_cu_config_template }} -output = ${directory:etc}/{{B('%s-cu_inactive_config.xml' % ru_ref)}} -extra-context = - import xearfcn_module xlte.earfcn - import xnrarfcn_module xlte.nrarfcn - key ru :ru - key cell :cell -ru = {{ dumps(ns.inactive_ru) }} -cell = {{ dumps(cell) }} - -[{{ B('%s-config-template' % ru_ref) }}] -recipe = slapos.recipe.template:jinja2 -extensions = jinja2.ext.do -log-output = ${directory:var}/log/{{B('%s-config.log' % ru_ref)}} -context = - section directory directory - section vtap vtap.{{ ru.cpri_link._tap }} - key log_file :log-output - raw testing {{ testing }} - raw python_path {{ buildout_directory}}/bin/pythonwitheggs - raw buildout_directory_path {{ buildout_directory }} - raw CreateProcessingEle_template {{ ru_lopcomm_CreateProcessingEle_template }} - key cu_config_template {{B('%s-cu-config' % ru_ref)}}:output - key cu_inactive_config_template {{B('%s-cu-inactive-config' % ru_ref)}}:output - import netaddr netaddr -mode = 0775 -url = {{ ru_lopcomm_config_template }} -output = ${directory:script}/{{B('%s-config.py' % ru_ref)}} - -{{ promise('%s-config-log' % ru_ref) }} -promise = check_lopcomm_config_log -config-config-log = ${ {{-B('%s-config-template' % ru_ref)}}:log-output} - - -{#- handle notifications from RU + keep on touching RU watchdog #} - -[{{ B('%s-stats-template' % ru_ref) }}] -recipe = slapos.recipe.template:jinja2 -extensions = jinja2.ext.do -_logbase = ${directory:var}/log/{{B('%s' % ru_ref)}} -log-output = ${:_logbase}-stats.log -json-log-output = ${:_logbase}-stats.json.log -cfg-json-log-output = ${:_logbase}-config.json.log -supervision-json-log-output = ${:_logbase}-supervision.json.log -ncsession-json-log-output = ${:_logbase}-ncsession.json.log -software-json-log-output = ${:_logbase}-software.json.log -supervision-reply-json-log-output = ${:_logbase}-supervision-reply.json.log -is_netconf_connected = ${directory:etc}/{{B('%s.is_netconf_connected' % ru_ref)}} -context = - section directory directory - section vtap vtap.{{ ru.cpri_link._tap }} - key slapparameter_dict myslap:parameter_dict - key log_file :log-output - key json_log_file :json-log-output - key cfg_json_log_file :cfg-json-log-output - key supervision_json_log_file :supervision-json-log-output - key supervision_reply_json_log_file :supervision-reply-json-log-output - key is_netconf_connected :is_netconf_connected - key ncsession_json_log_file :ncsession-json-log-output - key software_json_log_file :software-json-log-output - raw testing {{ testing }} - raw python_path {{ buildout_directory}}/bin/pythonwitheggs - raw buildout_directory_path {{ buildout_directory }} - import netaddr netaddr -mode = 0775 -url = {{ ru_lopcomm_stats_template }} -output = ${directory:bin}/{{B('%s-stats.py' % ru_ref)}} - -{{ part('%s-stats-service' % ru_ref) }} -recipe = slapos.cookbook:wrapper -command-line = ${ {{-B('%s-stats-template' % ru_ref)}}:output} -wrapper-path = ${directory:service}/{{B('%s-stats' % ru_ref)}} -mode = 0775 -hash-files = - ${:command-line} - -{%- if not testing %} -{{ promise('%s-netconf-connection' % ru_ref) }} -promise = check_command_execute -config-command = [ -f ${ {{-B('%s-stats-template' % ru_ref)}}:is_netconf_connected} ] -{%- endif %} - -{{ promise('%s-vswr' % ru_ref) }} -promise = check_lopcomm_vswr -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-rssi' % ru_ref) }} -promise = check_lopcomm_rssi -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-pa-current' % ru_ref) }} -promise = check_lopcomm_pa_current -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-pa-output-power' % ru_ref) }} -promise = check_lopcomm_pa_output_power -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-sync' % ru_ref) }} -promise = check_lopcomm_sync -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-lof' % ru_ref) }} -promise = check_lopcomm_lof -config-netconf-log = ${ {{-B('%s-stats-template' % ru_ref)}}:json-log-output} - -{{ promise('%s-stats-log' % ru_ref) }} -promise = check_lopcomm_stats_log -config-stats-log = ${ {{-B('%s-stats-template' % ru_ref)}}:log-output} - - -{#- reset RU periodically #} - -{%- if ru.get("reset_schedule") %} - -[{{ B('%s-reset-info-template' % ru_ref) }}] -recipe = slapos.recipe.template:jinja2 -extensions = jinja2.ext.do -_logbase = ${directory:var}/log/{{B('%s-reset-info' % ru_ref)}} -log-output = ${:_logbase}.log -json-log-output = ${:_logbase}.json.log -context = - section vtap vtap.{{ ru.cpri_link._tap }} - key log_file :log-output - key json_log_file :json-log-output - raw stats_period {{ slapparameter_dict.get("enb_stats_fetch_period", 60) }} - raw testing {{ testing }} - raw python_path {{ buildout_directory}}/bin/pythonwitheggs - import netaddr netaddr -mode = 0775 -url = {{ ru_lopcomm_reset_info_template }} -output = ${directory:bin}/{{B('%s-reset-info.py' % ru_ref)}} - -[{{ B('%s-reset-template' % ru_ref) }}] -recipe = slapos.recipe.template:jinja2 -extensions = jinja2.ext.do -_logbase = ${directory:var}/log/{{B('%s-reset' % ru_ref)}} -log-output = ${:_logbase}.log -json-log-output = ${:_logbase}.json.log -context = - section vtap vtap.{{ ru.cpri_link._tap }} - key log_file :log-output - raw python_path {{ buildout_directory}}/bin/pythonwitheggs - raw buildout_directory_path {{ buildout_directory }} - import netaddr netaddr -mode = 0775 -url = {{ ru_lopcomm_reset_template }} -output = ${directory:etc}/{{B('%s-reset.py' % ru_ref)}} - -{{ part('%s-reset-cron' % ru_ref) }} -recipe = slapos.cookbook:cron.d -cron-entries = ${cron:cron-entries} -name = {{B('%s-reset' % ru_ref)}} -frequency = {{ ru.reset_schedule }} -command = {{ buildout_directory}}/bin/pythonwitheggs ${ {{-B('%s-reset-template' % ru_ref)}}:output} - -{{ part('%s-reset-info-service' % ru_ref) }} -recipe = slapos.cookbook:wrapper -command-line = ${ {{-B('%s-reset-info-template' % ru_ref)}}:output} -wrapper-path = ${directory:service}/{{B('%s-reset-info' % ru_ref)}} -mode = 0775 -hash-files = - ${:command-line} - -{%- endif %} - - -{#- amend RU-published information with Lopcomm-specific bits #} -[{{ B('ipublish-%s' % ru_ref) }}] -bbu-ssh-command = ssh ${user-info:pw-name}@${sshd-service:ipv6} -p ${sshd-service:port} -bbu-ssh-url = ssh://${user-info:pw-name}@[${sshd-service:ipv6}]:${sshd-service:port} -firmware = {{ru_lopcomm_firmware_filename}} - -{%- endmacro %} - - -{%- macro buildout() %} - -# deploy openssh-server for software upgrade -# -# FIXME user-authorized-key is global for eNB. Either we need to put SSH server -# to be also global, or unroll an SSH server via paramiko inside -# ru/lopcomm/software.py just to handle software upgrades there. -[user-info] -recipe = slapos.cookbook:userinfo - -[sshd-port] -recipe = slapos.cookbook:free_port -minimum = 22222 -maximum = 22231 -ip = {{my_ipv6}} - -[sshd-config] -recipe = slapos.recipe.template:jinja2 -output = ${directory:etc}/sshd.conf -path_pid = ${directory:run}/sshd.pid -inline = - PidFile ${:path_pid} - Port ${sshd-port:port} - ListenAddress ${sshd-port:ip} - Protocol 2 - HostKey ${sshd-ssh-host-rsa-key:output} - HostKey ${sshd-ssh-host-ecdsa-key:output} - PasswordAuthentication no - PubkeyAuthentication yes - HostKeyAlgorithms ssh-rsa,rsa-sha2-512,rsa-sha2-256,ecdsa-sha2-nistp521 - AuthorizedKeysFile ${buildout:directory}/.ssh/authorized_keys - Subsystem sftp {{ openssh_location }}/libexec/sftp-server - -{{ part('sshd-service') }} -recipe = slapos.cookbook:wrapper -command-line = {{ openssh_location }}/sbin/sshd -D -e -f ${sshd-config:output} -wrapper-path = ${directory:service}/sshd -hash-files = ${sshd-config:output} -environment = - HOME=${directory:home} -ipv6 = ${sshd-port:ip} -port = ${sshd-port:port} - -{{ part('sshd-add-authorized-key') }} -recipe = slapos.cookbook:dropbear.add_authorized_key -home = ${buildout:directory} -key = {{ slapparameter_dict.get("user-authorized-key", '') }} - -[sshd-ssh-keygen-base] -recipe = plone.recipe.command -output = ${directory:etc}/${:_buildout_section_name_} -command = {{ openssh_output_keygen }} -f ${:output} -N '' ${:extra-args} - -[sshd-ssh-host-rsa-key] -<=sshd-ssh-keygen-base -extra-args=-t rsa -[sshd-ssh-host-ecdsa-key] -<=sshd-ssh-keygen-base -extra-args=-t ecdsa -b 521 - -{{ promise('sshd') }} -promise = check_socket_listening -config-host = ${sshd-service:ipv6} -config-port = ${sshd-service:port} - -{%- endmacro %} diff --git a/software/ors-amarisoft/ru/lopcomm/ncclient_common.py b/software/ors-amarisoft/ru/lopcomm/ncclient_common.py deleted file mode 100644 index bf4f690e696643039f8e76e87a196f40fbc55063..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/ncclient_common.py +++ /dev/null @@ -1,222 +0,0 @@ -import time -import logging -import json -import xmltodict -from logging.handlers import RotatingFileHandler -from ncclient import manager -from ncclient.operations import RPCError -from ncclient.xml_ import * -from ncclient.devices.default import DefaultDeviceHandler - -class LopcommNetconfClient: - - def __init__(self, log_file, json_log_file=None, cfg_json_log_file=None, supervision_json_log_file=None, ncsession_json_log_file=None, software_json_log_file=None, software_reply_json_log_file=None, supervision_reply_json_log_file=None, testing=False): - - self.logger = logging.getLogger('logger') - self.logger.setLevel(logging.DEBUG) - handler = RotatingFileHandler(log_file, maxBytes=100000, backupCount=5) - self.logger.addHandler(handler) - formatter = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s") - handler.setFormatter(formatter) - - if json_log_file: - self.json_logger = logging.getLogger('json_logger') - self.json_logger.setLevel(logging.DEBUG) - json_handler = RotatingFileHandler(json_log_file, maxBytes=100000, backupCount=5) - json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - json_handler.setFormatter(json_formatter) - self.json_logger.addHandler(json_handler) - - self.cfg_json_logger = logging.getLogger('cfg_json_logger') - self.cfg_json_logger.setLevel(logging.DEBUG) - cfg_json_handler = RotatingFileHandler(cfg_json_log_file, maxBytes=100000, backupCount=5) - cfg_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - cfg_json_handler.setFormatter(cfg_json_formatter) - self.cfg_json_logger.addHandler(cfg_json_handler) - - self.supervision_json_logger = logging.getLogger('supervision_json_logger') - self.supervision_json_logger.setLevel(logging.DEBUG) - supervision_json_handler = RotatingFileHandler(supervision_json_log_file, maxBytes=100000, backupCount=5) - supervision_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - supervision_json_handler.setFormatter(supervision_json_formatter) - self.supervision_json_logger.addHandler(supervision_json_handler) - - self.ncsession_json_logger = logging.getLogger('ncsession_json_logger') - self.ncsession_json_logger.setLevel(logging.DEBUG) - ncsession_json_handler = RotatingFileHandler(ncsession_json_log_file, maxBytes=100000, backupCount=5) - ncsession_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - ncsession_json_handler.setFormatter(ncsession_json_formatter) - self.ncsession_json_logger.addHandler(ncsession_json_handler) - - self.software_json_logger = logging.getLogger('software_json_logger') - self.software_json_logger.setLevel(logging.DEBUG) - software_json_handler = RotatingFileHandler(software_json_log_file, maxBytes=100000, backupCount=5) - software_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - software_json_handler.setFormatter(software_json_formatter) - self.software_json_logger.addHandler(software_json_handler) - - else: - self.json_logger = None - self.cfg_json_logger = None - self.supervision_json_logger = None - self.ncsession_json_logger = None - self.software_json_logger = None - - if supervision_reply_json_log_file: - self.supervision_reply_json_logger = logging.getLogger('supervision_reply_json_logger') - self.supervision_reply_json_logger.setLevel(logging.DEBUG) - supervision_reply_json_handler = RotatingFileHandler(supervision_reply_json_log_file, maxBytes=100000, backupCount=5) - supervision_reply_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - supervision_reply_json_handler.setFormatter(supervision_reply_json_formatter) - self.supervision_reply_json_logger.addHandler(supervision_reply_json_handler) - else: - self.supervision_reply_json_logger = None - - if software_reply_json_log_file: - self.software_reply_json_logger = logging.getLogger('software_reply_json_logger') - self.software_reply_json_logger.setLevel(logging.DEBUG) - software_reply_json_handler = RotatingFileHandler(software_reply_json_log_file, maxBytes=100000, backupCount=5) - software_reply_json_formatter = logging.Formatter('{"time": "%(asctime)s", "log_level": "%(levelname)s", "message": "%(message)s", "data": %(data)s}') - software_reply_json_handler.setFormatter(software_reply_json_formatter) - self.software_reply_json_logger.addHandler(software_reply_json_handler) - else: - self.software_reply_json_logger = None - - if testing: - return - - def connect(self, host, port, user, password): - self.address = (host, port) - self.logger.info('Connecting to %s, user %s...' % (self.address, user)) - self.conn = manager.connect(host=host, - port=port, - username=user, - password=password, - timeout=1800, - device_params={ - 'name': 'default' - }, - hostkey_verify=False) - self.logger.info('Connection to %s successful' % (self.address,)) - - def subscribe(self): - sub = self.conn.create_subscription() - self.logger.info('Subscription to %s successful' % (self.address,)) - def get_notification(self): - self.logger.debug('Waiting for notification from %s...' % (self.address,)) - result = self.conn.take_notification(block=True, timeout=120) - if result: - self.logger.debug('Got new notification from %s...' % (self.address,)) - result_in_xml = result._raw - data_dict = xmltodict.parse(result_in_xml) - if 'alarm-notif' in data_dict['notification']: - self.json_logger.info('', extra={'data': json.dumps(data_dict)}) - elif 'supervision-notification' in data_dict['notification']: - self.supervision_json_logger.info('', extra={'data': json.dumps(data_dict)}) - elif 'netconf-session-start' in data_dict['notification'] or 'netconf-session-end' in data_dict['notification']: - self.ncsession_json_logger.info('', extra={'data': json.dumps(data_dict)}) - elif any(event in data_dict['notification'] for event in ['install-event', 'activation-event', 'download-event']): - self.software_json_logger.info('', extra={'data': json.dumps(data_dict)}) - else: - self.cfg_json_logger.info('', extra={'data': json.dumps(data_dict)}) - else: - raise TimeoutError - def edit_config(self, config_files): - for config_file in config_files: - with open(config_file) as f: - config_xml = f.read() - try: - self.logger.info('Sending edit-config RPC request...') - self.conn.edit_config(target='running', config=config_xml) - self.logger.info('Edit-config RPC request sent successfully') - except RPCError as e: - self.logger.error('Error sending edit-config RPC request: %s' % e) - - def custom_rpc_request(self, rpc_xml): - try: - self.logger.info('Sending custom RPC request...') - response = self.conn.dispatch(to_ele(rpc_xml)) - if response.ok: - self.logger.info('Custom RPC request sent successfully') - return response.xml - else: - self.logger.error('Error sending custom RPC request: %s' % response.error) - except RPCError as e: - self.logger.error('Error sending custom RPC request: %s' % e) - - def reset_device(self): - self.logger.info('Resetting...') - reset_rpc_xml = """ - <reset xmlns="urn:o-ran:operations:1.0"> - </reset> - """ - reset_reply_xml = self.custom_rpc_request(reset_rpc_xml) - if reset_reply_xml: - reset_data = xmltodict.parse(reset_reply_xml) - if self.software_reply_json_logger: - self.software_reply_json_logger.info('', extra={'data': json.dumps(reset_data)}) - self.logger.info('Wait 60 second then reboot!') - time.sleep(60) - - def get_inventory(self): - self.logger.info('Fetching software inventory...') - inventory_rpc_xml = """ - <get xmlns="urn:ietf:params:xml:ns:netconf:base:1.0"> - <filter type="subtree"> - <software-inventory xmlns="urn:o-ran:software-management:1.0" /> - </filter> - </get> - """ - inventory_reply_xml = self.custom_rpc_request(inventory_rpc_xml) - if inventory_reply_xml: - self.logger.info('Finish fetching software inventory.') - inventory_data = xmltodict.parse(inventory_reply_xml) - self.software_reply_json_logger.info('', extra={'data': json.dumps(inventory_data)}) - - nonrunning_slot_name = None - running_slot_name = None - active_nonrunning_slot_name = None - nonrunning_slot_name_build_version = None - running_slot_name_build_version = None - - software_slots = inventory_data['nc:rpc-reply']['data']['software-inventory']['software-slot'] - for slot in software_slots: - if slot['running'] == 'false': - nonrunning_slot_name = slot['name'] - nonrunning_slot_name_build_version = slot['build-version'] - - if slot['running'] == 'true': - running_slot_name = slot['name'] - running_slot_name_build_version = slot['build-version'] - elif slot['active'] == 'true' and slot['running'] == 'false': - active_nonrunning_slot_name = slot['name'] - - return { - "nonrunning_slot_name": nonrunning_slot_name, - "running_slot_name": running_slot_name, - "active_nonrunning_slot_name": active_nonrunning_slot_name, - "nonrunning_slot_name_build_version": nonrunning_slot_name_build_version, - "running_slot_name_build_version": running_slot_name_build_version - } - - def supervision_reset(self, interval=60, margin=10): - self.logger.info("NETCONF server supervision replying...") - supervision_watchdog_rpc_xml = f""" - <supervision-watchdog-reset xmlns="urn:o-ran:supervision:1.0"> - <supervision-notification-interval>{interval}</supervision-notification-interval> - <guard-timer-overhead>{margin}</guard-timer-overhead> - </supervision-watchdog-reset> - """ - supervision_watchdog_reply_xml = self.custom_rpc_request(supervision_watchdog_rpc_xml) - replied = False - if supervision_watchdog_reply_xml: - replied = True - self.logger.info("NETCONF server supervision replied") - supervision_watchdog_data = xmltodict.parse(supervision_watchdog_reply_xml) - self.supervision_reply_json_logger.info('', extra={'data': json.dumps(supervision_watchdog_data)}) - return replied - - def close(self): - # Close not compatible between ncclient and netconf server - #self.conn.close() - pass diff --git a/software/ors-amarisoft/ru/lopcomm/reset-info.jinja2.py b/software/ors-amarisoft/ru/lopcomm/reset-info.jinja2.py deleted file mode 100644 index 390c6e4b170f8d2d9ff5bcdcfef1ba5bf339b8b1..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/reset-info.jinja2.py +++ /dev/null @@ -1,39 +0,0 @@ -#!{{ python_path }} -import paramiko -import logging -from logging.handlers import RotatingFileHandler - -def get_uptime(hostname, username, password): - client = paramiko.SSHClient() - client.set_missing_host_key_policy(paramiko.AutoAddPolicy()) - - try: - client.connect(hostname, username=username, password=password) - stdin, stdout, stderr = client.exec_command('uptime') - uptime_output = stdout.read().decode() - return uptime_output - - except Exception as e: - logger.info(f"Error: {e}") - finally: - client.close() - -# Usage -hostname = "{{ netaddr.IPAddress(vtap.gateway) }}" -username = "oranuser" -password = "oranpassword" - -# Initialize logger -log_file = "{{ log_file }}" -logger = logging.getLogger('logger') -logger.setLevel(logging.INFO) -handler = RotatingFileHandler(log_file, maxBytes=30000, backupCount=2) -formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s') -handler.setFormatter(formatter) -logger.addHandler(handler) - -if {{ testing }}: - pass -else: - rrh_uptime = get_uptime(hostname, username, password) - logger.info(f"Uptime from RRH: {rrh_uptime}") diff --git a/software/ors-amarisoft/ru/lopcomm/reset.jinja2.py b/software/ors-amarisoft/ru/lopcomm/reset.jinja2.py deleted file mode 100644 index da7f10158eaf270031f789e2ae42c465bae6f92a..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/reset.jinja2.py +++ /dev/null @@ -1,17 +0,0 @@ -#!{{ python_path }} -import time -import sys -sys.path.append({{ repr(buildout_directory_path) }}) -from ncclient_common import LopcommNetconfClient - -if __name__ == '__main__': - nc = LopcommNetconfClient(log_file="{{ log_file }}") - try: - nc.connect("{{ netaddr.IPAddress(vtap.gateway) }}", 830, "oranuser", "oranpassword") - nc.reset_device() - nc.logger.info("Device reset successful.") - except Exception as e: - nc.logger.debug('Got exception while resetting...') - nc.logger.debug(e) - finally: - nc.close() diff --git a/software/ors-amarisoft/ru/lopcomm/software.jinja2.py b/software/ors-amarisoft/ru/lopcomm/software.jinja2.py deleted file mode 100644 index 39f17c39068fb832c21c061f8f7b9f88967a9d71..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/software.jinja2.py +++ /dev/null @@ -1,104 +0,0 @@ -#!{{ python_path }} -import time -import json -import xmltodict -import sys -import re -import os -sys.path.append({{ repr(buildout_directory_path) }}) -from ncclient_common import LopcommNetconfClient - -if __name__ == '__main__': - nc = LopcommNetconfClient( - log_file="{{ log_file }}", - software_reply_json_log_file="{{ software_reply_json_log_file }}" - ) - while True: - try: - firmware_check_file= '{{ is_firmware_updated }}' - nc.connect("{{ netaddr.IPAddress(vtap.gateway) }}", 830, "oranuser", "oranpassword") - # Fetch software inventory - - inventory_vars = nc.get_inventory() - - nonrunning_slot_name = inventory_vars["nonrunning_slot_name"] - running_slot_name = inventory_vars["running_slot_name"] - active_nonrunning_slot_name = inventory_vars["active_nonrunning_slot_name"] - nonrunning_slot_name_build_version = inventory_vars["nonrunning_slot_name_build_version"] - running_slot_name_build_version = inventory_vars["running_slot_name_build_version"] - - if running_slot_name and nonrunning_slot_name: - if running_slot_name: - nc.logger.info("One slot is running and one is non-running. Proceeding...") - if running_slot_name_build_version in "{{firmware_name}}": - if not os.path.exists(firmware_check_file): - open(firmware_check_file, "w").write('True') - nc.logger.info("Running slot's build-version %s is already updated. Skipping install." % running_slot_name_build_version) - else: - if os.path.exists(firmware_check_file): - os.remove(firmware_check_file) - nc.logger.info("Current build version: %s" % running_slot_name_build_version) - user_authorized_key ="""{{ slapparameter_dict.get('user-authorized-key', '') }}""" - match = re.match(r'ssh-rsa ([^\s]+)', user_authorized_key) - if match: - extracted_key = match.group(1) - else: - nc.logger.info("No valid key found in user authorized key.") - download_rpc_xml = f""" - <software-download xmlns="urn:o-ran:software-management:1.0"> - <remote-file-path>{{remote_file_path}}</remote-file-path> - <server> - <keys> - <algorithm xmlns:ct="urn:ietf:params:xml:ns:yang:ietf-crypto-types">1024</algorithm> - <public-key>{extracted_key}</public-key> - </keys> - </server> - </software-download> - """ - download_reply_xml = nc.custom_rpc_request(download_rpc_xml) - nc.logger.info("Downloading software...") - time.sleep(60) - if download_reply_xml: - nc.logger.info("Download proceed.") - download_data = xmltodict.parse(download_reply_xml) - nc.software_reply_json_logger.info('', extra={'data': json.dumps(download_data)}) - - install_rpc_xml = f""" - <software-install xmlns="urn:o-ran:software-management:1.0"> - <slot-name>{nonrunning_slot_name}</slot-name> - <file-names>{{firmware_name}}</file-names> - </software-install> - """ - install_reply_xml = nc.custom_rpc_request(install_rpc_xml) - nc.logger.info("Installing software...") - time.sleep(60) - if install_reply_xml: - nc.logger.info("Installation proceed.") - install_data = xmltodict.parse(install_reply_xml) - nc.software_reply_json_logger.info('', extra={'data': json.dumps(install_data)}) - - if nonrunning_slot_name_build_version in "{{firmware_name}}": - activate_rpc_xml = f""" - <software-activate xmlns="urn:o-ran:software-management:1.0"> - <slot-name>{nonrunning_slot_name}</slot-name> - </software-activate> - """ - activate_reply_xml = nc.custom_rpc_request(activate_rpc_xml) - nc.logger.info("Activating software...") - time.sleep(60) - if activate_reply_xml: - nc.logger.info("Activation proceed.") - activate_data = xmltodict.parse(activate_reply_xml) - nc.software_reply_json_logger.info('', extra={'data': json.dumps(activate_data)}) - - nc.get_inventory() - if nonrunning_slot_name_build_version in "{{firmware_name}}" and active_nonrunning_slot_name: - nc.logger.info("Active non-running slot has the updated build version. Resetting device.") - nc.reset_device() - break - except Exception as e: - nc.logger.debug('Got exception, waiting 10 seconds before reconnecting...') - nc.logger.debug(str(e)) - time.sleep(10) - finally: - nc.close() diff --git a/software/ors-amarisoft/ru/lopcomm/stats.jinja2.py b/software/ors-amarisoft/ru/lopcomm/stats.jinja2.py deleted file mode 100644 index 18f5f0bb73e4ef824b21b1d787fe15f044a15782..0000000000000000000000000000000000000000 --- a/software/ors-amarisoft/ru/lopcomm/stats.jinja2.py +++ /dev/null @@ -1,81 +0,0 @@ -#!{{ python_path }} -import time -import sys -import os -import threading - -sys.path.append({{ repr(buildout_directory_path) }}) -from ncclient_common import LopcommNetconfClient - -# Shared variable to indicate error occurred -error_occurred = False -lock = threading.Lock() - -def get_notification_continuously(nc): - global error_occurred - try: - while not error_occurred: - nc.get_notification() - pass - except Exception as e: - with lock: - error_occurred = True - nc.logger.error(f'Error in get_notification_continuously: {e}') - -# supervision watchdog keeps on -def run_supervision_reset_continuously(nc): - global error_occurred - netconf_check_file = '{{ is_netconf_connected }}' - interval = 60 - margin = 10 - try: - while not error_occurred: - t0 = time.time() - replied = nc.supervision_reset(interval, margin) - if replied: - with open(netconf_check_file, "w") as f: - f.write('') - elif os.path.exists(netconf_check_file): - os.remove(netconf_check_file) - - t1 = time.time() - time.sleep(interval - (t1 - t0)) - except Exception as e: - with lock: - error_occurred = True - nc.logger.error(f'Error in run_supervision_reset_continuously: {e}') - -if __name__ == '__main__': - nc = LopcommNetconfClient( - log_file="{{ log_file }}", - json_log_file="{{ json_log_file }}", - cfg_json_log_file="{{ cfg_json_log_file }}", - supervision_json_log_file="{{ supervision_json_log_file }}", - ncsession_json_log_file="{{ ncsession_json_log_file }}", - software_json_log_file="{{ software_json_log_file }}", - supervision_reply_json_log_file="{{ supervision_reply_json_log_file }}" - ) - threads = [] - - try: - nc.connect("{{ netaddr.IPAddress(vtap.gateway) }}", 830, "oranuser", "oranpassword") - nc.subscribe() - - notification_thread = threading.Thread(target=get_notification_continuously, args=(nc,)) - supervision_thread = threading.Thread(target=run_supervision_reset_continuously, args=(nc,)) - - threads.append(notification_thread) - threads.append(supervision_thread) - - for thread in threads: - thread.start() - - for thread in threads: - thread.join() - - except Exception as e: - nc.logger.debug('Got exception, waiting 10 seconds before reconnecting...') - nc.logger.debug(e) - time.sleep(10) - finally: - nc.close() diff --git a/software/ors-amarisoft/slaplte.jinja2 b/software/ors-amarisoft/slaplte.jinja2 index 837693285a2c7f73d644e559a6074cca00a67277..e91e787cb18bfd30a02254f05094d84c5ae80b33 100644 --- a/software/ors-amarisoft/slaplte.jinja2 +++ b/software/ors-amarisoft/slaplte.jinja2 @@ -34,17 +34,6 @@ 'tx_dbm': 0, }, - 'ru/lopcomm': { - 'n_antenna_dl': 2, - 'n_antenna_ul': 2, - }, - 'ru/lopcomm/cpri_link': { - 'mapping': 'hw', - 'rx_delay': 25.11, - 'tx_delay': 14.71, - 'tx_dbm': 63, - }, - 'ru/sunwave': { 'n_antenna_dl': 2, 'n_antenna_ul': 1, diff --git a/software/ors-amarisoft/test/test.py b/software/ors-amarisoft/test/test.py index 3112c87ce729000d194c065a915c41cb726c37a2..3bb955351302c9fa020a33273e80f778ee0e7b69 100644 --- a/software/ors-amarisoft/test/test.py +++ b/software/ors-amarisoft/test/test.py @@ -502,171 +502,6 @@ class SDR4: )) -# Lopcomm4 is mixin to verify Lopcomm driver wrt all LTE/NR x FDD/TDD modes. -class Lopcomm4: - @classmethod - def RUcfg(cls, i): - return { - 'ru_type': 'lopcomm', - 'ru_link_type': 'cpri', - 'cpri_link': { - 'sdr_dev': 0, - 'sfp_port': i, - 'mult': 4, - 'mapping': 'hw', - 'rx_delay': 40+i, - 'tx_delay': 50+i, - 'tx_dbm': 60+i - }, - 'mac_addr': '00:0A:45:00:00:%02x' % i, - } - - # radio units configuration in enb.cfg - def test_rf_cfg_ru(t): - assertMatch(t, t.rf_cfg['rf_driver'], dict( - name='sdr', - args='dev0=/dev/sdr0@1,dev1=/dev/sdr0@2,dev2=/dev/sdr0@3,dev3=/dev/sdr0@4', - cpri_mapping='hw,hw,hw,hw', - cpri_mult='4,4,4,4', - cpri_rx_delay='41,42,43,44', - cpri_tx_delay='51,52,53,54', - cpri_tx_dbm='61,62,63,64', - )) - - # RU configuration in cu_config.xml - def test_ru_cu_config_xml(t): - def uctx(rf_mode, cell_type, dl_arfcn, ul_arfcn, bw, dl_freq, ul_freq, tx_gain, rx_gain): - return { - 'tx-array-carriers': { - 'rw-duplex-scheme': rf_mode, - 'rw-type': cell_type, - 'absolute-frequency-center': '%d' % dl_arfcn, - 'center-of-channel-bandwidth': '%d' % dl_freq, - 'channel-bandwidth': '%d' % bw, - 'gain': '%d' % tx_gain, - 'active': 'ACTIVE', - }, - 'rx-array-carriers': { - 'absolute-frequency-center': '%d' % ul_arfcn, - 'center-of-channel-bandwidth': '%d' % ul_freq, - 'channel-bandwidth': '%d' % bw, - # XXX no rx_gain - 'active': 'ACTIVE', - }, - } - - _ = t._test_ru_cu_config_xml - - # rf_mode ctype dl_arfcn ul_arfcn bw dl_freq ul_freq txg rxg - _(1, uctx('FDD', 'LTE', 100, 18100, 5000000, 2120000000, 1930000000, 11, 21)) - _(2, uctx('TDD', 'LTE', 40200, 40200, 10000000, 2551000000, 2551000000, 12, 22)) - _(3, uctx('FDD', 'NR', 300300, 290700, 15000000, 1501500000, 1453500000, 13, 23)) - _(4, uctx('TDD', 'NR', 470400, 470400, 20000000, 2352000000, 2352000000, 14, 24)) - - def _test_ru_cu_config_xml(t, i, uctx): - cu_xml = t.ipath('etc/%s' % xbuildout.encode('%s-cu_config.xml' % t.ref('RU%d' % i))) - with open(cu_xml, 'r') as f: - cu = f.read() - cu = xmltodict.parse(cu) - - assertMatch(t, cu, { - 'xc:config': { - 'user-plane-configuration': { - 'tx-endpoints': [ - {'name': 'TXA0P00C00', 'e-axcid': {'eaxc-id': '0'}}, - {'name': 'TXA0P00C01', 'e-axcid': {'eaxc-id': '1'}}, - {'name': 'TXA0P01C00', 'e-axcid': {'eaxc-id': '2'}}, - {'name': 'TXA0P01C01', 'e-axcid': {'eaxc-id': '3'}}, - ], - 'tx-links': [ - {'name': 'TXA0P00C00', 'tx-endpoint': 'TXA0P00C00'}, - {'name': 'TXA0P00C01', 'tx-endpoint': 'TXA0P00C01'}, - {'name': 'TXA0P01C00', 'tx-endpoint': 'TXA0P01C00'}, - {'name': 'TXA0P01C01', 'tx-endpoint': 'TXA0P01C01'}, - ], - 'rx-endpoints': [ - {'name': 'RXA0P00C00', 'e-axcid': {'eaxc-id': '0'}}, - {'name': 'PRACH0P00C00', 'e-axcid': {'eaxc-id': '8'}}, - {'name': 'RXA0P00C01', 'e-axcid': {'eaxc-id': '1'}}, - {'name': 'PRACH0P00C01', 'e-axcid': {'eaxc-id': '24'}}, - ], - 'rx-links': [ - {'name': 'RXA0P00C00', 'rx-endpoint': 'RXA0P00C00'}, - {'name': 'PRACH0P00C00', 'rx-endpoint': 'PRACH0P00C00'}, - {'name': 'RXA0P00C01', 'rx-endpoint': 'RXA0P00C01'}, - {'name': 'PRACH0P00C01', 'rx-endpoint': 'PRACH0P00C01'}, - ], - } | uctx - } - }) - - # RU configuration in cu_inactive_config.xml - def test_ru_cu_inactive_config_xml(t): - def uctx(rf_mode, cell_type, dl_arfcn, ul_arfcn, bw, dl_freq, ul_freq, tx_gain, rx_gain): - return { - 'tx-array-carriers': { - 'rw-duplex-scheme': rf_mode, - 'rw-type': cell_type, - 'absolute-frequency-center': '%d' % dl_arfcn, - 'center-of-channel-bandwidth': '%d' % dl_freq, - 'channel-bandwidth': '%d' % bw, - 'gain': '%d' % tx_gain, - 'active': 'INACTIVE', - }, - 'rx-array-carriers': { - 'absolute-frequency-center': '%d' % ul_arfcn, - 'center-of-channel-bandwidth': '%d' % ul_freq, - 'channel-bandwidth': '%d' % bw, - # XXX no rx_gain - 'active': 'INACTIVE', - }, - } - - _ = t._test_ru_cu_inactive_config_xml - - # rf_mode ctype dl_arfcn ul_arfcn bw dl_freq ul_freq txg rxg - _(1, uctx('FDD', 'LTE', 100, 18100, 5000000, 2120000000, 1930000000, 11, 21)) - _(2, uctx('TDD', 'LTE', 40200, 40200, 10000000, 2551000000, 2551000000, 12, 22)) - _(3, uctx('FDD', 'NR', 300300, 290700, 15000000, 1501500000, 1453500000, 13, 23)) - _(4, uctx('TDD', 'NR', 470400, 470400, 20000000, 2352000000, 2352000000, 14, 24)) - - def _test_ru_cu_inactive_config_xml(t, i, uctx): - cu_xml = t.ipath('etc/%s' % xbuildout.encode('%s-cu_inactive_config.xml' % t.ref('RU%d' % i))) - with open(cu_xml, 'r') as f: - cu = f.read() - cu = xmltodict.parse(cu) - - assertMatch(t, cu, { - 'xc:config': { - 'user-plane-configuration': { - 'tx-endpoints': [ - {'name': 'TXA0P00C00', 'e-axcid': {'eaxc-id': '0'}}, - {'name': 'TXA0P00C01', 'e-axcid': {'eaxc-id': '1'}}, - {'name': 'TXA0P01C00', 'e-axcid': {'eaxc-id': '2'}}, - {'name': 'TXA0P01C01', 'e-axcid': {'eaxc-id': '3'}}, - ], - 'tx-links': [ - {'name': 'TXA0P00C00', 'tx-endpoint': 'TXA0P00C00'}, - {'name': 'TXA0P00C01', 'tx-endpoint': 'TXA0P00C01'}, - {'name': 'TXA0P01C00', 'tx-endpoint': 'TXA0P01C00'}, - {'name': 'TXA0P01C01', 'tx-endpoint': 'TXA0P01C01'}, - ], - 'rx-endpoints': [ - {'name': 'RXA0P00C00', 'e-axcid': {'eaxc-id': '0'}}, - {'name': 'PRACH0P00C00', 'e-axcid': {'eaxc-id': '8'}}, - {'name': 'RXA0P00C01', 'e-axcid': {'eaxc-id': '1'}}, - {'name': 'PRACH0P00C01', 'e-axcid': {'eaxc-id': '24'}}, - ], - 'rx-links': [ - {'name': 'RXA0P00C00', 'rx-endpoint': 'RXA0P00C00'}, - {'name': 'PRACH0P00C00', 'rx-endpoint': 'PRACH0P00C00'}, - {'name': 'RXA0P00C01', 'rx-endpoint': 'RXA0P00C01'}, - {'name': 'PRACH0P00C01', 'rx-endpoint': 'PRACH0P00C01'}, - ], - } | uctx - } - }) - # Sunwave4 is mixin to verify Sunwave driver wrt all LTE/NR x FDD/TDD modes. class Sunwave4: @classmethod @@ -699,35 +534,35 @@ class Sunwave4: )) # RUMultiType4 is mixin to verify that different RU types can be used at the same time. -class RUMultiType4: - # ENB does not support mixing SDR + CPRI - verify only with CPRI-based units - # see https://support.amarisoft.com/issues/26021 for details - @classmethod - def RUcfg(cls, i): - assert 1 <= i <= 4, i - if i in (1,2): - return Lopcomm4.RUcfg(i) - else: - return Sunwave4.RUcfg(i) - - # radio units configuration in enb.cfg - def test_rf_cfg_ru(t): - assertMatch(t, t.rf_cfg['rf_driver'], dict( - name='sdr', - args='dev0=/dev/sdr0@1,dev1=/dev/sdr0@2,dev2=/dev/sdr1@3,dev3=/dev/sdr1@4', - cpri_mapping='hw,hw,bf1,bf1', - cpri_mult='4,4,5,5', - cpri_rx_delay='41,42,143,144', - cpri_tx_delay='51,52,153,154', - cpri_tx_dbm='61,62,163,164', - )) +# Due to only one type of RU being supported in the SR, the test is currently not applicable. +#class RUMultiType4: +# # ENB does not support mixing SDR + CPRI - verify only with CPRI-based units +# # see https://support.amarisoft.com/issues/26021 for details +# @classmethod +# def RUcfg(cls, i): +# assert 1 <= i <= 4, i +# if i in (1,2): +# return SDR4.RUcfg(i) +# else: +# return Sunwave4.RUcfg(i) +# +# # radio units configuration in enb.cfg +# def test_rf_cfg_ru(t): +# assertMatch(t, t.rf_cfg['rf_driver'], dict( +# name='sdr', +# args='dev0=/dev/sdr0@1,dev1=/dev/sdr0@2,dev2=/dev/sdr1@3,dev3=/dev/sdr1@4', +# cpri_mapping='hw,hw,bf1,bf1', +# cpri_mult='4,4,5,5', +# cpri_rx_delay='41,42,143,144', +# cpri_tx_delay='51,52,153,154', +# cpri_tx_dbm='61,62,163,164', +# )) # instantiate eNB tests class TestENB_SDR4 (ENBTestCase4, SDR4): pass -class TestENB_Lopcomm4 (ENBTestCase4, Lopcomm4): pass class TestENB_Sunwave4 (ENBTestCase4, Sunwave4): pass -class TestENB_RUMultiType4(ENBTestCase4, RUMultiType4): pass +# class TestENB_RUMultiType4(ENBTestCase4, RUMultiType4): pass # ---- UEsim ---- @@ -844,9 +679,8 @@ class UEsimTestCase4(RFTestCase4): # instantiate UEsim tests class TestUEsim_SDR4 (UEsimTestCase4, SDR4): pass -class TestUEsim_Lopcomm4 (UEsimTestCase4, Lopcomm4): pass class TestUEsim_Sunwave4 (UEsimTestCase4, Sunwave4): pass -class TestUEsim_RUMultiType4(UEsimTestCase4, RUMultiType4): pass +# class TestUEsim_RUMultiType4(UEsimTestCase4, RUMultiType4): pass # ---- misc ----