AI导航网
微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦！

特来电混沌工程实践-混沌事件注入

分类：C#作者：编程之家

上篇博文特来电混沌工程实践中，我们详细介绍了特来电混沌工程实践的设计和规划。目前我们已经启动了应用层的混沌实验。

在应用层的混沌实验中，我们经常需要模拟HSF服务容器的线程被打爆、cpu使用率25%，50%，75%、端口被打爆、内存泄露、服务超时、服务异常等场景。

前期我们实现的时候，一般会选择一个典型的HSF服务去模拟注入上述混沌事件场景。但是每次注入，准备时间长、耗时长、控制复杂，遇到这些问题。

后来和阿里的中亭老师交流，收获到了启发，我们应该写一个混沌事件注入工具。然后根据混沌实验场景，灵活的注入混沌事件。

因此，我们启动了混沌实验注入工具的研发。先说一下具体的思路吧：

  1. 统一混沌事件的注入接口，实现各类混沌事件注入
  2. 设计一个统一的混沌事件注入器，支持各类混沌事件注入，支持混沌事件的热更新和取消
  3. 在HSF、API网关、中间件SDK层面依赖注入混沌事件注入器

一、统一混沌事件的注入接口，实现各类混沌事件注入

  1. 先定义混沌事件注入接口IChaosEvent，包含两个方法Inject注入和Stop停止

1 interface IChaosEvent
2 {
3     void Inject(Dictionary<string,string> context);
4 
5     void Stop();
6 }

  同时增加一个混沌事件枚举ChaosEventType

public enum ChaosEventType
    {
        cpu25,cpu50,cpu75,ServiceTimeout,ServiceException,Memory,Threads,Ports
    }

2. 实现各类混沌事件注入

   Highcpu-25%cpu使用率

 class Chaos_Highcpu25 : IChaosEvent
  {
        CancellationTokenSource cts;

        public Chaos_Highcpu25()
        {
            cts = new CancellationTokenSource();
        }

         context)
        {
            try
            {
                var count = (25 / 100.0) * Environment.ProcessorCount;
                for (int i = 0; i < count; i++)
                {
                    var cpuTask = new Task(() =>
                    {
                        while (true && cts.IsCancellationRequested == false)
                        {

                        }
                    },cts.Token,TaskCreationoptions.LongRunning);

                    cpuTask.Start();
                }
            }
            catch { }
        }

         Stop()
        {
            cts.Cancel();
        }
}

  Highcpu-50%cpu使用率

  Chaos_Highcpu50 : IChaosEvent
    {
        CancellationTokenSource cts;

         Chaos_Highcpu50()
        {
            cts = 50 /  Stop()
        {
            cts.Cancel();
        }
    }
View Code

  Highcpu-75%cpu使用率

 Chaos_Highcpu75 : IChaosEvent
    {
        CancellationTokenSource cts;

         Chaos_Highcpu75()
        {
            cts = 75 /  Stop()
        {
            cts.Cancel();
        }
    }
View Code

  内存泄露-2G

   Chaos_Memory : IChaosEvent
    {
        CancellationTokenSource cts;

        static string OneKB = "111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
        static List<string> list = new List<();

         Chaos_Memory()
        {
            cts = var count = System.Configuration.ConfigurationManager.AppSettings[Chaos.MemoryMB];
                if (count == null) count = 2000;
                int c;
                if (int.TryParse(count,1)">out c))
                {
                    Task task =  Task(
                            () =>
                            {
                                int k = 0; k < c / 2; k++)
                                {
                                    StringBuilder builder =  StringBuilder();
                                    0; i < 1024; i++)
                                    {
                                        builder.Append(OneKB);
                                    }
                                    list.Add(builder.ToString());
                                }
                            },TaskCreationoptions.LongRunning);
                    task.Start();
                }
            }
             Stop()
        {
            cts.Cancel();
            list.Clear();
            list = ();
        }
    }
View Code

  端口被打爆：

  Chaos_Ports : IChaosEvent
    {
        CancellationTokenSource cts;

        static List<Socket> sockets;

         Chaos_Ports()
        {
            cts =  CancellationTokenSource();
            sockets = new List<Socket>();
        }

        var count = Convert.ToInt32(context[Count]);
                var server = Convert.ToString(context[Servervar sp = server.Split(':');
                var task = Task.Factory.StartNew(() =>
                {
                    )
                    {
                        
                        {
                            Socket socket =  Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
                            socket.SetSocketoption(SocketoptionLevel.socket,SocketoptionName.KeepAlive,true);
                            socket.Connect(sp[0],Convert.ToInt32(sp[1]));
                            SetKeepAliveValues(socket,1)">true,36000000,1)">1000);

                            sockets.Add(socket);
                        }
                         (Exception e) { }
                    }
                    while (cts.IsCancellationRequested == )
                    {
                        Thread.Sleep(20 * 60000);
                    }
                },TaskCreationoptions.LongRunning);
            }
             Stop()
        {
            cts.Cancel();
            if (sockets != null)
            {
                foreach (var socket in sockets)
                {
                    
                    {
                        socket.Close();
                    }
                     { }
                }

                sockets.Clear();
                sockets = ;
            }
        }

         SetKeepAliveValues
          (
               System.Net.sockets.socket Socket,1)">bool On_Off,1)">uint KeepaLiveTime,1)"> KeepaLiveInterval
           )
        {
            int Result = -;

            unsafe
            {
                TcpKeepAlive KeepAliveValues =  TcpKeepAlive();

                KeepAliveValues.On_Off = Convert.ToUInt32(On_Off);
                KeepAliveValues.KeepaLiveTime = KeepaLiveTime;
                KeepAliveValues.KeepaLiveInterval = KeepaLiveInterval;

                byte[] InValue = new byte[12];

                int I = 0; I < 12; I++)
                    InValue[I] = KeepAliveValues.Bytes[I];

                Result = Socket.IOControl(IOControlCode.KeepAliveValues,InValue,1)">);
            }

            return Result;
        }
    }
    [
           System.Runtime.InteropServices.StructLayout
           (
               System.Runtime.InteropServices.LayoutKind.Explicit
           )
    ]
    unsafe struct TcpKeepAlive
    {
        [System.Runtime.InteropServices.FieldOffset(0)]
        [
              System.Runtime.InteropServices.MarshalAs
               (
                   System.Runtime.InteropServices.UnmanagedType.ByValArray,SizeConst = 
               )
        ]
        fixed byte Bytes[];

        [System.Runtime.InteropServices.FieldOffset()]
         On_Off;

        [System.Runtime.InteropServices.FieldOffset(4 KeepaLiveTime;

        [System.Runtime.InteropServices.FieldOffset(8 KeepaLiveInterval;
    }
View Code

  线程被打爆：

 Chaos_Threads : IChaosEvent
    {
        CancellationTokenSource cts;
        List<Task> tasks = new List<Task> Chaos_Threads()
        {
            cts = var count = context[Threadsif (Int32.TryParse(count,1)"> c))
                {
                    //Parallel.For(0,c,new ParallelOptions() { MaxDegreeOfParallelism = Environment.ProcessorCount },(i) =>
                    0; i < c; i++var task = 
                        {
                            int j = 0; j < 120; j++)
                            {
                                if (cts.IsCancellationRequested)
                                    ;

                                Thread.Sleep(10 * );

                            }

                        },cts.Token);

                        task.Start();
                        tasks.Add(task);
                    }
                }
            }
            if (tasks != var task  tasks)
                {
                    
                    {
                        task.dispose();
                    }
                     { }
                }
            }
        }
    }
View Code

  服务调用异常：

   Chaos_ServiceException : IChaosEvent
    {
        bool isstop = ;

         Chaos_ServiceException()
        {

        }

        if (isstop == )
                throw new Exception(Chaos_ServiceException);
        }

         Stop()
        {
            isstop = ;
        }
    }
View Code

  服务调用超时：

  Chaos_ServiceTimeout : IChaosEvent
    {
        CancellationTokenSource cts;

         Chaos_ServiceTimeout()
        {
            cts = )
                Task.Delay(,cts.Token).Wait();
        }

         Stop()
        {
            cts.Cancel();
            isstop = ;
        }
    }
View Code

二、设计一个统一的混沌事件注入器，支持各类混沌事件注入，支持混沌事件的热更新和取消

  1. ChaosEventInjecter

     支持混沌事件接口实现的创建、混沌事件注入（全局注入一次，每次调用都注入）、混沌事件取消（停止）

     混沌事件接口实现的创建

private IChaosEvent GetorCreateChaosEvent(ChaosEventType chaosEventType)
        {
            if (!eventDic.ContainsKey(chaosEventType))
            {
                lock (syncObj)
                {
                    eventDic.ContainsKey(chaosEventType))
                    {
                        IChaosEvent chaosEvent = ;
                        switch (chaosEventType)
                        {
                            case ChaosEventType.cpu75:
                                chaosEvent =  Chaos_Highcpu75();
                                break;
                             ChaosEventType.cpu50:
                                chaosEvent =  Chaos_Highcpu50();
                                 ChaosEventType.cpu25:
                                chaosEvent =  Chaos_Highcpu25();
                                 ChaosEventType.Memory:
                                chaosEvent =  Chaos_Memory();
                                 ChaosEventType.Threads:
                                chaosEvent =  Chaos_Threads();
                                 ChaosEventType.ServiceException:
                                chaosEvent =  Chaos_ServiceException();
                                 ChaosEventType.ServiceTimeout:
                                chaosEvent =  Chaos_ServiceTimeout();
                                 ChaosEventType.Ports:
                                chaosEvent =  Chaos_Ports();
                                default:
                                ;
                        }

                        if (chaosEvent != )
                        {
                            eventDic.TryAdd(chaosEventType,chaosEvent);

                             chaosEvent;
                        }
                    }
                }
            }

             eventDic[chaosEventType];
        }
View Code

    混沌事件注入（全局注入一次，每次调用都注入）

 1 private object syncObj = object();
 2 object eventObj =  3 
 4 static ChaosEventInjecter instance;
 5 private ConcurrentDictionary<ChaosEventType,IChaosEvent> eventDic;
 6 
 7  triggeredEvent;
 8 
 9  ChaosEventInjecter()
10 11             eventDic = new ConcurrentDictionary<ChaosEventType,1)">12             triggeredEvent = 13 }
 void SingletonInject(ChaosEventType chaosEventType,Dictionary<string> context = )
        {
            triggeredEvent.ContainsKey(chaosEventType))
            {
                 (eventObj)
                {
                    triggeredEvent.ContainsKey(chaosEventType))
                    {
                        var chaosEvent = GetorCreateChaosEvent(chaosEventType);
                        if (chaosEvent == null) ;

                        chaosEvent.Inject(context);
                        triggeredEvent.TryAdd(chaosEventType,chaosEventType);
                    }
                }
            }
        }

  按服务每次调用都注入

void ServiceInject(List< serviceId)
        {
            ChaosEventManager.GetIntance().StopInject = StopInject;
             (ChaosEventManager.GetIntance().IsEmpty())
            {
                StopInject();
            }

            var service  serviceId)
            {
                 ChaosEventManager.GetIntance().GetChaosEvent(service);
                 (chaosEvent.ChaosEventType)
                    {
                         ChaosEventType.ServiceException:
                         ChaosEventType.ServiceTimeout:
                            Inject(chaosEvent.ChaosEventType,chaosEvent.ChaosValue);
                            :
                            SingletonInject(chaosEvent.ChaosEventType,1)">;
                    }
                }
            }
        }

  停止混沌注入

  StopInject()
        {
            if (triggeredEvent == null && triggeredEvent.Count == 0) var chaosEventType  triggeredEvent)
            {
                 GetorCreateChaosEvent(chaosEventType.Key);
                ;

                chaosEvent.Stop();
            }

            triggeredEvent = ();
        }

  完整的ChaosEventInjecter代码：

 /// <summary>
    /// 混沌事件注入器
    </summary>
     ChaosEventInjecter
    {
         ChaosEventInjecter instance;

         eventDic;

         triggeredEvent;

         ChaosEventInjecter()
        {
            eventDic = ();
            triggeredEvent =  ChaosEventInjecter GetIntance()
        {
            if (instance == )
                    {
                        instance =  ChaosEventInjecter();
                    }
                }
            }

             instance;
        }

         SingletonInject()
        {
            var eventType = System.Configuration.ConfigurationManager.AppSettings[Chaos.Event];
            if (eventType != )
            {
                ChaosEventType chaosEvent = (ChaosEventType)Enum.Parse(typeof(ChaosEventType),eventType.ToString());

                SingletonInject(chaosEvent);
            }
        }

        ;
                    }
                }
            }
        }

        void Inject(ChaosEventType chaosEventType,1)"> GetorCreateChaosEvent(chaosEventType);
            ;

            chaosEvent.Inject(context);
        }

         eventDic[chaosEventType];
        }
    }
View Code

  2. ChaosEventManager

    混沌事件管理类，负责从Redis中实时获取每个服务配置的混沌事件，支持混沌事件的定时更新10s：

  ChaosEventManager
    {
         ChaosEventManager instance;

        private ConcurrentDictionary< eventDic;

        CacheService service = CacheService.GetInstance(DefaultPool);

        public Action StopInject { get; set; }

         ChaosEventManager()
        {
            eventDic = new ConcurrentDictionary<();
            GetAllChaosEvents();

            StartUpdateTask();
        }

         StartUpdateTask()
        {
            )
                {
                    Thread.Sleep(10000);
                    GetAllChaosEvents();
                }
            },TaskCreationoptions.LongRunning);

            task.ContinueWith((t) => (t.IsFaulted)
                    StartUpdateTask();
            });

            task.Start();
        }

         ChaosEventManager GetIntance()
        {
             ChaosEventManager();
                    }
                }
            }

            public ChaosEvent GetChaosEvent(string serviceId)
        {
             (eventDic.ContainsKey(serviceId))
                 eventDic[serviceId];

            else return ;
        }

         IsEmpty()
        {
            return eventDic == null || eventDic.Count ==  GetAllChaosEvents()
        {
            var newEventDic = ();
            using (var client = service.GetClient())
            {

                List<string> keys = client.GetHashKeys(ChaosEventsif (keys != )
                    keys.ForEach(x => newEventDic.TryAdd(x,client.GetValueFromHash<ChaosEvent>(var item  newEventDic)
            {
                eventDic[item.Key] = item.Value;
            }

            if (newEventDic.Count == if (StopInject != )
                    StopInject();
        }
    }
View Code

三、在HSF、API网关、中间件SDK层面依赖注入混沌事件注入器

  在HSF服务调用时增加混沌实验事件AOP注入

 

  API网关、中间件SDK类似的方法进行注入。

 同时我们设计了一个混沌事件注入工具：支持混沌事件实时注入、取消、仿真模拟执行：

 

  分享：仿真模拟执行的效果，例如cpu25%使用率：

  

 以上工具和设计思路，分享给大家。

 

周国庆

2019/3/30

 

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。

相关推荐

Blazor 调用 Clipboard API 读写剪贴板数据
目录简介使用JS互操作使用ClipLazor库创建项目使用方法简单测试参考链接 简介 Clipboard API 是一种允许网页读取剪贴板数据或向其中写入数据的API，主要有两个方法： navigator.clipboard.writeText() ：用于将文本写...
C# 轻量级 ORM 框架 NPoco 的简单应用
目录简介快速入门安装 NuGet 包实体类User数据库类DbFactory增删改查InsertSelectUpdateDelete总结 简介 NPoco 是 PetaPoco 的一个分支，具有一些额外的功能，截至现在 github 星数 839。NPoco 中文资料没多少，我是...
C#简单配置类及数据绑定
本文实现一个简单的配置类，原理比较简单，适用于一些小型项目。主要实现以下功能：保存配置到json文件、从文件或实例加载配置类的属性值、数据绑定到界面控件。&#xA;一般情况下，项目都会提供配置的设置界面，很...
C#获取Description特性的扩展类
C#中Description特性主要用于枚举和属性，方法比较简单，记录一下以便后期使用。 扩展类DescriptionExtension代码如下： using System; using System.ComponentModel; using System.Reflection; /// &lt;
C#实现软件开机自启动（不需要管理员权限）
[TOC] # 原理简介 本文参考[C#/WPF/WinForm/程序实现软件开机自动启动的两种常用方法](https://blog.csdn.net/weixin_42288432/article/details/120059296)，将里面中的第一种方法做了封装成**AutoStart**类，使
C#爬取动态网页上的信息：B站主页
目录简介获取 HTML 文档解析 HTML 文档测试补充：使用 CSS 选择器参考文章 简介 动态内容网站使用 JavaScript 脚本动态检索和渲染数据，爬取信息时需要模拟浏览器行为，否则获取到的源码基本是空的。 本文使用的爬取...
C#项目管理引用的dll文件
这篇文章主要简单记录一下C#项目的dll文件管理方法，以便后期使用。 设置dll路径 参考C#开发奇技淫巧三：把dll放在不同的目录让你的程序更整洁中间的 方法一：配置App.config文件的privatePath ： &lt;runtime&a...
C# 常用特性(Attribute)
使用特性，可以有效地将元数据或声明性信息与代码（程序集、类型、方法、属性等）相关联。 将特性与程序实体相关联后，可以在运行时使用反射这项技术查询特性。&#xA;在 C# 中，通过用方括号 ([]) 将特性名称括起...
C#事件总线
事件总线是对发布-订阅模式的一种实现，是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。&#xA;EventBus维护一个事件的字典，发布者、订阅者在事件总线中获取...
C#中使用jieba.NET、WordCloudSharp制作词云图
词云”由美国西北大学新闻学副教授、新媒体专业主任里奇·戈登（Rich Gordon）于2006年最先使用，是通过形成“关键词云层”或“关键词渲染”，对文本中出现频率较高的“关键词”的视觉上的突出。词云图过滤掉大量的文...
    pythonJavaScriptjavaHTMLreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-bootreact-native