micro/runtime/kubernetes/service.go

164 lines
4.4 KiB
Go
Raw Normal View History

package kubernetes
import (
2020-01-18 05:13:24 +03:00
"encoding/json"
"strings"
"time"
"github.com/micro/go-micro/runtime"
2020-01-18 05:13:24 +03:00
"github.com/micro/go-micro/util/kubernetes/api"
"github.com/micro/go-micro/util/kubernetes/client"
"github.com/micro/go-micro/util/log"
)
type service struct {
// service to manage
*runtime.Service
// Kubernetes service
kservice *client.Service
// Kubernetes deployment
kdeploy *client.Deployment
}
2020-01-18 05:13:24 +03:00
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)
2019-11-29 14:35:00 +03:00
kservice := client.NewService(name, version, c.Type)
kdeploy := client.NewDeployment(name, version, c.Type)
// 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...)
}
2019-11-29 14:35:00 +03:00
// specify the command to exec
if len(c.Command) > 0 {
kdeploy.Spec.Template.PodSpec.Containers[0].Command = c.Command
} else if len(s.Source) > 0 {
// default command for our k8s service should be source
kdeploy.Spec.Template.PodSpec.Containers[0].Command = []string{"go", "run", s.Source}
}
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
2019-12-24 20:51:30 +03:00
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)
2020-01-11 00:54:28 +03:00
s.Status("error", err)
2020-01-18 05:13:24 +03:00
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)
2020-01-11 00:54:28 +03:00
s.Status("error", err)
2020-01-18 05:13:24 +03:00
v := parseError(err)
if v.Reason == "AlreadyExists" {
return runtime.ErrAlreadyExists
}
return err
}
2020-01-11 00:54:28 +03:00
s.Status("started", nil)
return nil
}
2019-12-24 20:51:30 +03:00
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)
2020-01-11 00:54:28 +03:00
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)
2020-01-11 00:54:28 +03:00
s.Status("error", err)
return err
}
2020-01-11 00:54:28 +03:00
s.Status("stopped", nil)
return nil
}
2019-12-24 20:51:30 +03:00
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)
2020-01-11 00:54:28 +03:00
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
}
2020-01-11 00:54:28 +03:00
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()
}