package kubernetes import ( "encoding/json" "strings" "time" log "github.com/micro/go-micro/v2/logger" "github.com/micro/go-micro/v2/runtime" "github.com/micro/go-micro/v2/util/kubernetes/api" "github.com/micro/go-micro/v2/util/kubernetes/client" ) type service struct { // service to manage *runtime.Service // Kubernetes service kservice *client.Service // Kubernetes deployment kdeploy *client.Deployment } func parseError(err error) *api.Status { status := new(api.Status) json.Unmarshal([]byte(err.Error()), &status) return status } func newService(s *runtime.Service, c runtime.CreateOptions) *service { // use pre-formatted name/version name := client.Format(s.Name) version := client.Format(s.Version) kservice := client.NewService(name, version, c.Type) kdeploy := client.NewDeployment(name, version, c.Type) if len(c.Source) > 0 { for i := range kdeploy.Spec.Template.PodSpec.Containers { kdeploy.Spec.Template.PodSpec.Containers[i].Image = c.Source kdeploy.Spec.Template.PodSpec.Containers[i].Command = []string{} kdeploy.Spec.Template.PodSpec.Containers[i].Args = []string{name} } } // attach our values to the deployment; name, version, source kdeploy.Metadata.Annotations["name"] = s.Name kdeploy.Metadata.Annotations["version"] = s.Version kdeploy.Metadata.Annotations["source"] = s.Source // associate owner:group to be later augmented kdeploy.Metadata.Annotations["owner"] = "micro" kdeploy.Metadata.Annotations["group"] = "micro" // set a build timestamp to the current time if kdeploy.Spec.Template.Metadata.Annotations == nil { kdeploy.Spec.Template.Metadata.Annotations = make(map[string]string) } kdeploy.Spec.Template.Metadata.Annotations["build"] = time.Now().Format(time.RFC3339) // define the environment values used by the container env := make([]client.EnvVar, 0, len(c.Env)) for _, evar := range c.Env { evarPair := strings.Split(evar, "=") env = append(env, client.EnvVar{Name: evarPair[0], Value: evarPair[1]}) } // if environment has been supplied update deployment default environment if len(env) > 0 { kdeploy.Spec.Template.PodSpec.Containers[0].Env = append(kdeploy.Spec.Template.PodSpec.Containers[0].Env, env...) } // specify the command to exec if strings.HasPrefix(c.Source, "github.com") && len(c.Command) > 0 { kdeploy.Spec.Template.PodSpec.Containers[0].Command = c.Command } return &service{ Service: s, kservice: kservice, kdeploy: kdeploy, } } func deploymentResource(d *client.Deployment) *client.Resource { return &client.Resource{ Name: d.Metadata.Name, Kind: "deployment", Value: d, } } func serviceResource(s *client.Service) *client.Resource { return &client.Resource{ Name: s.Metadata.Name, Kind: "service", Value: s, } } // Start starts the Kubernetes service. It creates new kubernetes deployment and service API objects func (s *service) Start(k client.Client) error { // create deployment first; if we fail, we dont create service if err := k.Create(deploymentResource(s.kdeploy)); err != nil { log.Debugf("Runtime failed to create deployment: %v", err) s.Status("error", err) v := parseError(err) if v.Reason == "AlreadyExists" { return runtime.ErrAlreadyExists } return err } // create service now that the deployment has been created if err := k.Create(serviceResource(s.kservice)); err != nil { log.Debugf("Runtime failed to create service: %v", err) s.Status("error", err) v := parseError(err) if v.Reason == "AlreadyExists" { return runtime.ErrAlreadyExists } return err } s.Status("started", nil) return nil } func (s *service) Stop(k client.Client) error { // first attempt to delete service if err := k.Delete(serviceResource(s.kservice)); err != nil { log.Debugf("Runtime failed to delete service: %v", err) s.Status("error", err) return err } // delete deployment once the service has been deleted if err := k.Delete(deploymentResource(s.kdeploy)); err != nil { log.Debugf("Runtime failed to delete deployment: %v", err) s.Status("error", err) return err } s.Status("stopped", nil) return nil } func (s *service) Update(k client.Client) error { if err := k.Update(deploymentResource(s.kdeploy)); err != nil { log.Debugf("Runtime failed to update deployment: %v", err) s.Status("error", err) return err } if err := k.Update(serviceResource(s.kservice)); err != nil { log.Debugf("Runtime failed to update service: %v", err) return err } return nil } func (s *service) Status(status string, err error) { if err == nil { s.Metadata["status"] = status return } s.Metadata["status"] = "error" s.Metadata["error"] = err.Error() }