Golang NewHandler Examples

Example #1

File: main.go Project: yacloud-io/cf-redis-broker

func main() {
	brokerConfigPath := configPath()

	brokerLogger := lager.NewLogger("redis-broker")
	brokerLogger.RegisterSink(lager.NewWriterSink(os.Stdout, lager.DEBUG))
	brokerLogger.RegisterSink(lager.NewWriterSink(os.Stderr, lager.ERROR))

	brokerLogger.Info("Starting CF Redis broker")

	brokerLogger.Info("Config File: " + brokerConfigPath)

	config, err := brokerconfig.ParseConfig(brokerConfigPath)
	if err != nil {
		brokerLogger.Fatal("Loading config file", err, lager.Data{
			"broker-config-path": brokerConfigPath,
		})
	}

	commandRunner := system.OSCommandRunner{
		Logger: brokerLogger,
	}

	localRepo := redis.NewLocalRepository(config.RedisConfiguration, brokerLogger)

	localRepo.AllInstancesVerbose()

	processController := &redis.OSProcessController{
		CommandRunner:            commandRunner,
		InstanceInformer:         localRepo,
		Logger:                   brokerLogger,
		ProcessChecker:           &process.ProcessChecker{},
		ProcessKiller:            &process.ProcessKiller{},
		PingFunc:                 redis.PingServer,
		WaitUntilConnectableFunc: availability.Check,
	}

	localCreator := &redis.LocalInstanceCreator{
		FindFreePort:            system.FindFreePort,
		RedisConfiguration:      config.RedisConfiguration,
		ProcessController:       processController,
		LocalInstanceRepository: localRepo,
	}

	agentClient := &redis.RemoteAgentClient{
		HttpAuth: config.AuthConfiguration,
	}
	remoteRepo, err := redis.NewRemoteRepository(agentClient, config, brokerLogger)
	if err != nil {
		brokerLogger.Fatal("Error initializing remote repository", err)
	}

	sigChannel := make(chan os.Signal, 1)
	signal.Notify(sigChannel, syscall.SIGTERM)
	go func() {
		<-sigChannel
		brokerLogger.Info("Starting Redis Broker shutdown")
		localRepo.AllInstancesVerbose()
		remoteRepo.StateFromFile()
		os.Exit(0)
	}()

	serviceBroker := &broker.RedisServiceBroker{
		InstanceCreators: map[string]broker.InstanceCreator{
			"shared":    localCreator,
			"dedicated": remoteRepo,
		},
		InstanceBinders: map[string]broker.InstanceBinder{
			"shared":    localRepo,
			"dedicated": remoteRepo,
		},
		Config: config,
	}

	brokerCredentials := brokerapi.BrokerCredentials{
		Username: config.AuthConfiguration.Username,
		Password: config.AuthConfiguration.Password,
	}

	brokerAPI := brokerapi.New(serviceBroker, brokerLogger, brokerCredentials)

	authWrapper := auth.NewWrapper(brokerCredentials.Username, brokerCredentials.Password)
	debugHandler := authWrapper.WrapFunc(debug.NewHandler(remoteRepo))
	instanceHandler := authWrapper.WrapFunc(redisinstance.NewHandler(remoteRepo))

	http.HandleFunc("/instance", instanceHandler)
	http.HandleFunc("/debug", debugHandler)
	http.Handle("/", brokerAPI)

	brokerLogger.Fatal("http-listen", http.ListenAndServe(config.Host+":"+config.Port, nil))
}

Example #2

File: dedicated_locator_test.go Project: nimbus-cloud/cf-redis-broker

			logger.RegisterSink(lager.NewWriterSink(log, lager.DEBUG))

			idLocator = id.DedicatedInstanceIDLocator(endpoint, clientUsername, clientPassword, logger)
			actualInstanceID, instanceIDErr = idLocator.LocateID("", nodeIP)

			expectedURL = fmt.Sprintf("%s?host=%s", endpoint, nodeIP)
		})

		Context("when the broker responds", func() {
			BeforeEach(func() {
				nodeIP = "8.8.8.8"

				authWrapper := auth.NewWrapper(brokerUsername, brokerPassword)

				instanceHandler := authWrapper.WrapFunc(redisinstance.NewHandler(&instanceFinder{
					InstanceID: expectedInstanceID,
					InstanceIP: nodeIP,
				}))

				server = httptest.NewServer(instanceHandler)
				endpoint = server.URL

				clientUsername = brokerUsername
				clientPassword = brokerPassword
			})

			AfterEach(func() {
				server.Close()
			})

			It("does not return an error", func() {
				Expect(instanceIDErr).ToNot(HaveOccurred())

Example #3

File: redisinstance_test.go Project: nimbus-cloud/cf-redis-broker

func (finder fakeInstanceFinder) IDForHost(host string) string {
	return map[string]string{
		"1.2.3.4": "1_2_3_4",
		"9.8.7.6": "9_8_7_6",
	}[host]
}

var _ = Describe("Redisinstance", func() {
	var (
		recorder *httptest.ResponseRecorder
		handler  http.HandlerFunc
	)

	BeforeEach(func() {
		recorder = httptest.NewRecorder()
		handler = redisinstance.NewHandler(fakeInstanceFinder{})
	})

	It("it responds with a 200", func() {
		request, err := http.NewRequest("GET", "http://localhost/instances?host=1.2.3.4", nil)
		Expect(err).NotTo(HaveOccurred())
		handler.ServeHTTP(recorder, request)

		Expect(recorder.Code).To(Equal(http.StatusOK))
	})

	It("returns the correct instance id for the host provided", func() {
		request, err := http.NewRequest("GET", "http://localhost/instances?host=1.2.3.4", nil)
		Expect(err).NotTo(HaveOccurred())
		handler.ServeHTTP(recorder, request)