SignInManager.PasswordSignInAsync Throws OperationCanceledException. Timing out?

[vector-man]

Hello,

I'm integrating Cognito into Piranha CMS (Source: https://github.com/PiranhaCMS/piranha.core), and I get an OperationCanceledException, while using this:

public async Task<bool> SignIn(object context, string username, string password)
        {
            if (_seed != null)
            {
                await _seed.CreateAsync();
            }

            SignInResult result = null;

            result = await _signInManager.PasswordSignInAsync(username, password, true, false)
                .ConfigureAwait(false); // OperationCanceledException. I'm guessing that indicates a timeout, but not positive.

            return result?.Succeeded == true;
        }

I'm not positive if it is related to the CMS, but I see nothing in their source or anything else that would cause that exception, so I posted this on your end to see what you think. The sign in line throws,

Full Code of ISecurity:

        public class CognitoIdentitySecurity : ISecurity
    {
        /// <summary>
        /// The optional identity seed.
        /// </summary>
        private readonly IIdentitySeed _seed;

        /// <summary>
        /// The sign in manager.
        /// </summary>
        private readonly SignInManager<CognitoUser> _signInManager;

        /// <summary>
        ///     Default constructor.
        /// </summary>
        public CognitoIdentitySecurity(SignInManager<CognitoUser> signInManager, IIdentitySeed seed = null)
        {
            _signInManager = signInManager;
            _seed = seed;
        }

        /// <summary>
        /// Authenticates and signs in the user with the
        /// given credentials.
        /// </summary>
        /// <param name="context">The current application context</param>
        /// <param name="username">The username</param>
        /// <param name="password">The password</param>
        /// <returns>If the user was signed in</returns>
        public async Task<bool> SignIn(object context, string username, string password)
        {
            if (_seed != null)
            {
                await _seed.CreateAsync();
            }

            SignInResult result = null;

            result = await _signInManager.PasswordSignInAsync(username, password, true, false)
                .ConfigureAwait(false);

            return result?.Succeeded == true;
        }

        /// <summary>
        /// Signs out the current user.
        /// </summary>
        /// <param name="context">The current application context</param>
        public Task SignOut(object context)
        {
            return _signInManager.SignOutAsync();
        }
    }
}

Startup.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.AspNetCore.Identity.Cognito;
using Amazon.CognitoIdentityProvider;
using Amazon.Extensions.CognitoAuthentication;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Piranha;
using Piranha.AspNetCore.Identity;
using Piranha.AspNetCore.Identity.Data;
using Piranha.AspNetCore.Identity.SQLite;
using Piranha.ImageSharp;
using Piranha.Local;
using Piranha.Manager;
using SmoothOdds.Services;

namespace SmoothOdds
{
    public class Startup
    {
        // This method gets called by the runtime. Use this method to add services to the container.
        // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public IServiceProvider ConfigureServices(IServiceCollection services)
        {
            services.AddMvc(config =>
            {
                config.ModelBinderProviders.Insert(0, new Piranha.Manager.Binders.AbstractModelBinderProvider());
            });
            services.AddCognitoIdentity();
            //services.AddTransient<CognitoSignInManager<CognitoUser>>();
            services.AddTransient<ISecurity, CognitoIdentitySecurity>();
            //services.AddTransient<UserManager<CognitoUser>>();

            services.AddPiranhaApplication();
            services.AddPiranhaFileStorage();
            services.AddPiranhaImageSharp();
            services.AddPiranhaEF(options => options.UseSqlite("Filename=./piranha.db"));
            services.AddPiranhaManager();
            services.AddPiranhaMemCache();

            // Setup authorization policies
            services.AddAuthorization(o =>
            {
                // Role policies
                o.AddPolicy(Permissions.Roles, policy =>
                    {
                        policy.RequireClaim(Permission.Admin, Permission.Admin);
                        policy.RequireClaim(Permissions.Roles, Permissions.Roles);
                    });
                o.AddPolicy(Permissions.RolesAdd, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Roles, Permissions.Roles);
                    policy.RequireClaim(Permissions.RolesAdd, Permissions.RolesAdd);
                });
                o.AddPolicy(Permissions.RolesDelete, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Roles, Permissions.Roles);
                    policy.RequireClaim(Permissions.RolesDelete, Permissions.RolesDelete);
                });
                o.AddPolicy(Permissions.RolesEdit, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Roles, Permissions.Roles);
                    policy.RequireClaim(Permissions.RolesEdit, Permissions.RolesEdit);
                });
                o.AddPolicy(Permissions.RolesSave, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Roles, Permissions.Roles);
                    policy.RequireClaim(Permissions.RolesSave, Permissions.RolesSave);
                });

                // User policies
                o.AddPolicy(Permissions.Users, policy =>
                    {
                        policy.RequireClaim(Permission.Admin, Permission.Admin);
                        policy.RequireClaim(Permissions.Users, Permissions.Users);
                    });
                o.AddPolicy(Permissions.UsersAdd, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Users, Permissions.Users);
                    policy.RequireClaim(Permissions.UsersAdd, Permissions.UsersAdd);
                });
                o.AddPolicy(Permissions.UsersDelete, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Users, Permissions.Users);
                    policy.RequireClaim(Permissions.UsersDelete, Permissions.UsersDelete);
                });
                o.AddPolicy(Permissions.UsersEdit, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Users, Permissions.Users);
                    policy.RequireClaim(Permissions.UsersEdit, Permissions.UsersEdit);
                });
                o.AddPolicy(Permissions.UsersSave, policy =>
                {
                    policy.RequireClaim(Permission.Admin, Permission.Admin);
                    policy.RequireClaim(Permissions.Users, Permissions.Users);
                    policy.RequireClaim(Permissions.UsersSave, Permissions.UsersSave);
                });
            });

            return services.BuildServiceProvider();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider services, IApi api)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            // Initialize Piranha
            App.Init();

            // Configure cache level
            App.CacheLevel = Piranha.Cache.CacheLevel.Basic;

            // Build content types
            var pageTypeBuilder = new Piranha.AttributeBuilder.PageTypeBuilder(api)
                .AddType(typeof(Models.BlogArchive))
                .AddType(typeof(Models.StandardPage))
                .AddType(typeof(Models.StartPage));
            pageTypeBuilder.Build()
                .DeleteOrphans();
            var postTypeBuilder = new Piranha.AttributeBuilder.PostTypeBuilder(api)
                .AddType(typeof(Models.BlogPost));
            postTypeBuilder.Build()
                .DeleteOrphans();

            // Register middleware
            app.UseStaticFiles();
            app.UseAuthentication();
            app.UsePiranha();
            app.UsePiranhaManager();
            app.UseHttpsRedirection();
            app.UseMvc(routes =>
            {
                routes.MapRoute(name: "areaRoute",
                    template: "{area:exists}/{controller}/{action}/{id?}",
                    defaults: new { controller = "Home", action = "Index" });

                routes.MapRoute(
                    name: "default",
                    template: "{controller=home}/{action=index}/{id?}");
            });
        }
    }
}

[vector-man]

So, apparently, this may be a config issue in the debugger. I'll try this solution and see if it helps: https://stackoverflow.com/questions/37474309/timeouts-with-long-running-asp-net-mvc-core-controller-httppost-method

[assyadh]

Hi,

It does sound like an SDK thrown error thrown when the cancellation token is set to canceled.

Closing as this is not directly related to the Cognito provider.

Please reopen if your findings require so.