ServiceStack.Redis Unable to Connect: sPort: 0, when deploying at IIS in a Windows Server

Question

I'm building .Net Core application Backend that is published in a Windows server with IIS. In this scenario a user can create a session and receive messages to it. The session and the messages are stored in a Database but to make it faster I'm using Redis with the PubSub tool, which handles the messages instead of the actual corresponding REST request. To make it clear, when a session is created, a subscription to a Redis channel is created too, and messages are published to that channel, then the handler stores the message at the database.

I'm using a licensed version of ServiceStack.Redis and everything works fine in the development server from Visual Studio (Kestrel), but once I deploy it to the IIS I get this error most of the times:

Unable to Connect: sPort: 0, Error: Object reference not set to an instance of an object.
   at ServiceStack.Redis.RedisNativeClient.Connect()
   at ServiceStack.Redis.RedisNativeClient.SendReceive[T](Byte[][] cmdWithBinaryArgs, Func`1 fn, Action`1 completePipelineFn, Boolean sendWithoutRead)

It's a bit random since maybe subscription can be made to a couple of channels and then it starts to fail again for a while, or maybe it fails since the beginning. The server's firewall is disabled, Redis has been installed through the msi installer as a service too with the default configuration and redis-cli works fine. In fact I can subscribe a channel from redis-cli and send messages to that channel through the backend without any problem.

As this question's answer suggests I've tried to add a bigger timeout to the Redis Client, but still fails.

Here's the code, if it helps:

private void CreateRedisSubscription(string channelName)
    {
        _log.LogInformation("Creating subscription to channel " + channelName);
        using (RedisClient redisClient = new RedisClient(Globals.REDIS_HOST, Globals.REDIS_PORT)){

         // Too big timeout to make sure the error it's not because of a timeout.
        redisClient.ConnectTimeout = 30000;

        using (subscription = redisClient.CreateSubscription())
        {
            subscription.OnSubscribe = channel =>
            {
                Console.Write("Subscribed to channel: " + channel);
            };

            subscription.OnUnSubscribe = channel =>
            {
                Console.Write("Unsubscribed from channel: " + channel);
                ThreadsMember threadMember = subscriptionThreads.Find(t => t.ThreadName.Equals(channel));
                if(threadMember != null)
                {
                    threadMember.subscriptionThread.Abort();
                    subscriptionThreads.Remove(threadMember);
                }
            };

            subscription.OnMessage += (channel, message) => ProcessMessage(channel, message);

            Thread thread = new Thread(() =>
            {
                try{
                        subscription.SubscribeToChannels(channelName);
                        _log.LogInformation("Subscribed to channel " + channelName);
                    }catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                        _log.LogWarning("Can not subscribe to channel " + channelName);
                        _log.LogError(e.Message);
                        _log.LogTrace(e.StackTrace);
                        if(e.InnerException != null)
                        _log.LogError(e.InnerException.Message);                                    
                    }            
                });
                thread.IsBackground = true;
                //Add the thread to a list for future management (unsubscribe from that channel)
                subscriptionThreads.Add(new ThreadsMember(channelName, thread));
                thread.Start();
            }
        }

    }

Thanks in advance.

Answer 1

Using Thread.Abort() should be avoided as it can leave aborted instances in an inconsistent state.

I recommend using ServiceStack.Redis managed subscription instead which takes care of managing the subscription and lets you implement callbacks to handle different subscription events:

var clientsManager = new PooledRedisClientManager();
var redisPubSub = new RedisPubSubServer(clientsManager, "channel-1", "channel-2") {
        OnMessage = (channel, msg) => "Received '{0}' from '{1}'".Print(msg, channel)
    }.Start();