Golang receptor.Client類代碼示例

func sshPermissionsFromProcess(
	processGuid string,
	index int,
	receptorClient receptor.Client,
	remoteAddr net.Addr,
) (*ssh.Permissions, error) {
	actual, err := receptorClient.ActualLRPByProcessGuidAndIndex(processGuid, index)
	if err != nil {
		return nil, err
	}

	desired, err := receptorClient.GetDesiredLRP(processGuid)
	if err != nil {
		return nil, err
	}

	sshRoute, err := getRoutingInfo(&desired)
	if err != nil {
		return nil, err
	}

	logMessage := fmt.Sprintf("Successful remote access by %s", remoteAddr.String())

	return createPermissions(sshRoute, &actual, desired.LogGuid, logMessage, index)
}

func TaskStatePoller(receptorClient receptor.Client, taskGuid string, task *receptor.TaskResponse) func() string {
	return func() string {
		rTask, err := receptorClient.GetTask(taskGuid)
		Expect(err).NotTo(HaveOccurred())

		*task = rTask

		return task.State
	}
}

func handleDelete(receptorClient receptor.Client) {
	if *processGuid == "" {
		logger.Fatal("missing-processGuid", errors.New("Missing mandatory processGuid parameter for delete action"))
	}

	err := receptorClient.DeleteDesiredLRP(*processGuid)
	if err != nil {
		logger.Error("failed-to-delete", err, lager.Data{"process-guid": *processGuid})
		return
	}
	fmt.Printf("Desired LRP successfully deleted for process guid %s\n", *processGuid)
}

func LRPInstanceStatePoller(receptorClient receptor.Client, processGuid string, index int, lrp *receptor.ActualLRPResponse) func() receptor.ActualLRPState {
	return func() receptor.ActualLRPState {
		lrpInstance, err := receptorClient.ActualLRPByProcessGuidAndIndex(processGuid, index)
		Expect(err).NotTo(HaveOccurred())

		if lrp != nil {
			*lrp = lrpInstance
		}

		return lrpInstance.State
	}
}

func ActiveActualLRPs(receptorClient receptor.Client, processGuid string) []receptor.ActualLRPResponse {
	lrps, err := receptorClient.ActualLRPsByProcessGuid(processGuid)
	Expect(err).NotTo(HaveOccurred())

	startedLRPs := make([]receptor.ActualLRPResponse, 0, len(lrps))
	for _, l := range lrps {
		if l.State != receptor.ActualLRPStateUnclaimed {
			startedLRPs = append(startedLRPs, l)
		}
	}

	return startedLRPs
}

func handleScale(receptorClient receptor.Client) {
	if *processGuid == "" {
		logger.Fatal("missing-processGuid", errors.New("Missing mandatory processGuid parameter for scale action"))
	}

	updatePayload := receptor.DesiredLRPUpdateRequest{
		Instances: numberOfInstances,
	}
	err := receptorClient.UpdateDesiredLRP(*processGuid, updatePayload)
	if err != nil {
		logger.Error("failed-to-scale", err, lager.Data{"process-guid": *processGuid, "update-request": updatePayload})
		return
	}
	fmt.Printf("LRP %s scaled to number of instances %d\n", *processGuid, *numberOfInstances)
}

func LRPStatePoller(receptorClient receptor.Client, processGuid string, lrp *receptor.ActualLRPResponse) func() receptor.ActualLRPState {
	return func() receptor.ActualLRPState {
		lrps, err := receptorClient.ActualLRPsByProcessGuid(processGuid)
		Expect(err).NotTo(HaveOccurred())

		if len(lrps) == 0 {
			return receptor.ActualLRPStateInvalid
		}

		if lrp != nil {
			*lrp = lrps[0]
		}

		return lrps[0].State
	}
}

func handleCreate(receptorClient receptor.Client) {
	newProcessGuid, err := uuid.NewV4()
	if err != nil {
		logger.Error("failed-generate-guid", err)
		return
	}
	route := tcpRoute{
		ExternalPort:  uint16(*externalPort),
		ContainerPort: uint16(*containerPort),
	}
	routes := []tcpRoute{route}
	data, err := json.Marshal(routes)
	if err != nil {
		logger.Error("failed-to-marshal", err)
		return
	}
	routingInfo := json.RawMessage(data)
	lrp := receptor.DesiredLRPCreateRequest{
		ProcessGuid: newProcessGuid.String(),
		LogGuid:     "log-guid",
		Domain:      "ge",
		Instances:   1,
		Setup: &models.SerialAction{
			Actions: []models.Action{
				&models.RunAction{
					Path: "sh",
					User: "vcap",
					Args: []string{
						"-c",
						"curl https://s3.amazonaws.com/router-release-blobs/tcp-sample-receiver.linux -o /tmp/tcp-sample-receiver && chmod +x /tmp/tcp-sample-receiver",
					},
				},
			},
		},
		Action: &models.ParallelAction{
			Actions: []models.Action{
				&models.RunAction{
					Path: "sh",
					User: "vcap",
					Args: []string{
						"-c",
						fmt.Sprintf("/tmp/tcp-sample-receiver -address 0.0.0.0:%d -serverId %s", *containerPort, *serverId),
						// fmt.Sprintf("nc -l -k %d > /tmp/output", *containerPort),
					},
				},
			},
		},
		Monitor: &models.RunAction{
			Path: "sh",
			User: "vcap",
			Args: []string{
				"-c",
				fmt.Sprintf("nc -z 0.0.0.0 %d", *containerPort),
			}},
		StartTimeout: 60,
		RootFS:       "preloaded:cflinuxfs2",
		MemoryMB:     128,
		DiskMB:       128,
		Ports:        []uint16{uint16(*containerPort)},
		Routes: receptor.RoutingInfo{
			"tcp-router": &routingInfo,
		},
		EgressRules: []models.SecurityGroupRule{
			{
				Protocol:     models.TCPProtocol,
				Destinations: []string{"0.0.0.0-255.255.255.255"},
				Ports:        []uint16{80, 443},
			},
			{
				Protocol:     models.UDPProtocol,
				Destinations: []string{"0.0.0.0/0"},
				PortRange: &models.PortRange{
					Start: 53,
					End:   53,
				},
			},
		},
	}
	err = receptorClient.CreateDesiredLRP(lrp)
	if err != nil {
		logger.Error("failed-create", err, lager.Data{"LRP": lrp})
	} else {
		fmt.Printf("Successfully created LRP with process guid %s\n", newProcessGuid)
	}
}

func UpsertInigoDomain(receptorClient receptor.Client) {
	err := receptorClient.UpsertDomain(defaultDomain, 0)
	Expect(err).NotTo(HaveOccurred())
}

			}, 20*time.Second, 1*time.Second).ShouldNot(HaveOccurred())

			conn1, response1 := sendAndReceive(address)
			conn2, response2 := sendAndReceive(address)
			Expect(response1).ShouldNot(Equal(response2))

			err := conn1.Close()
			Expect(err).ShouldNot(HaveOccurred())
			err = conn2.Close()
			Expect(err).ShouldNot(HaveOccurred())
		})
	})

	Describe("LRP with TCP routing requirements is desired", func() {
		var (
			receptorClient receptor.Client
			processGuid    string
		)

		BeforeEach(func() {

			receptorClient = receptor.NewClient(routerApiConfig.DiegoAPIURL)

			externalPort = 62000 + GinkgoParallelNode()
			sampleReceiverPort1 = 8000 + GinkgoParallelNode()
			serverId1 = fmt.Sprintf("serverId-%d", GinkgoParallelNode())

			lrp := helpers.CreateDesiredLRP(logger,
				uint16(externalPort), uint16(sampleReceiverPort1), serverId1, 1)

			err := receptorClient.CreateDesiredLRP(lrp)
			Expect(err).ShouldNot(HaveOccurred())