func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
address := appEnv.PachydermPfsd1Port
if address == "" {
address = appEnv.PfsAddress
} else {
address = strings.Replace(address, "tcp://", "", -1)
}
return dockervolume.Serve(
dockervolume.NewVolumeDriverHandler(
newVolumeDriver(
func() (fuse.Mounter, error) {
clientConn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
return nil, err
}
return fuse.NewMounter(
pfs.NewApiClient(
clientConn,
),
), nil
},
appEnv.BaseMountpoint,
),
dockervolume.VolumeDriverHandlerOptions{},
),
dockervolume.ProtocolUnix,
volumeDriverName,
volumeDriverGroup,
)
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
discoveryClient, err := getEtcdClient()
if err != nil {
return err
}
sharder := route.NewSharder(appEnv.NumShards, appEnv.NumReplicas)
addresser := route.NewDiscoveryAddresser(
discoveryClient,
sharder,
"namespace",
)
return addresser.AssignRoles(nil)
}
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,
},
)
}
func init() {
logrus.Register()
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
address := appEnv.PachydermPfsd1Port
if address == "" {
address = appEnv.Address
} else {
address = strings.Replace(address, "tcp://", "", -1)
}
clientConn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
return err
}
apiClient := pfs.NewApiClient(clientConn)
var shard int
var modulus int
createRepo := cobramainutil.Command{
Use: "create-repo repo-name",
Short: "Create a new repo.",
Long: "Create a new repo.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.CreateRepo(apiClient, args[0])
},
}.ToCobraCommand()
inspectRepo := cobramainutil.Command{
Use: "inspect-repo repo-name",
Short: "Return info about a repo.",
Long: "Return info about a repo.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
repoInfo, err := pfsutil.InspectRepo(apiClient, args[0])
if err != nil {
return err
}
if repoInfo == nil {
return fmt.Errorf("repo %s not found", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintRepoHeader(writer)
pretty.PrintRepoInfo(writer, repoInfo)
return writer.Flush()
},
}.ToCobraCommand()
listRepo := cobramainutil.Command{
Use: "list-repo",
Short: "Return all repos.",
Long: "Reutrn all repos.",
NumArgs: 0,
Run: func(cmd *cobra.Command, args []string) error {
repoInfos, err := pfsutil.ListRepo(apiClient)
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintRepoHeader(writer)
for _, repoInfo := range repoInfos {
pretty.PrintRepoInfo(writer, repoInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
deleteRepo := cobramainutil.Command{
Use: "delete-repo repo-name",
Short: "Delete a repo.",
Long: "Delete a repo.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.DeleteRepo(apiClient, args[0])
},
}.ToCobraCommand()
startCommit := cobramainutil.Command{
Use: "start-commit repo-name parent-commit-id",
Short: "Start a new commit.",
Long: "Start a new commit with parent-commit-id as the parent.",
NumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
commit, err := pfsutil.StartCommit(apiClient, args[0], args[1])
if err != nil {
return err
}
fmt.Println(commit.Id)
return nil
},
}.ToCobraCommand()
finishCommit := cobramainutil.Command{
Use: "finish-commit repo-name commit-id",
Short: "Finish a started commit.",
Long: "Finish a started commit. Commit-id must be a writeable commit.",
NumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.FinishCommit(apiClient, args[0], args[1])
},
}.ToCobraCommand()
inspectCommit := cobramainutil.Command{
Use: "inspect-commit repo-name commit-id",
Short: "Return info about a commit.",
Long: "Return info about a commit.",
NumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
commitInfo, err := pfsutil.InspectCommit(apiClient, args[0], args[1])
if err != nil {
return err
}
if commitInfo == nil {
return fmt.Errorf("commit %s not found", args[1])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintCommitInfoHeader(writer)
pretty.PrintCommitInfo(writer, commitInfo)
return writer.Flush()
},
}.ToCobraCommand()
listCommit := cobramainutil.Command{
Use: "list-commit repo-name",
Short: "Return all commits on a repo.",
Long: "Return all commits on a repo.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
commitInfos, err := pfsutil.ListCommit(apiClient, args[0])
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintCommitInfoHeader(writer)
for _, commitInfo := range commitInfos {
pretty.PrintCommitInfo(writer, commitInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
deleteCommit := cobramainutil.Command{
Use: "delete-commit repo-name commit-id",
Short: "Delete a commit.",
Long: "Delete a commit.",
NumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.DeleteCommit(apiClient, args[0], args[1])
},
}.ToCobraCommand()
putBlock := cobramainutil.Command{
Use: "put-block repo-name commit-id path/to/file",
Short: "Put a block from stdin",
Long: "Put a block from stdin. Directories must exist. commit-id must be a writeable commit.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
block, err := pfsutil.PutBlock(apiClient, args[0], args[1], args[2], os.Stdin)
if err != nil {
return err
}
fmt.Println(block.Hash)
return nil
},
}.ToCobraCommand()
getBlock := cobramainutil.Command{
Use: "get-block hash",
Short: "Return the contents of a block.",
Long: "Return the contents of a block.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.GetBlock(apiClient, args[0], os.Stdout)
},
}.ToCobraCommand()
inspectBlock := cobramainutil.Command{
Use: "inspect-block hash",
Short: "Return info about a block.",
Long: "Return info about a block.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
blockInfo, err := pfsutil.InspectBlock(apiClient, args[0])
if err != nil {
return err
}
if blockInfo == nil {
return fmt.Errorf("block %s not found", args[2])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintBlockInfoHeader(writer)
pretty.PrintBlockInfo(writer, blockInfo)
return writer.Flush()
},
}.ToCobraCommand()
listBlock := cobramainutil.Command{
Use: "list-block",
Short: "Return the blocks in a directory.",
Long: "Return the blocks in a directory.",
NumArgs: 0,
Run: func(cmd *cobra.Command, args []string) error {
blockInfos, err := pfsutil.ListBlock(apiClient, uint64(shard), uint64(modulus))
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintBlockInfoHeader(writer)
for _, blockInfo := range blockInfos {
pretty.PrintBlockInfo(writer, blockInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
listBlock.Flags().IntVarP(&shard, "shard", "s", 0, "shard to read from")
listBlock.Flags().IntVarP(&modulus, "modulus", "m", 1, "modulus of the shards")
mkdir := cobramainutil.Command{
Use: "mkdir repo-name commit-id path/to/dir",
Short: "Make a directory.",
Long: "Make a directory. Parent directories need not exist.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.MakeDirectory(apiClient, args[0], args[1], args[2])
},
}.ToCobraCommand()
putFile := cobramainutil.Command{
Use: "put-file repo-name commit-id path/to/file",
Short: "Put a file from stdin",
Long: "Put a file from stdin. Directories must exist. commit-id must be a writeable commit.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
_, err := pfsutil.PutFile(apiClient, args[0], args[1], args[2], 0, os.Stdin)
return err
},
}.ToCobraCommand()
getFile := cobramainutil.Command{
Use: "get-file repo-name commit-id path/to/file",
Short: "Return the contents of a file.",
Long: "Return the contents of a file.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.GetFile(apiClient, args[0], args[1], args[2], 0, math.MaxInt64, os.Stdout)
},
}.ToCobraCommand()
inspectFile := cobramainutil.Command{
Use: "inspect-file repo-name commit-id path/to/file",
Short: "Return info about a file.",
Long: "Return info about a file.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
fileInfo, err := pfsutil.InspectFile(apiClient, args[0], args[1], args[2])
if err != nil {
return err
}
if fileInfo == nil {
return fmt.Errorf("file %s not found", args[2])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintFileInfoHeader(writer)
pretty.PrintFileInfo(writer, fileInfo)
return writer.Flush()
},
}.ToCobraCommand()
listFile := cobramainutil.Command{
Use: "list-file repo-name commit-id path/to/dir",
Short: "Return the files in a directory.",
Long: "Return the files in a directory.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
fileInfos, err := pfsutil.ListFile(apiClient, args[0], args[1], args[2], uint64(shard), uint64(modulus))
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintFileInfoHeader(writer)
for _, fileInfo := range fileInfos {
pretty.PrintFileInfo(writer, fileInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
listFile.Flags().IntVarP(&shard, "shard", "s", 0, "shard to read from")
listFile.Flags().IntVarP(&modulus, "modulus", "m", 1, "modulus of the shards")
deleteFile := cobramainutil.Command{
Use: "delete-file repo-name commit-id path/to/file",
Short: "Delete a file.",
Long: "Delete a file.",
NumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
return pfsutil.DeleteFile(apiClient, args[0], args[1], args[2])
},
}.ToCobraCommand()
listChange := cobramainutil.Command{
Use: "list-change repo-name commit-id path/to/dir",
Short: "Return the changes in a directory.",
Long: "Return the changes in a directory.",
NumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
changeInfos, err := pfsutil.ListChange(apiClient, args[0], args[1], args[2], uint64(shard), uint64(modulus))
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintChangeHeader(writer)
for _, changeInfo := range changeInfos {
pretty.PrintChange(writer, changeInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
listChange.Flags().IntVarP(&shard, "shard", "s", 0, "shard to read from")
listChange.Flags().IntVarP(&modulus, "modulus", "m", 1, "modulus of the shards")
inspectServer := cobramainutil.Command{
Use: "inspect-server server-id",
Short: "Inspect a server.",
Long: "Inspect a server.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
serverInfo, err := pfsutil.InspectServer(apiClient, args[0])
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintServerInfoHeader(writer)
pretty.PrintServerInfo(writer, serverInfo)
return writer.Flush()
},
}.ToCobraCommand()
listServer := cobramainutil.Command{
Use: "list-server",
Short: "Return all servers in the cluster.",
Long: "Return all servers in the cluster.",
NumArgs: 0,
Run: func(cmd *cobra.Command, args []string) error {
serverInfos, err := pfsutil.ListServer(apiClient)
if err != nil {
return err
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintServerInfoHeader(writer)
for _, serverInfo := range serverInfos {
pretty.PrintServerInfo(writer, serverInfo)
}
return writer.Flush()
},
}.ToCobraCommand()
mount := cobramainutil.Command{
Use: "mount mountpoint repo-name [commit-id]",
Short: "Mount a repo as a local file system.",
Long: "Mount a repo as a local file system.",
MinNumArgs: 2,
MaxNumArgs: 3,
Run: func(cmd *cobra.Command, args []string) error {
mountPoint := args[0]
repo := args[1]
commitID := ""
if len(args) == 3 {
commitID = args[2]
}
mounter := fuse.NewMounter(apiClient)
if err := mounter.Mount(repo, commitID, mountPoint, uint64(shard), uint64(modulus)); err != nil {
return err
}
return mounter.Wait(mountPoint)
},
}.ToCobraCommand()
mount.Flags().IntVarP(&shard, "shard", "s", 0, "shard to read from")
mount.Flags().IntVarP(&modulus, "modulus", "m", 1, "modulus of the shards")
rootCmd := &cobra.Command{
Use: "pfs",
Long: `Access the PFS API.
Note that this CLI is experimental and does not even check for common errors.
The environment variable PFS_ADDRESS controls what server the CLI connects to, the default is 0.0.0.0:650.`,
}
rootCmd.AddCommand(protoclient.NewVersionCommand(clientConn, pachyderm.Version, nil))
rootCmd.AddCommand(createRepo)
rootCmd.AddCommand(inspectRepo)
rootCmd.AddCommand(listRepo)
rootCmd.AddCommand(deleteRepo)
rootCmd.AddCommand(startCommit)
rootCmd.AddCommand(finishCommit)
rootCmd.AddCommand(inspectCommit)
rootCmd.AddCommand(listCommit)
rootCmd.AddCommand(deleteCommit)
rootCmd.AddCommand(mkdir)
rootCmd.AddCommand(putBlock)
rootCmd.AddCommand(getBlock)
rootCmd.AddCommand(inspectBlock)
rootCmd.AddCommand(listBlock)
rootCmd.AddCommand(putFile)
rootCmd.AddCommand(getFile)
rootCmd.AddCommand(inspectFile)
rootCmd.AddCommand(listFile)
rootCmd.AddCommand(deleteFile)
rootCmd.AddCommand(listChange)
rootCmd.AddCommand(inspectServer)
rootCmd.AddCommand(listServer)
rootCmd.AddCommand(mount)
return rootCmd.Execute()
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
address := appEnv.PachydermPpsd1Port
if address == "" {
address = appEnv.Address
} else {
address = strings.Replace(address, "tcp://", "", -1)
}
clientConn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
return err
}
apiClient := pps.NewApiClient(clientConn)
var protoFlag bool
inspectCmd := cobramainutil.Command{
Use: "inspect github.com/user/repository [path/to/specDir]",
Long: "Inspect a pipeline specification.",
MinNumArgs: 1,
MaxNumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
githubPipelineSource, err := getGithubPipelineSource(args)
if err != nil {
return err
}
pipelineSource, err := apiClient.CreatePipelineSource(
context.Background(),
&pps.CreatePipelineSourceRequest{
PipelineSource: &pps.PipelineSource{
TypedPipelineSource: &pps.PipelineSource_GithubPipelineSource{
GithubPipelineSource: githubPipelineSource,
},
},
},
)
if err != nil {
return err
}
pipeline, err := apiClient.CreateAndGetPipeline(
context.Background(),
&pps.CreateAndGetPipelineRequest{
PipelineSourceId: pipelineSource.Id,
},
)
if err != nil {
return err
}
if protoFlag {
fmt.Printf("%v\n", pipeline)
} else {
data, err := json.MarshalIndent(pipeline, "", "\t ")
if err != nil {
return err
}
fmt.Println(string(data))
}
return nil
},
}.ToCobraCommand()
inspectCmd.Flags().BoolVar(&protoFlag, "proto", false, "Print in proto format instead of JSON.")
startCmd := cobramainutil.Command{
Use: "start github.com/user/repository [path/to/specDir]",
Long: "Start a pipeline specification run.",
MinNumArgs: 1,
MaxNumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
githubPipelineSource, err := getGithubPipelineSource(args)
if err != nil {
return err
}
pipelineSource, err := apiClient.CreatePipelineSource(
context.Background(),
&pps.CreatePipelineSourceRequest{
PipelineSource: &pps.PipelineSource{
TypedPipelineSource: &pps.PipelineSource_GithubPipelineSource{
GithubPipelineSource: githubPipelineSource,
},
},
},
)
if err != nil {
return err
}
pipeline, err := apiClient.CreateAndGetPipeline(
context.Background(),
&pps.CreateAndGetPipelineRequest{
PipelineSourceId: pipelineSource.Id,
},
)
if err != nil {
return err
}
pipelineRun, err := apiClient.CreatePipelineRun(
context.Background(),
&pps.CreatePipelineRunRequest{
PipelineId: pipeline.Id,
},
)
if err != nil {
return err
}
_, err = apiClient.StartPipelineRun(
context.Background(),
&pps.StartPipelineRunRequest{
PipelineRunId: pipelineRun.Id,
},
)
if err != nil {
return err
}
fmt.Println(pipelineRun.Id)
return nil
},
}.ToCobraCommand()
statusCmd := cobramainutil.Command{
Use: "status pipelineRunID",
Long: "Get the status of a pipeline run.",
NumArgs: 1,
Run: func(cmd *cobra.Command, args []string) error {
pipelineRunStatuses, err := apiClient.GetPipelineRunStatus(
context.Background(),
&pps.GetPipelineRunStatusRequest{
PipelineRunId: args[0],
},
)
if err != nil {
return err
}
pipelineRunStatus := pipelineRunStatuses.PipelineRunStatus[0]
name, ok := pps.PipelineRunStatusType_name[int32(pipelineRunStatus.PipelineRunStatusType)]
if !ok {
return fmt.Errorf("unknown run status")
}
fmt.Printf("%s %s\n", args[0], strings.Replace(name, "PIPELINE_RUN_STATUS_TYPE_", "", -1))
return nil
},
}.ToCobraCommand()
logsCmd := cobramainutil.Command{
Use: "logs pipelineRunID [node]",
Long: "Get the logs from a pipeline run.",
MinNumArgs: 1,
MaxNumArgs: 2,
Run: func(cmd *cobra.Command, args []string) error {
node := ""
if len(args) == 2 {
node = args[1]
}
pipelineRunLogs, err := apiClient.GetPipelineRunLogs(
context.Background(),
&pps.GetPipelineRunLogsRequest{
PipelineRunId: args[0],
Node: node,
},
)
if err != nil {
return err
}
for _, pipelineRunLog := range pipelineRunLogs.PipelineRunLog {
name, ok := pps.OutputStream_name[int32(pipelineRunLog.OutputStream)]
if !ok {
return fmt.Errorf("unknown pps.OutputStream")
}
name = strings.Replace(name, "OUTPUT_STREAM_", "", -1)
containerID := pipelineRunLog.ContainerId
if len(containerID) > 8 {
containerID = containerID[:8]
}
logInfo := &logInfo{
Node: pipelineRunLog.Node,
ContainerID: containerID,
OutputStream: name,
Time: prototime.TimestampToTime(pipelineRunLog.Timestamp),
}
logInfoData, err := json.Marshal(logInfo)
if err != nil {
return err
}
s := fmt.Sprintf("%s %s", string(logInfoData), string(pipelineRunLog.Data))
fmt.Println(strings.TrimSpace(s))
}
return nil
},
}.ToCobraCommand()
rootCmd := &cobra.Command{
Use: "pps",
Long: `Access the PPS API.
Note that this CLI is experimental and does not even check for common errors.
The environment variable PPS_ADDRESS controls what server the CLI connects to, the default is 0.0.0.0:651.`,
}
rootCmd.AddCommand(protoclient.NewVersionCommand(clientConn, pachyderm.Version, nil))
rootCmd.AddCommand(inspectCmd)
rootCmd.AddCommand(startCmd)
rootCmd.AddCommand(statusCmd)
rootCmd.AddCommand(logsCmd)
return rootCmd.Execute()
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
config := &client.Config{
Host: appEnv.KubernetesAddress,
}
client, err := client.New(config)
if err != nil {
return err
}
apiServer := server.NewAPIServer(client)
createCluster := &cobra.Command{
Use: "create-cluster cluster-name nodes shards replicas",
Short: "Create a new pachyderm cluster.",
Long: "Create a new pachyderm cluster.",
Run: pkgcobra.RunFixedArgs(4, func(args []string) error {
nodes, err := strconv.ParseUint(args[1], 10, 64)
if err != nil {
return err
}
shards, err := strconv.ParseUint(args[2], 10, 64)
if err != nil {
return err
}
replicas, err := strconv.ParseUint(args[3], 10, 64)
if err != nil {
return err
}
_, err = apiServer.CreateCluster(
context.Background(),
&deploy.CreateClusterRequest{
Cluster: &deploy.Cluster{
Name: args[0],
},
Nodes: nodes,
Shards: shards,
Replicas: replicas,
})
return err
}),
}
deleteCluster := &cobra.Command{
Use: "delete-cluster cluster-name",
Short: "Delete a cluster.",
Long: "Delete a cluster.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
_, err = apiServer.DeleteCluster(
context.Background(),
&deploy.DeleteClusterRequest{
Cluster: &deploy.Cluster{
Name: args[0],
},
})
return err
}),
}
rootCmd := &cobra.Command{
Use: "deploy",
Long: `Deploy Pachyderm clusters.
The environment variable KUBERNETES_ADDRESS controls the Kubernetes endpoint the CLI connects to, the default is https://localhost:8080.`,
}
rootCmd.AddCommand(createCluster)
rootCmd.AddCommand(deleteCluster)
return rootCmd.Execute()
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
logrus.Register()
discoveryClient, err := getEtcdClient()
if err != nil {
return err
}
address := appEnv.Address
if address == "" {
address, err = netutil.ExternalIP()
if err != nil {
return err
}
}
sharder := route.NewSharder(appEnv.NumShards, 0)
address = fmt.Sprintf("%s:%d", address, appEnv.Port)
addresser := route.NewDiscoveryAddresser(
discoveryClient,
sharder,
"namespace",
)
var driver drive.Driver
switch appEnv.DriverType {
case "btrfs":
driver, err = btrfs.NewDriver(appEnv.DriverRoot, "")
if err != nil {
return err
}
default:
return fmt.Errorf("unknown value for PFS_DRIVER_TYPE: %s", appEnv.DriverType)
}
apiServer := server.NewAPIServer(
route.NewSharder(
appEnv.NumShards,
0,
),
route.NewRouter(
addresser,
grpcutil.NewDialer(
grpc.WithInsecure(),
),
address,
),
)
internalAPIServer := server.NewInternalAPIServer(
route.NewSharder(
appEnv.NumShards,
0,
),
route.NewRouter(
addresser,
grpcutil.NewDialer(
grpc.WithInsecure(),
),
address,
),
driver,
)
go func() {
if err := addresser.Register(nil, "id", address, internalAPIServer); err != nil {
log.Print(err)
}
}()
go func() {
if err := addresser.AssignRoles(nil); err != nil {
log.Print(err)
}
}()
// TODO(pedge): no!
trace.AuthRequest = func(_ *http.Request) (bool, bool) {
return true, true
}
return protoserver.Serve(
uint16(appEnv.Port),
func(s *grpc.Server) {
pfs.RegisterApiServer(s, apiServer)
pfs.RegisterInternalApiServer(s, internalAPIServer)
},
protoserver.ServeOptions{
HTTPPort: uint16(appEnv.HTTPPort),
DebugPort: uint16(appEnv.DebugPort),
Version: pachyderm.Version,
HTTPRegisterFunc: func(ctx context.Context, mux *runtime.ServeMux, clientConn *grpc.ClientConn) error {
return pfs.RegisterApiHandler(ctx, mux, clientConn)
},
},
)
}
