Golang Controller.ConfigureServer方法代码示例

func configureServer(controller confab.Controller, agentClient *agent.Client, timeout confab.Timeout) {
	rpcClient, err := consulagent.NewRPCClient("localhost:8400")

	if err != nil {
		stderr.Printf("error connecting to RPC server: %s", err)
		exit(controller, 1)
	}

	agentClient.ConsulRPCClient = &agent.RPCClient{*rpcClient}
	err = controller.ConfigureServer(timeout)
	if err != nil {
		stderr.Printf("error configuring server: %s", err)
		exit(controller, 1)
	}
}

func main() {
	flagSet := flag.NewFlagSet("flags", flag.ContinueOnError)
	flagSet.BoolVar(&isServer, "server", false, "whether to start the agent in server mode")
	flagSet.StringVar(&agentPath, "agent-path", "", "path to the on-filesystem consul `executable`")
	flagSet.StringVar(&consulConfigDir, "consul-config-dir", "", "path to consul configuration `directory`")
	flagSet.StringVar(&pidFile, "pid-file", "", "path to consul PID `file`")
	flagSet.Var(&expectedMembers, "expected-member", "address `list` of the expected members")
	flagSet.Var(&encryptionKeys, "encryption-key", "`key` used to encrypt consul traffic")

	if len(os.Args) < 2 {
		printUsageAndExit("invalid number of arguments", flagSet)
	}

	command := os.Args[1]
	if !validCommand(command) {
		printUsageAndExit(fmt.Sprintf("invalid COMMAND %q", command), flagSet)
	}

	flagSet.Parse(os.Args[2:])

	path, err := exec.LookPath(agentPath)
	if err != nil {
		printUsageAndExit(fmt.Sprintf("\"agent-path\" %q cannot be found", agentPath), flagSet)
	}

	if len(pidFile) == 0 {
		printUsageAndExit("\"pid-file\" cannot be empty", flagSet)
	}

	if command == "start" {
		_, err = os.Stat(consulConfigDir)
		if err != nil {
			printUsageAndExit(fmt.Sprintf("\"consul-config-dir\" %q could not be found", consulConfigDir), flagSet)
		}

		if len(expectedMembers) == 0 {
			printUsageAndExit("at least one \"expected-member\" must be provided", flagSet)
		}

		agentRunner := confab.AgentRunner{
			Path:      path,
			PIDFile:   pidFile,
			ConfigDir: consulConfigDir,
			Stdout:    os.Stdout,
			Stderr:    os.Stderr,
		}
		consulAPIClient, err := api.NewClient(api.DefaultConfig())
		if err != nil {
			panic(err) // not tested, NewClient never errors
		}

		agentClient := confab.AgentClient{
			ExpectedMembers: expectedMembers,
			ConsulAPIAgent:  consulAPIClient.Agent(),
			ConsulRPCClient: nil,
		}

		controller := confab.Controller{
			AgentRunner:    &agentRunner,
			AgentClient:    &agentClient,
			MaxRetries:     10,
			SyncRetryDelay: 1 * time.Second,
			SyncRetryClock: clock.NewClock(),
			EncryptKeys:    encryptionKeys,
			SSLDisabled:    false,
			Logger:         stdout,
		}

		err = controller.BootAgent()
		if err != nil {
			stderr.Printf("error booting consul agent: %s", err)
			os.Exit(1)
		}

		if !isServer {
			return
		}
		rpcClient, err := agent.NewRPCClient("localhost:8400")
		if err != nil {
			stderr.Printf("error connecting to RPC server: %s", err)
			os.Exit(1)
		}
		agentClient.ConsulRPCClient = &confab.RPCClient{
			*rpcClient,
		}

		err = controller.ConfigureServer()
		if err != nil {
			stderr.Printf("error connecting to RPC server: %s", err)
			os.Exit(1) // not tested; it is challenging with the current fake agent.
		}
	}

	if command == "stop" {
		agentRunner := confab.AgentRunner{
			Path:      path,
			PIDFile:   pidFile,
			ConfigDir: "",
			Stdout:    os.Stdout,
			Stderr:    os.Stderr,
//.........这里部分代码省略.........

			It("swallows the error", func() {
				Expect(controller.StopAgent()).To(Succeed())
				Expect(agentRunner.WaitCall.CallCount).To(Equal(1))
			})

			It("logs the error", func() {
				Expect(controller.StopAgent()).To(Succeed())
				Expect(logBuffer.String()).To(ContainSubstring("wait error"))
			})
		})
	})

	Describe("ConfigureServer", func() {
		It("does not launch the consul agent", func() {
			Expect(controller.ConfigureServer()).To(Succeed())
			Expect(agentRunner.RunCalls.CallCount).To(Equal(0))
		})

		It("does not check that the agent has joined a cluster", func() {
			Expect(controller.ConfigureServer()).To(Succeed())
			Expect(agentClient.VerifyJoinedCalls.CallCount).To(Equal(0))
		})

		Context("when it is not the last node in the cluster", func() {
			It("does not check that it is synced", func() {
				Expect(controller.ConfigureServer()).To(Succeed())
				Expect(agentClient.VerifySyncedCalls.CallCount).To(Equal(0))
			})
		})

					{
						Action: "controller.stop-agent.cleanup.failed",
						Error:  errors.New("cleanup error"),
					},
					{
						Action: "controller.stop-agent.success",
					},
				}))
			})
		})
	})

	Describe("ConfigureServer", func() {
		Context("when it is not the last node in the cluster", func() {
			It("does not check that it is synced", func() {
				Expect(controller.ConfigureServer(confab.NewTimeout(make(chan time.Time)))).To(Succeed())
				Expect(agentClient.VerifySyncedCalls.CallCount).To(Equal(0))
				Expect(agentRunner.WritePIDCall.CallCount).To(Equal(1))
				Expect(logger.Messages).To(ContainSequence([]fakes.LoggerMessage{
					{
						Action: "controller.configure-server.is-last-node",
					},
					{
						Action: "controller.configure-server.set-keys",
						Data: []lager.Data{{
							"keys": []string{"key 1", "key 2", "key 3"},
						}},
					},
					{
						Action: "controller.configure-server.success",
					},