NLB

package
v1.17.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 9, 2024 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	StatusActive   = "Active"
	StatusInactive = "Inactive"
)

Status mappings

Variables

View Source 
var AwsxHostHealthStatusOverTimeCmd = &cobra.Command{
	Use:   "host_health_status_overtime_panel",
	Short: "Get host health status over time metrics data",
	Long:  `Command to get host health status over time metrics data for NLB`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running Host Health Status Over Time Panel")
		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			cmd.Help()
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetHostHealthStatusOverTimePanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting host health status metrics: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxInstanceTypeCountPanelCmd = &cobra.Command{

	Use:   "instance_type_count_panel",
	Short: "get instance type Count data",

	Long: `command to get instance type Count logs data`,

	Run: func(cmd *cobra.Command, args []string) {

		fmt.Println("running from child command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {

			log.Printf("Error during authentication: %v\n", err)

			err := cmd.Help()

			if err != nil {

				return
			}

			return
		}
		if authFlag {
			panel, err := GetInstanceTypeCountData(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)

		}

	},
}
View Source 
var AwsxLoadBalancerAvailabilityByRegionCmd = &cobra.Command{
	Use:   "region_wise_load_balancer_availability_panel",
	Short: "Gets Load Balancers by region",
	Long:  `Command to get AWS Load Balancers (NLB/ALB) by region`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running Load Balancers by Region Command")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, loadBalancerCounts, err := GetLoadBalancersByRegion(clientAuth)
			if err != nil {
				log.Println("Error getting Load Balancers by region: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(loadBalancerCounts)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxLoadBalancerCountPanelCmd = &cobra.Command{
	Use:   "laodbalancer_count_panel",
	Short: "Get NLB load balancer count",
	Long:  `Command to retrieve NLB load balancer count`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running NLB load balancer count panel command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			panel, err := GetNLBCount(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)

		}
	},
}
View Source 
var AwsxNLBActiveConnectionsCmd = &cobra.Command{
	Use:   "nlb_active_connections_panel",
	Short: "Get NLB active connections metrics data",
	Long:  `Command to get NLB active connections metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBActiveConnectionsPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB active connections: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBActiveFlowCountTCPCmd = &cobra.Command{
	Use:   "active_flow_count_tcp_panel",
	Short: "Get NLB active flow count TCP",
	Long:  `Command to get NLB active flow count TCP`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBActiveFlowCountTCP(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB active flow count TCP data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBActiveFlowTCPCountCmd = &cobra.Command{
	Use:   "tcp_active_flow_count_panel",
	Short: "Get NLB TCP active flow  count metrics data",
	Long:  `Command to get NLB TCP active flow count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBActiveFlowCountTCPPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting tcp active flow count count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBAvailabilityTrendCmd = &cobra.Command{
	Use:   "availability_trend_panel",
	Short: "Get  Availability trend metrics data",
	Long:  `Command to get  Availability trend metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBAvailabilityTrend(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB availability trend data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBBackendConnectionsErrorCmd = &cobra.Command{
	Use:   "nlb_backend_connections_error_panel",
	Short: "Get NLB backend connections error metrics data",
	Long:  `Command to get NLB connections error metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetBackendConnectionsErrorPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB client tls negotiation error: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBClientTlsNegotiationErrorCmd = &cobra.Command{
	Use:   "nlb_client_tls_negotiation_error_panel",
	Short: "Get NLB client tls negotiation error metrics data",
	Long:  `Command to get NLB client tls negotiation error metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBClientTLSNegotiationError(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB client tls negotiation error: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBConnectionErrorsCmd = &cobra.Command{
	Use:   "nlb_connection_errors_panel",
	Short: "Get NLB connection errors metrics data",
	Long:  `Command to get NLB connection errors metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBConnectionErrorsData(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB connection errors: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBCountCmd = &cobra.Command{
	Use:   "nlb_count",
	Short: "Get the total number of Network Load Balancers (NLBs)",
	Long:  `Command to get the total number of Network Load Balancers (NLBs) in the region.`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running NLB count command")

		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				log.Printf("Error displaying help: %v\n", err)
			}
			return
		}

		if authFlag {

			nlbCount, err := GetNlbCount(clientAuth)
			if err != nil {
				log.Printf("Error getting NLB count data: %v\n", err)
				return
			}

			fmt.Printf("NLB Count Response: %s\n", nlbCount)
		}
	},
}
View Source 
var AwsxNLBErrorCountCmd = &cobra.Command{
	Use:   "error_count_panel",
	Short: "Get error count data",
	Long:  `Command to get error count data from CloudWatch logs for Network Load Balancers (NLB)`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running error count command")

		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				log.Printf("Error displaying help: %v\n", err)
			}
			return
		}

		if authFlag {

			panel, err := GetNLBErrorCountData(cmd, clientAuth, nil)
			if err != nil {
				log.Printf("Error getting NLB error count data: %v\n", err)
				return
			}
			fmt.Println(panel)
		}
	},
}
View Source 
var AwsxNLBErrorLogCmd = &cobra.Command{

	Use:   "error_log_panel",
	Short: "Get error log logs data",
	Long:  `Command to get error log logs data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running error log panel command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			panel, err := GetNLBErrorLogData(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)
		}
	},
}
View Source 
var AwsxNLBErrorTrackingCmd = &cobra.Command{

	Use:   "nlb_error_tracking_log_panel",
	Short: "Get error tracking  logs data",
	Long:  `Command to get error tracking logs data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running error log panel command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			panel, err := GetNLBErrorTrackingData(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)
		}
	},
}
View Source 
var AwsxNLBFlowCountAnalysisCmd = &cobra.Command{
	Use:   "flow_count_analysis_panel",
	Short: "Get flow count analysis metrics NLB",
	Long:  `Command to get flow count analysis metrics data  for nlb instances with Timestamp`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetNLBFlowCountAnalysis(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting overall availability overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						activeFlowCount := *metricData.MetricDataResults[0].Values[i]
						newFlowCount := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, Active connections: %f, New connections: %f\n", timestamp, activeFlowCount, newFlowCount)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}
View Source 
var AwsxNLBHealthyHostCountCmd = &cobra.Command{
	Use:   "nlb_healthy_host_count",
	Short: "Get Healthy Host Count metrics data",
	Long:  `Command to get Healthy Host Count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBHealthyHostCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB Healthy Host Count: ", err)
				return
			}

			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBNewConnectionsCmd = &cobra.Command{
	Use:   "nlb_new_connections_panel",
	Short: "Get NLB new connections metrics data",
	Long:  `Command to get NLB new connections metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBNewConnectionsPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB new connections: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBNewFlowCountTCPCmd = &cobra.Command{
	Use:   "tcp_new_flow_count_panel",
	Short: "Get NLB TCP new flow count metrics data",
	Long:  `Command to get NLB TCP new flow count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBNewFlowCountTCPPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB TCP target reset count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBNewFlowCountTLSCmd = &cobra.Command{
	Use:   "new_flow_count_tls_panel",
	Short: "Get NLB new flow count TLS metrics data",
	Long:  `Command to get NLB new flow count TLS metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBNewFlowCountTLSPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB new flow count TLS: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBNewFlowTCPCountCmd = &cobra.Command{
	Use:   "new_flow_count_tcp_panel",
	Short: "Get NLB TCP client reset count metrics data",
	Long:  `Command to get NLB TCP client reset count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBNewFlowTCPCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB TCP target reset count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBOverallAvailabilityStatusCmd = &cobra.Command{
	Use:   "overall_availability_status_panel",
	Short: "Get overall avilability status metrics NLB",
	Long:  `Command to get overall availability status metrics data  for nlb instances with Timestamp`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetNLBOverallAvailabilityStatus(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting overall avilability overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						activeFlowCount := *metricData.MetricDataResults[0].Values[i]
						newFlowCount := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, Active connections: %f, New connections: %f\n", timestamp, activeFlowCount, newFlowCount)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}
View Source 
var AwsxNLBProcessedBytesCmd = &cobra.Command{
	Use:   "nlb_processed_bytes_panel",
	Short: "Get NLB processed bytes metrics data",
	Long:  `Command to get NLB processed bytes metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBProcessedBytesPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB processed bytes: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBProcessedPacketsCmd = &cobra.Command{
	Use:   "processed_packets_panel",
	Short: "Get NLB processed packets metrics data",
	Long:  `Command to get NLB processed packets metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBProcessedPacketsPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB processed packets: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBRejectedFlowCountCmd = &cobra.Command{
	Use:   "nlb_client_tls_negotiation_error_panel",
	Short: "Get NLB client tls negotiation error metrics data",
	Long:  `Command to get NLB client tls negotiation error metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBRejectedFlowCount(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB rejected flow count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBSSLTLSNegotiationCmd = &cobra.Command{
	Use:   "nlb_ssl_tls_negotiation_panel",
	Short: "Get NLB SSL/TLS negotiation time metrics data",
	Long:  `Command to get NLB SSL/TLS negotiation time metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			rawData, calculatedData, err := GetSSLTLSNegotiationDataData(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB SSL/TLS negotiation time metrics: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(calculatedData)
			} else {
				fmt.Println(rawData)
			}
		}

	},
}
View Source 
var AwsxNLBTCPClientResetCountCmd = &cobra.Command{
	Use:   "tcp_client_reset_count_panel",
	Short: "Get NLB TCP client reset count metrics data",
	Long:  `Command to get NLB TCP client reset count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTCPClientResetCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB TCP target reset count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBTCPConnectionsCmd = &cobra.Command{
	Use:   "tcp_connections_count_panel",
	Short: "Get TCP Connections Count metrics for NLB instances",
	Long:  `Command to get TCP Connections Count metrics (New Flow Count and Active Flow Count) for NLB instances with Timestamps`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetTCPConnectionsCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting TCP Connections Count overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					if len(metricData.MetricDataResults) < 2 {
						log.Println("Insufficient metric data results")
						continue
					}

					if len(metricData.MetricDataResults[0].Timestamps) == 0 || len(metricData.MetricDataResults[0].Values) == 0 {
						log.Println("No data available for New Flow Count")
						continue
					}

					if len(metricData.MetricDataResults[1].Timestamps) == 0 || len(metricData.MetricDataResults[1].Values) == 0 {
						log.Println("No data available for Active Flow Count")
						continue
					}

					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						if i >= len(metricData.MetricDataResults[0].Values) || i >= len(metricData.MetricDataResults[1].Values) {
							log.Println("Index out of range for values")
							break
						}
						newFlowCount := *metricData.MetricDataResults[0].Values[i]
						activeFlowCount := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, New Flow Count: %f, Active Flow Count: %f\n", timestamp, newFlowCount, activeFlowCount)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}

Cobra command for TCP Connections Count

View Source 
var AwsxNLBTCPElbResetCountCmd = &cobra.Command{
	Use:   "tcp_elb_reset_count_panel",
	Short: "Get NLB TCP elb reset count metrics data",
	Long:  `Command to get NLB TCP elb reset count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTCPElbResetCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB TCP target reset count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBTCPResetCmd = &cobra.Command{
	Use:   "tcp_reset_count_panel",
	Short: "Get TCP Reset Count metrics for NLB instances",
	Long:  `Command to get TCP reset count metrics (ELB Reset Count and Target Reset Count) for NLB instances with Timestamp`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetTCPResetCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting TCP reset count overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					if len(metricData.MetricDataResults) < 2 {
						log.Println("Insufficient metric data results")
						continue
					}

					if len(metricData.MetricDataResults[0].Timestamps) == 0 || len(metricData.MetricDataResults[0].Values) == 0 {
						log.Println("No data available for ELB Reset Count")
						continue
					}

					if len(metricData.MetricDataResults[1].Timestamps) == 0 || len(metricData.MetricDataResults[1].Values) == 0 {
						log.Println("No data available for Target Reset Count")
						continue
					}

					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						if i >= len(metricData.MetricDataResults[0].Values) || i >= len(metricData.MetricDataResults[1].Values) {
							log.Println("Index out of range for values")
							break
						}
						elbResetCount := *metricData.MetricDataResults[0].Values[i]
						targetResetCount := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, ELB Reset Count: %f, Target Reset Count: %f\n", timestamp, elbResetCount, targetResetCount)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}
View Source 
var AwsxNLBTCPResetCountCmd = &cobra.Command{
	Use:   "tcp_target_reset_count_panel",
	Short: "Get NLB TCP target reset count metrics data",
	Long:  `Command to get NLB TCP target reset count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTCPResetCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB TCP target reset count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBTargetCountCmd = &cobra.Command{
	Use:   "target_count",
	Short: "Get target count data for all NLBs",
	Long:  `Command to get the total number of targets across all Network Load Balancers (NLBs) in the region`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running target count command")

		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				log.Printf("Error displaying help: %v\n", err)
			}
			return
		}

		if authFlag {

			jsonResponse, err := GetNLBTargetCountData(cmd, clientAuth)
			if err != nil {
				log.Printf("Error getting NLB target count data: %v\n", err)
				return
			}

			fmt.Println(jsonResponse)
		}
	},
}
View Source 
var AwsxNLBTargetGroupCountCmd = &cobra.Command{
	Use:   "target_count",
	Short: "Get target count data for all NLBs",
	Long:  `Command to get the total number of targets and target group names across all Network Load Balancers (NLBs) in the region`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running target count command")

		authFlag, clientAuth, err := authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				log.Printf("Error displaying help: %v\n", err)
			}
			return
		}

		if authFlag {

			jsonResponse, err := GetNLBTargetGroupCountData(cmd, clientAuth)
			if err != nil {
				log.Printf("Error getting NLB target count data: %v\n", err)
				return
			}

			fmt.Println(jsonResponse)
		}
	},
}
View Source 
var AwsxNLBTargetHealthCheckCmd = &cobra.Command{

	Use:   "target_health_check_configuration_panel",
	Short: "Get target health check configuration logs data",
	Long:  `Command to get target health check configuration logs data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running target health check configuration panel command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			panel, err := GetNLBTargetHealthCheckData(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)
		}
	},
}
View Source 
var AwsxNLBTargetHealthChecksCmd = &cobra.Command{
	Use:   "nlb_target_health_checks_panel",
	Short: "Get NLB target health checks metrics data",
	Long:  `Command to get NLB target health checks metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTargetHealthCheckPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB target health check data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNLBTargetHealthOverviewCmd = &cobra.Command{
	Use:   "target_group_health_overview_panel",
	Short: "Get NLB target health checks metrics data",
	Long:  `Command to get NLB target health checks metrics data for the last 6 months`,
	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			_, cloudwatchMetricResp, err := GetNLBTargetHealthOverviewPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB target health check data: ", err)
				return
			}
			fmt.Println(cloudwatchMetricResp)
		}
	},
}
View Source 
var AwsxNLBTargetStatussCmd = &cobra.Command{
	Use:   "new_target_status_panel",
	Short: "Retrieve target status metrics data",
	Long:  `Command to retrieve target status metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		authFlag, clientAuth, err := handleAuths(cmd)
		if err != nil {
			log.Println("Error during authentication:", err)
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			targetStatuses, printresp, err := GetTargetStatussPanel(clientAuth)
			if err != nil {
				log.Println("Error getting target status:", err)
				return
			}

			if responseType == "frame" {
				fmt.Println(targetStatuses)
			} else {
				fmt.Println(printresp)
			}
		}
	},
}
View Source 
var AwsxNLBTcpProcesedBytesCmd = &cobra.Command{
	Use:   "tcp_procesed_bytes_panel",
	Short: "Get NLB tcp procesed bytes",
	Long:  `Command to get NLB procesed bytes`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTcpProcesedBytes(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB tcp procesed bytes data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBTlsActiveConnectionCmd = &cobra.Command{
	Use:   "tls_active_connection_panel",
	Short: "Get NLB active connection",
	Long:  `Command to get NLB active connection`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTlsActiveConnection(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB tls new connection data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBTlsNewConnectionCmd = &cobra.Command{
	Use:   "tls_new_connection_panel",
	Short: "Get NLB new connection",
	Long:  `Command to get NLB new connection`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTlsNewConnectionPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB tls new connection data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBTotalRequestCmd = &cobra.Command{
	Use:   "total_request_panel",
	Short: "Get Processed Bytes metrics data",
	Long:  `Command to get Processed Bytes metrics data for Network Load Balancer`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command...")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			cmd.Help()
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBTotalRequest(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB processed bytes data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNLBTrafficTrendsCmd = &cobra.Command{
	Use:   "traffic_trend_panel",
	Short: "Get Traffic Trend metrics for NLB instances",
	Long:  `Command to get Traffic Trend metrics (ProcessedBytesTCP and ProcessedBytesTLS) for NLB instances with Timestamps`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetTrafficTrendPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting Traffic Trend overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					if len(metricData.MetricDataResults) < 2 {
						log.Println("Insufficient metric data results")
						continue
					}

					if len(metricData.MetricDataResults[0].Timestamps) == 0 || len(metricData.MetricDataResults[0].Values) == 0 {
						log.Println("No data available for ProcessedBytesTCP")
						continue
					}

					if len(metricData.MetricDataResults[1].Timestamps) == 0 || len(metricData.MetricDataResults[1].Values) == 0 {
						log.Println("No data available for ProcessedBytesTLS")
						continue
					}

					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						if i >= len(metricData.MetricDataResults[0].Values) || i >= len(metricData.MetricDataResults[1].Values) {
							log.Println("Index out of range for values")
							break
						}
						processedBytesTCP := *metricData.MetricDataResults[0].Values[i]
						processedBytesTLS := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, ProcessedBytesTCP: %f, ProcessedBytesTLS: %f\n", timestamp, processedBytesTCP, processedBytesTLS)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}
View Source 
var AwsxNLBUnhealthyHostCountCmd = &cobra.Command{
	Use:   "nlb_unhealthy_host_count_panel",
	Short: "Get NLB unhealthy host count metrics data",
	Long:  `Command to get NLB unhealthy host count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running from child command..")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetNLBUnhealthyHostCountPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting NLB unhealthy host count: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {

				fmt.Println(jsonResp)
			}
		}

	},
}
View Source 
var AwsxNlbPortAllocationErrorCountCmd = &cobra.Command{
	Use:   "port_allocation_error_count_panel",
	Short: "get port allocation error count metrics data",
	Long:  `command to get target tls count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("running from child command")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetPortAllocationErrorCountData(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting nlb target tls response data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNlbTargetErrorCountCmd = &cobra.Command{
	Use:   "target_error_count_panel",
	Short: "get target error count metrics data",
	Long:  `command to get target count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("running from child command")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetTargetErrorCountData(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting nlb target response data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxNlbTargetTlsErrorCountCmd = &cobra.Command{
	Use:   "target_tls_negotiation_error_count_panel",
	Short: "get target tls error count metrics data",
	Long:  `command to get target tls count metrics data`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("running from child command")
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			jsonResp, cloudwatchMetricResp, err := GetTargetTlsErrorCountData(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting nlb target tls response data: ", err)
				return
			}
			if responseType == "frame" {
				fmt.Println(cloudwatchMetricResp)
			} else {
				fmt.Println(jsonResp)
			}
		}
	},
}
View Source 
var AwsxSecurityGroupCmd = &cobra.Command{
	Use:   "security_group_panel",
	Short: "Retrieve security group configurations",
	Long:  `Command to retrieve security group configurations`,

	Run: func(cmd *cobra.Command, args []string) {
		authFlag, clientAuth, err := handleAuth(cmd)
		if err != nil {
			log.Println("Error during authentication:", err)
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			securityGroups, printresp, err := GetSecurityGroupConfigurations(clientAuth)
			if err != nil {
				log.Println("Error getting security group configurations:", err)
				return
			}

			if responseType == "frame" {
				fmt.Println(securityGroups)
			} else {
				fmt.Println(printresp)
			}
		}
	},
}
View Source 
var AwsxTargetDeregistrationsCmd = &cobra.Command{
	Use:   "target_deregistration_panel",
	Short: "Get target deregistration panel",
	Long:  `Command to retrieve target deregistration panel`,

	Run: func(cmd *cobra.Command, args []string) {
		fmt.Println("Running target deregistration command")

		var authFlag bool
		var clientAuth *model.Auth
		var err error
		authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)

		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}
		if authFlag {
			panel, err := GetTargetDeregistrationspanel(cmd, clientAuth, nil)
			if err != nil {
				return
			}
			fmt.Println(panel)

		}
	},
}
View Source 
var AwsxTcpFlowAnalysisCmd = &cobra.Command{
	Use:   "tcp_flow_analysis_panel",
	Short: "Get tcp flow analysis metrics for RDS instances",
	Long:  `Command to get tcp flow analysis metrics data (ActiveFlowCount_TCP  and NewFlowCount_TCP ) for NLB instances with Timestamp`,

	Run: func(cmd *cobra.Command, args []string) {
		var authFlag, clientAuth, err = authenticate.AuthenticateCommand(cmd)
		if err != nil {
			log.Printf("Error during authentication: %v\n", err)
			err := cmd.Help()
			if err != nil {
				return
			}
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			_, cloudwatchMetricResp, err := GetTcpFlowAnalysisPanel(cmd, clientAuth, nil)
			if err != nil {
				log.Println("Error getting data transfer overview: ", err)
				return
			}

			if responseType == "frame" {
				for _, metricData := range cloudwatchMetricResp {
					if len(metricData.MetricDataResults) < 2 {
						log.Println("Insufficient metric data results")
						continue
					}

					if len(metricData.MetricDataResults[0].Timestamps) == 0 || len(metricData.MetricDataResults[0].Values) == 0 {
						log.Println("No data available for ActiveFlowCount_TCP")
						continue
					}

					if len(metricData.MetricDataResults[1].Timestamps) == 0 || len(metricData.MetricDataResults[1].Values) == 0 {
						log.Println("No data available for NewFlowCount_TCP")
						continue
					}

					for i, timestamp := range metricData.MetricDataResults[0].Timestamps {
						if i >= len(metricData.MetricDataResults[0].Values) || i >= len(metricData.MetricDataResults[1].Values) {
							log.Println("Index out of range for values")
							break
						}
						activeConnections := *metricData.MetricDataResults[0].Values[i]
						newConnections := *metricData.MetricDataResults[1].Values[i]
						fmt.Printf("Timestamp: %v, ActiveFlowCount_TCP: %f, NewFlowCount_TCP: %f\n", timestamp, activeConnections, newConnections)
					}
				}
			} else {
				fmt.Println("Invalid response type. Use 'frame' for output.")
			}
		}
	},
}
View Source 
var NLBAlarmAndNotificationCmd = &cobra.Command{
	Use:   "nlb_alerts_and_notifications_panel",
	Short: "Retrieve recent alerts and notifications related to NLB",
	Long:  `Command to retrieve recent alerts and notifications related to NLB availability and health`,

	Run: func(cmd *cobra.Command, args []string) {
		authFlag, clientAuth, err := handleAuth(cmd)
		if err != nil {
			log.Println("Error during authentication:", err)
			return
		}

		if authFlag {
			responseType, _ := cmd.PersistentFlags().GetString("responseType")
			notifications, err := GetNLBAlertsAndNotificationsPanel(cmd, clientAuth)
			if err != nil {
				log.Println("Error getting NLB alerts and notifications:", err)
				return
			}

			if responseType == "frame" {
				fmt.Println(notifications)
			} else {

			}
		}
	},
}

Functions

func GetBackendConnectionsErrorPanel added in v1.12.6 

func GetBackendConnectionsErrorPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetHostHealthStatusOverTimePanel added in v1.12.6 

func GetHostHealthStatusOverTimePanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetInstanceTypeCountData added in v1.12.6 

func GetInstanceTypeCountData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetLoadBalancersByRegion added in v1.12.6 

func GetLoadBalancersByRegion(clientAuth *model.Auth) (string, map[string]interface{}, error)

func GetNLBActiveConnectionsPanel 

func GetNLBActiveConnectionsPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBActiveFlowCountTCP added in v1.11.7 

func GetNLBActiveFlowCountTCP(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBActiveFlowCountTCPPanel added in v1.12.6 

func GetNLBActiveFlowCountTCPPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBAvailabilityTrend added in v1.12.6 

func GetNLBAvailabilityTrend(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBClientTLSNegotiationError added in v1.12.6 

func GetNLBClientTLSNegotiationError(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBConnectionErrorsData added in v1.10.5 

func GetNLBConnectionErrorsData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBConnectionErrorsMetricData added in v1.10.5 

func GetNLBConnectionErrorsMetricData(clientAuth *model.Auth, loadBalancerArn string, startTime, endTime *time.Time, cloudWatchClient *cloudwatch.CloudWatch) (*cloudwatch.GetMetricDataOutput, error)

func GetNLBCount added in v1.11.7 

func GetNLBCount(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetNLBErrorCountData added in v1.12.6 

func GetNLBErrorCountData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

GetNLBErrorCountData retrieves error count data from CloudWatch logs for NLBs

func GetNLBErrorLogData 

func GetNLBErrorLogData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetNLBErrorTrackingData added in v1.12.6 

func GetNLBErrorTrackingData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetNLBFlowCountAnalysis added in v1.12.6 

func GetNLBFlowCountAnalysis(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBHealthyHostCountPanel added in v1.10.6 

func GetNLBHealthyHostCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBNewConnectionsPanel 

func GetNLBNewConnectionsPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBNewFlowCountTCPPanel added in v1.12.6 

func GetNLBNewFlowCountTCPPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBNewFlowCountTLSMetricData added in v1.10.6 

func GetNLBNewFlowCountTLSMetricData(clientAuth *model.Auth, instanceId, elementType string, startTime, endTime *time.Time, statistic string, cloudWatchClient *cloudwatch.CloudWatch) (*cloudwatch.GetMetricDataOutput, error)

func GetNLBNewFlowCountTLSPanel added in v1.10.6 

func GetNLBNewFlowCountTLSPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBNewFlowTCPCountPanel added in v1.11.7 

func GetNLBNewFlowTCPCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBOverallAvailabilityStatus added in v1.12.6 

func GetNLBOverallAvailabilityStatus(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBProcessedBytesPanel added in v1.10.6 

func GetNLBProcessedBytesPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBProcessedPacketsPanel added in v1.10.6 

func GetNLBProcessedPacketsPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBRejectedFlowCount added in v1.12.6 

func GetNLBRejectedFlowCount(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTCPClientResetCountPanel added in v1.11.7 

func GetNLBTCPClientResetCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTCPElbResetCountPanel added in v1.11.7 

func GetNLBTCPElbResetCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTCPResetCountPanel added in v1.10.6 

func GetNLBTCPResetCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTargetCountData added in v1.12.6 

func GetNLBTargetCountData(cmd *cobra.Command, clientAuth *model.Auth) (string, error)

GetNLBTargetCountData retrieves the target count data for all NLBs and calculates the total count of targets

func GetNLBTargetGroupCountData added in v1.12.6 

func GetNLBTargetGroupCountData(cmd *cobra.Command, clientAuth *model.Auth) (string, error)

GetNLBTargetCountData retrieves the target count data, target group names, target details, and timestamp for all NLBs

func GetNLBTargetHealthCheckData 

func GetNLBTargetHealthCheckData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetNLBTargetHealthCheckMetricData added in v1.10.6 

func GetNLBTargetHealthCheckMetricData(clientAuth *model.Auth, instanceId string, startTime, endTime *time.Time, metricName, statistic string, cloudWatchClient *cloudwatch.CloudWatch) (*cloudwatch.GetMetricDataOutput, error)

func GetNLBTargetHealthCheckPanel added in v1.10.6 

func GetNLBTargetHealthCheckPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTargetHealthOverviewData added in v1.12.6 

func GetNLBTargetHealthOverviewData(clientAuth *model.Auth, instanceId string, startTime, endTime *time.Time, metricName, statistic string, cloudWatchClient *cloudwatch.CloudWatch) (*cloudwatch.GetMetricDataOutput, error)

func GetNLBTcpProcesedBytes added in v1.11.7 

func GetNLBTcpProcesedBytes(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTlsActiveConnection added in v1.11.7 

func GetNLBTlsActiveConnection(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTlsNewConnectionPanel added in v1.11.9 

func GetNLBTlsNewConnectionPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBTotalRequest added in v1.12.6 

func GetNLBTotalRequest(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNLBUnhealthyHostCountPanel added in v1.10.6 

func GetNLBUnhealthyHostCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetNlbCount added in v1.12.6 

func GetNlbCount(clientAuth *model.Auth) (string, error)

GetNlbCount retrieves the total number of Network Load Balancers (NLBs)

func GetPortAllocationErrorCountData added in v1.10.9 

func GetPortAllocationErrorCountData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetSSLTLSNegotiationDataData added in v1.10.6 

func GetSSLTLSNegotiationDataData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetSSLTLSNegotiationDataMetricData added in v1.10.6 

func GetSSLTLSNegotiationDataMetricData(clientAuth *model.Auth, lbID, elementType string, startTime, endTime *time.Time, cloudWatchClient *cloudwatch.CloudWatch) (*cloudwatch.GetMetricDataOutput, error)

func GetTCPConnectionsCountPanel added in v1.12.6 

func GetTCPConnectionsCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

Function to get TCP Connections Count metrics

func GetTCPResetCountPanel added in v1.12.6 

func GetTCPResetCountPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetTargetDeregistrationspanel added in v1.10.5 

func GetTargetDeregistrationspanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchLogs *cloudwatchlogs.CloudWatchLogs) ([]*cloudwatchlogs.GetQueryResultsOutput, error)

func GetTargetErrorCountData added in v1.10.6 

func GetTargetErrorCountData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetTargetTlsErrorCountData added in v1.10.9 

func GetTargetTlsErrorCountData(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetTcpFlowAnalysisPanel added in v1.12.6 

func GetTcpFlowAnalysisPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func GetTrafficTrendPanel added in v1.12.6 

func GetTrafficTrendPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, map[string]*cloudwatch.GetMetricDataOutput, error)

func ProcessQueriesResult added in v1.12.6 

func ProcessQueriesResult(results []*cloudwatchlogs.GetQueryResultsOutput) []*cloudwatchlogs.GetQueryResultsOutput

func ProcessQueryResult 

func ProcessQueryResult(results []*cloudwatchlogs.GetQueryResultsOutput) []*cloudwatchlogs.GetQueryResultsOutput

func ProcessQueryResults 

func ProcessQueryResults(results []*cloudwatchlogs.GetQueryResultsOutput) []*cloudwatchlogs.GetQueryResultsOutput

Types

type ConnectionErrorsResult added in v1.10.5 

type ConnectionErrorsResult struct {
	ConnectionErrors []TimeSeriesData `json:"ConnectionErrors"`
}

type FlowCountAnalysis added in v1.12.6 

type FlowCountAnalysis struct {
	Timestamp         time.Time
	ActiveConnections float64
	NewConnections    float64
}

type MonthlyHealthCount added in v1.12.6 

type MonthlyHealthCount struct {
	Month          string  `json:"month"`
	HealthyCount   float64 `json:"healthy_count"`
	UnhealthyCount float64 `json:"unhealthy_count"`
}

func GetNLBTargetHealthOverviewPanel added in v1.12.6 

func GetNLBTargetHealthOverviewPanel(cmd *cobra.Command, clientAuth *model.Auth, cloudWatchClient *cloudwatch.CloudWatch) (string, []MonthlyHealthCount, error)

type NLBAlarmNotification added in v1.12.6 

type NLBAlarmNotification struct {
	Timestamp   time.Time `json:"Timestamp"`
	AlertType   string    `json:"AlertType"`
	Description string    `json:"Description"`
	Severity    string    `json:"Severity"`
	Status      string    `json:"Status"`
}

func GetNLBAlertsAndNotificationsPanel added in v1.12.6 

func GetNLBAlertsAndNotificationsPanel(cmd *cobra.Command, clientAuth *model.Auth) ([]NLBAlarmNotification, error)

type NLBMetricResult added in v1.12.6 

type NLBMetricResult struct {
	Value     float64   `json:"Value"`
	Timestamp time.Time `json:"Timestamp"`
}

type NLBTargetCount added in v1.12.6 

type NLBTargetCount struct {
	NumberOfTargets int `json:"number_of_targets"` // Updated field name for clarity
}

Struct to hold the target count and associated target group info

type NLBTargetGroupCount added in v1.12.6 

type NLBTargetGroupCount struct {
	NumberOfTargets  int            `json:"number_of_targets"`  // Number of total targets
	TargetGroupNames []string       `json:"target_group_names"` // Names of the target groups
	TargetDetails    []TargetDetail `json:"target_details"`     // Details of each target (container, IP, lambda, etc.)
	Timestamp        string         `json:"timestamp"`          // Timestamp when the data was retrieved
}

Struct to hold the target count, target group info, target details, and timestamp

type NewFlowCountTLSData added in v1.10.6 

type NewFlowCountTLSData struct {
	NewFlowCountTLS []struct {
		Timestamp time.Time
		Value     float64
	} `json:"NewFlowCountTLS"`
}

type NlbCountResponse added in v1.12.6 

type NlbCountResponse struct {
	NlbCount int `json:"nlb_count"`
}

Structure to hold the NLB count response

type OverallAvailabilityStatus added in v1.12.6 

type OverallAvailabilityStatus struct {
	Timestamp         time.Time
	ActiveConnections float64
	NewConnections    float64
}

type SSLTLSNegotiationData added in v1.10.6 

type SSLTLSNegotiationData struct {
	Timestamp             time.Time
	SSLTLSNegotiationData float64
}

type SSLTLSNegotiationDataa added in v1.10.6 

type SSLTLSNegotiationDataa struct {
	SSLTLSNegotiationData []SSLTLSNegotiationData `json:"SSLTLSNegotiationData"`
}

type SecurityGroupInfo added in v1.10.5 

type SecurityGroupInfo struct {
	GroupID       string
	InboundRules  string
	OutboundRules string
}

func DescribeSecurityGroups added in v1.10.5 

func DescribeSecurityGroups(clientAuth *model.Auth) ([]SecurityGroupInfo, error)

func GetSecurityGroupConfigurations added in v1.10.5 

func GetSecurityGroupConfigurations(clientAuth *model.Auth) ([]SecurityGroupInfo, string, error)

type TCPConnectionsCountResult added in v1.12.6 

type TCPConnectionsCountResult struct {
	Timestamp       time.Time
	NewFlowCount    float64
	ActiveFlowCount float64
}

Define the struct for TCP Connections Count results

type TCPResetCountResult added in v1.12.6 

type TCPResetCountResult struct {
	Timestamp        time.Time
	ELBResetCount    float64
	TargetResetCount float64
}

type TargetDetail added in v1.12.6 

type TargetDetail struct {
	TargetType string `json:"target_type"` // The type of target (IP, instance, Lambda, etc.)
	Target     string `json:"target"`      // The target itself (IP address, Instance ID, Lambda ARN)
	Status     string `json:"status"`      // Status of the target (healthy, unhealthy, etc.)
}

Struct to hold details of individual targets (IP, Instance, Lambda, etc.)

type TargetHealthCheckData added in v1.10.6 

type TargetHealthCheckData struct {
	HostCount map[string][]struct {
		Timestamp time.Time
		Value     float64
	} `json:"HostCount"`
}

type TargetStatuss 

type TargetStatuss struct {
	TargetID     string
	TargetHealth string
	Reason       string // Reason field added
	Region       string // Region field added
}

func GetNLBTargetStatus 

func GetNLBTargetStatus(clientAuth *model.Auth) ([]TargetStatuss, error)

func GetTargetStatussPanel 

func GetTargetStatussPanel(clientAuth *model.Auth) ([]TargetStatuss, string, error)

type TcpFlowAnalysisResult added in v1.12.6 

type TcpFlowAnalysisResult struct {
	Timestamp           time.Time
	ActiveFlowCount_TCP float64
	NewFlowCount_TCP    float64
}

type TimeSeriesData added in v1.10.5 

type TimeSeriesData struct {
	Timestamp time.Time
	Count     float64
}

type TrafficTrendResult added in v1.12.6 

type TrafficTrendResult struct {
	Timestamp         time.Time
	ProcessedBytesTCP float64
	ProcessedBytesTLS float64
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.