Golang client.NewClient函数代码示例

func collectEvents(cURL *url.URL, dnURL *url.URL, start time.Time, end time.Time) {

	cAdvisorClient, err := client.NewClient(cURL.String())
	if err != nil {
		glog.Errorf("tried to make client and got error %v", err)
		return
	}
	params := "?all_events=true&subcontainers=true&start_time=" + start.Format(time.RFC3339) + "&end_time=" + end.Format(time.RFC3339)
	einfo, err := cAdvisorClient.EventStaticInfo(params)
	if err != nil {
		glog.Errorf("got error retrieving event info: %v", err)
		return
	}

	var dataPoints DataPointList

	// The json returned by the metrics is almost in the proper format. We just need to:
	//     add the container alias
	//     rename "timestamp" to "time"
	//     remove "event_data"
	//     add source_type: event

	for idx, ev := range einfo {
		glog.V(3).Infof("static einfo %v: %v", idx, ev)
		hdr := &DataPointHeader{ev.Timestamp, ev.ContainerName, getContainerAlias(cAdvisorClient, ev.ContainerName), "event", config.DataSource}
		dataPoints = append(dataPoints,
			&EventDataPoint{*hdr, "container_event", ev.EventType},
		)
	}

	sendDataPoints(dataPoints, dnURL)
}

func monitor(address string, requestChannel chan *request, responseChannel chan *response) {

	client, err := cadvisorClient.NewClient(address)

	if err != nil {
		fmt.Print(err.Error())
		return
	}

	containerInfoRequest := info.ContainerInfoRequest{
		NumStats: 1,
	}
	for signal := range requestChannel {

		containerInfo, err := client.ContainerInfo("/", &containerInfoRequest)

		if err != nil {
			fmt.Print(err.Error())
			return
		}

		//	spew.Dump(containerInfo.Stats[0].Memory)
		//	spew.Dump(containerInfo.Stats[0].Cpu)

		responseChannel <- &response{
			memoryStats: containerInfo.Stats[0].Memory,
			cpuStats:    containerInfo.Stats[0].Cpu,
			identifier:  address,
			timestamp:   signal.timestamp,
		}

	}

}

func collectMetrics(cURL *url.URL, dnURL *url.URL, sendToDataNode bool) {

	cAdvisorClient, err := client.NewClient(cURL.String())
	if err != nil {
		glog.Errorf("tried to make cAdvisor client and got error: %v", err)
		return
	}

	request := &info.ContainerInfoRequest{
		NumStats: 1,
	}

	cInfos, err := cAdvisorClient.AllDockerContainers(request)

	if err != nil {
		glog.Errorf("unable to get info on all docker containers: %v", err)
		return
	}

	var dataPoints DataPointList

	for _, info := range cInfos {
		updateContainerAlias(info.Name, getAliasSafely(info.Aliases))
		if sendToDataNode {
			dataPoints = append(dataPoints, allDataPoints(info)...)
		}
	}

	if sendToDataNode {
		glog.Info("Collecting Metrics")
		sendDataPoints(dataPoints, dnURL)
	}
}

func main() {

	if len(os.Args) < 2 {
		log.Fatalf("commad must has one parameters!\n")
		return
	}
	var testingProject = os.Args[1] //"docker"  or  "rkt"
	if testingProject != "docker" && testingProject != "rkt" {
		log.Fatalf("commad is %v %v, is not corrected!\n", os.Args[0], os.Args[1])
		return
	}

	var containers []string
	client, err := client.NewClient("http://localhost:8080/")
	if err != nil {
		log.Fatalf("tried to make client and got error %v\n", err)
		return
	}

	switch testingProject {
	case "docker":
		containers, err = adaptor.GetDockerContainers()
	case "rkt":
		containers, err = adaptor.GetRktContainers()
	default:
		return
	}
	if err != nil {
		log.Fatalf("getContainerName fail, error: %v\n", err)
		return
	}
	//cpuusageinfo := new(CpuUsageInfo)
	mInfo, err := client.MachineInfo()
	var jsonString []byte
	for _, container := range containers {
		fmt.Printf("container %v's cpu info: \n", container)
		cInfo, err := getContainerInfo(client, container)
		if err != nil {
			fmt.Printf("getContainerInfo fail and got error %v\n", err)
			return
		}
		cpuUsageInfo := new(CpuUsageInfo)
		cpuUsageInfo.ContainerID = cInfo.Name
		//fmt.Println(cpuUsageInfo.ContainerID)
		//var usageInfo CpuUsageInfo
		err = getCpu(cInfo, mInfo, cpuUsageInfo)
		fmt.Println(cpuUsageInfo)

		//fmt.Println(usageInfo.ContainerID)
		jsonString, err = json.Marshal(cpuUsageInfo)
		if err != nil {
			log.Fatalf("convert to json err, error:  %v\n", err)
			return
		}

	}
	err = ioutil.WriteFile("./"+testingProject+"_cpu.json", []byte(jsonString), 0666)

}

// Gets a client to the cAdvisor being tested.
func (self *realFramework) Client() *client.Client {
	if self.cadvisorClient == nil {
		cadvisorClient, err := client.NewClient(self.Hostname().FullHostname())
		if err != nil {
			self.t.Fatalf("Failed to instantiate the cAdvisor client: %v", err)
		}
		self.cadvisorClient = cadvisorClient
	}
	return self.cadvisorClient
}

// TODO: move this into the kubelet itself
func MonitorCAdvisor(k *Kubelet, cp uint) {
	defer util.HandleCrash()
	// TODO: Monitor this connection, reconnect if needed?
	glog.V(1).Infof("Trying to create cadvisor client.")
	cadvisorClient, err := cadvisor.NewClient("http://127.0.0.1:" + strconv.Itoa(int(cp)))
	if err != nil {
		glog.Errorf("Error on creating cadvisor client: %v", err)
		return
	}
	glog.V(1).Infof("Successfully created cadvisor client.")
	k.SetCadvisorClient(cadvisorClient)
}

// NewCAdvisor creates an instance of CAdvisor
func NewCAdvisor(url string, numstats int) (*CAdvisor, error) {
	client, err := client.NewClient(url)
	if err != nil {
		return nil, err
	}
	log.Printf("[INFO] [cadvisor] Create cAdvisor client using: %s", url)
	return &CAdvisor{
		Client:   client,
		NumStats: numstats,
		Query:    &info.ContainerInfoRequest{NumStats: numstats},
	}, nil
}

func (self *cadvisorSource) GetAllContainers(host Host, start, end time.Time) (subcontainers []*api.Container, root *api.Container, err error) {
	url := fmt.Sprintf("http://%s:%d/", host.IP, host.Port)
	client, err := cadvisorClient.NewClient(url)
	if err != nil {
		return
	}
	subcontainers, root, err = self.getAllContainers(client, start, end)
	if err != nil {
		glog.Errorf("failed to get stats from cadvisor %q - %v\n", url, err)
	}
	return
}

func main() {

	if len(os.Args) < 2 {
		fmt.Printf("commad must has one parameters!\n")
		return
	}
	var testingProject = os.Args[1] //"docker"  or  "rkt"
	if testingProject != "docker" && testingProject != "rkt" {
		fmt.Printf("commad is %v %v, is not corrected!\n", os.Args[0], os.Args[1])
		return
	}

	var containers []string
	client, err := client.NewClient("http://localhost:8080/")
	if err != nil {
		fmt.Printf("tried to make client and got error %v\n", err)
		return
	}

	switch testingProject {
	case "docker":
		containers, err = adaptor.GetDockerContainers()
	case "rkt":
		containers, err = adaptor.GetRktContainers()
	default:
		return
	}
	if err != nil {
		fmt.Printf("getContainerName fail, error: %v\n", err)
		return
	}

	var jsonString string = ""
	for _, container := range containers {
		//fmt.Printf("container %v's memory info: \n", container)
		cinfo, err := getContainerInfo(client, container)
		if err != nil {
			fmt.Printf("getContainerInfo fail and got error %v\n", err)
			return
		}
		temp, err := getMemory(cinfo)
		if err != nil {
			fmt.Printf("getMemory faile, error: %v\n", err)
		}
		jsonString = jsonString + temp
	}

	err = ioutil.WriteFile("./"+testingProject+"_memory.json", []byte(jsonString), 0666)
	if err != nil {
		fmt.Printf("ioutil.WriteFile faile, error: %v\n", err)
	}
}

func startCadvisorCollector(c *conf.Conf) {
	for _, config := range c.Cadvisor {
		cClient, err := client.NewClient(config.URL)
		if err != nil {
			slog.Warningf("Could not start collector for URL [%s] due to err: %v", config.URL, err)
		}
		collectors = append(collectors, &IntervalCollector{
			F: func() (opentsdb.MultiDataPoint, error) {
				return c_cadvisor(cClient, &config)
			},
			name: "cadvisor",
		})
	}
}

// Get node information from cAdvisor.
func (self *CadvisorSource) GetMachineInfo(host Host) (machineInfo *cadvisor.MachineInfo, err error) {
	url := fmt.Sprintf("http://%s:%d/", host.IP, host.Port)
	client, err := cadvisorClient.NewClient(url)
	if err != nil {
		glog.Errorf("Failed to create cAdvisor client: %s", err)
		return nil, fmt.Errorf("Failed to create cAdvisor client: %s", err)
	}
	machineInfo, err = client.MachineInfo()
	if err != nil {
		glog.Errorf("failed to get stats from cadvisor %q - %v\n", url, err)
		return nil, fmt.Errorf("failed to get stats from cadvisor %q - %v\n", url, err)
	}
	return
}

// Build list of work
func (swc *scrapWorkCache) buildWorkList(URLList []string) {
	for _, serverURL := range URLList {
		cadvisorClient, localERR := client.NewClient(serverURL)
		if localERR != nil {
			glog.Errorf("Failed connect to server: %v\n", localERR)
			continue
		}

		swc.addWork(&scrapWork2{
			serverURL:  serverURL,
			collector:  NewCadvisorCollector(newCadvisorInfoProvider(cadvisorClient), nameToLabel),
			chRecvOnly: make(chan datapoint.Datapoint),
		})
	}
}

func staticClientExample() {
	staticClient, err := client.NewClient("http://localhost:8080/")
	if err != nil {
		glog.Errorf("tried to make client and got error %v", err)
		return
	}
	einfo, err := staticClient.EventStaticInfo("?oom_events=true")
	if err != nil {
		glog.Errorf("got error retrieving event info: %v", err)
		return
	}
	for idx, ev := range einfo {
		glog.Infof("static einfo %v: %v", idx, ev)
	}
}

func main() {
	client, err := client.NewClient("http://localhost:8080/")
	if err != nil {
		fmt.Printf("tried to make client and got error %v", err)
		return
	}

	cinfos, err := GetAllContainer(client)
	if err != nil {
		fmt.Printf("tried to SubcontainersInfo and got error %v", err)
		return
	}
	GetContainerMemoryUsage(cinfos)
	fmt.Printf("\n")
	GetContainerMemoryWorkingSet(cinfos)

}

func streamingClientExample(url string) {
	streamingClient, err := client.NewClient("http://localhost:8080/")
	if err != nil {
		glog.Errorf("tried to make client and got error %v", err)
		return
	}
	einfo := make(chan *info.Event)
	go func() {
		err = streamingClient.EventStreamingInfo(url, einfo)
		if err != nil {
			glog.Errorf("got error retrieving event info: %v", err)
			return
		}
	}()
	for ev := range einfo {
		glog.Infof("streaming einfo: %v\n", ev)
	}
}