test

Documentation

Index

• Constants
• Variables
• type QosItem

Constants

const (
	QUOTA_VIF_INBOUND_PEAK      = "quota:vif_inbound_peak"
	QUOTA_VIF_INBOUND_BURST     = "quota:vif_inbound_burst"
	QUOTA_VIF_INBOUND_PPS_PEAK  = "quota:vif_inbound_pps_peak"
	QUOTA_VIF_INBOUND_PPS_PEADK = "quota:vif_inbound_pps_burst"

	QUOTA_VIF_OUTBOUND_PEAK     = "quota:vif_outbound_peak"
	QUOTA_VIF_OUTBOUND_BURST    = "quota:vif_outbound_burst"
	QUOTA_VIF_OUTBOUND_PPS_PEAK = "quota:vif_outbound_pps_peak"
	QUOTA_VIF_OUTBOUND_PPS_PEAD = "quota:vif_outbound_pps_burst"
)

const SERVER_FIO_TEST_EXAMPLE = `
1. 测试IOPS:
  skyman test server-fio <server> iops --disk-path /dev/vdb1
`

const SERVER_IPERF3_TEST_EXAMPLE = `` /* 539-byte string literal not displayed */

Variables

var ServerPing = &cobra.Command{
	Use:   "server-ping <SERVER> <CLIENT>",
	Short: "Run ping from server to client",
	Args:  cobra.ExactArgs(2),
	Run: func(cmd *cobra.Command, args []string) {
		client := openstack.DefaultClient()

		interval, _ := cmd.Flags().GetFloat32("interval")
		count, _ := cmd.Flags().GetInt("count")

		serverInstance, err := client.NovaV2().Server().Find(args[0])
		utility.LogError(err, "get server failed", true)
		clientInstance, err := client.NovaV2().Server().Find(args[1])
		utility.LogError(err, "get client failed", true)

		console.Debug("get server host and client host ...")
		serverHost, err := client.NovaV2().Hypervisor().Find(serverInstance.Host)
		utility.LogError(err, "get server host failed", true)

		clientHost, err := client.NovaV2().Hypervisor().Find(clientInstance.Host)
		utility.LogError(err, "get client host failed", true)

		serverGuest := guest.Guest{Connection: serverHost.HostIp, Domain: serverInstance.Id}
		clientGuest := guest.Guest{Connection: clientHost.HostIp, Domain: clientInstance.Id}

		serverAddresses := serverGuest.GetIpaddrs()
		clientAddresses := clientGuest.GetIpaddrs()
		console.Debug("客户端实例IP地址: %s", clientAddresses)
		console.Debug("服务端实例IP地址: %s", serverAddresses)
		if len(clientAddresses) == 0 || len(serverAddresses) == 0 {
			console.Fatal("客户端和服务端实例必须至少有一张启用的网卡")
		}

		var stdout, stderr string
		if count > 0 {
			result := serverGuest.Ping(clientAddresses[0], interval, count, serverAddresses[0], count > 0)
			if result.ErrData != "" {
				fmt.Println(result.ErrData)
				return
			}
			stdout, stderr = result.OutData, result.ErrData

		} else {
			stdout, stderr = serverGuest.WithPing(
				clientAddresses[0], interval, serverAddresses[0],
				func() {
					console.Info("waiting, stop by ctrl+C ...")
					sigCh := make(chan os.Signal, 1)
					signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
					sig := <-sigCh
					console.Info("received signal: %s\n", sig)
				},
			)
		}

		if stderr != "" {
			fmt.Println(color.RedString(stdout))
			os.Exit(1)
		}
		reg := regexp.MustCompile(`(\d+)% +packet +loss`)
		matchedNoLossed := reg.FindAllStringSubmatch(stdout, -1)
		if len(matchedNoLossed) >= 1 && len(matchedNoLossed[0]) >= 2 {
			lossPackage, _ := strconv.Atoi(matchedNoLossed[0][1])
			switch {
			case lossPackage == 0:
				fmt.Println(stdout)
			case lossPackage == 100:
				fmt.Println(color.RedString(stdout))
			default:
				fmt.Println(color.YellowString(stdout))
			}
			return
		}
		fmt.Println(color.RedString(stdout))
	},
}

var TestFio = &cobra.Command{
	Use:     fmt.Sprintf("server-fio <server> <%s>", strings.Join(VALID_TEST_TYPES, "|")),
	Short:   i18n.T("testServerDiskIO"),
	Long:    "基于fio工具测试实例磁盘IO",
	Example: strings.TrimRight(SERVER_FIO_TEST_EXAMPLE, "\n"),
	Args: func(cmd *cobra.Command, args []string) error {
		if err := cobra.ExactArgs(2)(cmd, args); err != nil {
			return err
		}
		testType := args[1]
		if testType == "" || !slice.Contain(VALID_TEST_TYPES, testType) {
			return fmt.Errorf("invalid test type: %s, must be one of %s", testType, VALID_TEST_TYPES)
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		idOrName, testType := args[0], args[1]
		numjobs, _ := cmd.Flags().GetInt("numjobs")
		runtime, _ := cmd.Flags().GetInt("runtime")
		filename, _ := cmd.Flags().GetString("filename")
		size, _ := cmd.Flags().GetString("size")

		openstackClient := openstack.DefaultClient()
		server, err := openstackClient.NovaV2().Server().Find(idOrName)
		utility.LogError(err, "get server failed", true)

		if !server.IsActive() {
			console.Fatal("instance %s is not active", server.Id)
		}

		console.Info("get server host and client host")
		serverHost, err := openstackClient.NovaV2().Hypervisor().Find(server.Host)
		utility.LogError(err, "get server host failed", true)

		serverConn := guest.Guest{Connection: serverHost.HostIp, Domain: server.Id}
		console.Info("start test with QGA")
		testOptsList := []guest.FioOptions{}

		switch testType {
		case "iops":
			testOptsList = append(testOptsList,
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "randwrite", IODepth: 128, BS: "4K"},
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "randread", IODepth: 128, BS: "4K"},
			)
		case "bandwidth":
			testOptsList = append(testOptsList,
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "write", IODepth: 64, BS: "1024k"},
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "read", IODepth: 64, BS: "1024k"})
		case "latency":
			testOptsList = append(testOptsList,
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "randwrite", IODepth: 1, BS: "4k"},
				guest.FioOptions{
					Numjobs: numjobs, Runtime: runtime, Size: size, FileName: filename,
					RW: "randread", IODepth: 1, BS: "4k"},
			)
		}
		for _, opts := range testOptsList {
			console.Info("============= Test %s %s =================", testType, opts.RW)
			job := guest.FioTest{
				Guest: serverConn, Options: opts,
			}
			err = job.Run()
			utility.LogIfError(err, true, "test failed")
		}
	},
}

var TestNetQos = &cobra.Command{
	Use:     "server-iperf3 <server> --client <client>",
	Short:   i18n.T("testServerNetworkQOS"),
	Long:    "基于iperf3工具测试两个虚拟机的网络QOS",
	Example: strings.TrimRight(SERVER_IPERF3_TEST_EXAMPLE, "\n"),
	Args:    cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		server := args[0]
		client, _ := cmd.Flags().GetString("client")

		pps, _ := cmd.Flags().GetBool("pps")
		localIperf3File, _ := cmd.Flags().GetString("iperf3-package")
		serverOptions, _ := cmd.Flags().GetString("server-options")
		cilentOptions, _ := cmd.Flags().GetString("client-options")

		openstackClient := openstack.DefaultClient()
		console.Info("get server and client")
		serverInstance, err := openstackClient.NovaV2().Server().Find(server)
		utility.LogError(err, "get server failed", true)
		clientInstance, err := openstackClient.NovaV2().Server().Find(client)
		utility.LogError(err, "get client failed", true)

		if !serverInstance.IsActive() {
			console.Fatal("instance %s is not active", serverInstance.Id)
		}
		if !clientInstance.IsActive() {
			console.Fatal("instance %s is not active", clientInstance.Id)
		}

		console.Info("get server host and client host")
		serverHost, err := openstackClient.NovaV2().Hypervisor().Find(serverInstance.Host)
		utility.LogError(err, "get server host failed", true)

		clientHost, err := openstackClient.NovaV2().Hypervisor().Find(clientInstance.Host)
		utility.LogError(err, "get client host failed", true)

		serverConn := guest.Guest{Connection: serverHost.HostIp, Domain: serverInstance.Id}
		clientConn := guest.Guest{Connection: clientHost.HostIp, Domain: clientInstance.Id}

		println("服务端QOS配置:")
		printServerQOSItems(*serverInstance)
		println("客户端QOS配置:")
		printServerQOSItems(*clientInstance)

		console.Info("start test with QGA")

		job := guest.NetQosTest{
			ClientGuest:     clientConn,
			ServerGuest:     serverConn,
			PPS:             pps,
			LocalIperf3File: localIperf3File,
			ServerOptions:   serverOptions,
			ClientOptions:   cilentOptions,
		}
		_, _, err = job.Run()
		if err != nil {
			console.Fatal("test failed, %s", err)
		}
	},
}

var TestServerAction = &cobra.Command{
	Use:   "server-actions <TASK FILE> [server]",
	Short: "Test server actions",
	Args: func(cmd *cobra.Command, args []string) error {
		if err := cobra.ExactArgs(1)(cmd, args); err != nil {
			return err
		}
		actions, _ := cmd.Flags().GetString("actions")
		if actions != "" {
			if testActions, err := server_actions.NewActionCountList(actions); err != nil {
				return err
			} else {
				cliActions = testActions
			}
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		testConf, err := common.LoadTaskConfig(args[0])
		if err != nil {
			console.Fatal("load task file %s failed: %s", args[0], err)
		}

		servers, _ := cmd.Flags().GetString("servers")

		web, _ := cmd.Flags().GetBool("web")

		userServers := []string{}
		if servers != "" {
			userServers = strings.Split(servers, ",")
		}

		testCases := []server_actions.Case{}

		client := openstack.DefaultClient()
		console.Info("test on region: %s", utility.OneOfString(client.AuthPlugin.Region(), "RegionOne"))
		if cliActions != nil {
			worker, _ := cmd.Flags().GetInt("worker")
			actionInterval, _ := cmd.Flags().GetInt("action-interval")
			testCase := server_actions.Case{
				Actions:    *cliActions,
				UseServers: userServers,
				Client:     client,
				Config: common.NewActionCaseConfig(common.CaseConfig{
					Workers:        worker,
					ActionInterval: actionInterval,
				}, testConf.Default),
			}
			testCases = append(testCases, testCase)
		} else {
			console.Info("Found %d case(s)", len(testConf.Cases))
			for _, actionCase := range testConf.Cases {
				if actionCase.Skip {
					console.Warn("skip case '%s'", utility.OneOfString(actionCase.Name, actionCase.Actions))
					continue
				}
				acl, err := server_actions.NewActionCountList(actionCase.Actions)
				if err != nil {
					console.Fatal("parse actions '%s' failed, %s", actionCase.Actions, err)
				}
				testCase := server_actions.Case{
					Name:       actionCase.Name,
					UseServers: userServers,
					Actions:    *acl,
					Client:     client,
					Config:     common.NewActionCaseConfig(actionCase.Config, testConf.Default),
				}
				testCases = append(testCases, testCase)
			}
		}
		console.Info("Execute %d case(s)", len(testCases))

		if web {
			go server_actions.RunSimpleWebServer(testConf.Web)
		}

		caseReports := []server_actions.CaseReport{}
		for _, testCase := range testCases {
			testCase.Start()
			caseReports = append(caseReports, testCase.Report())
		}
		server_actions.PrintCaseReports(caseReports)

		if web {
			server_actions.WaitWebServer()
		}
	},
}

var VALID_TEST_TYPES = []string{
	"iops", "bandwidth", "latency",
}

Types

type QosItem

type QosItem struct {
	Position string
	BpsBurst string
	BpsPeak  string
	PPSBurst string
	PPSPeak  string
}