func runTest(
t *testing.T,
f func(t *testing.T, apiClient pps.ApiClient),
) {
storeClient, err := getRethinkClient()
require.NoError(t, err)
pfstesting.RunTest(
t,
func(t *testing.T, apiClient pfs.ApiClient, internalApiClient pfs.InternalApiClient) {
grpctest.Run(
t,
testNumServers,
func(servers map[string]*grpc.Server) {
for _, server := range servers {
pps.RegisterApiServer(server, newAPIServer(apiClient, storeClient, timing.NewSystemTimer()))
}
},
func(t *testing.T, clientConns map[string]*grpc.ClientConn) {
var clientConn *grpc.ClientConn
for _, c := range clientConns {
clientConn = c
break
}
f(
t,
pps.NewApiClient(
clientConn,
),
)
},
)
},
)
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
rethinkClient, err := getRethinkClient(appEnv.DatabaseAddress, appEnv.DatabaseName)
if err != nil {
return err
}
apiClient, err := getPfsAPIClient(appEnv.PfsAddress)
if err != nil {
return err
}
return grpcutil.GrpcDo(
appEnv.APIPort,
appEnv.TracePort,
pachyderm.Version,
func(s *grpc.Server) {
pps.RegisterApiServer(s, server.NewAPIServer(apiClient, rethinkClient, timing.NewSystemTimer()))
},
)
}
func do() error {
runtime.GOMAXPROCS(runtime.NumCPU())
appEnv := &appEnv{}
if err := env.Populate(appEnv, env.PopulateOptions{}); err != nil {
return err
}
//address := fmt.Sprintf("0.0.0.0:%d", appEnv.APIPort)
s := grpc.NewServer(grpc.MaxConcurrentStreams(math.MaxUint32))
pps.RegisterApiServer(s, server.NewAPIServer(store.NewInMemoryClient()))
listener, err := net.Listen("tcp", fmt.Sprintf(":%d", appEnv.APIPort))
if err != nil {
return err
}
errC := make(chan error)
go func() { errC <- s.Serve(listener) }()
//go func() { errC <- http.ListenAndServe(":8080", nil) }()
if appEnv.TracePort != 0 {
go func() { errC <- http.ListenAndServe(fmt.Sprintf(":%d", appEnv.TracePort), nil) }()
}
return <-errC
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
containerClient, err := getContainerClient(appEnv.DockerHost)
if err != nil {
return err
}
rethinkClient, err := getRethinkClient(appEnv.DatabaseAddress, appEnv.DatabaseName)
if err != nil {
return err
}
pfsAddress := appEnv.PachydermPfsd1Port
if pfsAddress == "" {
pfsAddress = appEnv.PfsAddress
} else {
pfsAddress = strings.Replace(pfsAddress, "tcp://", "", -1)
}
clientConn, err := grpc.Dial(pfsAddress, grpc.WithInsecure())
if err != nil {
return err
}
// TODO(pedge): no!
trace.AuthRequest = func(_ *http.Request) (bool, bool) {
return true, true
}
return protoserver.Serve(
uint16(appEnv.Port),
func(s *grpc.Server) {
pps.RegisterApiServer(s, server.NewAPIServer(pfs.NewApiClient(clientConn), containerClient, rethinkClient, timing.NewSystemTimer()))
},
protoserver.ServeOptions{
DebugPort: uint16(appEnv.DebugPort),
Version: pachyderm.Version,
},
)
}
