Uso del inicio de sesión único de forma eficaz en la solución orientada a servicios

La solución orientada a servicios utiliza el inicio de sesión único (SSO) empresarial tanto para almacenar valores de configuración como para controlar las credenciales de los sistemas servidor. Para reducir latencia, la solución utiliza una caché local para los valores de configuración. La solución actualiza la caché cada cinco minutos.

En muchas aplicaciones, los adaptadores controlan las operaciones de inicio de sesión único, incluida la obtención de un vale de SSO, el canje del vale y el uso de las credenciales para obtener acceso a la aplicación afiliada. Sin embargo, la versión en línea de la solución orientada a servicios no utiliza adaptadores. Debe utilizar SSO del código.

En este tema se describe el mecanismo de almacenamiento en caché utilizado por la solución y cómo utiliza SSO del código la versión en línea de la solución.

Almacenar en caché local los valores de configuración

La solución orientada a servicios usa dos objetos, ConfigPropertyBag y ConfigParameters, para controlar los valores de configuración. La clase ConfigPropertyBag contiene los valores y solo lo usa la clase ConfigParameters . La clase ConfigParameters la usan las demás partes de la solución para recuperar los parámetros de configuración. Ambas clases están en el espacio de nombres Microsoft.Samples.BizTalk.WoodgroveBank.ConfigHelper .

Nota

La solución orientada a servicios corrige el intervalo de actualización de caché a 300 segundos (5 minutos). En su lugar, puede hacer que el intervalo de actualización de caché sea una propiedad configurable en esta solución. Esto lo puede hacer en la solución Administración de procesos empresariales. Para obtener más información sobre cómo administra esa solución el inicio de sesión único, consulte Using SSO Efficiently in the Business Process Management Solution. Tenga en cuenta que, en tal caso, los cambios en el intervalo de actualización no se hacen efectivos hasta que se actualiza la caché al final del período del intervalo anterior.

ConfigPropertyBag tiene los métodos siguientes:

Método	Descripción
Leer	Recupera un valor para una propiedad dada.
Escritura	Asigna un valor a una propiedad.

La clase usa una instancia de nameValueCollection de .NET para contener los valores. Los dos métodos de acceso implementan la interfaz IPropertyBag desde el espacio de nombres Microsoft.BizTalk.SSOClient.Interop . La clase ConfigPropertyBag es una clase interna y solo la usa la clase ConfigParameters .

Nota

Los nombres de clave en la bolsa de propiedades no distinguen entre mayúsculas y minúsculas. NameValueCollection subyacente usa hash sin distinción entre mayúsculas y minúsculas y comparaciones que no distinguen mayúsculas de minúsculas.

La aplicación usa la clase ConfigParameters para controlar los valores de configuración de SSO. La clase tiene los siguientes métodos y atributos públicos:

Método o atributo	Descripción
SSOConfigParameter	Enumeración para especificar parámetros de configuración.
GetConfigParameters	Método usado para recuperar un valor para un parámetro dado. Utiliza SSOConfigParameter para indicar el parámetro.

La clase ConfigParameters usa la clase Timer de .NET y una función de delegado para configurar la actualización de ConfigPropertyBag:

private static Timer cacheRefreshTimer;  
private static ISSOConfigStore ssoConfigStore;  
private static ReaderWriterLock syncLock;  
  
// Cache refresh interval in milliseconds  
private const int CacheRefreshInterval = 5 * 60 * 1000;  
private static ConfigPropertyBag ssoPropBag;  
  
static ConfigParameters()  
{  
    ssoConfigStore = new ISSOConfigStore();  
    ssoPropBag = new ConfigPropertyBag();  
    syncLock = new ReaderWriterLock();  
  
    ssoConfigStore.GetConfigInfo(SSO_CONFIG_APP,  
         SSO_IDENTIFIER_NAME, SSOFlag.SSO_FLAG_RUNTIME,  
         ssoPropBag);  
  
    cacheRefreshTimer = new Timer(  
        new TimerCallback(ConfigParameters.cacheRefreshCallback),  
        null, CacheRefreshInterval, CacheRefreshInterval);  
}  

Observe que el constructor estático inicializa las variables de miembro estático además de habilitar el uso de los métodos de clase sin crear una instancia de la clase. El constructor crea instancias del almacén de configuración de SSO (ISSOConfigStore), el contenedor de propiedades de configuración (ConfigPropertyBag) y un bloqueo de sincronización (ReaderWriterLock) que se usa para controlar el acceso a ConfigurationPropertyBag durante las actualizaciones y lecturas. A continuación, el constructor usa GetConfigInfo para recuperar los valores de configuración de SSO y colocarlos en el contenedor de propiedades. Por último, el constructor crea un objeto Timer que, después del intervalo especificado, llama a la función delegate cacheRefreshCallback.

La función de delegado temporizador es relativamente sencilla:

private static void cacheRefreshCallback(object state)  
{  
    // Disable the timer until we are done loading the cache.  
    cacheRefreshTimer.Change(Timeout.Infinite, CacheRefreshInterval);  
  
    // Put the data from SSO in a new property bag so that  
    // we don't have to lock the property bag and block it from being  
    // used. The SSO call is a remote call and may take a while.  
    ConfigPropertyBag propBag2 = new ConfigPropertyBag();  
    ssoConfigStore.GetConfigInfo(SSO_CONFIG_APP,   
        SSO_IDENTIFIER_NAME, SSOFlag.SSO_FLAG_RUNTIME, propBag2);  
  
    // Get a writer lock before updating the cached values.  
    syncLock.AcquireWriterLock(Timeout.Infinite);  
  
    try  
    {  
        ssoPropBag = propBag2;  
    }  
    finally   
    {  
        syncLock.ReleaseWriterLock();  
    }  
    // Enable the timer.  
    cacheRefreshTimer.Change(CacheRefreshInterval,   
        CacheRefreshInterval);  
}  

Tenga en cuenta que el método de devolución de llamada de actualización de caché deshabilita el temporizador para que el método se pueda ejecutar por completo. Tenga también en cuenta el uso de bloqueos para controlar el acceso a la bolsa de propiedades. ReaderWriterLock es la mejor opción aquí: está diseñado para casos en los que hay más lecturas que escrituras. Observe también que el bloqueo, syncLock, es estático y se declara en el nivel de clase que todos los subprocesos comparten la misma instancia única de él.

Usar SSO desde código

Al usar el inicio de sesión único desde el código, el código debe asumir el rol del adaptador: es decir, recuperar el vale de inicio de sesión único del mensaje, canjear el vale para obtener el nombre de usuario y la contraseña del sistema back-end y, por último, usar el sistema back-end. La solución orientada a servicios lo hace a través del método GetPendingTransactionsResponse del objeto PendingTransactionsCaller .

El método se muestra de la siguiente forma:

public static PendingTransactionsResponse GetPendingTransactionsResponse(XLANGMessage requestMsg)  
{  
    try  
    {  
        // Get config parameter values.  
        int ptTimeout = Convert.ToInt32(  
            ConfigParameters.GetConfigParameter(  
                ConfigParameters.  
                    SSOConfigParameter.  
                        PENDING_TRANSACTIONS_INLINE_TIMEOUT  
            )  
        );  
  
        string ptURL = ConfigParameters.GetConfigParameter(  
            ConfigParameters.  
                SSOConfigParameter.  
                    PENDING_TRANSACTIONS_URL  
        );  
        string ssoAffliateApp = ConfigParameters.  
            GetConfigParameter(ConfigParameters.  
                SSOConfigParameter.  
                    PENDING_TRANSACTIONS_SSO_AFFILIATE_APP  
            );  
  
        // Redeem the SSO ticket and get the userid/password to   
        // use to interact with Pending Transaction System.  
  
        // Extract the ticket…  
        string msgTicket = (string)requestMsg.  
            GetPropertyValue(typeof(BTS.SSOTicket));  
  
        // and the user name of the originating user.  
        string originatorSID = (string)requestMsg.  
            GetPropertyValue(  
                typeof(  
                    Microsoft.BizTalk.XLANGs.BTXEngine.OriginatorSID  
                )  
            );  
  
        string pendTransUserName;  
        // Now, redeem the ticket.  
        string[] pendTransCredential =   
            ssoTicket.RedeemTicket(  
                ssoAffliateApp,  
                originatorSID,  
                msgTicket,  
                SSOFlag.SSO_FLAG_NONE,  
                out pendTransUserName  
            );   
  
        PendingTransactionsRequest req =   
            (PendingTransactionsRequest)requestMsg[0].  
                RetrieveAs(  
                    typeof(PendingTransactionsRequest)  
                );  
        PendingTransactionsResponse resp;  
  
        using (PendingTransactionsWebService  
            svc = new PendingTransactionsWebService())  
        {  
            svc.Url = ptURL;  
            svc.Timeout = ptTimeout;  
  
            // The web service uses basic authentication, so we  
            //need to send the user id and password in the request.  
            CredentialCache credCache = new CredentialCache();  
            NetworkCredential credentialToUse =  
                new NetworkCredential(  
                    pendTransUserName, pendTransCredential[0]  
                );  
            credCache.Add(new Uri(svc.Url), "Basic", credentialToUse);  
            svc.Credentials = credCache;  
  
            resp = svc.GetPendingTransactions(req);  
        }  
        return resp;                  
    }  
    catch (System.Net.WebException webEx)  
    {  
        if (webEx.Status == WebExceptionStatus.Timeout)  
        {  
            throw new PendingTransactionsTimeoutException();  
        }  
        else  
        {  
            Trace.WriteLine("Other Net.WebException: "  
                + webEx.ToString()   
                + (null == webEx.InnerException ? "" :  
                     ("Inner Exception: "   
                        + webEx.InnerException.ToString())  
                )  
            );  
            throw;  
        }  
    }  
    catch(System.Exception ex)  
    {  
        Trace.WriteLine("Other Exception: "  
            + ex.ToString()   
            + (null == ex.InnerException ? "" :   
                 ("Inner Exception: "  
                    + ex.InnerException.ToString())  
                  )  
            );  
        throw;  
    }  
}  

El método comienza recuperando la información de configuración, incluida la dirección URL, para el sistema servidor y el nombre de la aplicación servidor (afiliada).

Para canjear el vale, el método debe extraer el vale y el nombre de usuario original de la solicitud del mensaje. El mensaje contiene el vale como una de las propiedades de contexto del mensaje , BTS. SSOTicket. Para obtener más información, consulte Propiedades de contexto de mensaje en la guía de interfaz de usuario y referencia del espacio de nombres de la API de desarrolladores. El método también extrae el OriginatorSID de las propiedades de contexto del mensaje. Con el vale y el nombre del originador, el método llama al método RedeemTicket en el vale para recuperar las credenciales.

El resto del código crea la caché NetworkCredential de .NET para las credenciales y llama al servicio Web servidor.

Nota

Puesto que el nombre de usuario y la contraseña se devuelven desde SSO en forma de texto visible, se recomienda reducir la duración de las variables que contienen dicha información. Observe que el código declara las variables de credencial dentro de un bloque try . Aquí, las variables expiran al salir del bloque try .

Consulte también

Aspectos destacados de la implementación de la solución orientada a servicios