func getKubeClient() (*kube.Client, error) {
kubeClient, err := kube.NewInCluster()
if err != nil {
protolog.Errorf("Falling back to insecure kube client due to error from NewInCluster: %s", err.Error())
} else {
return kubeClient, err
}
kubeAddr, err := getKubeAddress()
if err != nil {
return nil, err
}
config := &kube.Config{
Host: kubeAddr,
Insecure: true,
}
return kube.New(config)
}
func (a *apiServer) CreateJob(ctx context.Context, request *pps.CreateJobRequest) (response *pps.Job, retErr error) {
defer func(start time.Time) { a.Log(request, response, retErr, time.Since(start)) }(time.Now())
if request.Shards == 0 {
return nil, fmt.Errorf("pachyderm.pps.jobserver: request.Shards cannot be 0")
}
repoSet := make(map[string]bool)
for _, input := range request.Inputs {
repoSet[input.Commit.Repo.Name] = true
}
if len(repoSet) < len(request.Inputs) {
return nil, fmt.Errorf("pachyderm.pps.jobserver: duplicate repo in job")
}
// TODO validate job to make sure input commits and output repo exist
persistJobInfo := &persist.JobInfo{
Shards: request.Shards,
Transform: request.Transform,
Inputs: request.Inputs,
ParentJob: request.ParentJob,
}
if request.Pipeline != nil {
persistJobInfo.PipelineName = request.Pipeline.Name
}
if a.kubeClient == nil {
return nil, fmt.Errorf("pachyderm.pps.jobserver: no job backend")
}
_, err := a.persistAPIServer.CreateJobInfo(ctx, persistJobInfo)
if err != nil {
return nil, err
}
defer func() {
if retErr != nil {
if _, err := a.persistAPIServer.CreateJobState(ctx, &persist.JobState{
JobId: persistJobInfo.JobId,
State: pps.JobState_JOB_STATE_FAILURE,
}); err != nil {
protolog.Errorf("error from CreateJobState %s", err.Error())
}
}
}()
if _, err := a.kubeClient.Jobs(api.NamespaceDefault).Create(job(persistJobInfo)); err != nil {
return nil, err
}
return &pps.Job{
Id: persistJobInfo.JobId,
}, nil
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
var err error
address := appEnv.Address
if address == "" {
address, err = netutil.ExternalIP()
if err != nil {
return err
}
}
var blockAPIServer pfs.BlockAPIServer
if err := func() error {
bucket, err := ioutil.ReadFile("/amazon-secret/bucket")
if err != nil {
return err
}
id, err := ioutil.ReadFile("/amazon-secret/id")
if err != nil {
return err
}
secret, err := ioutil.ReadFile("/amazon-secret/secret")
if err != nil {
return err
}
token, err := ioutil.ReadFile("/amazon-secret/token")
if err != nil {
return err
}
region, err := ioutil.ReadFile("/amazon-secret/region")
if err != nil {
return err
}
objClient, err := obj.NewAmazonClient(string(bucket), string(id), string(secret), string(token), string(region))
if err != nil {
return err
}
blockAPIServer, err = server.NewObjBlockAPIServer(appEnv.StorageRoot, objClient)
if err != nil {
return err
}
return nil
}(); err != nil {
protolog.Errorf("failed to create obj backend, falling back to local")
blockAPIServer, err = server.NewLocalBlockAPIServer(appEnv.StorageRoot)
if err != nil {
return err
}
}
return protoserver.Serve(
uint16(appEnv.Port),
func(s *grpc.Server) {
pfs.RegisterBlockAPIServer(s, blockAPIServer)
},
protoserver.ServeOptions{
HTTPPort: uint16(appEnv.HTTPPort),
DebugPort: uint16(appEnv.DebugPort),
Version: pachyderm.Version,
},
)
}