Xiao_Yang
Xiao_Yang

OpenFalcon源码分析(Agent组件)

一 基本说明

Agent VERSION "5.1.2"

  • Agent源代码文件目录说明
文件目录说明

  • 调用关系


    调用关系

  • 组件交互关系


    组件交互关系

二 源码分析

Main 入口函数

    # 命令行参数解析
    cfg := flag.String("c", "cfg.json", "configuration file")
    version := flag.Bool("v", false, "show version")
    check := flag.Bool("check", false, "check collector")

    flag.Parse()
    
    # 命令行版本查看
    if *version {
        fmt.Println(g.VERSION)
        os.Exit(0)
    }
    
    # 命令行收集器检测
    if *check {
        funcs.CheckCollector()      #【参考相关详细分析】
        os.Exit(0)
    }

    # Agent配置文件解析，g.Config()可获取完整配置
    g.ParseConfig(*cfg)   #【参考相关详细分析】

    if g.Config().Debug {
        g.InitLog("debug")
    } else {
        g.InitLog("info")
    }
    
    # 全局初始化工作（工作目录/本地IP/RPC_Client）
    g.InitRootDir()             #【参考相关详细分析】
    g.InitLocalIp()             #【参考相关详细分析】
    g.InitRpcClients()          #【参考相关详细分析】

    # 采集功能与模块构造映射Map
    funcs.BuildMappers()        #【参考相关详细分析】
    
    # 
    go cron.InitDataHistory()     #【参考相关详细分析】
    
    # 上报Agent自身状态
    cron.ReportAgentStatus()      #【参考相关详细分析】
    # 同步模块
    cron.SyncMinePlugins()        #【参考相关详细分析】
    cron.SyncBuiltinMetrics()     #【参考相关详细分析】
    cron.SyncTrustableIps()       #【参考相关详细分析】
    # 采集数据
    cron.Collect()                #【参考相关详细分析】

    # API服务器运行
    go http.Start()               #【参考相关详细分析】

    # 阻塞主进程
    select {}

funcs.CheckCollector() 各采集模块功能状态检测

func CheckCollector() {

    output := make(map[string]bool)

   #  引用外部"github.com/toolkits/nux"功能获取
   #  CurrentProcStat()
   #  ListDiskStats()
   #  ListeningPorts()
   #  AllProcs()
   
    _, procStatErr := nux.CurrentProcStat()
    _, listDiskErr := nux.ListDiskStats()
    ports, listeningPortsErr := nux.ListeningPorts()
    procs, psErr := nux.AllProcs()

    # 引用外部"github.com/toolkits/sys"功能执行模块Du系统命令    
    _, duErr := sys.CmdOut("du", "--help")
    
    # 各采集功能模块采集调用与结果判断（各模块采集代码实现可进一步分析）
    output["kernel  "] = len(KernelMetrics()) > 0
    output["df.bytes"] = DeviceMetricsCheck()
    output["net.if  "] = len(CoreNetMetrics([]string{})) > 0
    output["loadavg "] = len(LoadAvgMetrics()) > 0
    output["cpustat "] = procStatErr == nil
    output["disk.io "] = listDiskErr == nil
    output["memory  "] = len(MemMetrics()) > 0
    output["netstat "] = len(NetstatMetrics()) > 0
    output["ss -s   "] = len(SocketStatSummaryMetrics()) > 0
    output["ss -tln "] = listeningPortsErr == nil && len(ports) > 0
    output["ps aux  "] = psErr == nil && len(procs) > 0
    output["du -bs  "] = duErr == nil
   
    # 将MAP output的各值进行结果输出，True为OK,False为fail打印显示
    for k, v := range output {
        status := "fail"
        if v {
            status = "ok"
        }
        fmt.Println(k, "...", status)
    }
}

g.ParseConfig(*cfg) Agent配置文件解析

#通过命令指定配置文件，默认为同级目录下cfg.json
cfg := flag.String("c", "cfg.json", "configuration file")

# ParseConfig()解析cfg配置文件并保存在私有变量config内，可通过
# Config()公开方法来获取GlobalConfig结构
# Config().XXX 常用来获取单个配置项

func ParseConfig(cfg string) {
    if cfg == "" {
        log.Fatalln("use -c to specify configuration file")
    }

    if !file.IsExist(cfg) {
        log.Fatalln("config file:", cfg, "is not existent. maybe you need `mv cfg.example.json cfg.json`")
    }

    ConfigFile = cfg

    configContent, err := file.ToTrimString(cfg)
    if err != nil {
        log.Fatalln("read config file:", cfg, "fail:", err)
    }

    var c GlobalConfig
    err = json.Unmarshal([]byte(configContent), &c)
    if err != nil {
        log.Fatalln("parse config file:", cfg, "fail:", err)
    }

    lock.Lock()
    defer lock.Unlock()

    config = &c

    log.Println("read config file:", cfg, "successfully")
}

#公开方法返回config
func Config() *GlobalConfig {
    lock.RLock()
    defer lock.RUnlock()
    return config
}

#GlobalConfig结构化配置定义
type GlobalConfig struct {
    Debug         bool              `json:"debug"`
    Hostname      string            `json:"hostname"`
    IP            string            `json:"ip"`
    Plugin        *PluginConfig     `json:"plugin"`
    Heartbeat     *HeartbeatConfig  `json:"heartbeat"`
    Transfer      *TransferConfig   `json:"transfer"`
    Http          *HttpConfig       `json:"http"`
    Collector     *CollectorConfig  `json:"collector"`
    DefaultTags   map[string]string `json:"default_tags"`
    IgnoreMetrics map[string]bool   `json:"ignore"`
}

g 全局化初始化

    g.InitRootDir()  // 工作目录
    g.InitLocalIp()  // 本地IP
    g.InitRpcClients() // 实例化RPC_Client


# 通过os.Getwd()方式获取当前工作目录
var Root string
func InitRootDir() {
    var err error
    Root, err = os.Getwd()
    if err != nil {
        log.Fatalln("getwd fail:", err)
    }
}

# 通过net.DialTimeout方式获取本地IP地址
var LocalIp string
func InitLocalIp() {
    if Config().Heartbeat.Enabled {
        conn, err := net.DialTimeout("tcp", Config().Heartbeat.Addr, time.Second*10)
        if err != nil {
            log.Println("get local addr failed !")
        } else {
            LocalIp = strings.Split(conn.LocalAddr().String(), ":")[0]
            conn.Close()
        }
    } else {
        log.Println("hearbeat is not enabled, can't get localip")
    }
}

# 构造&SingleConnRpcClient{}对象
var HbsClient *SingleConnRpcClient
func InitRpcClients() {
    if Config().Heartbeat.Enabled {
        HbsClient = &SingleConnRpcClient{
            RpcServer: Config().Heartbeat.Addr,
            Timeout:   time.Duration(Config().Heartbeat.Timeout) * time.Millisecond,
        }
    }
}


type SingleConnRpcClient struct {
    sync.Mutex
    rpcClient *rpc.Client  
    RpcServer string       #RPC服务器
    Timeout   time.Duration #超时间隔ms
}

funcs.BuildMappers() 构建采集功能映射表，表内每项代表一个采集项
【重要模块：采集映射表】

func BuildMappers() {
    interval := g.Config().Transfer.Interval
    Mappers = []FuncsAndInterval{
        {   # 基础项采集 
            Fs: []func() []*model.MetricValue{
                AgentMetrics,   // Agent状态
                CpuMetrics,     // CPU
                NetMetrics,     // NET
                KernelMetrics,  // Kernel
                LoadAvgMetrics, // CPU Load Avg
                MemMetrics,     // Memory
                DiskIOMetrics,  // Disk IO
                IOStatsMetrics, // IO stats
                NetstatMetrics, // NetStat
                ProcMetrics,    // Proc
                UdpMetrics,     // Udp
            },
            Interval: interval,
        },
        {  # 设备采集
            Fs: []func() []*model.MetricValue{
                DeviceMetrics,
            },
            Interval: interval,
        },
        {  # Socket与port采集
            Fs: []func() []*model.MetricValue{
                PortMetrics,
                SocketStatSummaryMetrics,
            },
            Interval: interval,
        },
        {   # Du磁盘采集
            Fs: []func() []*model.MetricValue{
                DuMetrics,
            },
            Interval: interval,
        },
        {    # Url采集
            Fs: []func() []*model.MetricValue{
                UrlMetrics,
            },
            Interval: interval,
        },
        {   # Gpu采集
            Fs: []func() []*model.MetricValue{
                GpuMetrics,
            },
            Interval: interval,
        },
    }
}

# 单个采集功能项
type FuncsAndInterval struct {
    Fs       []func() []*model.MetricValue  //采集功能函数列表
    Interval int   //采集间隔 
}

# 完整映射列表
var Mappers []FuncsAndInterval

cron.InitDataHistory() 周期性更新CPU/Disk状态，构建历史数据

func InitDataHistory() {
    for {
        funcs.UpdateCpuStat()  
        funcs.UpdateDiskStats()
        time.Sleep(g.COLLECT_INTERVAL)
    }
}

# funcs->cpustat更新CPU状态，最新状态保存在procStatHistory[0]
func UpdateCpuStat() error {
    ps, err := nux.CurrentProcStat()
    if err != nil {
        return err
    }

    psLock.Lock()
    defer psLock.Unlock()
    for i := historyCount - 1; i > 0; i-- {
        procStatHistory[i] = procStatHistory[i-1]
    }

    procStatHistory[0] = ps
    return nil
}

# funcs->diskstats更新Disk状态
func UpdateDiskStats() error {
    dsList, err := nux.ListDiskStats()
    if err != nil {
        return err
    }

    dsLock.Lock()
    defer dsLock.Unlock()
    for i := 0; i < len(dsList); i++ {
        device := dsList[i].Device
        diskStatsMap[device] = [2]*nux.DiskStats{dsList[i], diskStatsMap[device][0]}   //?
    }
    return nil
}

cron.ReportAgentStatus() 周期性向HBS服务器上报状态

func ReportAgentStatus() {
    if g.Config().Heartbeat.Enabled && g.Config().Heartbeat.Addr != "" {
        go reportAgentStatus(time.Duration(g.Config().Heartbeat.Interval) * time.Second)
    }
}

# 通过RPC方式上报Agent信息
func reportAgentStatus(interval time.Duration) {
    for {
        hostname, err := g.Hostname()
        if err != nil {
            hostname = fmt.Sprintf("error:%s", err.Error())
        }

        req := model.AgentReportRequest{
            Hostname:      hostname,    //主机名
            IP:            g.IP(),      //IP
            AgentVersion:  g.VERSION,   //版本
            PluginVersion: g.GetCurrPluginVersion(), //「插件版本信息」
        }

        var resp model.SimpleRpcResponse

        //RPC请求类型"Agent.ReportStatus"
        err = g.HbsClient.Call("Agent.ReportStatus", req, &resp)
        if err != nil || resp.Code != 0 {
            log.Println("call Agent.ReportStatus fail:", err, "Request:", req, "Response:", resp)
        }

        time.Sleep(interval)
    }
}


//g->tool模块获取当前插件Hash信息
func GetCurrPluginVersion() string {
    if !Config().Plugin.Enabled {
        return "plugin not enabled"
    }

    pluginDir := Config().Plugin.Dir
    if !file.IsExist(pluginDir) {
        return "plugin dir not existent"
    }
  
    //获取当前活跃分支哈希值
    cmd := exec.Command("git", "rev-parse", "HEAD")
    cmd.Dir = pluginDir   //插件路径

    var out bytes.Buffer
    cmd.Stdout = &out
    err := cmd.Run()
    if err != nil {
        return fmt.Sprintf("Error:%s", err.Error())
    }

    return strings.TrimSpace(out.String())
}

cron.SyncMinePlugins() 周期性向HBS服务器同步插件，执行插件采集数据向Transfer上报数据。 【重要功能模块：插件管理】


# 公开同步插件方法
func SyncMinePlugins() {
    if !g.Config().Plugin.Enabled {
        return
    }

    if !g.Config().Heartbeat.Enabled {
        return
    }

    if g.Config().Heartbeat.Addr == "" {
        return
    }

    go syncMinePlugins()  //后台线程，同步函数
}

## RPC向HBS同步插件
func syncMinePlugins() {

    var (
        timestamp  int64 = -1
        pluginDirs []string
    )

    //同步周期间隔时长
    duration := time.Duration(g.Config().Heartbeat.Interval) * time.Second

    for {
        time.Sleep(duration)

        hostname, err := g.Hostname()
        if err != nil {
            continue
        }

        req := model.AgentHeartbeatRequest{
            Hostname: hostname,
        }

        var resp model.AgentPluginsResponse
        //RPC调用"Agent.MinePlugins"
        err = g.HbsClient.Call("Agent.MinePlugins", req, &resp)
        if err != nil {
            log.Println("ERROR:", err)
            continue
        }

        if resp.Timestamp <= timestamp {
            continue
        }

        pluginDirs = resp.Plugins
        timestamp = resp.Timestamp

        if g.Config().Debug {
            log.Println(&resp)
        }

        if len(pluginDirs) == 0 {
            plugins.ClearAllPlugins()
        }

        desiredAll := make(map[string]*plugins.Plugin)

        for _, p := range pluginDirs {
            underOneDir := plugins.ListPlugins(strings.Trim(p, "/"))
            for k, v := range underOneDir {
                desiredAll[k] = v   //同步到的插件格式化为MAP
            }
        }

        plugins.DelNoUsePlugins(desiredAll)  //依据同步信息，「清理插件」
        plugins.AddNewPlugins(desiredAll)    //依据同步信息，「更新插件」

    }
}


### plugins->plugins清理Agent插件（HBS服务器已不存在的插件）
func DelNoUsePlugins(newPlugins map[string]*Plugin) {
    for currKey, currPlugin := range Plugins {
        newPlugin, ok := newPlugins[currKey]
        if !ok || currPlugin.MTime != newPlugin.MTime {
            deletePlugin(currKey)
        }
    }
}

### plugins->plugins更新和添加插件
func AddNewPlugins(newPlugins map[string]*Plugin) {
    for fpath, newPlugin := range newPlugins {
        if _, ok := Plugins[fpath]; ok && newPlugin.MTime == Plugins[fpath].MTime {
            continue
        }

        Plugins[fpath] = newPlugin
        sch := NewPluginScheduler(newPlugin)
        PluginsWithScheduler[fpath] = sch
        sch.Schedule()  // 「 插件调度与执行（Ticker定时器）」
    }
}



### 公有插件变量
var (
    Plugins              = make(map[string]*Plugin)
    PluginsWithScheduler = make(map[string]*PluginScheduler)
)


#### plugins->scheduler插件调度
func (this *PluginScheduler) Schedule() {
    go func() {
        for {
            select {
            case <-this.Ticker.C:    
                PluginRun(this.Plugin) //
            case <-this.Quit:
                this.Ticker.Stop()
                return
            }
        }
    }()
}

##### plugins->scheduler插件执行
func PluginRun(plugin *Plugin) {
   
    timeout := plugin.Cycle*1000 - 500  //执行超时设置
    fpath := filepath.Join(g.Config().Plugin.Dir, plugin.FilePath)  //插件执行PATH

    if !file.IsExist(fpath) {
        log.Println("no such plugin:", fpath)
        return
    }

    debug := g.Config().Debug
    if debug {
        log.Println(fpath, "running...")
    }

    cmd := exec.Command(fpath)   // EXEC执行插件命令创建
    var stdout bytes.Buffer
    cmd.Stdout = &stdout
    var stderr bytes.Buffer
    cmd.Stderr = &stderr
    cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
    err := cmd.Start()    // CMD start
    if err != nil {
        log.Printf("[ERROR] plugin start fail, error: %s\n", err)
        return
    }
    if debug {
        log.Println("plugin started:", fpath)
    }

    err, isTimeout := sys.CmdRunWithTimeout(cmd, time.Duration(timeout)*time.Millisecond)  // CMD Run

    errStr := stderr.String()
    if errStr != "" {
        logFile := filepath.Join(g.Config().Plugin.LogDir, plugin.FilePath+".stderr.log")
        if _, err = file.WriteString(logFile, errStr); err != nil {
            log.Printf("[ERROR] write log to %s fail, error: %s\n", logFile, err)
        }
    }

    if isTimeout {
        // has be killed    超时处理
        if err == nil && debug {
            log.Println("[INFO] timeout and kill process", fpath, "successfully")
        }

        if err != nil {
            log.Println("[ERROR] kill process", fpath, "occur error:", err)
        }

        return
    }

    if err != nil {
        log.Println("[ERROR] exec plugin", fpath, "fail. error:", err)
        return
    }

    // exec successfully
    data := stdout.Bytes()
    if len(data) == 0 {
        if debug {
            log.Println("[DEBUG] stdout of", fpath, "is blank")
        }
        return
    }

    var metrics []*model.MetricValue
    err = json.Unmarshal(data, &metrics)  //序列化数据
    if err != nil {
        log.Printf("[ERROR] json.Unmarshal stdout of %s fail. error:%s stdout: \n%s\n", fpath, err, stdout.String())
        return
    }

    g.SendToTransfer(metrics)    //「 上报数据 」
}

g.SendToTransfer() 向transfer上报数据

#g->var向transfer服务器上报数据
func SendToTransfer(metrics []*model.MetricValue) {
    if len(metrics) == 0 {
        return
    }

    dt := Config().DefaultTags
    if len(dt) > 0 {
        var buf bytes.Buffer
        default_tags_list := []string{}
        for k, v := range dt {
            buf.Reset()
            buf.WriteString(k)
            buf.WriteString("=")
            buf.WriteString(v)
            default_tags_list = append(default_tags_list, buf.String())
        }
        default_tags := strings.Join(default_tags_list, ",")

        for i, x := range metrics {
            buf.Reset()
            if x.Tags == "" {
                metrics[i].Tags = default_tags
            } else {
                buf.WriteString(metrics[i].Tags)
                buf.WriteString(",")
                buf.WriteString(default_tags)
                metrics[i].Tags = buf.String()
            }
        }
    }

    debug := Config().Debug

    if debug {
        log.Printf("=>  %v\n", len(metrics), metrics[0])
    }

    var resp model.TransferResponse
    SendMetrics(metrics, &resp)  //「send」
    if debug {
        log.Println("<=", &resp)
    }
}


# g->transfer向transfer服务器发送采集数据
func SendMetrics(metrics []*model.MetricValue, resp *model.TransferResponse) {
    rand.Seed(time.Now().UnixNano())
    for _, i := range rand.Perm(len(Config().Transfer.Addrs)) {
         // 随机获取一台Transfer地址
        addr := Config().Transfer.Addrs[i]
         
        //「获取Transfer RPC Client」，如果获取为失败，「初始化Transfer RPC Client」
        c := getTransferClient(addr) 
        if c == nil {
            c = initTransferClient(addr) 
        }
  
        //「上报数据」
        if updateMetrics(c, metrics, resp) {
            break
        }
    }
}

## 获取可用的TransferClient对象
func getTransferClient(addr string) *SingleConnRpcClient {
    TransferClientsLock.RLock()
    defer TransferClientsLock.RUnlock()

    if c, ok := TransferClients[addr]; ok {
        return c
    }
    return nil
}

## 构建一个新的TransferClient对象
func initTransferClient(addr string) *SingleConnRpcClient {
    var c *SingleConnRpcClient = &SingleConnRpcClient{
        RpcServer: addr,
        Timeout:   time.Duration(Config().Transfer.Timeout) * time.Millisecond,
    }
    TransferClientsLock.Lock()
    defer TransferClientsLock.Unlock()
    TransferClients[addr] = c

    return c
}

## RPC向Transfer服务器上报metrics数据，RPC类型"Transfer.Update"
func updateMetrics(c *SingleConnRpcClient, metrics []*model.MetricValue, resp *model.TransferResponse) bool {
    err := c.Call("Transfer.Update", metrics, resp)
    if err != nil {
        log.Println("call Transfer.Update fail:", c, err)
        return false
    }
    return true
}

cron.SyncBuiltinMetrics() 向HBS服务器同步监控端口、du路径、进程和URL


func SyncBuiltinMetrics() {
    if g.Config().Heartbeat.Enabled && g.Config().Heartbeat.Addr != "" {
        go syncBuiltinMetrics()  //后台线程同步
    }
}

# 向HBS同步
func syncBuiltinMetrics() {

    var timestamp int64 = -1
    var checksum string = "nil"

    duration := time.Duration(g.Config().Heartbeat.Interval) * time.Second

    for {
        time.Sleep(duration)

        var ports = []int64{}
        var paths = []string{}
        var procs = make(map[string]map[int]string)
        var urls = make(map[string]string)

        hostname, err := g.Hostname()
        if err != nil {
            continue
        }

        req := model.AgentHeartbeatRequest{
            Hostname: hostname,
            Checksum: checksum,
        }

        var resp model.BuiltinMetricResponse
        
        // RPC调用类型"Agent.BuiltinMetrics"
        err = g.HbsClient.Call("Agent.BuiltinMetrics", req, &resp)
        if err != nil {
            log.Println("ERROR:", err)
            continue
        }

        if resp.Timestamp <= timestamp {
            continue
        }

        if resp.Checksum == checksum {
            continue
        }

        timestamp = resp.Timestamp
        checksum = resp.Checksum

        for _, metric := range resp.Metrics {
            
            //健康检测的URL列表
            if metric.Metric == g.URL_CHECK_HEALTH {
                arr := strings.Split(metric.Tags, ",")
                if len(arr) != 2 {
                    continue
                }
                url := strings.Split(arr[0], "=")
                if len(url) != 2 {
                    continue
                }
                stime := strings.Split(arr[1], "=")
                if len(stime) != 2 {
                    continue
                }
                if _, err := strconv.ParseInt(stime[1], 10, 64); err == nil {
                    urls[url[1]] = stime[1]
                } else {
                    log.Println("metric ParseInt timeout failed:", err)
                }
            }
           
            //监控PORT端口列表
            if metric.Metric == g.NET_PORT_LISTEN {
                arr := strings.Split(metric.Tags, "=")
                if len(arr) != 2 {
                    continue
                }

                if port, err := strconv.ParseInt(arr[1], 10, 64); err == nil {
                    ports = append(ports, port)
                } else {
                    log.Println("metrics ParseInt failed:", err)
                }

                continue
            }
             
             // du路径列表
            if metric.Metric == g.DU_BS {
                arr := strings.Split(metric.Tags, "=")
                if len(arr) != 2 {
                    continue
                }

                paths = append(paths, strings.TrimSpace(arr[1]))
                continue
            }
            
            // 进程列表
            if metric.Metric == g.PROC_NUM {
                arr := strings.Split(metric.Tags, ",")

                tmpMap := make(map[int]string)

                for i := 0; i < len(arr); i++ {
                    if strings.HasPrefix(arr[i], "name=") {
                        tmpMap[1] = strings.TrimSpace(arr[i][5:])
                    } else if strings.HasPrefix(arr[i], "cmdline=") {
                        tmpMap[2] = strings.TrimSpace(arr[i][8:])
                    }
                }

                procs[metric.Tags] = tmpMap
            }
        }

        // 设置同步数据
        g.SetReportUrls(urls)   
        g.SetReportPorts(ports) 
        g.SetReportProcs(procs) 
        g.SetDuPaths(paths)     

    }
}

cron.SyncTrustableIps() 向HBS同步执行脚本的信任IP列表

func SyncTrustableIps() {
    if g.Config().Heartbeat.Enabled && g.Config().Heartbeat.Addr != "" {
        go syncTrustableIps() //后台线程同步信任IP列表
    }
}

func syncTrustableIps() {
    duration := time.Duration(g.Config().Heartbeat.Interval) * time.Second

    for {
        time.Sleep(duration)
        
        var ips string
        // RPC调用类型"Agent.TrustableIps"
        err := g.HbsClient.Call("Agent.TrustableIps", model.NullRpcRequest{}, &ips)
        if err != nil {
            log.Println("ERROR: call Agent.TrustableIps fail", err)
            continue
        }
        
        // 设置列表
        g.SetTrustableIps(ips)
    }
}

cron.Collect() 周期性采集数据

func Collect() {

    if !g.Config().Transfer.Enabled {
        return
    }

    if len(g.Config().Transfer.Addrs) == 0 {
        return
    }

    for _, v := range funcs.Mappers {
        go collect(int64(v.Interval), v.Fs) //后台线程采集与上报
    }
}

## 采集与向transfer上报数据 【`关键执行收集与上报Codes`】
func collect(sec int64, fns []func() []*model.MetricValue) {
    t := time.NewTicker(time.Second * time.Duration(sec))
    defer t.Stop()
    for {
        <-t.C

        hostname, err := g.Hostname()
        if err != nil {
            continue
        }
         
        mvs := []*model.MetricValue{}
        ignoreMetrics := g.Config().IgnoreMetrics
        
        // 迭代所有采集项，执行采集Funcation，汇总Metrics
        for _, fn := range fns {
            items := fn()   //调用采集模块funcation
            if items == nil {
                continue
            }

            if len(items) == 0 {
                continue
            }

            for _, mv := range items {
                if b, ok := ignoreMetrics[mv.Metric]; ok && b {
                    continue
                } else {
                    mvs = append(mvs, mv) //汇总
                }
            }
        }

        now := time.Now().Unix()
     
        //标示Agent信息和时间戳
        for j := 0; j < len(mvs); j++ {
            mvs[j].Step = sec
            mvs[j].Endpoint = hostname
            mvs[j].Timestamp = now
        }

        g.SendToTransfer(mvs)  //向transfer上报所收集数据

    }
}

http.Start() API与Dashboard服务运行


func init() {
    configAdminRoutes()   //管理接口路由
    configCpuRoutes()     //CPU信息路由
    configDfRoutes()      //DF挂载点信息路由
    configHealthRoutes()  //Health路由
    configIoStatRoutes()  //IoStat路由
    configKernelRoutes()  //Kernel路由
    configMemoryRoutes()  //Memory路由
    configPageRoutes()    //Dashboard路由
    configPluginRoutes()  //插件路由
    configPushRoutes()    //Push路由
    configRunRoutes()     //脚本执行路由
    configSystemRoutes()  //System路由
}

func Start() {
    if !g.Config().Http.Enabled {
        return
    }

    addr := g.Config().Http.Listen
    if addr == "" {
        return
    }
   
   //
    s := &http.Server{
        Addr:           addr,
        MaxHeaderBytes: 1 << 30,
    }

    log.Println("listening", addr)
    log.Fatalln(s.ListenAndServe())
}

# 配置http路由（Admin管理）
func configAdminRoutes() {
    http.HandleFunc("/exit", func(w http.ResponseWriter, r *http.Request) {
        if g.IsTrustable(r.RemoteAddr) {
            w.Write([]byte("exiting..."))
            go func() {
                time.Sleep(time.Second)
                os.Exit(0)
            }()
        } else {
            w.Write([]byte("no privilege"))
        }
    })

    http.HandleFunc("/config/reload", func(w http.ResponseWriter, r *http.Request) {
        if g.IsTrustable(r.RemoteAddr) {
            g.ParseConfig(g.ConfigFile)
            RenderDataJson(w, g.Config())
        } else {
            w.Write([]byte("no privilege"))
        }
    })

    http.HandleFunc("/workdir", func(w http.ResponseWriter, r *http.Request) {
        RenderDataJson(w, file.SelfDir())
    })

    http.HandleFunc("/ips", func(w http.ResponseWriter, r *http.Request) {
        RenderDataJson(w, g.TrustableIps())
    })
}

# 配置http路由（Dashboard静态页）
func configPageRoutes() {

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if strings.HasSuffix(r.URL.Path, "/") {
            if !file.IsExist(filepath.Join(g.Root, "/public", r.URL.Path, "index.html")) {
                http.NotFound(w, r)
                return
            }
        }
        http.FileServer(http.Dir(filepath.Join(g.Root, "/public"))).ServeHTTP(w, r)
    })

}

三 默认采集模块分析

  1. AgentMetrics -- agent alive状态采集
func AgentMetrics() []*model.MetricValue {
    return []*model.MetricValue{GaugeValue("agent.alive", 1)}
}
  1. CpuMetrics -- CPU相关信息采集
# 在main入口后台线程已周期性收集CPU状态，保存在私有procStatHistory内
# go cron.InitDataHistory()-> UpdateCpuStat() 
# 解析procStatHistory历史数据
# 比如CpuIdle值获取
func CpuIdle() float64 {
    psLock.RLock()
    defer psLock.RUnlock()
    dt := deltaTotal()
    if dt == 0 {
        return 0.0
    }
    invQuotient := 100.00 / float64(dt)
    return float64(procStatHistory[0].Cpu.Idle-procStatHistory[1].Cpu.Idle) * invQuotient  //解析cpuidle
}


func CpuMetrics() []*model.MetricValue {
    if !CpuPrepared() {
        return []*model.MetricValue{}
    }

    # CPU信息: idle, busy, user, nice, system, iowait, irq, softirq, steal, guest, switches
    
    cpuIdleVal := CpuIdle()
    idle := GaugeValue("cpu.idle", cpuIdleVal) //空闲值
    busy := GaugeValue("cpu.busy", 100.0-cpuIdleVal) //繁忙值
    user := GaugeValue("cpu.user", CpuUser()) // 用户使用CPU
    nice := GaugeValue("cpu.nice", CpuNice()) //CPU NICE值
    system := GaugeValue("cpu.system", CpuSystem()) //系统使用CPU
    iowait := GaugeValue("cpu.iowait", CpuIowait()) //IO等待
    irq := GaugeValue("cpu.irq", CpuIrq()) //IO中断请求
    softirq := GaugeValue("cpu.softirq", CpuSoftIrq()) //软中断请求
    steal := GaugeValue("cpu.steal", CpuSteal()) //Steal值
    guest := GaugeValue("cpu.guest", CpuGuest()) //Guest值
    switches := CounterValue("cpu.switches",   CurrentCpuSwitches())  //交换值
    return []*model.MetricValue{idle, busy, user, nice, system, iowait, irq, softirq, steal, guest, switches}
}
  1. NetMetrics 网卡相关信息采集
# 依据配置网卡接口信息采集数据
func NetMetrics() []*model.MetricValue {
    return CoreNetMetrics(g.Config().Collector.IfacePrefix)
}

#引用"github.com/toolkits/nux"采集网卡信息
#实现读取与解析"/proc/net/dev"信息

func CoreNetMetrics(ifacePrefix []string) []*model.MetricValue {

    netIfs, err := nux.NetIfs(ifacePrefix)
    if err != nil {
        log.Println(err)
        return []*model.MetricValue{}
    }

    cnt := len(netIfs)
    ret := make([]*model.MetricValue, cnt*26)

    for idx, netIf := range netIfs {
        iface := "iface=" + netIf.Iface
        ret[idx*26+0] = CounterValue("net.if.in.bytes", netIf.InBytes, iface) //入字节数
        ret[idx*26+1] = CounterValue("net.if.in.packets", netIf.InPackages, iface) //入包数
        ret[idx*26+2] = CounterValue("net.if.in.errors", netIf.InErrors, iface) //入错误包数
        ret[idx*26+3] = CounterValue("net.if.in.dropped", netIf.InDropped, iface) //入丢包数
        ret[idx*26+4] = CounterValue("net.if.in.fifo.errs", netIf.InFifoErrs, iface) //FIFO ERROR
        ret[idx*26+5] = CounterValue("net.if.in.frame.errs", netIf.InFrameErrs, iface) //帧ERROR
        ret[idx*26+6] = CounterValue("net.if.in.compressed", netIf.InCompressed, iface) //压缩
        ret[idx*26+7] = CounterValue("net.if.in.multicast", netIf.InMulticast, iface) //多播
        ret[idx*26+8] = CounterValue("net.if.out.bytes", netIf.OutBytes, iface) //出字节数
        ret[idx*26+9] = CounterValue("net.if.out.packets", netIf.OutPackages, iface) //出包数
        ret[idx*26+10] = CounterValue("net.if.out.errors", netIf.OutErrors, iface) //出错误数
        ret[idx*26+11] = CounterValue("net.if.out.dropped", netIf.OutDropped, iface) // 出丢包数
        ret[idx*26+12] = CounterValue("net.if.out.fifo.errs", netIf.OutFifoErrs, iface) //出FIFO ERROR
        ret[idx*26+13] = CounterValue("net.if.out.collisions", netIf.OutCollisions, iface) //出冲突
        ret[idx*26+14] = CounterValue("net.if.out.carrier.errs", netIf.OutCarrierErrs, iface) //载波
        ret[idx*26+15] = CounterValue("net.if.out.compressed", netIf.OutCompressed, iface) //压缩
        ret[idx*26+16] = CounterValue("net.if.total.bytes", netIf.TotalBytes, iface) //总字节
        ret[idx*26+17] = CounterValue("net.if.total.packets", netIf.TotalPackages, iface) //总包数
        ret[idx*26+18] = CounterValue("net.if.total.errors", netIf.TotalErrors, iface) //总错误
        ret[idx*26+19] = CounterValue("net.if.total.dropped", netIf.TotalDropped, iface) //总丢包数
        ret[idx*26+20] = GaugeValue("net.if.speed.bits", netIf.SpeedBits, iface) //速率bs
        ret[idx*26+21] = CounterValue("net.if.in.percent", netIf.InPercent, iface) //进百分比
        ret[idx*26+22] = CounterValue("net.if.out.percent", netIf.OutPercent, iface) //出百分比
        ret[idx*26+23] = CounterValue("net.if.in.bits", netIf.InBytes*8, iface) //进速率bs
        ret[idx*26+24] = CounterValue("net.if.out.bits", netIf.OutBytes*8, iface) //出速率bs
        ret[idx*26+25] = CounterValue("net.if.total.bits", netIf.TotalBytes*8, iface) //总速率bs
    }
    return ret
}
  1. KernelMetrics 系统内核相关信息采集
#引用"github.com/toolkits/nux"采集内核信息
#实现读取"/proc/sys/fs/file-max" 
# "/proc/sys/fs/file-nr"  
# "/proc/sys/kernel/pid_max" 

func KernelMetrics() (L []*model.MetricValue) {

    maxFiles, err := nux.KernelMaxFiles()
    if err != nil {
        log.Println(err)
        return
    }
 
    //最大打开文件数
    L = append(L, GaugeValue("kernel.maxfiles", maxFiles))

    maxProc, err := nux.KernelMaxProc()
    if err != nil {
        log.Println(err)
        return
    }
   
    //最大进程数
    L = append(L, GaugeValue("kernel.maxproc", maxProc))

    allocateFiles, err := nux.KernelAllocateFiles()
    if err != nil {
        log.Println(err)
        return
    }
   
    //已分配文件数
    L = append(L, GaugeValue("kernel.files.allocated", allocateFiles))
    //已剩余文件数
    L = append(L, GaugeValue("kernel.files.left", maxFiles-allocateFiles))
    return
}
  1. LoadAvgMetrics -- CPU负载信息采集
#引用"github.com/toolkits/nux"采集CPU负载信息
#实现读取与解析 "/proc/loadavg"信息 
#

func LoadAvgMetrics() []*model.MetricValue {
    load, err := nux.LoadAvg()
    if err != nil {
        log.Println(err)
        return nil
    }

    return []*model.MetricValue{
        GaugeValue("load.1min", load.Avg1min), //1分钟平均
        GaugeValue("load.5min", load.Avg5min), //5分钟平均
        GaugeValue("load.15min", load.Avg15min), //15分钟平均
    }

}
  1. MemMetrics -- 内存信息采集
#引用"github.com/toolkits/nux"采集内存信息
#实现读取与解析"/proc/meminfo"信息

func MemMetrics() []*model.MetricValue {
    m, err := nux.MemInfo()
    if err != nil {
        log.Println(err)
        return nil
    }

    memFree := m.MemFree + m.Buffers + m.Cached
    memUsed := m.MemTotal - memFree

    pmemFree := 0.0
    pmemUsed := 0.0
    if m.MemTotal != 0 {
        pmemFree = float64(memFree) * 100.0 / float64(m.MemTotal)
        pmemUsed = float64(memUsed) * 100.0 / float64(m.MemTotal)
    }

    pswapFree := 0.0
    pswapUsed := 0.0
    if m.SwapTotal != 0 {
        pswapFree = float64(m.SwapFree) * 100.0 / float64(m.SwapTotal)
        pswapUsed = float64(m.SwapUsed) * 100.0 / float64(m.SwapTotal)
    }

    return []*model.MetricValue{
        GaugeValue("mem.memtotal", m.MemTotal),  //总内存大小
        GaugeValue("mem.memused", memUsed), //已使用内存大小
        GaugeValue("mem.memfree", memFree), //可用内存大小
        GaugeValue("mem.swaptotal", m.SwapTotal), //交换内存总大小
        GaugeValue("mem.swapused", m.SwapUsed), //已使用交换内存大小
        GaugeValue("mem.swapfree", m.SwapFree), //可用交换内存大小
        GaugeValue("mem.memfree.percent", pmemFree), //可用内存占比
        GaugeValue("mem.memused.percent", pmemUsed), //已用内存占比
        GaugeValue("mem.swapfree.percent", pswapFree), //可用交换内存占比
        GaugeValue("mem.swapused.percent", pswapUsed), //已用交换同内存占比
    }

}
  1. DiskIOMetrics -- 磁盘IO信息采集
#引用"github.com/toolkits/nux"采集DISK信息
#实现读取与解析"/proc/diskstats"信息

func DiskIOMetrics() (L []*model.MetricValue) {

    dsList, err := nux.ListDiskStats()
    if err != nil {
        log.Println(err)
        return
    }
   
    //迭代DISK列表
    for _, ds := range dsList {
        if !ShouldHandleDevice(ds.Device) {
            continue
        }

        device := "device=" + ds.Device

        L = append(L, CounterValue("disk.io.read_requests", ds.ReadRequests, device))//读请求
        L = append(L, CounterValue("disk.io.read_merged", ds.ReadMerged, device)) //相邻的读取请求合并
        L = append(L, CounterValue("disk.io.read_sectors", ds.ReadSectors, device)) //读扇区
        L = append(L, CounterValue("disk.io.msec_read", ds.MsecRead, device)) //disk读花费的时间
        L = append(L, CounterValue("disk.io.write_requests", ds.WriteRequests, device)) //写请求
        L = append(L, CounterValue("disk.io.write_merged", ds.WriteMerged, device)) //相邻的写请求合并
        L = append(L, CounterValue("disk.io.write_sectors", ds.WriteSectors, device)) //写扇区
        L = append(L, CounterValue("disk.io.msec_write", ds.MsecWrite, device)) //disk写花费的时间
        L = append(L, CounterValue("disk.io.ios_in_progress", ds.IosInProgress, device)) //正处理的IO数
        L = append(L, CounterValue("disk.io.msec_total", ds.MsecTotal, device)) //总花费的时间
        L = append(L, CounterValue("disk.io.msec_weighted_total", ds.MsecWeightedTotal, device)) //统计最近的IO完成时间和积压
    }
    return
}
  1. IOStatsMetrics -- 磁盘IO信息采集
# 在main入口后台线程已周期性收集CPU状态，保存在私有procStatHistory内
# go cron.InitDataHistory()-> UpdateDiskStats()
# 私有变量diskStatsMap保存周期性数据
# 解析 diskStatsMap 获取IO状态数据


func IOStatsMetrics() (L []*model.MetricValue) {
    dsLock.RLock()
    defer dsLock.RUnlock()

    for device := range diskStatsMap {
        if !ShouldHandleDevice(device) {
            continue
        }

        tags := "device=" + device
        rio := IODelta(device, IOReadRequests)
        wio := IODelta(device, IOWriteRequests)
        delta_rsec := IODelta(device, IOReadSectors)
        delta_wsec := IODelta(device, IOWriteSectors)
        ruse := IODelta(device, IOMsecRead)
        wuse := IODelta(device, IOMsecWrite)
        use := IODelta(device, IOMsecTotal)
        n_io := rio + wio
        avgrq_sz := 0.0
        await := 0.0
        svctm := 0.0
        if n_io != 0 {
            avgrq_sz = float64(delta_rsec+delta_wsec) / float64(n_io)
            await = float64(ruse+wuse) / float64(n_io)
            svctm = float64(use) / float64(n_io)
        }

        duration := IODelta(device, TS)

        L = append(L, GaugeValue("disk.io.read_bytes", float64(delta_rsec)*512.0, tags)) // 读字节数
        L = append(L, GaugeValue("disk.io.write_bytes", float64(delta_wsec)*512.0, tags)) // 写字节数
        L = append(L, GaugeValue("disk.io.avgrq_sz", avgrq_sz, tags)) //平均请求扇区的大小
        L = append(L, GaugeValue("disk.io.avgqu-sz",  float64(IODelta(device, IOMsecWeightedTotal))/1000.0, tags)) //是平均请求队列的长度
        L = append(L, GaugeValue("disk.io.await", await, tags)) //每一个IO请求的处理的平均时间
        L = append(L, GaugeValue("disk.io.svctm", svctm, tags))//表示平均每次设备I/O操作的服务时间
        tmp := float64(use) * 100.0 / float64(duration)
        if tmp > 100.0 {
            tmp = 100.0
        }
        L = append(L, GaugeValue("disk.io.util", tmp, tags)) //在统计时间内所有处理IO时间，除以总共统计时间
    }

    return
}
  1. NetstatMetrics -- TCP信息采集
#引用"github.com/toolkits/nux"采集TCP信息
#实现为读"/proc/net/netstat"信息并解析

func NetstatMetrics() (L []*model.MetricValue) {
    tcpExts, err := nux.Netstat("TcpExt")

    if err != nil {
        log.Println(err)
        return
    }

    cnt := len(tcpExts)
    if cnt == 0 {
        return
    }

    for key, val := range tcpExts {
        if _, ok := USES[key]; !ok {
            continue
        }
        L = append(L, CounterValue("TcpExt."+key, val))
    }

    return
}
  1. ProcMetrics -- 采集Proc相关信息
# main入口syncBuiltinMetrics()从HBS同步SetReportProcs()
# g.ReportProcs()获取Procs列表map
# 获取"/proc"目录下"/proc/%pid/cmdline"

func ProcMetrics() (L []*model.MetricValue) {

    reportProcs := g.ReportProcs()
    sz := len(reportProcs)
    if sz == 0 {
        return
    }

    ps, err := nux.AllProcs()
    if err != nil {
        log.Println(err)
        return
    }

    pslen := len(ps)

    for tags, m := range reportProcs {
        cnt := 0
        for i := 0; i < pslen; i++ {
            if is_a(ps[i], m) {
                cnt++
            }
        }

        L = append(L, GaugeValue(g.PROC_NUM, cnt, tags))
    }

    return
}
  1. UdpMetrics UDP接收和发送数据报采集
# 实现获取"/proc/net/snmp"信息UDP接收和发送数据报

func UdpMetrics() []*model.MetricValue {
    udp, err := nux.Snmp("Udp")
    if err != nil {
        log.Println("read snmp fail", err)
        return []*model.MetricValue{}
    }

    count := len(udp)
    ret := make([]*model.MetricValue, count)
    i := 0
    for key, val := range udp {
        ret[i] = CounterValue("snmp.Udp."+key, val)
        i++
    }

    return ret
}
  1. DeviceMetrics -- 挂载设备信息采集
# 实现获取与解析"/proc/mounts"信息

func DeviceMetrics() (L []*model.MetricValue) {
    mountPoints, err := nux.ListMountPoint()

    if err != nil {
        log.Error("collect device metrics fail:", err)
        return
    }

    var myMountPoints map[string]bool = make(map[string]bool)

    if len(g.Config().Collector.MountPoint) > 0 {
        for _, mp := range g.Config().Collector.MountPoint {
            myMountPoints[mp] = true
        }
    }

    var diskTotal uint64 = 0
    var diskUsed uint64 = 0

    for idx := range mountPoints {
        fsSpec, fsFile, fsVfstype := mountPoints[idx][0], mountPoints[idx][1], mountPoints[idx][2]
        if len(myMountPoints) > 0 {
            if _, ok := myMountPoints[fsFile]; !ok {
                log.Debug("mount point not matched with config", fsFile, "ignored.")
                continue
            }
        }

        var du *nux.DeviceUsage
        du, err = nux.BuildDeviceUsage(fsSpec, fsFile, fsVfstype)
        if err != nil {
            log.Error(err)
            continue
        }

        if du.BlocksAll == 0 {
            continue
        }

        diskTotal += du.BlocksAll
        diskUsed += du.BlocksUsed

        tags := fmt.Sprintf("mount=%s,fstype=%s", du.FsFile, du.FsVfstype) 
        L = append(L, GaugeValue("df.bytes.total", du.BlocksAll, tags))  //总大小字节
        L = append(L, GaugeValue("df.bytes.used", du.BlocksUsed, tags))  //已使用小大字节
        L = append(L, GaugeValue("df.bytes.free", du.BlocksFree, tags))  //剩余小大字节
        L = append(L, GaugeValue("df.bytes.used.percent", du.BlocksUsedPercent, tags)) //使用占比 
        L = append(L, GaugeValue("df.bytes.free.percent", du.BlocksFreePercent, tags)) //剩余块占比

        if du.InodesAll == 0 {
            continue
        }

        L = append(L, GaugeValue("df.inodes.total", du.InodesAll, tags))  //inode总数
        L = append(L, GaugeValue("df.inodes.used", du.InodesUsed, tags))  //已用inode数目
        L = append(L, GaugeValue("df.inodes.free", du.InodesFree, tags))  //可用inode数目
        L = append(L, GaugeValue("df.inodes.used.percent", du.InodesUsedPercent, tags)) // 已用inode占比
        L = append(L, GaugeValue("df.inodes.free.percent", du.InodesFreePercent, tags)) // 可用inode占比

    }

    if len(L) > 0 && diskTotal > 0 {
        L = append(L, GaugeValue("df.statistics.total", float64(diskTotal))) //统计总数 
        L = append(L, GaugeValue("df.statistics.used", float64(diskUsed))) // 统计使用
        L = append(L, GaugeValue("df.statistics.used.percent", float64(diskUsed)*100.0/float64(diskTotal)))  //统计使用占比
    }

    return
}
  1. PortMetrics -- TCP / UDP 端口信息采集
# main入口syncBuiltinMetrics()-> g.SetReportPorts(ports)从HBS同步检测端口列表
# g.ReportPorts() 获取列表
# 实现获取TCP "ss -t -l -n" /获取UDP "ss -u -a -n"监听信息

func PortMetrics() (L []*model.MetricValue) {

    reportPorts := g.ReportPorts()
    sz := len(reportPorts)
    if sz == 0 {
        return
    }
   
    allTcpPorts, err := nux.TcpPorts()
    if err != nil {
        log.Println(err)
        return
    }

    allUdpPorts, err := nux.UdpPorts()
    if err != nil {
        log.Println(err)
        return
    }

    for i := 0; i < sz; i++ {
        tags := fmt.Sprintf("port=%d", reportPorts[i])
        if slice.ContainsInt64(allTcpPorts, reportPorts[i]) || slice.ContainsInt64(allUdpPorts, reportPorts[i]) {
            L = append(L, GaugeValue(g.NET_PORT_LISTEN, 1, tags))
        } else {
            L = append(L, GaugeValue(g.NET_PORT_LISTEN, 0, tags))
        }
    }

    return
}
  1. SocketStatSummaryMetrics -- socket统计信息采集
# 实现获取socket统计信息 "ss -s" 
func SocketStatSummaryMetrics() (L []*model.MetricValue) {
    ssMap, err := nux.SocketStatSummary()
    if err != nil {
        log.Println(err)
        return
    }

    for k, v := range ssMap {
        L = append(L, GaugeValue("ss."+k, v))
    }

    return
}
  1. DuMetrics

# main入口syncBuiltinMetrics()从HBS同步g.SetDuPaths(paths)
# g.DuPaths()获取磁盘分区列表

func DuMetrics() (L []*model.MetricValue) {
    paths := g.DuPaths()
    result := make(chan *model.MetricValue, len(paths))
    var wg sync.WaitGroup

    //迭代所有PATH
    for _, path := range paths {
        wg.Add(1)
        go func(filepath string) {
            var err error
            defer func() {
                if err != nil {
                    log.Println(err)
                    result <- GaugeValue(g.DU_BS, -1, "path="+path)
                }
                wg.Done()
            }()
            //tips:osx  does not support -b.
            cmd := exec.Command("du", "-bs", path) //exec执行du
            var stdout bytes.Buffer
            cmd.Stdout = &stdout
            var stderr bytes.Buffer
            cmd.Stderr = &stderr
            err = cmd.Start()
            if err != nil {
                return

            }
            err, isTimeout := sys.CmdRunWithTimeout(cmd, time.Duration(timeout)*time.Second)
            if isTimeout {
                err = errors.New(fmt.Sprintf("exec cmd : du -bs %s timeout", path))
                return
            }

            errStr := stderr.String()
            if errStr != "" {
                err = errors.New(errStr)
                return
            }

            if err != nil {
                err = errors.New(fmt.Sprintf("du -bs %s failed: %s", path, err.Error()))
                return
            }

            arr := strings.Fields(stdout.String())
            if len(arr) < 2 {
                errors.New(fmt.Sprintf("du -bs %s failed: %s", path, "return fields < 2"))
                return
            }

            size, err := strconv.ParseUint(arr[0], 10, 64)
            if err != nil {
                err = errors.New(fmt.Sprintf("cannot parse du -bs %s output", path))
                return
            }
            result <- GaugeValue(g.DU_BS, size, "path="+path)
        }(path)
    }
    wg.Wait()

    resultLen := len(result)
    for i := 0; i < resultLen; i++ {
        L = append(L, <-result)
    }
    return
}
  1. UrlMetrics -- URL健康检测采集
 func UrlMetrics() (L []*model.MetricValue) {
    //获取周期性向HBS所同步的URL列表
    reportUrls := g.ReportUrls() 
    sz := len(reportUrls)
    if sz == 0 {
        return
    }
    hostname, err := g.Hostname()
    if err != nil {
        hostname = "None"
    }
    // 迭代URL列表，执行URL状态检测
    for furl, timeout := range reportUrls {
        tags := fmt.Sprintf("url=%v,timeout=%v,src=%v", furl, timeout, hostname)
        //「probeUrl检测」
        if ok, _ := probeUrl(furl, timeout); !ok {
            L = append(L, GaugeValue(g.URL_CHECK_HEALTH, 0, tags))
            continue
        }
        L = append(L, GaugeValue(g.URL_CHECK_HEALTH, 1, tags))
    }
    return
}

//通过调用系统命令执行Curl命令进行Http_code的状态检测
func probeUrl(furl string, timeout string) (bool, error) {
    bs, err := sys.CmdOutBytes("curl", "--max-filesize", "102400", "-I", "-m", timeout, "-o", "/dev/null", "-s", "-w", "%{http_code}", furl)
    if err != nil {
        log.Printf("probe url [%v] failed.the err is: [%v]\n", furl, err)
        return false, err
    }
    reader := bufio.NewReader(bytes.NewBuffer(bs))
    retcode, err := file.ReadLine(reader)
    if err != nil {
        log.Println("read retcode failed.err is:", err)
        return false, err
    }
    if strings.TrimSpace(string(retcode)) != "200" {
        log.Printf("return code [%v] is not 200.query url is [%v]", string(retcode), furl)
        return false, err
    }
    return true, err
}
  1. GpuMetrics -- GPU信息采集

// 引用外部库"github.com/mindprince/gonvml"
// 需要load libnvidia-ml.so.1库
func GpuMetrics() (L []*model.MetricValue) {

    if err := gonvml.Initialize(); err != nil {
        debug := g.Config().Debug
        if debug {
            log.Println("Initialize error: ", err)
        }
        return
    }

    defer gonvml.Shutdown()

    count, err := gonvml.DeviceCount()
    if err != nil {
        log.Println("DeviceCount error: ", err)
        return
    }

    if count == 0 {
        return
    }

    temperature := uint(0)
    totalMemory := uint64(0)
    usedMemory := uint64(0)
    gpuUtilization := uint(0)
    memoryUtilization := uint(0)
    powerUsage := uint(0)
    allUtilization := uint(0)
    allMemoryUtilization := uint(0)

    for i := 0; i < int(count); i++ {
        dev, err := gonvml.DeviceHandleByIndex(uint(i))
        if err != nil {
            log.Println("DeviceHandleByIndex error:", err)
            continue
        }

        uuid, err := dev.UUID()
        if err != nil {
            log.Println("dev.UUID error", err)
        }

        tag := "uuid=" + uuid

        // 不是所有gpu都有风扇
        fanSpeed, err := dev.FanSpeed()
        if err != nil {
            log.Println("dev.FanSpeed error: ", err)
        } else {
            L = append(L, GaugeValue("gpu.fan.speed", fanSpeed, tag))
        }

        temperature, err = dev.Temperature()
        if err != nil {
            log.Println("dev.Temperature error: ", err)
            continue
        }

        totalMemory, usedMemory, err = dev.MemoryInfo()
        if err != nil {
            log.Println("dev.MemoryInfo error: ", err)
            continue
        }

        // 单位换算为兆
        totalBillion := float64(totalMemory / 1024 / 1024)
        usedBillion := float64(usedMemory / 1024 / 1024)

        gpuUtilization, memoryUtilization, err = dev.UtilizationRates()
        if err != nil {
            log.Println("dev.UtilizationRates error: ", err)
            continue
        }

        allUtilization += gpuUtilization
        allMemoryUtilization += memoryUtilization

        powerUsage, err = dev.PowerUsage()
        if err != nil {
            log.Println("dev.PowerUsage error: ", err)
        }

        // 单位换算为瓦特
        powerWatt := float64(powerUsage / 1000)

        L = append(L, GaugeValue("gpu.temperature", temperature, tag))
        L = append(L, GaugeValue("gpu.memory.total", totalBillion, tag))
        L = append(L, GaugeValue("gpu.memory.used", usedBillion, tag))
        L = append(L, GaugeValue("gpu.memory.util", memoryUtilization, tag))
        L = append(L, GaugeValue("gpu.util", gpuUtilization, tag))
        L = append(L, GaugeValue("gpu.power.usage", powerWatt, tag))
    }

    L = append(L, GaugeValue("gpu.count", count))
    L = append(L, GaugeValue("gpu.util.avg", allUtilization/count))
    L = append(L, GaugeValue("gpu.memory.util.avg", allMemoryUtilization/count))
    return L
}

四 思考与查证

  1. 请查看源码，查证Agent所关联的组件HBS/Transfer哪个是集群模式？哪个是单点模式？为什么？
  2. 如果需要自定义Agent的采集数据有哪几种方式？从源码角度又应该如何添加相应的采集Code?
  3. 聊一聊从源码角度Agent组件哪些代码技术点或模式点值得你好好学习与借鉴的？

你可能感兴趣的:(OpenFalcon源码分析(Agent组件))

  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 利用Requests Toolkit轻松完成HTTP请求 nseejrukjhad http网络协议网络python
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
  • 利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchainmicrosoft数据库python
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
  • 在一台Ubuntu计算机上构建Hyperledger Fabric网络 落叶无声9 区块链超级账本Hyperledgerfabric区块链ubuntu构建hyperledgerfabric
    在一台Ubuntu计算机上构建HyperledgerFabric网络Hyperledgerfabric是一个开源的区块链应用程序平台，为开发基于区块链的应用程序提供了一个起点。当我们提到HyperledgerFabric网络时，我们指的是使用HyperledgerFabric的正在运行的系统。即使只使用最少数量的组件，部署Fabric网络也不是一件容易的事。Fabric社区创建了一个名为Cello
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • uniapp map组件自定义markers标记点 以对_ uni-app学习记录uni-appjavascript前端
    需求是根据后端返回数据在地图上显示标记点，并且根据数据状态控制标记点颜色，标记点背景通过两张图片实现控制{{item.options.labelName}}exportdefault{data(){return{storeIndex:0,locaInfo:{longitude:120.445172,latitude:36.111387},markers:[//标点列表{id:1,//标记点idin
  • 基于STM32与Qt的自动平衡机器人：从控制到人机交互的的详细设计流程 极客小张 stm32qt机器人物联网人机交互毕业设计c语言
    一、项目概述目标和用途本项目旨在开发一款基于STM32控制的自动平衡机器人，结合步进电机和陀螺仪传感器，实现对平衡机器人的精确控制。该机器人可以用于教育、科研、娱乐等多个领域，帮助用户了解自动控制、机器人运动学等相关知识。技术栈关键词STM32单片机步进电机陀螺仪传感器AD采集电路Qt人机界面实时数据监控二、系统架构系统架构设计本项目的系统架构设计包括以下主要组件：控制单元:STM32单片机传感器
  • JAVA·一个简单的登录窗口 MortalTom java开发语言学习
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
  • 信息系统安全相关概念(上) YuanDaima2048 课程笔记基础概念安全信息安全笔记
    文章总览：YuanDaiMa2048博客文章总览下篇:信息系统安全相关概念(下)信息系统安全相关概念[上]信息系统概述信息系统信息系统架构信息系统发展趋势：信息系统日趋大型化、复杂化信息系统面临的安全威胁信息系统安全架构设计--以云计算为例信息系统安全需求及安全策略自主访问控制策略DAC强制访问控制策略MAC信息系统概述信息系统用于收集、存储和处理数据以及传递信息、知识和数字产品的一组集成组件。几
  • HarmonyOS开发实战（ Beta5.0）搜索框热搜词自动切换 让开，我要吃人了 OpenHarmonyHarmonyOS鸿蒙开发harmonyos华为鸿蒙移动开发鸿蒙系统前端开发语言
    鸿蒙HarmonyOS开发往期必看：HarmonyOSNEXT应用开发性能实践总结最新版！“非常详细的”鸿蒙HarmonyOSNext应用开发学习路线！（从零基础入门到精通）介绍本示例介绍使用TextInput组件与Swiper组件实现搜索框内热搜词自动切换。效果图预览使用说明页面顶部搜索框内热搜词条自动切换，编辑搜索框时自动隐藏。实现思路使用TextInput实现搜索框TextInput({te
  • 内存保护学习（一）：tc27x的内存保护MPU设置浅析（个人理解） 剑从东方起 链接文件及功能安全开发语言c语言
    目录一、背景二、Tc27x相关寄存器1、注意点2、注意几个强相关寄存器1）、数据保护范围寄存器2）、代码保护范围寄存器3）、保护集启用寄存器命名约定4）、PSW（每个核都有一个）5）、SYSCON三、使用方法1、内存方面2、在ECUM里面初始化MPU3、OS回调CBK检查4、机理5、补充点一、背景根据低ASIL等级开发的软件组件可能会错误地访问具有较高ASIL等级的软件组件的内存区域，从而产生干扰
  • 详解“c:/work/src/components/a/b.vue“‘ has no default export报错原因 hw_happy 开发语言前端vue.jsjavascript
    前情提要在一个vue文件中需要引入定义的b.vue文件，但是提示b文件没有默认导出，对于vue2文件来说有exportdefault，在中，所有定义的变量、函数和组件都会自动被视为默认导出的组件内容。因此，不需要显式地使用exportdefault来导出组件。但是在我引用这个文件的时候还是提示了这个错误，原来是我的项目使用了ts和vite\webpack，因为TypeScript和Vue的默认导出
  • 【大模型应用开发 动手做AI Agent】第一轮行动：工具执行搜索 AI大模型应用之禅 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    【大模型应用开发动手做AIAgent】第一轮行动：工具执行搜索作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming1.背景介绍1.1问题的由来随着人工智能技术的飞速发展，大模型应用开发已经成为当下热门的研究方向。AIAgent作为人工智能领域的一个重要分支，旨在模拟人类智能行为，实现智能决策和自主行动。在AIAgent的构建过程中，工具执行搜索是至关重要
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • ansible的安装、使用 ytym00
    简介高度模块化，调用特定的模块，完成特定的任务，基于Yaml，来完成批量任务的模板化，来支持playbook。基于Python语言实现，主要使用Paramiko、PyYAML和JinJa2三个关键模块，部署简单(agentless)，主从模式，支持自定义模块，支持playbook，幂等性：允许重复执行N次，没有变化时，只会执行第一次。特点：1、Configuration(cfengine,chef
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • Istio pilot-discovery服务发现源码解析（1.13版本） xidianjiapei001 #Istioistio云原生服务发现
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
  • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
  • Vue3 vant组件库自动导入 不叫虎子 Vuevue.js前端javascript前端框架typescript
    实现：完整使用vant组件库文档安装：#Vue3项目，安装最新版Vantnpmivant#通过yarn安装yarnaddvant#通过pnpm安装pnpmaddvant【一】按需引入：https://vant-contrib.gitee.io/vant/#/zh-CN/quickstart#fang-fa-er.-an-xu-yin-ru-zu-jian-yang-shi【二】批量引入在基于vit
  • vant-element-ts一起使用存在的问题 flynn_ 问题总结vue
    由于vant-ui与element-ui部分组件存在冲突，导致在vue-typescript中出现错误:Subsequentpropertydeclarationsmusthavethesametype.Property'$notify'mustbeoftype'ElNotification',butherehastype'Notify'.方案：一个全局导入，一个按需导入,避免冲突的组件同时使用，
  • 【Python】tkinter及组件如何使用 小九不懂SAP 我的Python日记python开发语言tkinter
    一、tkinter的应用场景tkinter是Python的标准GUI（图形用户界面）库，它提供了丰富的控件和工具，使得开发者能够轻松创建跨平台的桌面应用程序。以下是一些tkinter的常见应用场景：桌面应用程序开发：开发者可以使用tkinter来创建各种桌面应用程序，如文本编辑器、计算器、图片查看器、游戏等。这些应用程序可以具有复杂的用户界面，包括窗口、按钮、文本框、下拉菜单、滚动条等。数据可视化
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面 2401_84544531 程序员android面试学习
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
  • 【前端】vue 报错:The template root requires exactly one element 程序员-张师傅 前端前端vue.jsjavascript
    【前端】vue报错:Thetemplaterootrequiresexactlyoneelement在Vue.js中，当你遇到错误“Thetemplaterootrequiresexactlyoneelement”时，这通常意味着你的Vue组件的模板（template）根节点不是单一的元素。Vue要求每个组件的模板必须有一个根元素来包裹所有的子元素。这个错误通常出现在以下几种情况：模板中有多个并行
  • [移动端自动化] AppAgent介绍 大卫软件测试 自动化
    AUITestAgentAUITestAgent/README_zh.mdatmain·bz-lab/AUITestAgent(github.com)1/MobileAgentX-PLUG/MobileAgent:Mobile-Agent:ThePowerfulMobileDeviceOperationAssistantFamily(github.com)2/AppAgentAppAgent/RE
  • 【鸿蒙应用】总结一下ArkUI 读心悦 鸿蒙基础鸿蒙应用
    ArkUI是HarmonyOS应用界面的UI开发框架，提供了简洁的UI语法、UI组件、动画机制和事件交互等等UI开发基础，以此满足应用开发者对UI界面开发的需求。组件是界面搭建的最小单位，开发者通过多种组件的组合构成完整的界面。页面是ArkUI最小的调度分隔单位，开发者可以将应用设计为多个功能页面，每一个页面进行单独的文件管理，并且通过页面路由API完成页面之间的调度管理，以此来实现应用内功能的解
  • Golang Channel PandaSkr golang
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
  • 谈谈你对AQS的理解 Mutig_s jucjava开发语言面试后端
    AQS概述AQS，全称为AbstractQueuedSynchronizer，是Java并发包（java.util.concurrent）中一个核心的框架，主要用于构建阻塞式锁和相关的同步器，也是构建锁或者其他同步组件的基础框架。AQS提供了一种基于FIFO（First-In-First-Out）的CLH(三个人名缩写)双向队列的机制，来实现各种同步器，如ReentrantLock、Semapho
  • Kafka 基础与架构理解 StaticKing KAFKAkafka
    目录前言Kafka基础概念消息队列简介：Kafka与传统消息队列（如RabbitMQ、ActiveMQ）的对比Kafka的组件Kafka的工作原理：消息的生产、分发、消费流程Kafka系统架构Kafka的分布式架构设计Leader-Follower机制与数据复制Log-basedStorage和持久化Broker间通信协议Zookeeper在Kafka中的角色总结前言Kafka是一个分布式的消息系
  • 构建常态化安全防线：XDR的态势感知与自动化响应机制 安胜ANSCEN 网络安全运维威胁分析自动化响应网络安全常态化安全运营
    当前，网络安全威胁日益复杂多变，企业正面临前所未有的严峻挑战。为有效应对这些挑战，态势感知与自动化响应机制在提升网络安全运营效率与防御效果中扮演着至关重要的角色。它们能够实时监测网络状态，智能分析潜在威胁，并在发现异常时立即触发自动化响应流程，从而迅速遏制安全风险，保障企业数字资产的安全。态势感知网络安全的“预警雷达”态势感知，作为网络安全运营的核心组件，犹如一张无形的“预警雷达”，全面监测网络环
  • Java实现的简单双向Map，支持重复Value superlxw1234 java双向map
    关键字：Java双向Map、DualHashBidiMap     有个需求，需要根据即时修改Map结构中的Value值，比如，将Map中所有value=V1的记录改成value=V2，key保持不变。   数据量比较大，遍历Map性能太差，这就需要根据Value先找到Key，然后去修改。   即：既要根据Key找Value，又要根据Value
  • PL/SQL触发器基础及例子 百合不是茶 oracle数据库触发器PL/SQL编程
      触发器的简介; 触发器的定义就是说某个条件成立的时候，触发器里面所定义的语句就会被自动的执行。因此触发器不需要人为的去调用，也不能调用。触发器和过程函数类似 过程函数必须要调用,   一个表中最多只能有12个触发器类型的,触发器和过程函数相似 触发器不需要调用直接执行, 触发时间：指明触发器何时执行，该值可取： before：表示在数据库动作之前触发
  • [时空与探索]穿越时空的一些问题 comsci 问题
          我们还没有进行过任何数学形式上的证明,仅仅是一个猜想.....       这个猜想就是; 任何有质量的物体(哪怕只有一微克)都不可能穿越时空,该物体强行穿越时空的时候,物体的质量会与时空粒子产生反应,物体会变成暗物质,也就是说,任何物体穿越时空会变成暗物质..(暗物质就我的理
  • easy ui datagrid上移下移一行 商人shang js上移下移easyuidatagrid
    /** * 向上移动一行 * * @param dg * @param row */ function moveupRow(dg, row) { var datagrid = $(dg); var index = datagrid.datagrid("getRowIndex", row); if (isFirstRow(dg, row)) {
  • Java反射 oloz 反射
    本人菜鸟，今天恰好有时间，写写博客，总结复习一下java反射方面的知识，欢迎大家探讨交流学习指教 首先看看java中的Class package demo; public class ClassTest { /*先了解java中的Class*/ public static void main(String[] args) { //任何一个类都
  • springMVC 使用JSR-303 Validation验证 杨白白 springmvc
    JSR-303是一个数据验证的规范，但是spring并没有对其进行实现，Hibernate Validator是实现了这一规范的，通过此这个实现来讲SpringMVC对JSR-303的支持。 JSR-303的校验是基于注解的，首先要把这些注解标记在需要验证的实体类的属性上或是其对应的get方法上。 登录需要验证类 public class Login { @NotEmpty
  • log4j 香水浓 log4j
    log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, HTML, DATABASE #log4j.rootCategory=DEBUG, STDOUT, DAILYFILE, ROLLINGFILE, HTML #console log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender log4
  • 使用ajax和history.pushState无刷新改变页面URL agevs jquery框架Ajaxhtml5chrome
    表现 如果你使用chrome或者firefox等浏览器访问本博客、github.com、plus.google.com等网站时，细心的你会发现页面之间的点击是通过ajax异步请求的，同时页面的URL发生了了改变。并且能够很好的支持浏览器前进和后退。 是什么有这么强大的功能呢？ HTML5里引用了新的API，history.pushState和history.replaceState，就是通过
  • centos中文乱码 AILIKES centosOSssh
    一、CentOS系统访问 g.cn ，发现中文乱码。 于是用以前的方式：yum -y install fonts-chinese CentOS系统安装后，还是不能显示中文字体。我使用 gedit 编辑源码，其中文注释也为乱码。       后来，终于找到以下方法可以解决，需要两个中文支持的包： fonts-chinese-3.02-12.
  • 触发器 baalwolf 触发器
    触发器(trigger)：监视某种情况，并触发某种操作。 触发器创建语法四要素：1.监视地点(table) 2.监视事件(insert/update/delete) 3.触发时间(after/before) 4.触发事件(insert/update/delete) 语法： create trigger triggerName after/before 
  • JS正则表达式的i m g bijian1013 JavaScript正则表达式
            g:表示全局（global)模式，即模式将被应用于所有字符串，而非在发现第一个匹配项时立即停止。         i:表示不区分大小写（case-insensitive）模式，即在确定匹配项时忽略模式与字符串的大小写。         m:表示
  • HTML5模式和Hashbang模式 bijian1013 JavaScriptAngularJSHashbang模式HTML5模式
            我们可以用$locationProvider来配置$location服务（可以采用注入的方式，就像AngularJS中其他所有东西一样）。这里provider的两个参数很有意思，介绍如下。 html5Mode         一个布尔值，标识$location服务是否运行在HTML5模式下。 ha
  • [Maven学习笔记六]Maven生命周期 bit1129 maven
    从mvn test的输出开始说起   当我们在user-core中执行mvn test时，执行的输出如下：   /software/devsoftware/jdk1.7.0_55/bin/java -Dmaven.home=/software/devsoftware/apache-maven-3.2.1 -Dclassworlds.conf=/software/devs
  • 【Hadoop七】基于Yarn的Hadoop Map Reduce容错 bit1129 hadoop
    运行于Yarn的Map Reduce作业，可能发生失败的点包括 Task Failure Application Master Failure Node Manager Failure Resource Manager Failure 1. Task Failure 任务执行过程中产生的异常和JVM的意外终止会汇报给Application Master。僵死的任务也会被A
  • 记一次数据推送的异常解决端口解决 ronin47 记一次数据推送的异常解决
    　　 需求：从db获取数据然后推送到B         程序开发完成，上jboss,刚开始报了很多错，逐一解决，可最后显示连接不到数据库。机房的同事说可以ping 通。 　　  自已画了个图，逐一排除，把linux 防火墙　和　setenforce　设置最低。 　　　service iptables stop
  • 巧用视错觉-UI更有趣 brotherlamp UIui视频ui教程ui自学ui资料
    我们每个人在生活中都曾感受过视错觉（optical illusion）的魅力。 视错觉现象是双眼跟我们开的一个玩笑，而我们往往还心甘情愿地接受我们看到的假象。其实不止如此，视觉错现象的背后还有一个重要的科学原理——格式塔原理。 格式塔原理解释了人们如何以视觉方式感觉物体，以及图像的结构，视角，大小等要素是如何影响我们的视觉的。 在下面这篇文章中，我们首先会简单介绍一下格式塔原理中的基本概念，
  • 线段树-poj1177-N个矩形求边长（离散化+扫描线） bylijinnan 数据结构算法线段树
    package com.ljn.base; import java.util.Arrays; import java.util.Comparator; import java.util.Set; import java.util.TreeSet; /** * POJ 1177 (线段树+离散化+扫描线)，题目链接为http://poj.org/problem?id=1177
  • HTTP协议详解 chicony http协议
    引言                                 
  • Scala设计模式 chenchao051 设计模式scala
    Scala设计模式                我的话： 在国外网站上看到一篇文章，里面详细描述了很多设计模式，并且用Java及Scala两种语言描述，清晰的让我们看到各种常规的设计模式，在Scala中是如何在语言特性层面直接支持的。基于文章很nice，我利用今天的空闲时间将其翻译，希望大家能一起学习，讨论。翻译
  • 安装mysql daizj mysql安装
    安装mysql   (1)删除linux上已经安装的mysql相关库信息。rpm  -e  xxxxxxx   --nodeps (强制删除)      执行命令rpm -qa |grep mysql 检查是否删除干净   (2)执行命令  rpm -i MySQL-server-5.5.31-2.el
  • HTTP状态码大全 dcj3sjt126com http状态码
    完整的 HTTP 1.1规范说明书来自于RFC 2616，你可以在http://www.talentdigger.cn/home/link.php?url=d3d3LnJmYy1lZGl0b3Iub3JnLw%3D%3D在线查阅。HTTP 1.1的状态码被标记为新特性，因为许多浏览器只支持 HTTP 1.0。你应只把状态码发送给支持 HTTP 1.1的客户端，支持协议版本可以通过调用request
  • asihttprequest上传图片 dcj3sjt126com ASIHTTPRequest
    NSURL *url =@"yourURL"; ASIFormDataRequest*currentRequest =[ASIFormDataRequest requestWithURL:url]; [currentRequest setPostFormat:ASIMultipartFormDataPostFormat];[currentRequest se
  • C语言中，关键字static的作用 e200702084 C++cC#
    在C语言中，关键字static有三个明显的作用： 1)在函数体，局部的static变量。生存期为程序的整个生命周期，（它存活多长时间）；作用域却在函数体内（它在什么地方能被访问（空间））。 一个被声明为静态的变量在这一函数被调用过程中维持其值不变。因为它分配在静态存储区，函数调用结束后并不释放单元，但是在其它的作用域的无法访问。当再次调用这个函数时，这个局部的静态变量还存活，而且用在它的访
  • win7/8使用curl geeksun win7
    1.  WIN7/8下要使用curl，需要下载curl-7.20.0-win64-ssl-sspi.zip和Win64OpenSSL_Light-1_0_2d.exe。 下载地址：  http://curl.haxx.se/download.html 请选择不带SSL的版本，否则还需要安装SSL的支持包   2.  可以给Windows增加c
  • Creating a Shared Repository; Users Sharing The Repository hongtoushizi git
    转载自：   http://www.gitguys.com/topics/creating-a-shared-repository-users-sharing-the-repository/ Commands discussed in this section: git init –bare git clone git remote git pull git p
  • Java实现字符串反转的8种或9种方法 Josh_Persistence 异或反转递归反转二分交换反转java字符串反转栈反转
    注：对于第7种使用异或的方式来实现字符串的反转，如果不太看得明白的，可以参照另一篇博客： http://josh-persistence.iteye.com/blog/2205768   /** * */ package com.wsheng.aggregator.algorithm.string; import java.util.Stack; /**
  • 代码实现任意容量倒水问题 home198979 PHP算法倒水
    形象化设计模式实战             HELLO!架构                     redis命令源码解析   倒水问题：有两个杯子，一个A升，一个B升，水有无限多，现要求利用这两杯子装C
  • Druid datasource zhb8015 druid
    推荐大家使用数据库连接池 DruidDataSource. http://code.alibabatech.com/wiki/display/Druid/DruidDataSource DruidDataSource经过阿里巴巴数百个应用一年多生产环境运行验证，稳定可靠。 它最重要的特点是：监控、扩展和性能。 下载和Maven配置看这里： http
  • 两种启动监听器ApplicationListener和ServletContextListener spjich javaspring框架
    引言:有时候需要在项目初始化的时候进行一系列工作，比如初始化一个线程池，初始化配置文件，初始化缓存等等，这时候就需要用到启动监听器，下面分别介绍一下两种常用的项目启动监听器   ServletContextListener  特点: 依赖于sevlet容器，需要配置web.xml 使用方法: public class StartListener implements
  • JavaScript Rounding Methods of the Math object 何不笑 JavaScriptMath
        The next group of methods has to do with rounding decimal values into integers. Three methods — Math.ceil(),  Math.floor(), and  Math.round() — handle rounding in differen
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他