private void PubSubMessageReceived(RedisPubSubMessage message)
 {
     if (!message.IsEmpty)
     {
         try
         {
             InvokeOnSentinelMessage(message);
         }
         catch (Exception)
         { }
     }
 }
        private void InvokeOnSentinelMessage(RedisPubSubMessage message)
        {
            var messageType = ToSentinelMessageType(message.Channel);

            if (messageType == RedisSentinelMessageType.Undefined)
            {
                return;
            }

            var data = message.Data;

            if (data != null)
            {
                var msgText = data.ToUTF8String();

                if (!msgText.IsEmpty())
                {
                    var parts = msgText.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

                    if (parts != null)
                    {
                        var partsLength = parts.Length;
                        if (partsLength > 0)
                        {
                            /*
                             +switch-master mymaster 127.0.0.1 6379 127.0.0.1 6380
                             */
                            if (messageType == RedisSentinelMessageType.MasterChanged)
                            {
                                if (partsLength > 2)
                                {
                                    var onSentinelMessage = m_OnSentinelMessage;
                                    if (onSentinelMessage != null)
                                    {
                                        var masterName = parts[0];
                                        if (masterName == MasterName)
                                        {
                                            var oldEndPoint = ToEndPoint(parts[1], parts[2]);
                                            var newEndPoint = (partsLength > 4) ? ToEndPoint(parts[3], parts[4]) : RedisEndPoint.Empty;

                                            onSentinelMessage(new RedisSentinelMessage(messageType, masterName,
                                                                                       new RedisNodeInfo(newEndPoint, RedisRole.Master),
                                                                                       new RedisNodeInfo(oldEndPoint, RedisRole.Master)));
                                        }
                                    }
                                }
                                return;
                            }

                            /* Samples:
                             +sdown master mymaster 127.0.0.1 6380
                             +sdown slave 127.0.0.1:6380 127.0.0.1 6380 @ mymaster 127.0.0.1 6379
                             * -sdown slave 127.0.0.1:6380 127.0.0.1 6380 @ mymaster 127.0.0.1 6379
                             *
                             +odown master mymaster 127.0.0.1 6379 #quorum 2/2
                             * -odown master mymaster 127.0.0.1 6379
                             *
                             +sdown sentinel 127.0.0.1:26381 127.0.0.1 26381 @ mymaster 127.0.0.1 6379
                             * -dup-sentinel master mymaster 127.0.0.1 6381 #duplicate of 127.0.0.1:26381 or cab1c287ec59309126ad1a63b354ba132bb4e55b
                             +sentinel sentinel 127.0.0.1:26381 127.0.0.1 26379 @ mymaster 127.0.0.1 6379
                             */
                            if (partsLength > 3)
                            {
                                var onSentinelMessage = m_OnSentinelMessage;
                                if (onSentinelMessage != null)
                                {
                                    var instanceType = (parts[0] ?? String.Empty).ToLowerInvariant();

                                    var role = instanceType.ToRedisRole();
                                    switch (role)
                                    {
                                    case RedisRole.Master:
                                    {
                                        var masterName = parts[1];
                                        if (masterName == MasterName)
                                        {
                                            var masterEndPoint = ToEndPoint(parts[2], parts[3]);

                                            onSentinelMessage(new RedisSentinelMessage(messageType, masterName,
                                                                                       new RedisNodeInfo(masterEndPoint, RedisRole.Master),
                                                                                       new RedisNodeInfo(RedisEndPoint.Empty, RedisRole.Undefined)));
                                        }
                                        break;
                                    }

                                    case RedisRole.Slave:
                                    case RedisRole.Sentinel:
                                    {
                                        if (partsLength > 4)
                                        {
                                            var masterName = parts[5];
                                            if (masterName == MasterName)
                                            {
                                                var instanceName = parts[1];

                                                var instanceEndPoint = ToEndPoint(parts[2], parts[3]);
                                                var masterEndPoint   = (partsLength > 7) ? ToEndPoint(parts[6], parts[7]) : RedisEndPoint.Empty;

                                                if (instanceEndPoint.IsEmpty() && !instanceName.IsEmpty())
                                                {
                                                    var nameParts = instanceName.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
                                                    if (!nameParts.IsEmpty())
                                                    {
                                                        instanceEndPoint = ToEndPoint(nameParts[0], nameParts[1]);
                                                    }
                                                }

                                                onSentinelMessage(new RedisSentinelMessage(messageType, masterName,
                                                                                           new RedisNodeInfo(instanceEndPoint, role, instanceName),
                                                                                           new RedisNodeInfo(masterEndPoint, !masterEndPoint.IsEmpty() ? RedisRole.Master : RedisRole.Undefined)));
                                            }
                                        }
                                        break;
                                    }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }