uopy

 63def connect(**kwargs):
 64    """Open a connection to an MV Database.
 65
 66    Args:
 67        kwargs: connection configuration keyword parameters:  host, port, user, password, account, service, timeout,
 68                encoding, ssl, min_pool_size, max_pool_size.
 69
 70                1. only user and password are required, the rest have default values in uopy.config.connection.
 71
 72                2. if connection pooling is turned on and connect() is called for the first time to open a connection
 73                to the database server, a connection pool will be created for the same host, account, user and password
 74                that are passed in. If min_pool_size and/or max_pool_size are passed in as well, they will be used
 75                instead of the default values in the uopy.config.pooling section to set the minimum and maximum pool
 76                sizes. Note that once a connection pool is created, its min_pool_size and max_pool_size cannot be
 77                changed. This means that the min_pool_size and max_pool_size parameters are ignored on subsequent calls
 78                to connect() for the same pool.
 79
 80    Returns:
 81        A Session object: either newly established or straight from a connection pool.
 82
 83    Raises:
 84        UOError, ValueError
 85
 86    Examples:
 87        >>> session = uopy.connect(user = 'test', password ='test')
 88
 89        >>> session = uopy.connect(host ='localhost', user = 'test', password ='test', account = 'HS.SALES',
 90                    service=uopy.UV_SERVICE, port=31438)
 91
 92        >>> config = {
 93                'user': 'test',
 94                'password': 'test',
 95                'service': 'udcs',
 96                'account': 'demo',
 97                'encoding': 'GB18030',
 98                'ssl': True
 99            }
100        >>> session = uopy.connect(**config)
101
102    """
103    global _pooling_on
104    config.update(kwargs)
105    connect_config = build_connect_config(kwargs)
106    pooling_config = build_pooling_config(kwargs)
107
108    _pooling_on = pooling_config.get("pooling_on")
109    if _pooling_on:
110        pool_key = make_pool_key(connect_config)
111        if not wrapper.hasrun:
112            wrapper()
113        with _lock:
114            pool = _pools.get(pool_key)
115            if not pool:
116                pool = Pool(connect_config, pooling_config)
117                _pools[pool_key] = pool
118
119        return pool.get()
120    else:
121        session = Session(connect_config)
122        session.connect()
123        return session

 48class Session:
 49    """A Session represents a MV database connection. It is the foundation for and embedded in other UOPY objects.
 50
 51    Session objects can be used in Python with statement so that whatever happens in the with statement block, they
 52    are guaranteed to be closed upon exit.
 53
 54    Applications can also perform transactions on a Session, and get supported @var values from the server.
 55
 56    Note:
 57        Applications should call uopy.connect() to get a Session object instead of directly instantiating a Session.
 58
 59    Examples:
 60
 61        >>> with uopy.connect(user='test', password='test'):
 62        >>>     cmd = uopy.Command("LIST VOC")
 63        >>>     cmd.run()
 64        >>>     print(cmd.response)
 65
 66
 67        >>> with uopy.connect(user="test", password="test") as session:
 68        >>>     session.tx_start()
 69        >>>     print(session.tx_is_active())
 70        ...
 71        >>>     session.tx_commit()
 72
 73    """
 74
 75    def __init__(self, connect_config):
 76        _logger.debug(
 77            "Enter", {k: connect_config[k] for k in connect_config if k != "password"}
 78        )
 79
 80        self._config = connect_config
 81
 82        self._lock = threading.RLock()
 83
 84        self._rpc_connection = None
 85        self._is_rpc_failed = False
 86
 87        self._is_nls_enabled = False
 88        self._is_nls_locale_enabled = False
 89        self._is_ud = False
 90        self._is_d3 = False
 91
 92        self.__pool = None
 93        self._idle_start_time = 0
 94
 95        self._mac_address = "JAVA"
 96        self._license_token = ""
 97
 98        self._host_type = None
 99        self._command = None
100        self._transaction = None
101
102        self.is_active = False
103        self.marks = DEFAULT_MARKS
104
105        self._uoserver_timeout = None
106        self._uv_timeout_flag = False
107
108    def __repr__(self):
109        format_string = "<{} object {} at 0x{:016X}>"
110        details = self._config
111        return format_string.format(
112            ".".join([Session.__module__, Session.__qualname__]), details, id(self)
113        )
114
115    def __enter__(self):
116        if not self.is_active:
117            self.connect()
118        return self
119
120    def __exit__(self, exec_type, exec_value, traceback):
121        self.close()
122
123    def bind_pool(self, pool):
124        self.__pool = pool
125
126    @property
127    def config(self):
128        """A copy of all the configuration parameters for this session."""
129        return copy.deepcopy(self._config)
130
131    @property
132    def idle_start_time(self):
133        return self._idle_start_time
134
135    def start_idle(self):
136        self._idle_start_time = time.time()
137
138    @property
139    def db_type(self):
140        """str: either "UD' for UniData,'UV' for UniVerse, or "D3" for D3."""
141
142        if self._is_ud:
143            return "UD"
144        elif self._is_d3:
145            return "D3"
146        else:
147            return "UV"
148
149    @property
150    def is_nls_enabled(self):
151        """boolean: whether NLS is enabled on the server."""
152        return self._is_nls_enabled
153
154    @property
155    def encoding(self):
156        """The name of the character encoding used for conversion between Python unicode strings and MV data.
157
158        By default it is set to the local system's preferred encoding when server NLS is off, and to UTF-8 when
159        server NLS is on. However it can be overridden by the application to what reflects the actual encoding of
160        the server data.
161
162        """
163        return self._config[ENCODING]
164
165    @encoding.setter
166    def encoding(self, encoding):
167        try:
168            "".encode(encoding.strip())
169            self._config[ENCODING] = encoding.strip()
170        except LookupError as e:
171            _logger.warning(
172                "Unsupported encoding setting, encoding is not changed:" + str(e)
173            )
174
175    def _get_uv_version(self, version: str):
176        uv_version = array("i")
177        if not version.startswith("UniVerse "):
178            return None
179        version = version.removeprefix("UniVerse")
180        version = version[1:]
181        version_arr = version.split(".")
182        if len(version_arr) != 3:
183            return None
184        try:
185            for item in version_arr:
186                uv_version.append(int(item))
187        except:
188            return None
189        return uv_version
190        pass
191
192    def _compare_version(self, version1: array, version2: array):
193        # The version1 >= version2, the result is True, otherwise, the result is False
194        if version1[0] > version2[0]:
195            return True
196        elif version1[0] < version2[0]:
197            return False
198        if version1[1] > version2[1]:
199            return True
200        elif version1[1] < version2[1]:
201            return False
202        if version1[2] > version2[2]:
203            return True
204        elif version1[2] < version2[2]:
205            return False
206        return True
207
208    def _get_server_timeout(self):
209        _logger.debug("Enter")
210
211        with self._lock:
212            in_packet = UniRPCPacket()
213            out_packet = UniRPCPacket()
214
215            out_packet.write(0, FuncCodes.EIC_UOTIMEOUT)
216
217            try:
218                self._rpc_connection.call(in_packet, out_packet)
219
220                retcode = in_packet.read(0)
221
222                if retcode:
223                    if (
224                        self.db_type == "UV"
225                        and not self._uv_timeout_flag
226                        or self.db_type == "UD"
227                    ):
228                        raise UOError(code=retcode)
229                    else:
230                        self._uoserver_timeout = retcode
231                elif self.db_type == "UV":
232                    self._uoserver_timeout = retcode
233                else:
234                    self._uoserver_timeout = in_packet.read(1)
235            except Exception as e:
236                raise UOError(message=str(e))
237
238        _logger.info("Exit")
239
240    @property
241    def uoserver_timeout(self):
242        """
243        The following code snippet retrieves the UO Server timeout value after connecting to the server:
244        ses = uopy.connect(user=user,password=passwd)
245        uotimeout = ses.uoserver_timeout
246        On the server side, the timeout can be set in the unirpcservice file and passed as an argument when the uvapi_server process is started.
247        """
248        if self._uoserver_timeout == None:
249            self._get_server_timeout()
250        return self._uoserver_timeout
251
252    def sync_marks(self, mark_list):
253        self.marks = MARKS_NAMED_TUPLE(*mark_list)
254
255    def encode(self, obj):
256        if isinstance(obj, str):
257            return obj.encode(self._config[ENCODING], errors="replace")
258        elif isinstance(obj, bytes) or isinstance(obj, bytearray):
259            return obj
260        elif isinstance(obj, MvDelimited):
261            return bytes(obj)
262        elif isinstance(obj, list):
263            return bytes(MvDelimited(obj=obj, session=self))
264        elif obj is None:
265            return b""
266        else:
267            return str(obj).encode(self._config[ENCODING], errors="replace")
268
269    def decode(self, obj):
270        if isinstance(obj, bytes) or isinstance(obj, bytearray):
271            return obj.decode(self._config[ENCODING], errors="replace")
272        else:
273            return str(obj)
274
275    def _check_callable(self, in_exec=False):
276        if self._rpc_connection is None or not self._rpc_connection.is_connected:
277            raise UOError(code=ErrorCodes.UOE_SESSION_NOT_OPEN)
278
279        if not in_exec:
280            if self._command is not None:
281                if self._command.status in {EXEC_MORE_OUTPUT, EXEC_REPLY}:
282                    raise UOError(code=ErrorCodes.UOE_EXECUTEISACTIVE)
283
284    def rpc_call(self, in_packet, out_packet, in_exec=False):
285        with self._lock:
286            self._check_callable(in_exec)
287            self._rpc_connection.call(in_packet, out_packet)
288
289    def read_packet4cmd(self, packet):
290        with self._lock:
291            self._rpc_connection.read_packet(packet)
292
293    def connect(self):
294        with self._lock:
295            if self.is_active:
296                _logger.warning("Session._connect: already connected.")
297                return
298
299            self._rpc_connection = UniRPCConnection(self._config)
300            self._rpc_connection.connect()
301            self._login()
302
303            # TODO initialize the transaction object
304            # self._transaction = self.Transaction()
305
306            thread_data.session = self
307            # get server version
308            cmd = Command()
309            suffix = "\r\n"
310            if self.db_type == "UV":
311                if self._host_type == 1:
312                    # Unix
313                    cmd.command_text = 'SH -c "uv -version"'
314                else:
315                    cmd.command_text = 'DOS /c "uv -version"'
316                cmd.run()
317                uv1135 = self._get_uv_version("UniVerse 11.3.5")
318                uv_version = self._get_uv_version(cmd.response.removesuffix(suffix))
319                if uv_version is None or uv1135 is None:
320                    raise UOError(ErrorCodes.UOE_UNKNOWN_ERROR)
321                self._uv_timeout_flag = self._compare_version(uv_version, uv1135)
322
323    def _login(self):
324        in_packet = UniRPCPacket()
325        out_packet = UniRPCPacket()
326
327        out_packet.write(0, _COMMS_VERSION)
328        out_packet.write(1, _CS_VERSION)
329        out_packet.write(2, self.encode(self._config[USER]))
330        out_packet.write(3, mangle(self.encode(self._config[PASSWORD]), _COMMS_VERSION))
331        out_packet.write(4, self.encode(self._config[ACCOUNT]))
332        out_packet.write(5, self.encode(self._license_token))
333        out_packet.write(6, _RESERVED)
334
335        ip_int, hostname = get_host_info()
336
337        out_packet.write(7, ip_int)
338        out_packet.write(8, self.encode(self._mac_address))
339        out_packet.write(9, self.encode(hostname))
340        out_packet.write(10, b"")
341
342        if config.pooling[POOLING_ON]:
343            if is_cp_supported(self._rpc_connection.server_id):
344                out_packet.write(11, 1)
345            else:
346                raise UOError(
347                    code=ErrorCodes.UOE_CP_NOTSUPPORTED,
348                    message="Database Server upgrade is needed.",
349                )
350
351        self._config[PASSWORD] = ""
352        self.rpc_call(in_packet, out_packet)
353
354        resp_code = in_packet.read(0)
355        if resp_code == 0:
356            self._nls_init()
357            self._get_host_info()
358            self.is_active = True
359            self._transaction = Transaction(session=self)
360        else:
361            if in_packet.argument_count > 1:
362                last_error = self.decode(in_packet.read(1))
363                raise UOError(message=last_error)
364            else:
365                raise UOError(code=resp_code)
366
367    def _nls_init(self):
368        from ._nlsmap import NLSMap
369
370        in_packet = UniRPCPacket()
371        out_packet = UniRPCPacket()
372        out_packet.write(0, FuncCodes.EIC_GETSERVERINFO)
373        self.rpc_call(in_packet, out_packet)
374
375        resp_code = in_packet.read(0)
376        if resp_code != 0:
377            raise UOError(code=resp_code)
378
379        nls_mode = in_packet.read(1)
380        nls_lc_mode = in_packet.read(2)
381
382        if nls_mode == 1:
383            self._is_nls_enabled = True
384            if nls_lc_mode == 1:
385                self._is_nls_locale_enabled = True
386        elif nls_mode == 2:
387            self._is_ud = True
388        elif nls_mode == 3:
389            self._is_d3 = True
390
391        if self._is_nls_enabled or self._is_ud:
392            NLSMap(self).set_server_map_name("NONE")
393            if self._is_nls_enabled:
394                self.encoding = "UTF-8"
395
396            # if self.is_nls_locale_enabled:
397            #     _NLSLocale(self).set_server_locale_names("DEFAULT")
398
399    def _get_host_info(self):
400        in_packet = UniRPCPacket()
401        out_packet = UniRPCPacket()
402        out_packet.write(0, FuncCodes.EIC_SESSIONINFO)
403
404        self.rpc_call(in_packet, out_packet)
405
406        resp_code = in_packet.read(0)
407        if resp_code == 0:
408            self._host_type = in_packet.read(2)
409        else:
410            raise UOError(code=resp_code)
411
412    def check_rpc_error(self, e):
413        if e.code in _RPC_ERRORS:
414            self._is_rpc_failed = True
415
416    def health_check(self):
417        with self._lock:
418            if self._is_rpc_failed:
419                _logger.debug("RPC failed")
420                return False
421
422        return self._rpc_connection.health_check()
423
424    def hard_close(self):
425        try:
426            self._rpc_connection.close()
427
428            with self._lock:
429                if self.__pool:
430                    self.__pool.hard_free(self)
431
432        except Exception as e:
433            _logger.warning(str(e))
434        finally:
435            self.is_active = False
436            self._rpc_connection = None
437            thread_data.session = None
438
439        _logger.debug("Exit", id(self), "is hard-closed ")
440
441    def get_atvar(self, atvar):
442        """Get a @var value from the server.
443
444        Args:
445            atvar: uopy.AtVar enum.
446
447        Returns:
448            DynArray: the value of the @var
449
450        Raises:
451            UOError
452
453        Examples:
454            >>> import uopy
455            >>> for atvar in uopy.AtVar:
456                    print(atvar.name, atvar.value)
457
458            LOG_NAME 1
459            PATH 2
460            USER_NO 3
461            WHO 4
462            TRANSACTION 5
463            DATA_PENDING 6
464            USER_RETURN_CODE 7
465            SYSTEM_RETURN_CODE 8
466            NULL_STR 9
467            SCHEMA 10
468            TRANSACTION_LEVEL 11
469
470            >>>
471            >>> with uopy.connect(user='test_user', password='test_password') as session:
472                    log_name = session.get_atvar(uopy.AtVar.LOG_NAME)
473                    account_path = session.get_atvar(uopy.AtVar.PATH)
474                    print(log_name)
475                    print(account_path)
476
477            test_user
478            C:\\U2\\ud82\\XDEMO
479
480        """
481        _logger.debug("Enter", atvar)
482
483        self._check_callable()
484
485        with self._lock:
486            in_packet = UniRPCPacket()
487            out_packet = UniRPCPacket()
488            out_packet.write(0, FuncCodes.EIC_GETVALUE)
489            out_packet.write(1, atvar.value)
490
491            self._rpc_connection.call(in_packet, out_packet)
492
493            resp_code = in_packet.read(0)
494            if resp_code == 0:
495                _logger.debug("Exit")
496                return DynArray(in_packet.read(1), self)
497            else:
498                raise UOError(code=resp_code)
499
500    def reset(self):
501        _logger.debug("Enter", id(self))
502
503        if self._is_rpc_failed:
504            return False
505
506        if self._command:
507            tmp_command = self._command
508            self._command = None
509
510            if tmp_command.status in {EXEC_MORE_OUTPUT, EXEC_REPLY}:
511                _logger.warning("Session is in the middle of a command execution.")
512                return False
513
514        if self.tx_is_active():
515            _logger.warning(
516                "Session is in the middle of a transaction, will try to roll back."
517            )
518            try:
519                self._transaction.rollback()
520            except Exception as e:
521                _logger.warning("Error occurred during transaction roll back." + str(e))
522                return False
523
524        _logger.debug("Exit")
525        return True
526
527    def close(self):
528        """Close the session or return it to the connection pool.
529
530        Raises:
531            UOError
532
533        """
534        _logger.debug("Enter", id(self))
535        if not self.is_active:
536            _logger.warning("Session::disconnect: session is inactive.")
537            return
538
539        with self._lock:
540            if self.__pool:
541                self.__pool.free(self)
542            else:
543                # self.reset()
544                self.hard_close()
545
546        _logger.debug("Exit")
547
548    def bind_command(self, command_obj):
549        if self._command:
550            _logger.warning(
551                "A session can only have one bound Command object, will replace the old one"
552            )
553        self._command = command_obj
554
555    def tx_start(self):
556        """Start a transaction on the server.
557
558        Args:
559
560        Returns:
561            None
562
563        Raises:
564            UOError
565
566        """
567        self._transaction.begin()
568
569    def tx_commit(self):
570        """Commit the current transaction on the server.
571
572        Args:
573
574        Returns:
575            None
576
577        Raises:
578            UOError
579
580        """
581        self._transaction.commit()
582
583    def tx_rollback(self):
584        """Roll back the current transaction on the server.
585
586        Args:
587
588        Returns:
589            None
590
591        Raises:
592            UOError
593
594        """
595
596        self._transaction.rollback()
597
598    def tx_level(self):
599        """Return the current transaction level on the server
600
601        Args:
602
603        Returns:
604            int: the current transaction level
605
606        Raises:
607             UOError
608
609        """
610        return int(str(self.get_atvar(AtVar.TRANSACTION_LEVEL)))
611
612    def tx_is_active(self):
613        """Check if a transaction is active on the server.
614
615        Args:
616
617        Returns:
618            True/False: in transaction or not
619
620        Raises:
621            UOError
622
623        """
624        resp = self.get_atvar(AtVar.TRANSACTION)
625        if resp == "" or resp == "0":
626            return False
627        else:
628            return True
629
630    def _server_transaction(self, tx_key):
631        _logger.debug("Enter", tx_key)
632
633        with self.lock:
634            in_packet = UniRPCPacket()
635            out_packet = UniRPCPacket()
636
637            out_packet.write(0, FuncCodes.EIC_TRANSACTION)
638            out_packet.write(1, tx_key)
639
640            try:
641                self._rpc_connection.call(in_packet, out_packet, self.encryption_type)
642                ret_code = in_packet.read(0)
643            except Exception as e:
644                raise UOError(message=str(e))
645
646            if ret_code == 0:
647                pass
648            else:
649                self._session.check_rpc_is_failed(ret_code)
650                self.status = in_packet.read(1)
651                raise UOError(code=ret_code)
652
653        _logger.info("Exit")

 21class Command(UniObject):
 22    """Command allows applications to run MV ECL/TCL commands or stored procedures on the remote server.
 23
 24    After a command is executed, it can have one of these three status:
 25        EXEC_COMPLETE: the command execution has completed.
 26
 27        EXEC_REPLY: the command awaits user input - the reply() method can be called to provide an input.
 28
 29        EXEC_MORE_OUTPUT: the command output buffer isn't big enough to hold all the results. In this case,
 30            the next_response() method can be called to get the next block of the response.
 31
 32    When the status is either EXEC_REPLY or EXEC_MORE_OUTPUT, the cancel() method can be called to terminate
 33    the command execution.
 34
 35    Attributes:
 36        command_text (str): the command text.
 37        at_system_return_code (int) : the value of the system variable @SYSTEM.RETURN.CODE on the server.
 38        at_selected (int): The value of the system variable @SELECTED on the server.
 39
 40    Examples:
 41
 42        >>> with uopy.connect(user='test', password='test'):
 43        >>>     cmd = uopy.Command("LIST VOC")
 44        >>>     cmd.run()
 45        >>>     print(cmd.response)
 46
 47        >>> with uopy.connect(user='test', password='test'):
 48        >>>     cmd = uopy.Command("RUN BP SAYHELLOTO")
 49        >>>     if cmd.status == uopy.EXEC_REPLY:
 50        >>>         cmd.reply("MV loyal user")
 51        >>>     print(cmd.response)
 52
 53    """
 54
 55    def __init__(self, command_text=None, session=None):
 56        """Initialize a Command object
 57
 58        Args:
 59            command_text (str, optional): the TCL/ECL command to be executed on the remote server.
 60            session (Session, optional): the Session object that the Command object is bound to.
 61                If omitted, the last opened Session in the current thread will be used.
 62
 63        Raises:
 64            UOError
 65
 66        """
 67        super().__init__(session)
 68
 69        self._buffer_size = _EXEC_DEFAULT_BUFFER_SIZE
 70        self._status = EXEC_COMPLETE
 71        self._response = ""
 72        self._next_block = ""
 73        self.command_text = "" if command_text is None else command_text
 74        self.at_system_return_code = 0
 75        self.at_selected = 0
 76        self._is_fetch_all = True
 77        self._session.bind_command(self)
 78
 79    def __repr__(self):
 80        format_string = "<{} object {} at 0x{:016X}>"
 81        details = {"command_text": self.command_text}
 82        return format_string.format(
 83            ".".join([Command.__module__, Command.__qualname__]), details, id(self)
 84        )
 85
 86    @property
 87    def status(self):
 88        """int: The current status of the Command object."""
 89        return self._status
 90
 91    @property
 92    def response(self):
 93        """str: The current response of the Command object from the server."""
 94        return self._response
 95
 96    @property
 97    def buffer_size(self):
 98        """int: The size of the output buffer for the Command object.
 99
100        If left unset, all the output of the command execution will be brought back at once.
101        If set explicitly, only the output of the specified size will be returned.
102
103        """
104        return self._buffer_size
105
106    @buffer_size.setter
107    def buffer_size(self, value):
108        if not isinstance(value, int):
109            raise UOError(message="output buffer size must be an integer!")
110        if value <= 0:
111            raise UOError(message="output buffer size must between greater than 0!")
112        self._buffer_size = value
113        self._is_fetch_all = False
114
115    def _exec(self, server_command, input_reply):
116        in_packet = UniRPCPacket()
117        out_packet = UniRPCPacket()
118
119        out_packet.write(0, server_command)
120
121        if server_command == FuncCodes.EIC_EXECUTE:
122            out_packet.write(1, self._buffer_size)
123            out_packet.write(2, self._session.encode(self.command_text))
124        elif server_command == FuncCodes.EIC_EXECUTECONTINUE:
125            out_packet.write(1, self._buffer_size)
126        elif server_command == FuncCodes.EIC_INPUTREPLY:
127            reply_str = input_reply + "\n"
128            out_packet.write(1, self._session.encode(reply_str))
129            out_packet.write(2, self._buffer_size)
130        else:
131            raise UOError(code=ErrorCodes.UOE_EINVAL)
132
133        resp_code = self._call_server(in_packet, out_packet, in_exec=True)
134
135        if resp_code == _EXEC_END:
136            tmp_resp = self._session.decode(in_packet.read(1))
137            self._session.read_packet4cmd(in_packet)
138            self.at_system_return_code = in_packet.read(1)
139            self.at_selected = in_packet.read(2)
140            resp_code = EXEC_COMPLETE
141        elif resp_code == _EXEC_BTS:
142            tmp_resp = self._session.decode(in_packet.read(1))
143            resp_code = EXEC_MORE_OUTPUT
144        elif resp_code == _EXEC_AT_INPUT:
145            tmp_resp = self._session.decode(in_packet.read(1))
146            resp_code = EXEC_REPLY
147        else:
148            e = UOError(code=resp_code)
149            _logger.debug(e)
150            raise e
151
152        if server_command == FuncCodes.EIC_EXECUTECONTINUE:
153            self._next_block = tmp_resp
154        else:
155            self._response = tmp_resp
156
157        _logger.debug("Response", tmp_resp, resp_code)
158        return resp_code
159
160    def _fetch_all(self, resp_code):
161        while resp_code == EXEC_MORE_OUTPUT:
162            resp_code = self._exec(FuncCodes.EIC_EXECUTECONTINUE, "")
163            if resp_code in [EXEC_MORE_OUTPUT, EXEC_COMPLETE]:
164                self._response += self._next_block
165        return resp_code
166
167    def run(self):
168        """Execute the command on the remote server.
169
170        Args:
171
172        Returns:
173            None
174
175        Raises:
176            UOError
177
178        """
179        _logger.debug("Enter", self.command_text)
180
181        with self._lock:
182            if self._status in {EXEC_MORE_OUTPUT, EXEC_REPLY}:
183                raise UOError(code=ErrorCodes.UOE_EXECUTEISACTIVE)
184
185            if self.command_text is None or self.command_text == "":
186                raise UOError(
187                    ErrorCodes.UOE_USAGE_ERROR, message="invalid command_text"
188                )
189
190            self.at_system_return_code = 0
191            self.at_selected = 0
192            self._response = ""
193
194            resp_code = self._exec(FuncCodes.EIC_EXECUTE, "")
195            self._status = resp_code
196
197            if self._is_fetch_all and resp_code == EXEC_MORE_OUTPUT:
198                self._status = self._fetch_all(resp_code)
199
200        _logger.debug("Exit", self._status, self._response)
201
202    def cancel(self):
203        """Cancel the execution of the command.
204
205        Args:
206
207        Returns:
208            None
209
210        Raises:
211            UOError
212
213        """
214        _logger.debug("Enter")
215
216        with self._lock:
217            in_packet = UniRPCPacket()
218            out_packet = UniRPCPacket()
219
220            if self._status in {EXEC_REPLY, EXEC_MORE_OUTPUT}:
221                self._status = EXEC_COMPLETE
222
223                out_packet.write(0, FuncCodes.EIC_CANCEL)
224
225                resp_code = self._call_server(in_packet, out_packet)
226
227                resp_code = in_packet.read(0)
228                if resp_code != 0:
229                    e = UOError(code=resp_code)
230                    _logger.debug(e)
231                    raise e
232            else:
233                _logger.warning("execution already finished")
234
235        _logger.debug("Exit")
236
237    def reply(self, reply_data):
238        """Send a reply to the server to continue the command execution.
239
240        Args:
241            reply_data: the input for the command.
242
243        Returns:
244            None
245
246        Raises:
247            UOError
248
249        """
250        _logger.debug("Enter", reply_data)
251
252        with self._lock:
253            if self._status != EXEC_REPLY:
254                raise UOError(code=ErrorCodes.UOE_NOTATINPUT)
255
256            # reply_data += "\n"
257            resp_code = self._exec(FuncCodes.EIC_INPUTREPLY, reply_data)
258
259            self._status = resp_code
260            if self._is_fetch_all and resp_code == EXEC_MORE_OUTPUT:
261                self._status = self._fetch_all(resp_code)
262
263        _logger.debug("Exit", self._status)
264
265    def next_response(self):
266        """Get the next block of output from the server.
267
268        Args:
269
270        Returns:
271            None
272
273        Raises:
274            UOError
275
276        """
277        _logger.debug("Enter")
278
279        with self._lock:
280            if self._status != EXEC_MORE_OUTPUT:
281                raise UOError(code=ErrorCodes.UOE_NOMORE)
282
283            self._response = None
284            resp_code = self._exec(FuncCodes.EIC_EXECUTECONTINUE, "")
285
286            self._response = self._next_block
287
288            self._status = resp_code
289            if self._is_fetch_all and resp_code == EXEC_MORE_OUTPUT:
290                self._status = self._fetch_all(resp_code)
291
292        _logger.debug("Exit", self._status, self._response)