Example #1
0
    /*****************************************************************************
    *  Function    : IsBPipeAuthorized
    *  Description : This function authorize the token. A valid Identiy will contain
    *             the user/application credentials on authorization success.
    *             Returns false on failure.
    *  Arguments   : token string from GenerateToken(), reference to Identity
    *  Returns     : bool
    *****************************************************************************/
    private bool IsBPipeAuthorized(string token, out Identity identity)
    {
        bool isAuthorized = false;
        bool isRunning    = true;

        identity = null;

        if (!d_session.OpenService(AUTH_SVC))
        {
            System.Console.Error.WriteLine("Failed to open " + AUTH_SVC);
            return(isAuthorized = false);
        }
        Service authService = d_session.GetService(AUTH_SVC);


        Request authRequest = authService.CreateAuthorizationRequest();

        authRequest.Set("token", token);
        identity = d_session.CreateIdentity();
        EventQueue authEventQueue = new EventQueue();

        d_session.SendAuthorizationRequest(authRequest, identity, authEventQueue, new CorrelationID(1));

        while (isRunning)
        {
            Event eventObj = authEventQueue.NextEvent();
            System.Console.WriteLine("processEvent");
            if (eventObj.Type == Event.EventType.RESPONSE || eventObj.Type == Event.EventType.REQUEST_STATUS)
            {
                foreach (Message msg in eventObj)
                {
                    if (msg.MessageType == AUTHORIZATION_SUCCESS)
                    {
                        System.Console.WriteLine("Authorization SUCCESS");

                        isAuthorized = true;
                        isRunning    = false;
                        break;
                    }
                    else if (msg.MessageType == AUTHORIZATION_FAILURE)
                    {
                        System.Console.WriteLine("Authorization FAILED");
                        System.Console.WriteLine(msg);
                        isRunning = false;
                    }
                    else
                    {
                        System.Console.WriteLine(msg);
                    }
                }
            }
        }
        return(isAuthorized);
    }
Example #2
0
        /// <summary>
        /// Authorize should be called before any requests are sent. Called by init.
        /// </summary>
        /// <param name="identity"></param>
        /// <param name="session"></param>
        private static void Authorize(out Identity identity, Session session)
        {
            identity = session.CreateIdentity();
            if (!session.OpenService(AUTH_SERVICE))
            {
                throw new Exception(
                          string.Format("Failed to open auth service: {0}",
                                        AUTH_SERVICE));
            }
            Service authService = session.GetService(AUTH_SERVICE);

            EventQueue tokenEventQueue = new EventQueue();

            session.GenerateToken(new CorrelationID(tokenEventQueue), tokenEventQueue);
            string token = null;
            // Generate token responses will come on the dedicated queue. There would be no other
            // messages on that queue.
            Event eventObj = tokenEventQueue.NextEvent(
                Convert.ToInt32(WAIT_TIME.TotalMilliseconds));

            if (eventObj.Type == Event.EventType.TOKEN_STATUS ||
                eventObj.Type == Event.EventType.REQUEST_STATUS)
            {
                foreach (Message msg in eventObj)
                {
                    System.Console.WriteLine(msg);
                    if (msg.MessageType == TOKEN_SUCCESS)
                    {
                        token = msg.GetElementAsString(TOKEN_ELEMENT);
                    }
                }
            }
            if (token == null)
            {
                throw new Exception("Failed to get token");
            }

            Request authRequest = authService.CreateAuthorizationRequest();

            authRequest.Set(TOKEN_ELEMENT, token);

            session.SendAuthorizationRequest(authRequest, identity, null);

            TimeSpan ts = WAIT_TIME;

            for (DateTime startTime = DateTime.UtcNow;
                 ts.TotalMilliseconds > 0;
                 ts = ts - (DateTime.UtcNow - startTime))
            {
                eventObj = session.NextEvent(Convert.ToInt32(ts.TotalMilliseconds));
                // Since no other requests were sent using the session queue, the response can
                // only be for the Authorization request
                if (eventObj.Type != Event.EventType.RESPONSE &&
                    eventObj.Type != Event.EventType.PARTIAL_RESPONSE &&
                    eventObj.Type != Event.EventType.REQUEST_STATUS)
                {
                    continue;
                }

                foreach (Message msg in eventObj)
                {
                    System.Console.WriteLine(msg);
                    if (msg.MessageType != AUTHORIZATION_SUCCESS)
                    {
                        throw new Exception("Authorization Failed");
                    }
                }
                return;
            }
            throw new Exception("Authorization Failed");
        }