6582689038

Committed 20 Oct 2023 02:31AM UTC coverage: 25.971% (-0.3%) from 26.31%

Build # 6582689038

Build Type

push

github

Committed by

web-flow

Commit Message

feat: log pod start time (#190)

Signed-off-by: cutecutecat <junyuchen@tensorchord.ai>

Run Details

72 of 72 new or added lines in 4 files covered. (100.0%)

956 of 3681 relevant lines covered (25.97%)

1.61 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/agent/pkg/k8s/generate_job.go

package k8s

import (
        "time"

        "github.com/cockroachdb/errors"
        batchv1 "k8s.io/api/batch/v1"
        corev1 "k8s.io/api/core/v1"
        metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/apimachinery/pkg/runtime/schema"

        "github.com/tensorchord/openmodelz/agent/api/types"
        "github.com/tensorchord/openmodelz/modelzetes/pkg/apis/modelzetes/v2alpha1"
        "github.com/tensorchord/openmodelz/modelzetes/pkg/consts"
)

func MakeBuild(req types.Build, inference *v2alpha1.Inference, builderImage, buildkitdAddr, buildctlBin, secret string) (*batchv1.Job, error) {
        job := &batchv1.Job{}
        duration, err := time.ParseDuration(req.Spec.BuildTarget.Duration)
        if err != nil {
                return nil, errors.Wrap(err, "failed to parse duration")
        }
        seconds := int64(duration.Seconds())
        defaultBackoffLimit := int32(0)
        defaultTTLSecondsAfterFinished := int32(60 * 60 * 24 * 7) // 7 days

        envs := []corev1.EnvVar{
                {
                        Name:  "MODELZ_BUILD_NAME",
                        Value: req.Spec.Name,
                },
                {
                        Name:  "MODELZ_BUILDER",
                        Value: string(req.Spec.BuildTarget.Builder),
                },
                {
                        Name:  "MODELZ_BUILD_ARTIFACT_IMAGE",
                        Value: req.Spec.BuildTarget.ArtifactImage,
                },
                {
                        Name:  "MODELZ_BUILD_ARTIFACT_IMAGE_TAG",
                        Value: req.Spec.BuildTarget.ArtifactImageTag,
                },
                {
                        Name:  "MODELZ_REGISTRY",
                        Value: req.Spec.BuildTarget.Registry,
                },
                {
                        Name:  "MODELZ_REGISTRY_TOKEN",
                        Value: req.Spec.BuildTarget.RegistryToken,
                },
        }
        if req.Spec.BuildTarget.Builder != types.BuilderTypeImage {
                envs = append(envs, buildEnvsForDockerfileOrEnvd(req, buildkitdAddr, buildctlBin)...)
        } else {
                envs = append(envs, buildEnvsForImage(req)...)
        }

        ownerReference := []metav1.OwnerReference{
                *metav1.NewControllerRef(inference, schema.GroupVersionKind{
                        Group:   v2alpha1.SchemeGroupVersion.Group,
                        Version: v2alpha1.SchemeGroupVersion.Version,
                        Kind:    v2alpha1.Kind,
                }),
        }
        job = &batchv1.Job{
                ObjectMeta: metav1.ObjectMeta{
                        Name:            req.Spec.Name,
                        Namespace:       req.Spec.Namespace,
                        OwnerReferences: ownerReference,
                        Labels: map[string]string{
                                consts.LabelBuildName:     req.Spec.Name,
                                consts.AnnotationBuilding: "true",
                        },
                },
                Spec: batchv1.JobSpec{
                        ActiveDeadlineSeconds:   &seconds,
                        BackoffLimit:            &defaultBackoffLimit,
                        TTLSecondsAfterFinished: &defaultTTLSecondsAfterFinished,
                        Template: corev1.PodTemplateSpec{
                                ObjectMeta: metav1.ObjectMeta{
                                        Labels: map[string]string{
                                                consts.LabelBuildName: req.Spec.Name,
                                        },
                                },
                                Spec: corev1.PodSpec{
                                        ImagePullSecrets: []corev1.LocalObjectReference{
                                                {Name: secret},
                                        },
                                        Volumes: []corev1.Volume{
                                                {
                                                        Name: "workspace",
                                                        VolumeSource: corev1.VolumeSource{
                                                                EmptyDir: &corev1.EmptyDirVolumeSource{},
                                                        },
                                                },
                                        },
                                        RestartPolicy: corev1.RestartPolicyNever,
                                        Containers: []corev1.Container{
                                                {
                                                        Name:            req.Spec.Name,
                                                        Image:           builderImage,
                                                        ImagePullPolicy: corev1.PullAlways,
                                                        VolumeMounts: []corev1.VolumeMount{
                                                                {
                                                                        Name:      "workspace",
                                                                        MountPath: "/workspace",
                                                                },
                                                        },
                                                        Env: envs,
                                                },
                                        },
                                },
                        },
                },
        }

        return job, nil
}

func buildEnvsForImage(req types.Build) []corev1.EnvVar {
        envs := []corev1.EnvVar{}
        if req.Spec.DockerSource.AuthN.Username != "" {
                envs = append(envs, corev1.EnvVar{
                        Name:  "MODELZ_SOURCE_REGISTRY_USERNAME",
                        Value: req.Spec.DockerSource.AuthN.Username,
                })
        }

        if req.Spec.DockerSource.AuthN.Password != "" {
                envs = append(envs, corev1.EnvVar{
                        Name:  "MODELZ_SOURCE_REGISTRY_PASSWORD",
                        Value: req.Spec.DockerSource.AuthN.Password,
                })
        }

        if req.Spec.DockerSource.AuthN.Token != "" {
                envs = append(envs, corev1.EnvVar{
                        Name:  "MODELZ_SOURCE_REGISTRY_TOKEN",
                        Value: req.Spec.DockerSource.AuthN.Token,
                })
        }

        if req.Spec.DockerSource.ArtifactImage != "" {
                envs = append(envs, corev1.EnvVar{
                        Name:  "MODELZ_SOURCE_REGISTRY_IMAGE",
                        Value: req.Spec.DockerSource.ArtifactImage,
                })
        }

        if req.Spec.DockerSource.ArtifactImageTag != "" {
                envs = append(envs, corev1.EnvVar{
                        Name:  "MODELZ_SOURCE_REGISTRY_IMAGE_TAG",
                        Value: req.Spec.DockerSource.ArtifactImageTag,
                })
        }

        return envs
}

func buildEnvsForDockerfileOrEnvd(req types.Build, buildkitdAddr, buildctlBin string) []corev1.EnvVar {
        return []corev1.EnvVar{
                {
                        Name:  "MODELZ_BUILD_GIT_URL",
                        Value: req.Spec.Repository,
                },
                {
                        Name:  "MODELZ_BUILD_GIT_BRANCH",
                        Value: req.Spec.Branch,
                },
                {
                        Name:  "MODELZ_BUILD_GIT_COMMIT",
                        Value: req.Spec.Revision,
                },
                {
                        Name:  "MODELZ_BUILD_BASE_DIR",
                        Value: req.Spec.BuildTarget.Directory,
                },
                {
                        Name:  "MODELZ_WORKSPACE",
                        Value: "/workspace",
                },
                {
                        Name:  "MODELZ_BUILDKITD_ADDRESS",
                        Value: buildkitdAddr,
                },
                {
                        Name:  "MODELZ_BUILDER_BIN",
                        Value: buildctlBin,
                },
        }
}

1	package k8s
2
3	import (
4	"time"
5
6	"github.com/cockroachdb/errors"
7	batchv1 "k8s.io/api/batch/v1"
8	corev1 "k8s.io/api/core/v1"
9	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
10	"k8s.io/apimachinery/pkg/runtime/schema"
11
12	"github.com/tensorchord/openmodelz/agent/api/types"
13	"github.com/tensorchord/openmodelz/modelzetes/pkg/apis/modelzetes/v2alpha1"
14	"github.com/tensorchord/openmodelz/modelzetes/pkg/consts"
15	)
16
17	func MakeBuild(req types.Build, inference v2alpha1.Inference, builderImage, buildkitdAddr, buildctlBin, secret string) (batchv1.Job, error) {	×
18	job := &batchv1.Job{}	×
19	duration, err := time.ParseDuration(req.Spec.BuildTarget.Duration)	×
20	if err != nil {	×
21	return nil, errors.Wrap(err, "failed to parse duration")	×
22	}	×
23	seconds := int64(duration.Seconds())	×
24	defaultBackoffLimit := int32(0)	×
25	defaultTTLSecondsAfterFinished := int32(60 * 60 * 24 * 7) // 7 days	×
26		×
27	envs := []corev1.EnvVar{	×
28	{	×
29	Name: "MODELZ_BUILD_NAME",	×
30	Value: req.Spec.Name,	×
31	},	×
32	{	×
33	Name: "MODELZ_BUILDER",	×
34	Value: string(req.Spec.BuildTarget.Builder),	×
35	},	×
36	{	×
37	Name: "MODELZ_BUILD_ARTIFACT_IMAGE",	×
38	Value: req.Spec.BuildTarget.ArtifactImage,	×
39	},	×
40	{	×
41	Name: "MODELZ_BUILD_ARTIFACT_IMAGE_TAG",	×
42	Value: req.Spec.BuildTarget.ArtifactImageTag,	×
43	},	×
44	{	×
45	Name: "MODELZ_REGISTRY",	×
46	Value: req.Spec.BuildTarget.Registry,	×
47	},	×
48	{	×
49	Name: "MODELZ_REGISTRY_TOKEN",	×
50	Value: req.Spec.BuildTarget.RegistryToken,	×
51	},	×
52	}	×
53	if req.Spec.BuildTarget.Builder != types.BuilderTypeImage {	×
54	envs = append(envs, buildEnvsForDockerfileOrEnvd(req, buildkitdAddr, buildctlBin)...)	×
55	} else {	×
56	envs = append(envs, buildEnvsForImage(req)...)	×
57	}	×
58
59	ownerReference := []metav1.OwnerReference{	×
60	*metav1.NewControllerRef(inference, schema.GroupVersionKind{	×
61	Group: v2alpha1.SchemeGroupVersion.Group,	×
62	Version: v2alpha1.SchemeGroupVersion.Version,	×
63	Kind: v2alpha1.Kind,	×
64	}),	×
65	}	×
66	job = &batchv1.Job{	×
67	ObjectMeta: metav1.ObjectMeta{	×
68	Name: req.Spec.Name,	×
69	Namespace: req.Spec.Namespace,	×
70	OwnerReferences: ownerReference,	×
71	Labels: map[string]string{	×
72	consts.LabelBuildName: req.Spec.Name,	×
73	consts.AnnotationBuilding: "true",	×
74	},	×
75	},	×
76	Spec: batchv1.JobSpec{	×
77	ActiveDeadlineSeconds: &seconds,	×
78	BackoffLimit: &defaultBackoffLimit,	×
79	TTLSecondsAfterFinished: &defaultTTLSecondsAfterFinished,	×
80	Template: corev1.PodTemplateSpec{	×
81	ObjectMeta: metav1.ObjectMeta{	×
82	Labels: map[string]string{	×
83	consts.LabelBuildName: req.Spec.Name,	×
84	},	×
85	},	×
86	Spec: corev1.PodSpec{	×
87	ImagePullSecrets: []corev1.LocalObjectReference{	×
88	{Name: secret},	×
89	},	×
90	Volumes: []corev1.Volume{	×
91	{	×
92	Name: "workspace",	×
93	VolumeSource: corev1.VolumeSource{	×
94	EmptyDir: &corev1.EmptyDirVolumeSource{},	×
95	},	×
96	},	×
97	},	×
98	RestartPolicy: corev1.RestartPolicyNever,	×
99	Containers: []corev1.Container{	×
100	{	×
101	Name: req.Spec.Name,	×
102	Image: builderImage,	×
103	ImagePullPolicy: corev1.PullAlways,	×
104	VolumeMounts: []corev1.VolumeMount{	×
105	{	×
106	Name: "workspace",	×
107	MountPath: "/workspace",	×
108	},	×
109	},	×
110	Env: envs,	×
111	},	×
112	},	×
113	},	×
114	},	×
115	},	×
116	}	×
117		×
118	return job, nil	×
119	}
120
121	func buildEnvsForImage(req types.Build) []corev1.EnvVar {	×
122	envs := []corev1.EnvVar{}	×
123	if req.Spec.DockerSource.AuthN.Username != "" {	×
124	envs = append(envs, corev1.EnvVar{	×
125	Name: "MODELZ_SOURCE_REGISTRY_USERNAME",	×
126	Value: req.Spec.DockerSource.AuthN.Username,	×
127	})	×
128	}	×
129
130	if req.Spec.DockerSource.AuthN.Password != "" {	×
131	envs = append(envs, corev1.EnvVar{	×
132	Name: "MODELZ_SOURCE_REGISTRY_PASSWORD",	×
133	Value: req.Spec.DockerSource.AuthN.Password,	×
134	})	×
135	}	×
136
137	if req.Spec.DockerSource.AuthN.Token != "" {	×
138	envs = append(envs, corev1.EnvVar{	×
139	Name: "MODELZ_SOURCE_REGISTRY_TOKEN",	×
140	Value: req.Spec.DockerSource.AuthN.Token,	×
141	})	×
142	}	×
143
144	if req.Spec.DockerSource.ArtifactImage != "" {	×
145	envs = append(envs, corev1.EnvVar{	×
146	Name: "MODELZ_SOURCE_REGISTRY_IMAGE",	×
147	Value: req.Spec.DockerSource.ArtifactImage,	×
148	})	×
149	}	×
150
151	if req.Spec.DockerSource.ArtifactImageTag != "" {	×
152	envs = append(envs, corev1.EnvVar{	×
153	Name: "MODELZ_SOURCE_REGISTRY_IMAGE_TAG",	×
154	Value: req.Spec.DockerSource.ArtifactImageTag,	×
155	})	×
156	}	×
157
158	return envs	×
159	}
160
161	func buildEnvsForDockerfileOrEnvd(req types.Build, buildkitdAddr, buildctlBin string) []corev1.EnvVar {	×
162	return []corev1.EnvVar{	×
163	{	×
164	Name: "MODELZ_BUILD_GIT_URL",	×
165	Value: req.Spec.Repository,	×
166	},	×
167	{	×
168	Name: "MODELZ_BUILD_GIT_BRANCH",	×
169	Value: req.Spec.Branch,	×
170	},	×
171	{	×
172	Name: "MODELZ_BUILD_GIT_COMMIT",	×
173	Value: req.Spec.Revision,	×
174	},	×
175	{	×
176	Name: "MODELZ_BUILD_BASE_DIR",	×
177	Value: req.Spec.BuildTarget.Directory,	×
178	},	×
179	{	×
180	Name: "MODELZ_WORKSPACE",	×
181	Value: "/workspace",	×
182	},	×
183	{	×
184	Name: "MODELZ_BUILDKITD_ADDRESS",	×
185	Value: buildkitdAddr,	×
186	},	×
187	{	×
188	Name: "MODELZ_BUILDER_BIN",	×
189	Value: buildctlBin,	×
190	},	×
191	}	×
192	}	×

tensorchord / openmodelz / 6582689038

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous