func testBlock(t *testing.T, apiServer persist.APIServer) {
jobInfo, err := apiServer.CreateJobInfo(context.Background(), &persist.JobInfo{
JobID: uuid.NewWithoutDashes(),
})
require.NoError(t, err)
jobID := jobInfo.JobID
go func() {
_, err := apiServer.CreateJobOutput(
context.Background(),
&persist.JobOutput{
JobID: jobID,
OutputCommit: client.NewCommit("foo", "bar"),
})
require.NoError(t, err)
_, err = apiServer.CreateJobState(
context.Background(),
&persist.JobState{
JobID: jobID,
State: ppsclient.JobState_JOB_SUCCESS,
})
require.NoError(t, err)
}()
_, err = apiServer.InspectJob(
context.Background(),
&ppsclient.InspectJobRequest{
Job: &ppsclient.Job{ID: jobID},
BlockState: true,
},
)
require.NoError(t, err)
}
func NewTestRethinkAPIServer() (server.APIServer, error) {
address := "0.0.0.0:28015"
databaseName := uuid.NewWithoutDashes()
if err := server.InitDBs(address, databaseName); err != nil {
return nil, err
}
return server.NewRethinkAPIServer(address, databaseName)
}
func ReportMetrics(clusterID string, kubeClient *kube.Client) {
metrics.ID = clusterID
metrics.PodID = uuid.NewWithoutDashes()
metrics.Version = version.PrettyPrintVersion(version.Version)
for {
write := atomic.SwapInt64(&modified, 0)
if write == 1 {
externalMetrics(kubeClient, metrics)
protolion.Info(metrics)
reportSegment(metrics)
}
<-time.After(15 * time.Second)
}
}
func newFilesystem(
pfsAPIClient pfsclient.APIClient,
shard *pfsclient.Shard,
commitMounts []*CommitMount,
) *filesystem {
return &filesystem{
apiClient: client.APIClient{PfsAPIClient: pfsAPIClient},
Filesystem: Filesystem{
shard,
commitMounts,
},
inodes: make(map[string]uint64),
lock: sync.RWMutex{},
handleID: uuid.NewWithoutDashes(),
}
}
func getJobID(req *ppsclient.CreateJobRequest) string {
// If the job belongs to a pipeline, and the pipeline has inputs,
// we want to make sure that the same
// job does not run twice. We ensure that by generating the job id by
// hashing the pipeline name and input commits. That way, two same jobs
// will have the sam job IDs, therefore won't be created in the database
// twice.
if req.Pipeline != nil && len(req.Inputs) > 0 && !req.Force {
s := req.Pipeline.Name
s += req.Transform.String()
for _, input := range req.Inputs {
s += "/" + input.String()
}
hash := md5.Sum([]byte(s))
return fmt.Sprintf("%x", hash)
}
return uuid.NewWithoutDashes()
}
func (c *mockClient) CreateInDir(dir string, value string, ttl uint64) error {
c.lock.Lock()
defer c.lock.Unlock()
key := path.Join(dir, uuid.NewWithoutDashes())
return c.unsafeSet(key, value, ttl)
}
func setClusterID(client discovery.Client) error {
return client.Set(clusterIDKey, uuid.NewWithoutDashes(), 0)
}
func testBasicRethink(t *testing.T, apiServer persist.APIServer) {
_, err := apiServer.CreatePipelineInfo(
context.Background(),
&persist.PipelineInfo{
PipelineName: "foo",
},
)
require.NoError(t, err)
pipelineInfo, err := apiServer.GetPipelineInfo(
context.Background(),
&ppsclient.Pipeline{Name: "foo"},
)
require.NoError(t, err)
require.Equal(t, pipelineInfo.PipelineName, "foo")
input := &ppsclient.JobInput{Commit: client.NewCommit("bar", uuid.NewWithoutDashes())}
jobInfo, err := apiServer.CreateJobInfo(
context.Background(),
&persist.JobInfo{
JobID: uuid.NewWithoutDashes(),
PipelineName: "foo",
Inputs: []*ppsclient.JobInput{input},
},
)
jobID := jobInfo.JobID
input2 := &ppsclient.JobInput{Commit: client.NewCommit("fizz", uuid.NewWithoutDashes())}
_, err = apiServer.CreateJobInfo(
context.Background(),
&persist.JobInfo{
JobID: uuid.NewWithoutDashes(),
PipelineName: "buzz",
Inputs: []*ppsclient.JobInput{input2},
},
)
require.NoError(t, err)
jobInfo, err = apiServer.InspectJob(
context.Background(),
&ppsclient.InspectJobRequest{
Job: &ppsclient.Job{
ID: jobInfo.JobID,
},
},
)
require.NoError(t, err)
require.Equal(t, jobInfo.JobID, jobID)
require.Equal(t, "foo", jobInfo.PipelineName)
jobInfos, err := apiServer.ListJobInfos(
context.Background(),
&ppsclient.ListJobRequest{
Pipeline: &ppsclient.Pipeline{Name: "foo"},
},
)
require.NoError(t, err)
require.Equal(t, len(jobInfos.JobInfo), 1)
require.Equal(t, jobInfos.JobInfo[0].JobID, jobID)
jobInfos, err = apiServer.ListJobInfos(
context.Background(),
&ppsclient.ListJobRequest{
InputCommit: []*pfsclient.Commit{input.Commit},
},
)
require.NoError(t, err)
require.Equal(t, len(jobInfos.JobInfo), 1)
require.Equal(t, jobInfos.JobInfo[0].JobID, jobID)
jobInfos, err = apiServer.ListJobInfos(
context.Background(),
&ppsclient.ListJobRequest{
Pipeline: &ppsclient.Pipeline{Name: "foo"},
InputCommit: []*pfsclient.Commit{input.Commit},
},
)
require.NoError(t, err)
require.Equal(t, len(jobInfos.JobInfo), 1)
require.Equal(t, jobInfos.JobInfo[0].JobID, jobID)
}