def __init__(self, app_main): """ :param str app_main: the file name, such as "network.tcp_echo" :return: """ CradlepointAppBase.__init__(self, app_main) return
def __init__(self, app_main): """ :param str app_main: the file name, such as "serial.serial_echo" :return: """ CradlepointAppBase.__init__(self, app_main) return
def __init__(self, app_name): """ :param str app_name: the file name, such as "simple.hello_world_app" :return: """ CradlepointAppBase.__init__(self, app_name) return
def __init__(self): """Basic Init""" from cp_lib.load_settings_ini import copy_config_ini_to_json if not os.path.isfile("./config/settings.json"): # make sure we have at least a basic ./config/settings.json copy_config_ini_to_json() # we don't contact router for model/fw - will do in sanity_check, # IF the command means contact router CradlepointAppBase.__init__(self, call_router=False, log_name="target") self.action = self.ACTION_DEFAULT self.verbose = True # the one 'target' we are working on (if given) self.target_alias = None # the data loaded from the TARGET.INI file self.target_dict = None # the one computer interface we are targeting self.target_interface = DEF_INTERFACE # save IP related to target and/or the interface self.target_my_ip = None self.target_my_net = None self.target_router_ip = None return
def test_import_full_file_name(self): """ :return: """ from cp_lib.app_base import CradlepointAppBase print() # move past the '.' if True: return name = "network.tcp_echo" obj = CradlepointAppBase(name) # here, INIT is used, it exists and is larger than trivial (5 bytes) # we want the tcp-echo.py to exist, but won't use expect = os.path.join("network", "tcp_echo", "tcp_echo.py") self.assertTrue(os.path.exists(expect)) expect = os.path.join("network", "tcp_echo", "__init__.py") self.assertTrue(os.path.exists(expect)) logging.info("TEST names when {} can be run_name".format(expect)) self.assertEqual(obj.run_name, expect) expect = os.path.join("network", "tcp_echo") + os.sep self.assertEqual(obj.app_path, expect) self.assertEqual(obj.app_name, "tcp_echo") self.assertEqual(obj.mod_name, "network.tcp_echo") name = "RouterSDKDemo" obj = CradlepointAppBase(name) # here, the app name is used (the INIT is empty / zero bytes) expect = os.path.join("RouterSDKDemo", "__init__.py") self.assertTrue(os.path.exists(expect)) logging.info( "TEST names when {} is too small to be run_name".format(expect)) expect = os.path.join(name, name) + ".py" self.assertTrue(os.path.exists(expect)) logging.info("TEST names when {} can be run_name".format(expect)) self.assertEqual(obj.run_name, expect) expect = name + os.sep self.assertEqual(obj.app_path, expect) self.assertEqual(obj.app_name, "RouterSDKDemo") self.assertEqual(obj.mod_name, "RouterSDKDemo") return
def __init__(self): """Basic Init""" from cp_lib.load_settings_ini import copy_config_ini_to_json # make sure we have at least a basic ./config/settings.json # ALWAYS copy existing ./config/settings.ini over, which makes # CradlepointAppBase.__init__() happy copy_config_ini_to_json() # we don't contact router for model/fw - will do in sanity_check, IF # the command means contact router CradlepointAppBase.__init__(self, call_router=False, log_name="make") # 'attrib' are our internal pre-processed settings for MAKE use self.attrib = {} self.command = "make" self.action = self.ACTION_DEFAULT # these are in CradlepointAppBase # self.run_name = None # like "network/tcp_echo/__init__.py" # self.app_path = None # like "network/tcp_echo/", used to find files # self.app_name = None # like "tcp_echo" # self.mod_name = None # like "network.tcp_echo", used for importlib # self.settings = load_settings_json(self.app_path) # self.logger = get_recommended_logger(self.settings) # self.cs_client = init_cs_client_on_my_platform(self.logger, # self.settings) # should MAKE edit/change the [app][version] in setting.ini? self.increment_version = False # are we building for running on PC? Then don't include PIP add-ins self.ignore_pip = False # define LOGGING between DEBUG or INFO self.verbose = False self.last_url = None self.last_reply = None self.last_status = None self._last_uuid = None self._exclude = [] return
def test_startup(self): """ :return: """ global USE_UUID print() # move past the '.' app_base = CradlepointAppBase("simple.do_it") if USE_UUID is None: USE_UUID = str(uuid.uuid4()) app_base.logger.debug("UUID:{}".format(USE_UUID)) obj = StatusTreeData(app_base) try: obj.set_uuid(USE_UUID) except ValueError: app_base.logger.error("No APPS installed") raise obj.clear_data() # if True: # return # if this is a FRESH system, then first get will be NULL/NONE result = obj.get_data() self.assertEqual(obj.data, dict()) result = obj.put_data(force=True) app_base.logger.debug("data:{}".format(result)) self.assertEqual(obj.clean, True) obj.set_data_value('health', 100.0) self.assertEqual(obj.clean, False) result = obj.put_data(force=True) app_base.logger.debug("data:{}".format(result)) return
self.assertFalse(obj.enabled("fifth_port")) return def test_probe_if_serial_available(self): global base_app print("") # skip paste '.' on line result = probe_serial.probe_if_serial_available(base_app) if PPRINT_RESULT: print(json.dumps(result, indent=4, sort_keys=True)) # these would only be true in some situations expect_port = "ttyS1" result = probe_serial.probe_if_serial_available(base_app, expect_port) if PPRINT_RESULT: print(json.dumps(result, indent=4, sort_keys=True)) return if __name__ == '__main__': from cp_lib.app_base import CradlepointAppBase base_app = CradlepointAppBase() unittest.main()
else: raise IOError except IOError: self.send_error(404, 'File Not Found: %s' % self.path) return if send_reply: # Send response status code self.send_response(200) # Send headers self.send_header('Content-type', mime_type) self.end_headers() # Send message back to client # Write content as utf-8 data self.wfile.write(web_message) return if __name__ == "__main__": import sys my_app = CradlepointAppBase("network/simple_web") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
if save_file is not None: # if am_running_on_router(): if sys.platform != "win32": pass # app_base.logger.error( # Skip save to file - am running on router.") else: app_base.logger.debug("Save file:{}".format(save_file)) file_han = open(save_file, "w") for line in report_lines: file_han.write(line + '\n') file_han.close() return 0 if __name__ == "__main__": import logging # get this started, else we don't see anything for a while logging.basicConfig(level=logging.DEBUG) my_app = CradlepointAppBase("gps/probe_gps") _result = probe_gps(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
# our fake data, time-fixed to me NOW request = fix_time_sentence("$GPGGA,094013.0,4334.784909,N,11612.7664" + "48,W,1,09,0.9,830.6,M,-11.0,M,,*60") request = request.encode() base_app.logger.debug("Req({})".format(request)) sock.send(request) # this message has NO response! time.sleep(2.0) sock.close() return 0 if __name__ == '__main__': from cp_lib.app_base import CradlepointAppBase import tools.make_load_settings app_name = 'demo.gps_gate' # we share the settings.ini in demo/gps_gate/settings.ini base_app = CradlepointAppBase(full_name=app_name, call_router=False) # force a full make/read of {app_path}/settings.ini base_app.settings = tools.make_load_settings.load_settings( base_app.app_path) run_client()
app_base.logger.debug("result({})".format(result)) return result # Required keys # ['smtp_tls] = T/F to use TLS, defaults to True # ['smtp_url'] = URL, such as 'smtp.gmail.com' # ['smtp_port'] = TCP port like 587 - be careful, as some servers have more # than one, with the number defining the security demanded. # ['username'] = your smtp user name (often your email acct address) # ['password'] = your smtp acct password # ['email_to'] = the target email address, as str or list # ['subject'] = the email subject # Optional keys # ['email_from'] = the from address - any smtp server will ignore, and force # this to be your user/acct email address; def = ['username'] # ['body'] = the email body; def = ['subject'] if __name__ == "__main__": import sys my_app = CradlepointAppBase("network/send_email") _result = send_one_email(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
break time.sleep(1.0) app_base.logger.info("Client disconnected") client.close() # since this server is expected to run on a small embedded system, # free up memory ASAP (see MEMORY note) del client gc.collect() return 0 if __name__ == "__main__": import sys from cp_lib.load_settings_ini import copy_config_ini_to_json, \ load_sdk_ini_as_dict copy_config_ini_to_json() app_path = "demo/gps_replay" my_app = CradlepointAppBase(app_path) # force a heavy reload of INI (app base normally only finds JSON) my_app.settings = load_sdk_ini_as_dict(app_path) _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
from cp_lib.app_base import CradlepointAppBase from cp_lib.cs_ping import cs_ping # this name "run_router_app" is not important, reserved, or demanded # - but must match below in __main__ and also in __init__.py def run_router_app(app_base, ping_ip=None): """ :param CradlepointAppBase app_base: prepared resources: logger, cs_client :param str ping_ip: the IP to ping :return: """ if ping_ip is None: # then try settings.ini if "ping" in app_base.settings: ping_ip = app_base.settings["ping"].get("ping_ip", '') # else, just assume passed in value is best result = cs_ping(app_base, ping_ip) return result if __name__ == "__main__": import sys my_app = CradlepointAppBase("network/send_ping") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
result = app_base.cs_client.get_bool("status/system/gpio_actions/") app_base.logger.debug("GET: status/system/gpio_actions/ = [{}]".format(result)) if result is None: # then the serial GPIO function is NOT enabled app_base.logger.error("The Serial GPIO is NOT enabled!") app_base.logger.info("Router Application is exiting") return -1 while loop_delay: # loop as long as not None or zero result1 = app_base.cs_client.get(DEF_SERIAL_NAME_1) result2 = app_base.cs_client.get(DEF_SERIAL_NAME_2) result3 = app_base.cs_client.get(DEF_SERIAL_NAME_3) app_base.logger.info("Inp = ({}, {}, {})".format(result1, result2, result3)) app_base.logger.debug("Looping - delay {} seconds".format(loop_delay)) time.sleep(loop_delay) app_base.logger.info("Router Application is exiting") return 0 if __name__ == "__main__": my_app = CradlepointAppBase("gpio/serial_gpio") _result = read_gpio(my_app, loop=False) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
if not result: break gps.publish() app_base.logger.debug("See({})".format( gps.get_attributes())) # client.send(data) else: break time.sleep(1.0) app_base.logger.info("Client disconnected") client.close() # since this server is expected to run on a small embedded system, # free up memory ASAP (see MEMORY note) del client gc.collect() return 0 if __name__ == "__main__": import sys my_app = CradlepointAppBase("gps/gps_localhost") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
print("Write to file:{}".format(file_name)) file_han = open(file_name, "w") file_han.write(pretty) file_han.close() if False: print("Output:{}".format(pretty)) return def test_object(self): global base_app obj = GpsConfig(base_app) self.assertIsNotNone(obj) self.assertIsNotNone(obj.data) base_app.logger.debug("GPS Enabled:{}".format(obj.is_enabled())) base_app.logger.debug("Keepalive Enabled:{}".format( obj.keepalive_is_enabled())) base_app.logger.debug("GPS to Server:{}".format(obj.get_client_info())) return if __name__ == '__main__': from cp_lib.app_base import CradlepointAppBase base_app = CradlepointAppBase(call_router=False) unittest.main()
:param CradlepointAppBase app_base: resources: logger, settings, etc """ app_base.logger.info("Send ALERT to ECM via CSClient") # user may have passed in another path alert = "Default Message - All is well!" if "send_alert" in app_base.settings: if "alert" in app_base.settings["send_alert"]: alert = app_base.settings["send_alert"]["alert"] # here we send to Syslog using our OWN facility/channel app_base.logger.info('LOG: Sending alert to ECM=[{}].'.format(alert)) # this line will be sent via Router's Syslog facility/channel app_base.cs_client.log('RouterSDKDemo', 'CS: Sending alert to ECM=[{}].'.format(alert)) app_base.cs_client.alert('RouterSDKDemo', alert) return 0 if __name__ == "__main__": import sys my_app = CradlepointAppBase("simple/send_alert") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
def test_get_settings(self): """ :return: """ from cp_lib.app_base import CradlepointAppBase print() # move past the '.' # we'll just use this as example, assuming .config/setting.ini # and name = "network.tcp_echo" obj = CradlepointAppBase(name, call_router=False) # just slam in a known 'data tree' obj.settings = { 'application': { 'firmware': '6.1', 'name': 'make', 'restart': 'true', 'reboot': True, 'sleeping': 'On', 'explosion': 'enabled', }, 'router_api': { 'user_name': 'admin', 'interface': 'ENet USB-1', 'password': '******', 'local_ip': '192.168.1.1' }, 'logging': { 'syslog_ip': '192.168.1.6', 'pc_syslog': 'false', 'level': 'debug' }, 'startup': { 'boot_delay_for_wan': 'True', 'exit_delay': '30 sec', 'boot_delay_max': '5 min', 'bomb_delay': 17, 'rain_delay': '19', 'boot_delay_for_time': 'True' }, 'glob_dir': 'config', 'base_name': 'settings', 'app_dir': 'network\\tcp_echo\\', } logging.info("TEST simple get_setting(), without force_type") self.assertEqual("make", obj.get_setting("application.name")) self.assertEqual("6.1", obj.get_setting("application.firmware")) self.assertEqual(True, obj.get_setting("application.reboot")) logging.info("TEST get_setting(), with force_type=bool") self.assertEqual("true", obj.get_setting("application.restart")) self.assertEqual( True, obj.get_setting("application.restart", force_type=bool)) self.assertEqual(True, obj.get_setting("application.reboot")) self.assertEqual( True, obj.get_setting("application.reboot", force_type=bool)) self.assertEqual(1, obj.get_setting("application.reboot", force_type=int)) self.assertEqual("On", obj.get_setting("application.sleeping")) self.assertEqual( True, obj.get_setting("application.sleeping", force_type=bool)) self.assertEqual("enabled", obj.get_setting("application.explosion")) self.assertEqual( True, obj.get_setting("application.explosion", force_type=bool)) # doesn't exist, but force to String means "None" self.assertEqual( None, obj.get_setting("application.not_exists", force_type=bool)) with self.assertRaises(ValueError): # string 'true' can't be forced to int, bool True can obj.get_setting("application.name", force_type=bool) logging.info("TEST get_setting(), with force_type=str") # [restart] is already string, but [reboot] is bool(True) self.assertEqual( "true", obj.get_setting("application.restart", force_type=str)) self.assertEqual("True", obj.get_setting("application.reboot", force_type=str)) # doesn't exist, & force to String does not means "None" self.assertEqual(None, obj.get_setting("application.not_exists")) self.assertEqual( None, obj.get_setting("application.not_exists", force_type=str)) logging.info("TEST get_setting_time_secs()") self.assertEqual("30 sec", obj.get_setting("startup.exit_delay")) self.assertEqual(30.0, obj.get_setting_time_secs("startup.exit_delay")) self.assertEqual("5 min", obj.get_setting("startup.boot_delay_max")) self.assertEqual(300.0, obj.get_setting_time_secs("startup.boot_delay_max")) self.assertEqual(17, obj.get_setting("startup.bomb_delay")) self.assertEqual(17.0, obj.get_setting_time_secs("startup.bomb_delay")) self.assertEqual("19", obj.get_setting("startup.rain_delay")) self.assertEqual(19.0, obj.get_setting_time_secs("startup.rain_delay")) with self.assertRaises(ValueError): # string 'true' can't be forced to int, bool True can obj.get_setting("application.restart", force_type=int) return
data = data.encode('utf-8') app_base.logger.debug("Sent:{}".format(data)) server_address = (DEF_HOST_IP, DEF_HOST_PORT) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: # Connect to server and send data sock.connect(server_address) sock.sendall(data) # Receive data from the server and shut down received = str(sock.recv(1024), "utf-8") finally: sock.close() app_base.logger.debug("Recv:{}".format(received)) return json.loads(received) if __name__ == "__main__": my_app = CradlepointAppBase("data/jsonrpc_settings") _result = run_client(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
message = json_get_put.jsonrpc_get(my_base.data, message) elif method == "put_data": my_base.logger.debug("PutData:{}".format(message["params"])) message = json_get_put.jsonrpc_put(my_base.data, message) else: message["error"] = { "code": -32601, "message": "Unknown \"method\": {}".format(method) } # else, if request["error"] is already true, then return error message = json_get_put.jsonrpc_prep_response(message, encode=True) """ :type message: str """ my_base.logger.debug("returning:{}".format(message)) self.request.sendall(message.encode()) my_base.logger.debug("") return if __name__ == "__main__": import sys my_app = CradlepointAppBase("network/simple_jsonrpc") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
else: # for RTU, we want HEX form logger_buffer_dump(self.logger, "RTU-REQ", data) self.ser.write(data) # we have 1 second response timeout in the Serial() open time.sleep(0.25) response = self.ser.read(256) if self.logger.getEffectiveLevel() <= logging.DEBUG: if response is None or response == b'': self.logger.debug("SER-RSP:None/No response") elif self.serial_protocol == IA_PROTOCOL_MBASC: # for ASCII, just print as string self.logger.debug("ASC-RSP:{}".format(response)) else: # for RTU, we want HEX form logger_buffer_dump(self.logger, "RTU-RSP", response) return response if __name__ == "__main__": import sys my_app = CradlepointAppBase("serial_port/mbus_simple_bridge", call_router=False) _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
def probe_directory(app_base, base_dir): """ dump a directory in router FW :param CradlepointAppBase app_base: resources: logger, settings, etc :param str base_dir: the directory to dump """ import os app_base.logger.debug("Dump Directory:{}".format(base_dir)) result = os.access(base_dir, os.R_OK) if result: app_base.logger.debug("GOOD name:{}".format(base_dir)) else: app_base.logger.debug("BAD name:{}".format(base_dir)) if result: result = os.listdir(base_dir) for name in result: app_base.logger.debug(" file:{}".format(name)) return if __name__ == "__main__": my_app = CradlepointAppBase("serial_port/list_ports") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
if line_in is None or len(line_in) == 0: break if line_in[0] == '{': # then assume like {"offset":1, "data":$GPGGA,094013.0 ... }, if line_in[-1] == ',': line_in = line_in[:-1] return eval(line_in) # else, get next line return None if __name__ == "__main__": import sys from cp_lib.load_settings_ini import copy_config_ini_to_json, \ load_sdk_ini_as_dict copy_config_ini_to_json() app_path = "demo/gps_replay" my_app = CradlepointAppBase(app_path, call_router=False) # force a heavy reload of INI (app base normally only finds JSON) my_app.settings = load_sdk_ini_as_dict(app_path) _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
app_base.logger.info( "CTS changed to {}, setting RTS".format(cts_was)) ser.setRTS(cts_was) else: if dsr_was != ser.dsr: dsr_was = ser.dsr app_base.logger.info( "DSR changed to {}, setting DTR".format(dsr_was)) ser.dtr = dsr_was if cts_was != ser.cts: cts_was = ser.cts app_base.logger.info( "CTS changed to {}, setting RTS".format(cts_was)) ser.rts = cts_was # if you lose the serial port - like disconnected, then # ser.getDSR() will throw OSError #5 Input/Output error finally: ser.close() return if __name__ == "__main__": my_app = CradlepointAppBase("serial/serial_echo") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
if result_out in (1, "1"): value = 0 else: value = 1 # self.client.put('/control/gpio', {self.name: self.state}) result = app_base.cs_client.put("control/gpio", {"CGPIO_CONNECTOR_OUTPUT": value}) if value != int(result): app_base.logger.error("BAD - change failed {}".format(result)) # else app_base.logger.info("Change was GOOD {}".format(result)) break else: app_base.logger.debug( "Looping - delay {} seconds".format(loop_delay)) time.sleep(loop_delay) return 0 if __name__ == "__main__": my_app = CradlepointAppBase("gpio/power") _result = run_router_app(my_app, loop=False) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
"Bad NMEA sentence:[{}]".format(line)) raise # gps.publish() # app_base.logger.debug( # "See({})".format(gps.get_attributes())) # client.send(data) else: break time.sleep(1.0) app_base.logger.info("Client disconnected") client.close() # since this server is expected to run on a small embedded system, # free up memory ASAP (see MEMORY note) del client gc.collect() return 0 if __name__ == "__main__": import sys my_app = CradlepointAppBase("gps/gps_gate") _result = run_router_app(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)
return -1 # note: sock.send('Hello, world') will fail, because Python 3 socket() # handles BYTES (see BYTES and STR note) data = b'Hello, world' app_base.logger.debug("Request({})".format(data)) sock.send(data) data = sock.recv(buffer_size) app_base.logger.debug("Response({})".format(data)) sock.close() time.sleep(1.0) return 0 if __name__ == "__main__": import sys my_app = CradlepointAppBase("network/tcp_echo") if len(sys.argv) == 1: # if no cmdline args, we assume SERVER _result = tcp_echo_server(my_app) else: _result = tcp_echo_client(my_app) my_app.logger.info("Exiting, status code is {}".format(_result)) sys.exit(_result)