func (ProxyAwareCreator) CreateReceptorClient(target string) receptor.Client { receptorClient := receptor.NewClient(target) transport := receptorClient.GetClient().Transport httpTransport := transport.(*http.Transport) httpTransport.Proxy = http.ProxyFromEnvironment receptorClient.GetClient().Transport = httpTransport return receptorClient }
func main() { cf_lager.AddFlags(flag.CommandLine) logger, _ = cf_lager.New("desiredlrp-client") flag.Parse() if *action == "" { logger.Fatal("action-required", errors.New("Missing mandatory action parameter")) } receptorClient := receptor.NewClient(*diegoAPIURL) switch *action { case CREATE_ACTION: handleCreate(receptorClient) case DELETE_ACTION: handleDelete(receptorClient) case SCALE_ACTION: handleScale(receptorClient) default: logger.Fatal("unknown-parameter", errors.New(fmt.Sprintf("The command [%s] is not valid", *action))) } }
func NewCliApp() *cli.App { config := config.New(persister.NewFilePersister(config_helpers.ConfigFileLocation(ltcConfigRoot()))) signalChan := make(chan os.Signal) signal.Notify(signalChan, os.Interrupt) exitHandler := exit_handler.New(signalChan, os.Exit) go exitHandler.Run() targetVerifier := target_verifier.New(func(target string) receptor.Client { return receptor.NewClient(target) }) return cli_app_factory.MakeCliApp( diegoVersion, latticeVersion, ltcConfigRoot(), exitHandler, config, logger(), targetVerifier, os.Stdout, ) }
func cliCommands(ltcConfigRoot string, exitHandler exit_handler.ExitHandler, config *config.Config, logger lager.Logger, targetVerifier target_verifier.TargetVerifier, ui terminal.UI) []cli.Command { receptorClient := receptor.NewClient(config.Receptor()) noaaConsumer := noaa.NewConsumer(LoggregatorUrl(config.Loggregator()), nil, nil) appRunner := app_runner.New(receptorClient, config.Target()) clock := clock.NewClock() logReader := logs.NewLogReader(noaaConsumer) tailedLogsOutputter := console_tailed_logs_outputter.NewConsoleTailedLogsOutputter(ui, logReader) taskExaminer := task_examiner.New(receptorClient) taskExaminerCommandFactory := task_examiner_command_factory.NewTaskExaminerCommandFactory(taskExaminer, ui, exitHandler) taskRunner := task_runner.New(receptorClient, taskExaminer) taskRunnerCommandFactory := task_runner_command_factory.NewTaskRunnerCommandFactory(taskRunner, ui, exitHandler) appExaminer := app_examiner.New(receptorClient, app_examiner.NewNoaaConsumer(noaaConsumer)) graphicalVisualizer := graphical.NewGraphicalVisualizer(appExaminer) appExaminerCommandFactory := app_examiner_command_factory.NewAppExaminerCommandFactory(appExaminer, ui, clock, exitHandler, graphicalVisualizer, taskExaminer, config.Target()) appRunnerCommandFactoryConfig := app_runner_command_factory.AppRunnerCommandFactoryConfig{ AppRunner: appRunner, AppExaminer: appExaminer, UI: ui, Domain: config.Target(), Env: os.Environ(), Clock: clock, Logger: logger, TailedLogsOutputter: tailedLogsOutputter, ExitHandler: exitHandler, } appRunnerCommandFactory := app_runner_command_factory.NewAppRunnerCommandFactory(appRunnerCommandFactoryConfig) dockerRunnerCommandFactoryConfig := docker_runner_command_factory.DockerRunnerCommandFactoryConfig{ AppRunner: appRunner, AppExaminer: appExaminer, UI: ui, Domain: config.Target(), Env: os.Environ(), Clock: clock, Logger: logger, ExitHandler: exitHandler, TailedLogsOutputter: tailedLogsOutputter, DockerMetadataFetcher: docker_metadata_fetcher.New(docker_metadata_fetcher.NewDockerSessionFactory()), } dockerRunnerCommandFactory := docker_runner_command_factory.NewDockerRunnerCommandFactory(dockerRunnerCommandFactoryConfig) logsCommandFactory := logs_command_factory.NewLogsCommandFactory(appExaminer, taskExaminer, ui, tailedLogsOutputter, exitHandler) clusterTestRunner := cluster_test.NewClusterTestRunner(config, ltcConfigRoot) clusterTestCommandFactory := cluster_test_command_factory.NewClusterTestCommandFactory(clusterTestRunner) blobStore := blob_store.New(config) blobStoreVerifier := blob_store.NewVerifier(config) dropletRunner := droplet_runner.New(appRunner, taskRunner, config, blobStore, appExaminer) cfIgnore := cf_ignore.New() zipper := &zipper_package.DropletArtifactZipper{} dropletRunnerCommandFactory := droplet_runner_command_factory.NewDropletRunnerCommandFactory(*appRunnerCommandFactory, blobStoreVerifier, taskExaminer, dropletRunner, cfIgnore, zipper, config) configCommandFactory := config_command_factory.NewConfigCommandFactory(config, ui, targetVerifier, blobStoreVerifier, exitHandler) helpCommand := cli.Command{ Name: "help", Aliases: []string{"h"}, Usage: "Shows a list of commands or help for one command", Description: "ltc help", Action: defaultAction, } return []cli.Command{ appExaminerCommandFactory.MakeCellsCommand(), dockerRunnerCommandFactory.MakeCreateAppCommand(), appRunnerCommandFactory.MakeSubmitLrpCommand(), logsCommandFactory.MakeDebugLogsCommand(), appExaminerCommandFactory.MakeListAppCommand(), logsCommandFactory.MakeLogsCommand(), appRunnerCommandFactory.MakeRemoveAppCommand(), appRunnerCommandFactory.MakeScaleAppCommand(), appExaminerCommandFactory.MakeStatusCommand(), taskRunnerCommandFactory.MakeSubmitTaskCommand(), configCommandFactory.MakeTargetCommand(), taskExaminerCommandFactory.MakeTaskCommand(), taskRunnerCommandFactory.MakeDeleteTaskCommand(), taskRunnerCommandFactory.MakeCancelTaskCommand(), clusterTestCommandFactory.MakeClusterTestCommand(), appRunnerCommandFactory.MakeUpdateRoutesCommand(), appRunnerCommandFactory.MakeUpdateCommand(), appExaminerCommandFactory.MakeVisualizeCommand(), dropletRunnerCommandFactory.MakeBuildDropletCommand(), dropletRunnerCommandFactory.MakeListDropletsCommand(), dropletRunnerCommandFactory.MakeLaunchDropletCommand(), dropletRunnerCommandFactory.MakeRemoveDropletCommand(), dropletRunnerCommandFactory.MakeImportDropletCommand(), dropletRunnerCommandFactory.MakeExportDropletCommand(), helpCommand, } }
func configure(logger lager.Logger) (*ssh.ServerConfig, error) { cf_http.Initialize(*communicationTimeout) if *diegoAPIURL == "" { err := errors.New("diegoAPIURL is required") logger.Fatal("diego-api-url-required", err) } url, err := url.Parse(*diegoAPIURL) if err != nil { logger.Fatal("failed-to-parse-diego-api-url", err) } _, err = url.Parse(*ccAPIURL) if *ccAPIURL != "" && err != nil { logger.Fatal("failed-to-parse-cc-api-url", err) } var diegoCreds string if url.User != nil { diegoCreds = url.User.String() } receptorClient := receptor.NewClient(*diegoAPIURL) authenticatorMap := map[string]authenticators.PasswordAuthenticator{} if *enableDiegoAuth { diegoAuthenticator := authenticators.NewDiegoProxyAuthenticator(logger, receptorClient, []byte(diegoCreds)) authenticatorMap[diegoAuthenticator.Realm()] = diegoAuthenticator } if *ccAPIURL != "" && *enableCFAuth { ccClient := cf_http.NewClient() cfAuthenticator := authenticators.NewCFAuthenticator(logger, ccClient, *ccAPIURL, receptorClient) authenticatorMap[cfAuthenticator.Realm()] = cfAuthenticator } authenticator := authenticators.NewCompositeAuthenticator(authenticatorMap) sshConfig := &ssh.ServerConfig{ PasswordCallback: authenticator.Authenticate, AuthLogCallback: func(cmd ssh.ConnMetadata, method string, err error) { logger.Error("authentication-failed", err, lager.Data{"user": cmd.User()}) }, } if *hostKey == "" { err := errors.New("hostKey is required") logger.Fatal("host-key-required", err) } key, err := parsePrivateKey(logger, *hostKey) if err != nil { logger.Fatal("failed-to-parse-host-key", err) } sshConfig.AddHostKey(key) return sshConfig, err }
func MakeReceptorClient(target string) receptor.Client { return receptor.NewClient(target) }
etcdAdapter = etcdRunner.Adapter(nil) legacyBBS = Bbs.NewBBS(etcdAdapter, consulSession, "http://"+receptorTaskHandlerAddress, clock.NewClock(), logger) natsPort = 4051 + GinkgoParallelNode() natsAddress = fmt.Sprintf("127.0.0.1:%d", natsPort) natsClient = diegonats.NewClient() natsGroupProcess = ginkgomon.Invoke(newNatsGroup()) receptorURL := &url.URL{ Scheme: "http", Host: receptorAddress, User: url.UserPassword(username, password), } client = receptor.NewClient(receptorURL.String()) receptorArgs = testrunner.Args{ RegisterWithRouter: true, DomainNames: "example.com", Address: receptorAddress, TaskHandlerAddress: receptorTaskHandlerAddress, EtcdCluster: etcdUrl, Username: username, Password: password, NatsAddresses: natsAddress, NatsUsername: "******", NatsPassword: "******", ConsulCluster: consulRunner.ConsulCluster(), BBSAddress: bbsURL.String(), }
func cliCommands(ltcConfigRoot string, exitHandler exit_handler.ExitHandler, config *config.Config, logger lager.Logger, targetVerifier target_verifier.TargetVerifier, ui terminal.UI) []cli.Command { receptorClient := receptor.NewClient(config.Receptor()) noaaConsumer := noaa.NewConsumer(LoggregatorUrl(config.Loggregator()), nil, nil) appRunner := app_runner.New(receptorClient, config.Target()) clock := clock.NewClock() logReader := logs.NewLogReader(noaaConsumer) tailedLogsOutputter := console_tailed_logs_outputter.NewConsoleTailedLogsOutputter(ui, logReader) taskExaminer := task_examiner.New(receptorClient) taskExaminerCommandFactory := task_examiner_command_factory.NewTaskExaminerCommandFactory(taskExaminer, ui, exitHandler) taskRunner := task_runner.New(receptorClient, taskExaminer) taskRunnerCommandFactory := task_runner_command_factory.NewTaskRunnerCommandFactory(taskRunner, ui, exitHandler) appExaminer := app_examiner.New(receptorClient, app_examiner.NewNoaaConsumer(noaaConsumer)) graphicalVisualizer := graphical.NewGraphicalVisualizer(appExaminer) appExaminerCommandFactory := app_examiner_command_factory.NewAppExaminerCommandFactory(appExaminer, ui, clock, exitHandler, graphicalVisualizer, taskExaminer) appRunnerCommandFactoryConfig := app_runner_command_factory.AppRunnerCommandFactoryConfig{ AppRunner: appRunner, AppExaminer: appExaminer, UI: ui, Domain: config.Target(), Env: os.Environ(), Clock: clock, Logger: logger, TailedLogsOutputter: tailedLogsOutputter, ExitHandler: exitHandler, } appRunnerCommandFactory := app_runner_command_factory.NewAppRunnerCommandFactory(appRunnerCommandFactoryConfig) dockerRunnerCommandFactoryConfig := docker_runner_command_factory.DockerRunnerCommandFactoryConfig{ AppRunner: appRunner, AppExaminer: appExaminer, UI: ui, Domain: config.Target(), Env: os.Environ(), Clock: clock, Logger: logger, ExitHandler: exitHandler, TailedLogsOutputter: tailedLogsOutputter, DockerMetadataFetcher: docker_metadata_fetcher.New(docker_metadata_fetcher.NewDockerSessionFactory()), } dockerRunnerCommandFactory := docker_runner_command_factory.NewDockerRunnerCommandFactory(dockerRunnerCommandFactoryConfig) logsCommandFactory := logs_command_factory.NewLogsCommandFactory(appExaminer, ui, tailedLogsOutputter, exitHandler) configCommandFactory := config_command_factory.NewConfigCommandFactory(config, ui, targetVerifier, exitHandler) testRunner := integration_test.NewIntegrationTestRunner(config, ltcConfigRoot) integrationTestCommandFactory := integration_test_command_factory.NewIntegrationTestCommandFactory(testRunner) s3Auth := aws.Auth{ AccessKey: config.BlobTarget().AccessKey, SecretKey: config.BlobTarget().SecretKey, } s3S3 := s3.New(s3Auth, awsRegion, &http.Client{ Transport: &http.Transport{ Proxy: config.BlobTarget().Proxy(), Dial: (&net.Dialer{ Timeout: 30 * time.Second, KeepAlive: 30 * time.Second, }).Dial, TLSHandshakeTimeout: 10 * time.Second, }, }) blobStore := blob_store.NewBlobStore(config, s3S3) blobBucket := blobStore.Bucket(config.BlobTarget().BucketName) dropletRunner := droplet_runner.New(appRunner, taskRunner, config, blobStore, blobBucket, targetVerifier, appExaminer) cfIgnore := cf_ignore.New() dropletRunnerCommandFactory := droplet_runner_command_factory.NewDropletRunnerCommandFactory(*appRunnerCommandFactory, taskExaminer, dropletRunner, cfIgnore) helpCommand := cli.Command{ Name: "help", Aliases: []string{"h"}, Usage: "Shows a list of commands or help for one command", Description: "ltc help", Action: defaultAction, } return []cli.Command{ appExaminerCommandFactory.MakeCellsCommand(), dockerRunnerCommandFactory.MakeCreateAppCommand(), appRunnerCommandFactory.MakeSubmitLrpCommand(), logsCommandFactory.MakeDebugLogsCommand(), appExaminerCommandFactory.MakeListAppCommand(), logsCommandFactory.MakeLogsCommand(), appRunnerCommandFactory.MakeRemoveAppCommand(), appRunnerCommandFactory.MakeScaleAppCommand(), appExaminerCommandFactory.MakeStatusCommand(), taskRunnerCommandFactory.MakeSubmitTaskCommand(), configCommandFactory.MakeTargetCommand(), configCommandFactory.MakeTargetBlobCommand(), taskExaminerCommandFactory.MakeTaskCommand(), taskRunnerCommandFactory.MakeDeleteTaskCommand(), taskRunnerCommandFactory.MakeCancelTaskCommand(), integrationTestCommandFactory.MakeIntegrationTestCommand(), appRunnerCommandFactory.MakeUpdateRoutesCommand(), appExaminerCommandFactory.MakeVisualizeCommand(), dropletRunnerCommandFactory.MakeBuildDropletCommand(), dropletRunnerCommandFactory.MakeListDropletsCommand(), dropletRunnerCommandFactory.MakeLaunchDropletCommand(), dropletRunnerCommandFactory.MakeRemoveDropletCommand(), helpCommand, } }
func (maker ComponentMaker) ReceptorClient() receptor.Client { return receptor.NewClient("http://" + maker.Addresses.Receptor) }
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()) processGuid = lrp.ProcessGuid }) AfterEach(func() { err := receptorClient.DeleteDesiredLRP(processGuid)