Generic Identity Authorisation in 2-tier

Generic Identity Authorisation in 2-tier

Hi,
Using your example Console_SecurityWindowsAuthentication, which I have arranged to be 2-tier, I am adding code to support non-Windows Generic Identity Authorization.

In your code example of IEntityLoginManager you have a LoginException being generated on the Server side (which is of course in 2-tier also running on the client), if the login fails.

On the otherhand, if the GenericIdenity.IsAuthenticated
is false, the login as seen by the Client still succeeds.

Also, EntityServerQueryInterceptor is probed for after the login is completed.

The only way I can find of returning a failed login back to the Client is to return a null UserBase. This causes a EntityServerException
 of "Session Bundle is invalid". Which matches your code example.
Only in the Catch blocks is EntityManager.IsLoggedIn
false.

I'd much prefer to have LoginExceptionType.InvalidUserName returned to the Client.
Please can you suggest a way?

Alternatively, can you support:-
                var loginResult = mgr.Login((ILoginCredential)cred);
                var isLoggedIn = mgr.IsLoggedIn;

as false, when the login fails. So that one can test in the Client, and not have an exception.

//Client
        void DoIt()
        {
            NorthwindManager mgr = new NorthwindManager();

            //IdeaBlade.Core.IdeaBladeConfig.ConfigFileAssembly = Assembly.GetExecutingAssembly();
            var configInstance = IdeaBlade.Core.IdeaBladeConfig.Instance;
            configInstance.ObjectServer.ClientSettings.IsDistributed = false;
            configInstance.ObjectServer.ServerSettings.AllowAnonymousLogin = false;
            configInstance.ObjectServer.ServerSettings.LoginManagerRequired = true;
            configInstance.Logging.ShouldLogSqlQueries = true;
            configInstance.Logging.LogFile = "MyLogFile.xml"; //not working.

            Console.WriteLine("Thread principal before login: {0}", System.Threading.Thread.CurrentPrincipal.Identity.Name);
            bool isLoggedIn = false;
            bool loginResult = false;
            try
            {
                // Login will null credentials.  The LoginManager will decide what to do ...
                LoginCredential cred = new LoginCredential("john", "password", "domain");
                //loginResult = mgr.Login((ILoginCredential)null); 
                loginResult = mgr.Login((ILoginCredential)cred);
                isLoggedIn = mgr.IsLoggedIn;
                Console.WriteLine("Thread principal after login: {0}", System.Threading.Thread.CurrentPrincipal.Identity.Name);
            }
            catch (LoginException le)
            {
                Console.WriteLine("LoginException: " + le.Message);
                isLoggedIn = mgr.IsLoggedIn;
                Console.WriteLine("Press ENTER to exit...");
                Console.ReadLine();
                return;
            }
            catch (EntityServerException ese)
            {
                Console.WriteLine("EntityServerException Login failed: " + ese.Message);
                isLoggedIn = mgr.IsLoggedIn;
                Console.WriteLine("Press ENTER to exit...");
                Console.ReadLine();
                return;
            }
            catch (Exception ex)
            {
                bool isLogged = mgr.IsLoggedIn;
                Console.WriteLine(ex.Message);
                return;
            }

            // etc....
         }

//Server
        public IPrincipal Login(ILoginCredential credential, EntityManager entityManager)
        {
            if (credential == null)
            {
                // if running n-tier the user's Windows credentials will be passed and available on the thread:
                var principal = System.Threading.Thread.CurrentPrincipal;
                if (principal.Identity.IsAuthenticated)
                {
                    Logger.WriteMsg(string.Format("principal is {0}", principal.Identity.Name));
                    // Note that we can't return the WindowsPrincipal/WindowsIdentity back to the client, so
                    // create a new one, here we use the DevForce UserBase class, but you can create your own too. 
                    return CreateUser(principal);
                }
                else
                {
                    // This is here for 2-tier testing, since you'll probably want to throw an error or do
                    // some custom logic in n-tier.  When not running n-tier, the thread principal has not been set 
                    // but you can obtain the Windows Identity and use that.
                    var wi = WindowsIdentity.GetCurrent();
                    Logger.WriteMsg(string.Format("wi is {0}", wi.Name));
                    WindowsPrincipal wp = new WindowsPrincipal(wi);
                    return CreateUser(wp);
                }
            }
            else
            {
                Logger.WriteMsg("Non-Windows Login");
                GenericIdentity gi = null;
                if (credential.UserName.Equals("john")) //change to somthing else to force failure
                {
                    gi = new GenericIdentity(credential.UserName, "MyAuthoType");
                }
                else
                {
                    //This is the way of getting IsAuthenticated set to false
                    gi = new GenericIdentity("", "MyAuthoType");

                    //This will throw in EntityServer
                    // throw new LoginException(LoginExceptionType.InvalidUserName, credential.Domain, credential.UserName);
                }
                GenericPrincipal gp = new GenericPrincipal(gi, null);
                Logger.WriteMsg("Non-Windows Login Completed.");
                return CreateUser(gp);
            }
            throw new NotImplementedException("Some Login Error");
        }

        private UserBase CreateUser(IPrincipal currentUser)
        {
            // The UserBase and UserIdentity classes are custom IPrincipal/IIdentity implementations
            // within DevForce.  

            UserIdentity identity = new UserIdentity(currentUser.Identity.Name, currentUser.Identity.AuthenticationType, currentUser.Identity.IsAuthenticated);
            bool isInRole = currentUser.IsInRole("");
            var isAuth = currentUser.Identity.IsAuthenticated;

            // You can determine what roles to set, if any.
            string[] roles = new string[] { };

            if (isAuth)
            {
                Logger.WriteMsg("UserBase created.");
                return new UserBase(identity, roles);
            }
            //Will result in an EntityServerException in the Client
            Logger.WriteMsg("Null UserBase returned.");
            return null;
        }

thanks
John

Edited by jradxl - 18-Jun-2011 at 3:12pm