[_688] implement server_version_without_auth

This is a method of the iRODSSession object that returns the connected iRODS server
version without having to authenticate first.

codacy connect related

review change - assertGreater

unauthorized -> unauthenticated

Author: d-w-moore

irods/connection.py

@@ -83,6 +83,8 @@ def __init__(self, pool, account):
         self._disconnected = False
 
         scheme = self.account._original_authentication_scheme
+        if self.pool and not self.pool._need_auth:
+            return
 
         # These variables are just useful diagnostics.  The login_XYZ() methods should fail by
         # raising exceptions if they encounter authentication errors.

irods/helpers/__init__.py

@@ -36,3 +36,23 @@ def xml_mode(s):
         yield
     finally:
         ET(None)
+
+
+class _unlikely_value:
+    pass
+
+
+@contextlib.contextmanager
+def temporarily_assign_attribute(
+    target, attr, value, not_set_indicator=_unlikely_value()
+):
+    save = not_set_indicator
+    try:
+        save = getattr(target, attr, not_set_indicator)
+        setattr(target, attr, value)
+        yield
+    finally:
+        if save != not_set_indicator:
+            setattr(target, attr, save)
+        else:
+            delattr(target, attr)

irods/keywords.py

@@ -1,5 +1,4 @@
-"""From rodsKeyWdDef.hpp
-"""
+"""From rodsKeyWdDef.hpp"""
 
 ALL_KW = "all"  # operation done on all replicas #
 COPIES_KW = "copies"  # the number of copies #

irods/pool.py

@@ -1,3 +1,4 @@
+import contextlib
 import datetime
 import logging
 import threading
@@ -57,6 +58,7 @@ def __init__(
             or application_name
             or DEFAULT_APPLICATION_NAME
         )
+        self._need_auth = True
 
         if connection_refresh_time > 0:
             self.refresh_connection = True
@@ -65,6 +67,16 @@ def __init__(
             self.refresh_connection = False
             self.connection_refresh_time = None
 
+    @contextlib.contextmanager
+    def no_auto_authenticate(self):
+        import irods.helpers
+
+        with irods.helpers.temporarily_assign_attribute(self, "_need_auth", False):
+            yield self
+
+    def set_session_ref(self, session):
+        self.session_ref = weakref.ref(session) if session is not None else lambda: None
+
     @property
     def _conn(self):
         return getattr(self._thread_local, "_conn", None)

irods/session.py

@@ -1,5 +1,6 @@
 import ast
 import atexit
+import contextlib
 import copy
 import errno
 import json
@@ -355,10 +356,37 @@ def port(self):
 
     @property
     def server_version(self):
+        return self._server_version()
+
+    def server_version_without_auth(self):
+        """Returns the same version tuple as iRODSSession's server_version property, but
+        does not require successful authentication.
+        """
+        from irods.connection import Connection
+
+        with self.clone().pool.no_auto_authenticate() as pool:
+            return Connection(pool, pool.account).server_version
+
+    GET_SERVER_VERSION_WITHOUT_AUTH = staticmethod(
+        lambda s: s.server_version_without_auth()
+    )
+
+    def _server_version(self, version_func=None):
+        """The  server version can be retrieved by the usage
+            session._server_version()
+        with conditional substitution by another version by use of the environment variable:
+            PYTHON_IRODSCLIENT_REPORTED_SERVER_VERSION.
+
+        Also: if iRODSServer.GET_SERVER_VERSION_WITHOUT_AUTH is passed in version_func, the true server
+        version can be accessed without first going through authentication.
+        Example:
+            ses = irods.helpers.make_session()
+            vsn = ses._server_version( ses.GET_SERVER_VERSION_WITHOUT_AUTH )
+        """
         reported_vsn = os.environ.get("PYTHON_IRODSCLIENT_REPORTED_SERVER_VERSION", "")
         if reported_vsn:
             return tuple(ast.literal_eval(reported_vsn))
-        return self.__server_version()
+        return self.__server_version() if version_func is None else version_func(self)
 
     def __server_version(self):
         try:

irods/test/connection_test.py

@@ -1,16 +1,16 @@
 #! /usr/bin/env python
 
+import numbers
 import os
 import sys
 import tempfile
 import unittest
-from irods.exception import NetworkException
 from irods import MAXIMUM_CONNECTION_TIMEOUT
+from irods.exception import NetworkException, CAT_INVALID_AUTHENTICATION
+import irods.session
 import irods.test.helpers as helpers
-from irods.test.helpers import (
-    server_side_sleep,
-    temporarily_assign_attribute as temp_setter,
-)
+from irods.test.helpers import server_side_sleep
+from irods.helpers import temporarily_assign_attribute as temp_setter
 
 
 class TestConnections(unittest.TestCase):
@@ -34,6 +34,29 @@ def test_connection_destructor(self):
         self.assertTrue(conn._disconnected)
         conn.release(destroy=True)
 
+    def test_server_version_without_authentication__issue_688(self):
+        sess = self.sess
+
+        # Make a session object that cannot authenticate.
+        non_authenticating_session = irods.session.iRODSSession(
+            host=sess.host,
+            port=sess.port,
+            user=sess.username,
+            zone=sess.zone,
+            # No password.
+        )
+
+        # Test server_version_without_auth method returns a value.
+        version_tup = non_authenticating_session.server_version_without_auth()
+
+        # Test returned value is non-empty "version" tuple, i.e. holds only integer values.
+        self.assertGreater(len(version_tup), 0)
+        self.assertFalse(any(not isinstance(_, numbers.Integral) for _ in version_tup))
+
+        # Test that the older server_version property fails for the unauthenticated session object.
+        with self.assertRaises(CAT_INVALID_AUTHENTICATION):
+            _ = non_authenticating_session.server_version
+
     def test_failed_connection(self):
         # Make sure no connections are cached in self.sess.pool.idle to be grabbed by get_connection().
         # (Necessary after #418 fix; make_session() can probe server_version, which then leaves an idle conn.)

irods/test/helpers.py

@@ -172,6 +172,12 @@ def recast(k):
     return (config, auth)
 
 
+def get_server_version_for_test(session, curtail_length):
+    return session._server_version(session.GET_SERVER_VERSION_WITHOUT_AUTH)[
+        :curtail_length
+    ]
+
+
 # Create a connection for test, based on ~/.irods environment by default.
 
 
@@ -193,7 +199,7 @@ def make_session(test_server_version=True, **kwargs):
     env_file = env_filename_from_keyword_args(kwargs)
     session = iRODSSession(irods_env_file=env_file, **kwargs)
     if test_server_version:
-        connected_version = session.server_version[:3]
+        connected_version = get_server_version_for_test(session, curtail_length=3)
         advertised_version = IRODS_VERSION[:3]
         if connected_version > advertised_version:
             msg = (
@@ -430,26 +436,6 @@ def enableLogging(logger, handlerType, args, level_=logging.INFO):
             logger.removeHandler(h)
 
 
-class _unlikely_value:
-    pass
-
-
-@contextlib.contextmanager
-def temporarily_assign_attribute(
-    target, attr, value, not_set_indicator=_unlikely_value()
-):
-    save = not_set_indicator
-    try:
-        save = getattr(target, attr, not_set_indicator)
-        setattr(target, attr, value)
-        yield
-    finally:
-        if save != not_set_indicator:
-            setattr(target, attr, save)
-        else:
-            delattr(target, attr)
-
-
 # Implement a server-side wait that ensures no TCP communication from server end for a given interval.
 # Useful to test the effect of socket inactivity on a client.  See python-irodsclient issue #569
 def server_side_sleep(session, seconds):