Normalize 'mech' argument name

All instances of the 'mech_type' and 'mech_types' arguments have
been converted into the 'mech' and 'mechs' arguments, respectively.

Additionally, the relevant properties of the named tuples have been
updated as well.

Author: DirectXMan12

gssapi/names.py

@@ -99,20 +99,20 @@ def export(self):
 
         return rname.export_name(self)
 
-    def canonicalize(self, mech_type):
+    def canonicalize(self, mech):
         """Canonicalize a name with respect to a mechanism
 
         This method returns a new Name that is canonicalized according to
         the given mechanism.
 
         Args:
-            mech_type (OID): the mechanism type to use
+            mech (OID): the mechanism type to use
 
         Returns:
             Name: the canonicalized name
         """
 
-        return type(self)(rname.canonicalize_name(self, mech_type))
+        return type(self)(rname.canonicalize_name(self, mech))
 
     def __copy__(self):
         return type(self)(rname.duplicate_name(self))

gssapi/raw/misc.pyx

@@ -52,14 +52,14 @@ def indicate_mechs():
         raise GSSError(maj_stat, min_stat)
 
 
-def inquire_names_for_mech(OID mech_type not None):
+def inquire_names_for_mech(OID mech not None):
     """Get the name types supported by a mechanism.
 
     This method retrives the different name types supported by
     the given mechanism.
 
     Args:
-        mech_type (OID): the mechanism in question
+        mech (OID): the mechanism in question
 
     Returns:
         list: the name type OIDs supported by the given mechanism
@@ -72,7 +72,7 @@ def inquire_names_for_mech(OID mech_type not None):
 
     cdef OM_uint32 maj_stat, min_stat
 
-    maj_stat = gss_inquire_names_for_mech(&min_stat, &mech_type.raw_oid,
+    maj_stat = gss_inquire_names_for_mech(&min_stat, &mech.raw_oid,
                                           &name_types)
 
     if maj_stat == GSS_S_COMPLETE:
@@ -111,7 +111,7 @@ def inquire_mechs_for_name(Name name not None):
 
 
 def _display_status(unsigned int error_code, bint is_major_code,
-                    OID mech_type=None, unsigned int message_context=0):
+                    OID mech=None, unsigned int message_context=0):
     """
     Display a string message for a GSSAPI error code.
 
@@ -126,7 +126,7 @@ def _display_status(unsigned int error_code, bint is_major_code,
         error_code (int): The error code in question
         is_major_code (bool): is this a major code (True) or a
             minor code (False)
-        mech_type (MechType): The mechanism type that returned this error code
+        mech (MechType): The mechanism type that returned this error code
             (defaults to None, for the default mechanism)
         message_context (int): The context for this call -- this is used when
             multiple messages are available (defaults to 0)
@@ -147,10 +147,10 @@ def _display_status(unsigned int error_code, bint is_major_code,
     else:
         status_type = GSS_C_MECH_CODE
 
-    if mech_type is None:
+    if mech is None:
         c_mech_type = GSS_C_NO_OID
     else:
-        c_mech_type = &mech_type.raw_oid
+        c_mech_type = &mech.raw_oid
 
     cdef OM_uint32 maj_stat
     cdef OM_uint32 min_stat

gssapi/raw/named_tuples.py

@@ -39,19 +39,19 @@
 
 AcceptSecContextResult = namedtuple('AcceptSecContextResult',
                                     ['context', 'initiator_name',
-                                     'mech_type', 'token', 'flags', 'lifetime',
+                                     'mech', 'token', 'flags', 'lifetime',
                                      'delegated_creds', 'more_steps'])
 
 
 InitSecContextResult = namedtuple('InitSecContextResult',
-                                  ['context', 'mech_type', 'flags', 'token',
+                                  ['context', 'mech', 'flags', 'token',
                                    'lifetime', 'more_steps'])
 
 
 InquireContextResult = namedtuple('InquireContextResult',
                                   ['initiator_name', 'target_name',
-                                   'lifetime', 'mech_type', 'flags',
+                                   'lifetime', 'mech', 'flags',
                                    'locally_init', 'complete'])
 
 StoreCredResult = namedtuple('StoreCredResult',
-                             ['mech_types', 'usage'])
+                             ['mechs', 'usage'])

gssapi/raw/names.pyx

@@ -240,7 +240,7 @@ def export_name(Name name not None):
         raise GSSError(maj_stat, min_stat)
 
 
-def canonicalize_name(Name name not None, OID mech_type not None):
+def canonicalize_name(Name name not None, OID mech not None):
     """
     Canonicalize an arbitrary GSSAPI Name into a Mechanism Name
 
@@ -250,7 +250,7 @@ def canonicalize_name(Name name not None, OID mech_type not None):
 
     Args:
         name (Name): the name to canonicalize
-        mech_type (MechType): the mechanism type to use to
+        mech (MechType): the mechanism type to use to
             canonicalize the name
 
     Returns:
@@ -266,7 +266,7 @@ def canonicalize_name(Name name not None, OID mech_type not None):
 
     with nogil:
         maj_stat = gss_canonicalize_name(&min_stat, name.raw_name,
-                                         &mech_type.raw_oid,
+                                         &mech.raw_oid,
                                          &canonicalized_name)
 
     cdef Name cn = Name()

gssapi/raw/sec_contexts.pyx

@@ -111,7 +111,7 @@ cdef class SecurityContext:
 # TODO(directxman12): figure out whether GSS_C_NO_NAME can be passed in here
 def init_sec_context(Name target_name not None, Creds cred=None,
                      SecurityContext context=None,
-                     OID mech_type=None,
+                     OID mech=None,
                      flags=None, lifetime=None,
                      ChannelBindings channel_bindings=None,
                      input_token=None):
@@ -132,7 +132,7 @@ def init_sec_context(Name target_name not None, Creds cred=None,
             or None to use the default credentials
         context (SecurityContext): the security context to update, or
             None to create a new context
-        mech_type (MechType): the mechanism type for this security context,
+        mech (MechType): the mechanism type for this security context,
             or None for the default mechanism type
         flags ([RequirementFlag]): the flags to request for the security
             context, or None to use the default set: mutual_authentication and
@@ -156,8 +156,8 @@ def init_sec_context(Name target_name not None, Creds cred=None,
     """
 
     cdef gss_OID mech_oid
-    if mech_type is not None:
-        mech_oid = &mech_type.raw_oid
+    if mech is not None:
+        mech_oid = &mech.raw_oid
     else:
         mech_oid = GSS_C_NO_OID
 
@@ -343,13 +343,13 @@ def accept_sec_context(input_token not None, Creds acceptor_cred=None,
 
 
 def inquire_context(SecurityContext context not None, initiator_name=True,
-                    target_name=True, lifetime=True, mech_type=True,
+                    target_name=True, lifetime=True, mech=True,
                     flags=True, locally_init=True, complete=True):
     """
     Get information about a security context.
 
     This method obtains information about a security context, including
-    the initiator and target names, as well as the TTL, mech type,
+    the initiator and target names, as well as the TTL, mech,
     flags, and its current state (open vs closed).
 
     Note: the target name may be None if it would have been GSS_C_NO_NAME
@@ -384,7 +384,7 @@ def inquire_context(SecurityContext context not None, initiator_name=True,
 
     cdef gss_OID output_mech_type
     cdef gss_OID *mech_type_ptr = NULL
-    if mech_type:
+    if mech:
         mech_type_ptr = &output_mech_type
 
     cdef OM_uint32 output_flags
@@ -425,7 +425,7 @@ def inquire_context(SecurityContext context not None, initiator_name=True,
         else:
             tn = None
 
-        if mech_type:
+        if mech:
             py_mech_type = OID()
             py_mech_type.raw_oid = output_mech_type[0]
         else:

gssapi/sec_contexts.py

@@ -27,7 +27,7 @@ class SecurityContext(rsec_contexts.SecurityContext):
 
     def __new__(cls, base=None, token=None,
                 name=None, creds=None, lifetime=None, flags=None,
-                mech_type=None, channel_bindings=None, usage=None):
+                mech=None, channel_bindings=None, usage=None):
 
         if token is not None:
             base = rsec_contexts.import_sec_context(token)
@@ -36,7 +36,7 @@ def __new__(cls, base=None, token=None,
 
     def __init__(self, base=None, token=None,
                  name=None, creds=None, lifetime=None, flags=None,
-                 mech_type=None, channel_bindings=None, usage=None):
+                 mech=None, channel_bindings=None, usage=None):
         """
         The constructor creates a new security context, but does not begin
         the initiate or accept process.
@@ -55,7 +55,7 @@ def __init__(self, base=None, token=None,
         security context (if `base` or `token` are used) or the argument set.
 
         For a security context of the `initiate` usage, the `name` argument
-        must be used, and the `creds`, `mech_type`, `flags`,
+        must be used, and the `creds`, `mech`, `flags`,
         `lifetime`, and `channel_bindings` arguments may be
         used as well.
 
@@ -86,19 +86,19 @@ def __init__(self, base=None, token=None,
 
             # check for appropriate arguments
             if self.usage == 'initiate':
-                # takes: creds?, target_name, mech_type?, flags?,
+                # takes: creds?, target_name, mech?, flags?,
                 #        channel_bindings?
                 if name is None:
                     raise TypeError("You must pass the 'name' argument when "
                                     "creating an initiating security context")
                 self._target_name = name
-                self._mech_type = mech_type
+                self._mech = mech
                 self._desired_flags = IntEnumFlagSet(RequirementFlag, flags)
                 self._desired_lifetime = lifetime
             else:
                 # takes creds?
                 if (name is not None or flags is not None or
-                        mech_type is not None or lifetime is not None):
+                        mech is not None or lifetime is not None):
                     raise TypeError("You must pass at most the 'creds' "
                                     "argument when creating an accepting "
                                     "security context")
@@ -290,7 +290,7 @@ def export(self):
         return rsec_contexts.export_sec_context(self)
 
     _INQUIRE_ARGS = ('initiator_name', 'target_name', 'lifetime',
-                     'mech_type', 'flags', 'locally_init', 'complete')
+                     'mech', 'flags', 'locally_init', 'complete')
 
     @_utils.check_last_err
     def _inquire(self, **kwargs):
@@ -306,7 +306,7 @@ def _inquire(self, **kwargs):
             initiator_name (bool): get the initiator name for this context
             target_name (bool): get the target name for this context
             lifetime (bool): get the remaining lifetime for this context
-            mech_type (bool): get the mechanism used by this context
+            mech (bool): get the mechanism used by this context
             flags (bool): get the flags set on this context
             locally_init (bool): get whether this context was locally initiated
             complete (bool): get whether negotiation on this context has
@@ -339,7 +339,7 @@ def _inquire(self, **kwargs):
             target_name = None
 
         return tuples.InquireContextResult(init_name, target_name,
-                                           res.lifetime, res.mech_type,
+                                           res.lifetime, res.mech,
                                            res.flags, res.locally_init,
                                            res.complete)
 
@@ -352,8 +352,8 @@ def lifetime(self):
         'initiator_name', 'Get the Name of the initiator of this context')
     target_name = _utils.inquire_property(
         'target_name', 'Get the Name of the target of this context')
-    mech_type = _utils.inquire_property(
-        'mech_type', 'Get the mechanism in use by this context')
+    mech = _utils.inquire_property(
+        'mech', 'Get the mechanism in use by this context')
     actual_flags = _utils.inquire_property(
         'flags', 'Get the flags set on this context')
     locally_initiated = _utils.inquire_property(
@@ -412,7 +412,7 @@ def _acceptor_step(self, token):
 
     def _initiator_step(self, token=None):
         res = rsec_contexts.init_sec_context(self._target_name, self._creds,
-                                             self, self._mech_type,
+                                             self, self._mech,
                                              self._desired_flags,
                                              self._desired_lifetime,
                                              self._channel_bindings,

gssapi/tests/test_high_level.py

@@ -175,7 +175,7 @@ def test_store_acquire(self):
 
         store_res = deleg_creds.store(usage='initiate', set_default=True)
         store_res.usage.should_be('initiate')
-        store_res.mech_types.should_include(gb.MechType.kerberos)
+        store_res.mechs.should_include(gb.MechType.kerberos)
 
         reacquired_creds = gsscreds.Credentials(name=deleg_creds.name,
                                                 usage='initiate')
@@ -197,8 +197,8 @@ def test_store_into_acquire_from(self):
 
         store_res = initial_creds.store(store, overwrite=True)
 
-        store_res.mech_types.shouldnt_be_none()
-        store_res.mech_types.shouldnt_be_empty()
+        store_res.mechs.shouldnt_be_none()
+        store_res.mechs.shouldnt_be_empty()
         store_res.usage.should_be('initiate')
 
         name = gssnames.Name(princ_name)
@@ -288,8 +288,8 @@ def test_store_into_add_from(self):
 
         store_res = initial_creds.store(store, overwrite=True)
 
-        store_res.mech_types.shouldnt_be_none()
-        store_res.mech_types.shouldnt_be_empty()
+        store_res.mechs.shouldnt_be_none()
+        store_res.mechs.shouldnt_be_empty()
         store_res.usage.should_be('initiate')
 
         name = gssnames.Name(princ_name)
@@ -484,7 +484,7 @@ def test_create_from_other(self):
         high_level_ctx.target_name.should_be(self.target_name)
 
     @exist_perms(lifetime=30, flags=[],
-                 mech_type=gb.MechType.kerberos,
+                 mech=gb.MechType.kerberos,
                  channel_bindings=None)
     def test_create_new_init(self, str_name, kwargs):
         client_ctx = gssctx.SecurityContext(name=self.target_name,
@@ -524,14 +524,14 @@ def test_initiate_accept_steps(self):
 
         server_ctx.lifetime.should_be_at_most(400)
         server_ctx.initiator_name.should_be(client_ctx.initiator_name)
-        server_ctx.mech_type.should_be_a(gb.OID)
+        server_ctx.mech.should_be_a(gb.OID)
         server_ctx.actual_flags.should_be_a(gb.IntEnumFlagSet)
         server_ctx.locally_initiated.should_be_false()
         server_ctx.complete.should_be_true()
 
         client_ctx.lifetime.should_be_at_most(400)
         client_ctx.target_name.should_be(self.target_name)
-        client_ctx.mech_type.should_be_a(gb.OID)
+        client_ctx.mech.should_be_a(gb.OID)
         client_ctx.actual_flags.should_be_a(gb.IntEnumFlagSet)
         client_ctx.locally_initiated.should_be_true()
         client_ctx.complete.should_be_true()

gssapi/tests/test_raw.py

@@ -320,7 +320,7 @@ def test_store_cred_acquire_cred(self):
 
         store_res.shouldnt_be_none()
         store_res.usage.should_be('initiate')
-        store_res.mech_types.should_include(gb.MechType.kerberos)
+        store_res.mechs.should_include(gb.MechType.kerberos)
 
         deleg_name = gb.inquire_cred(deleg_creds).name
         acq_resp = gb.acquire_cred(deleg_name, usage='initiate')
@@ -343,7 +343,7 @@ def test_store_cred_into_acquire_cred(self):
         # NB(sross): overwrite because the ccache doesn't exist yet
         store_res = gb.store_cred_into(store, initial_creds, overwrite=True)
 
-        store_res.mech_types.shouldnt_be_none()
+        store_res.mechs.shouldnt_be_none()
         store_res.usage.should_be('initiate')
 
         name = gb.import_name(princ_name.encode('UTF-8'))