cmd

Documentation

Index

• Variables
• func Execute()

Variables

var CheckMemCmd = &cobra.Command{
	Use:   "check-mem",
	Short: "Check memory usage",
	Long:  `Check memory usage`,
	Run: func(cmd *cobra.Command, args []string) {
		log.Println("--- Memory Check ---")

		if info, err := monitoring.ReadProcMeminfo(); err == nil {
			log.Println("--- /proc/meminfo ---")
			log.Printf("MemTotal:     %d MiB", info.MemTotal/1024/1024)
			log.Printf("MemFree:      %d MiB", info.MemFree/1024/1024)
			log.Printf("MemAvailable: %d MiB", info.MemAvailable/1024/1024)
			log.Printf("Buffers:      %d MiB", info.Buffers/1024/1024)
			log.Printf("Cached:       %d MiB", info.Cached/1024/1024)
			log.Printf("SwapTotal:    %d MiB", info.SwapTotal/1024/1024)
			log.Printf("SwapFree:     %d MiB", info.SwapFree/1024/1024)
			log.Printf("SwapCached:   %d MiB", info.SwapCached/1024/1024)
			log.Printf("Shmem:        %d MiB", info.Shmem/1024/1024)
			log.Printf("SReclaimable: %d MiB", info.SReclaimable/1024/1024)
			log.Printf("Zswap:        %d MiB", info.Zswap/1024/1024)
			log.Printf("Zswapped:     %d MiB", info.Zswapped/1024/1024)
			log.Println("---------------------")
		}

		printRamInfo := func(info monitoring.RamInfo) {
			log.Printf("[%s] Total: %d bytes (%d MiB), Used: %d bytes (%d MiB)",
				info.Mode,
				info.Total, info.Total/(1024*1024),
				info.Used, info.Used/(1024*1024),
			)
		}

		printRamInfo(monitoring.GetMemHtopLike())
		printRamInfo(monitoring.GetMemGopsutil())
		printRamInfo(monitoring.CallFree())

		log.Println("--- Current Configured ---")
		printRamInfo(monitoring.Ram())
	},
}

var ListDiskCmd = &cobra.Command{
	Use:   "list-disk",
	Short: "List all physical disks",
	Long:  `List all physical disks`,
	Run: func(cmd *cobra.Command, args []string) {
		dl, err := disk.Partitions(true)
		if err != nil {
			log.Println("Failed to get disk partitions:", err)
			return
		}
		log.Println("All Disk Partitions:")
		w := tabwriter.NewWriter(cmd.OutOrStdout(), 0, 0, 2, ' ', 0)
		fmt.Fprintln(w, "Mountpoint\tFstype")
		for _, part := range dl {
			fmt.Fprintf(w, "%s\t%s\n", part.Mountpoint, part.Fstype)
		}
		_ = w.Flush()
		diskList, err := monitoring.DiskList()
		if err != nil {
			log.Println("Failed to get disk list:", err)
			return
		}
		log.Println("Monitoring Mountpoints:", diskList)
	},
}

var RootCmd = &cobra.Command{
	Use:   "Lite-agent",
	Short: "Lite agent",
	Long:  `Lite agent`,
	RunE: func(cmd *cobra.Command, args []string) error {
		if err := loadEffectiveConfig(cmd, flags); err != nil {
			return err
		}
		configureRuntimeMemory()
		if flags.ProtocolVersion == 0 {
			flags.ProtocolVersion = 2
		}
		if err := validateRuntimeConfig(flags); err != nil {
			return err
		}
		if _, err := applySavedAgentToken(); err != nil {
			return fmt.Errorf("load saved node token: %w", err)
		}
		if relocated, err := relocate.RelocateIfNeeded(); err != nil {
			log.Println("layout relocation failed; continuing on the current path:", err)
		} else if relocated {
			log.Println("layout relocation handed off to Lite-agent")
			os.Exit(0)
		}
		if taskLog, err := tasklog.Open(tasklog.PathForConfig(flags.ConfigFile)); err != nil {
			return fmt.Errorf("open task log: %w", err)
		} else {
			server.SetTaskLog(taskLog)
		}
		runtimeconfig.Initialize(runtimeconfig.State{
			MonthRotate:         flags.MonthRotate,
			MonthRotateTime:     flags.MonthRotateTime,
			MonthRotateTimezone: flags.MonthRotateTimezone,
			Interval:            flags.Interval,
			IncludeNics:         flags.IncludeNics,
			ExcludeNics:         flags.ExcludeNics,
			IncludeMountpoints:  flags.IncludeMountpoints,
			MemoryIncludeCache:  flags.MemoryIncludeCache,
			EnableGPU:           flags.EnableGPU,
		})

		stopCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
		defer stop()
		recoverCtx, stopRecover := context.WithCancel(context.Background())
		defer stopRecover()
		go func() {
			<-stopCtx.Done()
			log.Printf("shutting down gracefully...")
			stopRecover()
			netstatic.Stop()
			os.Exit(0)
		}()

		if flags.MonthRotate != 0 {
			err := netstatic.StartOrContinue()
			if err != nil {
				log.Println("Failed to start netstatic monitoring:", err)
			}
			nics, err := monitoring.InterfaceList()
			if err != nil {
				log.Println("Failed to get interface list for netstatic:", err)
			}
			err = netstatic.SetNewConfig(netstatic.NetStaticConfig{
				Nics: nics,
			})
			if err != nil {
				log.Println("Failed to set netstatic config:", err)
			}
		}

		log.Println("Lite Agent", update.CurrentVersion)
		log.Println("Github Repo:", update.Repo)

		if flags.CustomDNS != "" {
			dnsresolver.SetCustomDNSServer(flags.CustomDNS)
			log.Printf("Using custom DNS server: %s", flags.CustomDNS)
		} else {

			log.Printf("Using system default DNS resolver")
		}

		server.StartTaskRecovery(recoverCtx)
		diskList, err := monitoring.DiskList()
		if err != nil {
			log.Println("Failed to get disk list:", err)
		}
		log.Println("Monitoring Mountpoints:", diskList)
		interfaceList, err := monitoring.InterfaceList()
		if err != nil {
			log.Println("Failed to get interface list:", err)
		}
		log.Println("Monitoring Interfaces:", interfaceList)

		if flags.IgnoreUnsafeCert {
			http.DefaultTransport.(*http.Transport).TLSClientConfig = &tls.Config{InsecureSkipVerify: true}
		}

		if flags.DisableAutoUpdate {
			log.Println("Automatic updates are disabled by configuration.")
		} else {
			initialUpdateFailed := false
			if err := update.CheckAndUpdate(); err != nil {
				log.Println("[ERROR]", err)
				initialUpdateFailed = true
			}
			go update.DoUpdateWorks(initialUpdateFailed)
		}
		go server.DoUploadBasicInfoWorks()
		go server.DoRuntimeConfigStateUploadWorks()
		for {
			server.UpdateBasicInfo()
			server.EstablishWebSocketConnection()
		}
	},
}

Functions

func Execute

func Execute()