easy-utils-dev 2.159__tar.gz → 2.161__tar.gz

{easy_utils_dev-2.159 → easy_utils_dev-2.161}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.159
+Version: 2.161
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil

{easy_utils_dev-2.159 → easy_utils_dev-2.161}/easy_utils_dev/ne1830PSS.py

@@ -61,6 +61,7 @@ class PSS1830 :
         self.screenBuffer = ""
         self.main_controller_client : paramiko.SSHClient = None
         self.standby_controller_client : paramiko.SSHClient = None
+        self.verify_node_reachability_by_ping = False
         self.create_jumphost = self.nfmtJumpServer
         if self.auto_enable_tcp_forward :
             self.logger.info(f'***WARNING*** : Auto enable tcp forwarding is enabled. This will allow tcp fowarding in target machine then restarting sshd service agent.')
@@ -439,6 +440,8 @@ class PSS1830 :
 
 
     def verify_node_reachability(self , neip ) :
+        if not self.verify_node_reachability_by_ping :
+            return True
         self.logger.debug(f"verify_node_reachability from jhost={self.isjumpserver}")
         if  self.isjumpserver == False :
             if not pingAddress(neip) :
@@ -509,26 +512,33 @@ class PSS1830 :
                 return client
 
     def port_switcher( self , mode ) :
-        if mode == 'direct_cli' or self.sim:
-            port = 22
+        if self.sim :
+            return 22
+        if mode == 'direct_cli':
+            # real be
+            # root cli@19.19,19,9
+            return 22
         else:
-            port = 5122
-            if mode in ('cli', 'ssh'):
-                port = 5122
-        return port
+            # real NE
+            # ssh root@10.0.0.1 -p 5122
+            return 5122
 
     def _connect(self , mode='cli' , neip=None , rootpw='QUx1MTIj') :
         self.client = self.createClient()
         port = self.port_switcher(mode)
+        self.logger.debug(f"Auto switch to port : {port}")
         try :
             jhostserver = self.createJhostInstance(neip , port)
             self.verify_node_reachability(neip)
             ok = False
             self.logger.debug(f"connecting to {neip} with mode={mode} and port={port}")
             if mode == 'direct_cli' :
+                self.logger.debug("Mode direct_cli detected")
                 self.client.connect(neip , port , "cli" , '' , sock=jhostserver)
                 ok = True
             elif mode == 'cli' or mode == 'ssh' :
+                self.logger.debug("Mode cli or ssh detected")
+                port = 22
                 self.client.connect( neip , port , "root" , rootpw ,  sock=jhostserver )
                 ok = True
             self.logger.debug(f"client={self.client} ok={ok} port={port} mode={mode}")
@@ -580,6 +590,7 @@ class PSS1830 :
             self.logger.debug(f"rootpw specified is obfuscated. Switch to plain text ...")
             rootpw = self.encryptor.dec_base64(rootpw)
             self.logger.debug(f"pw specified is obfuscated. Switch to plain text result {rootpw}")
+        # self.logger.info(f'root password is {rootpw}')
         self.logger.debug(f'Opening SSH  connection to NE {neip} mode={mode}, resetRequired={resetRequired}')
         self.cliUser = user
         self.mode = mode
@@ -640,6 +651,8 @@ class PSS1830 :
         if mode == 'ssh' : 
             self.logger.debug(f"ssh mode detected. returning self.client object with no switch_to_cli_shell()")
             self.connected = True
+            if return_channel :
+                return self.client , None
             return self.client
         self.channel = self.switch_to_cli_shell()
         self.logger.debug(f'set timeout in rcv channel to {self.TIMEOUT}')

{easy_utils_dev-2.159 → easy_utils_dev-2.161}/easy_utils_dev/uiserver.py

@@ -56,25 +56,25 @@ class Response :
         self.success = self.ok
         self.failure = self.error
 
-    def ok(self , result=[] , message=None , payload={}) :
+    def ok(self , result=[] , message=None , **kwargs) :
         timestamp = getTimestamp()
-        return {'status' : 200 , 'message' : message , 'result' : result , **payload, 'timestamp' : timestamp}
+        return {'status' : 200 , 'message' : message , 'result' : result , **kwargs, 'timestamp' : timestamp}
 
-    def error(self , message=None , payload={}) :
+    def error(self , message=None , **kwargs) :
         timestamp = getTimestamp()
-        return {'status' : 400 , 'message' : message , **payload , 'timestamp' : timestamp}
+        return {'status' : 400 , 'message' : message , **kwargs , 'timestamp' : timestamp}
     
-    def internal_error(self , message=None , payload={}) :
+    def internal_error(self , message=None , **kwargs ) :
         timestamp = getTimestamp()
-        return {'status' : 500 , 'message' : message , **payload , 'timestamp' : timestamp}
+        return {'status' : 500 , 'message' : message , **kwargs , 'timestamp' : timestamp}
 
-    def not_found(self , message=None , payload={}) :
+    def not_found(self , message=None , **kwargs) :
         timestamp = getTimestamp()
-        return {'status' : 404 , 'message' : message , **payload , 'timestamp' : timestamp}
+        return {'status' : 404 , 'message' : message , **kwargs , 'timestamp' : timestamp}
     
-    def unauthorized(self , message=None , payload={}) :
+    def unauthorized(self , message=None , **kwargs) :
         timestamp = getTimestamp()
-        return {'status' : 401 , 'message' : message , **payload , 'timestamp' : timestamp}
+        return {'status' : 401 , 'message' : message , **kwargs , 'timestamp' : timestamp}
 
 class AbortRequest :
     def __init__(self, request ) :
@@ -229,35 +229,36 @@ class UISERVER :
                     if not alive :
                         break
                     time.sleep(.25)
-                return { 'status' : 200 , 'message' : 'Request aborted' , 'abort_timestamp' : timestamp , 'abort_id' : id , 'alive' : alive  , 'url' : abort.request.get('path')}
+                return Response().ok(message='Request aborted' , abort_timestamp=timestamp , abort_id=id , alive=alive , url=abort.request.get('path'))
+            
             else :
-                return { 'status' : 404 , 'message' : 'Request not found or request is not abortable. Check request headers for abortable flag.'}
+                return Response().not_found(message='Request not found or request is not abortable. Check request headers for abortable flag.')
         
         @self.app.route(f"/request/traceback/<key>" , methods=['GET'])
         def get_traceback(key : str ) :
             traceback = self.cache.get(key)
             if traceback :
-                return { 'status' : 200 , 'traceback' : traceback.get('traceback') }
+                return Response().ok(message='Traceback found' , traceback=traceback.get('traceback'))
             else :
-                return { 'status' : 404 , 'message' : 'Traceback not found or expired' }
+                return Response().not_found(message='Traceback not found or expired')
 
         @self.app.route(f'{self.request_reply_base_url}/<id>' , methods=['GET'])
         def get_result_of_async_request(id : str ) :
             request : AbortRequest = self.bg_requests.get(id)
             if request :
-                return {
-                    'status' : 200 , 
-                    'internalid' : id , 
-                    'result' : request.result ,
-                    'in_progress' : request.in_progress ,
-                    'async_request' : request.async_request ,
-                    'internalid' : request.internalid ,
-                    'start_ts' : request.start_ts ,
-                    'end_ts' : request.end_ts ,
-                    'execution' : request.execution,
-                    'success' : request.success,
-                    'killed' : request.killed
-                }
+                return Response().ok(
+                    message='Result of async request found' , 
+                    result=request.result ,
+                    in_progress=request.in_progress ,
+                    async_request=request.async_request ,
+                    internalid=request.internalid , 
+                    start_ts=request.start_ts , 
+                    end_ts=request.end_ts , 
+                    execution=request.execution ,
+                    success=request.success ,
+                    killed=request.killed
+                )
+
 
         @self.app.before_request
         def before_request() :
@@ -266,7 +267,7 @@ class UISERVER :
 
                 
             if (self.serve_with_secret_key) and (request.path not in self.secret_key_execlude_urls) and (request.headers.get('secretkey') != self.secretkey):
-                return jsonify({"error": "Secret key is invalid"}), 401
+                return Response().unauthorized(message='Secret key is invalid')
                         
             @copy_current_request_context
             def run_async_job_results( target_func , abort : AbortRequest ) :
@@ -305,11 +306,11 @@ class UISERVER :
                 if request.headers.get('async') == 'false' : 
                     target_func = current_app.view_functions.get(request.endpoint)
                     if not target_func:
-                        return {"error": "Route not found"}, 404
+                        return Response().not_found(message='Route not found')
                     th = start_thread(target=run_async_job_results, args=[target_func , abort ])
                     abort.thread = th
                     self.bg_requests[requestId] = abort
-                    return {"status": 200, "message": "Request now in running bg", "abort_id": abort.abort_id} , 200
+                    return Response().ok(message='Request now in running bg' , abort_id=abort.abort_id)
     
         if self.return_exception_as_code_400 :
             @self.app.errorhandler(Exception)
@@ -348,15 +349,13 @@ class UISERVER :
                 }
                 self.logger.error(f'error: {json.dumps(response , indent=4)}')
                 self.cache.set( custom_key=key , item={**response , 'traceback' : str(traceback.format_exc())} , auto_destroy_period=1800 , store_deleted_key=False )
-                # del response['traceback']
-                return response , 200
+                return Response().error( **response )
 
         @self.app.after_request
         def after_request(response) :
 
             if self.simulate_network_delay :
                 time.sleep(self.simulate_network_delay)
-
             try :
                 now = getTimestamp()
                 response.headers['internalid'] = request.internalid
@@ -427,7 +426,7 @@ class UISERVER :
     def _wait_th(self , t ) :
         # t.join()
         while True :
-            time.sleep(10)
+            time.sleep(36000)
     
 
     def thrStartUi(self , suppress_prints=True) :

{easy_utils_dev-2.159 → easy_utils_dev-2.161}/easy_utils_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easy_utils_dev
-Version: 2.159
+Version: 2.161
 Keywords: python3
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: psutil

{easy_utils_dev-2.159 → easy_utils_dev-2.161}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '2.159'
+VERSION = '2.161'
 
 # Setting up
 setup(