func (routes *Routes) renewInstance(w rest.ResponseWriter, r *rest.Request) {
iid := r.PathParam(RouteParamInstanceID)
if iid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is required",
}).Warn("Failed to renew instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceIdentifierMissing)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to renew instance %s", iid)
return
}
if err := catalog.Renew(iid); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to renew instance %s", iid)
i18n.Error(r, w, statusCodeFromError(err), i18n.ErrorInstanceHeartbeatFailed)
return
}
w.WriteHeader(http.StatusOK)
}
func (routes *Routes) getInstance(w rest.ResponseWriter, r *rest.Request) {
appid := r.PathParam(RouteParamAppID)
if appid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "application id is required",
}).Warn("Failed to query instancee")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorApplicationIdentifierMissing)
return
}
iid := r.PathParam(RouteParamInstanceID)
if iid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is required",
}).Warn("Failed to query instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceIdentifierMissing)
return
}
uid := buildUniqueInstanceID(appid, iid)
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to renew instance %s", iid)
return
}
si, err := catalog.Instance(uid)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to query instance %s", uid)
i18n.Error(r, w, http.StatusNotFound, i18n.ErrorInstanceNotFound)
return
}
inst := buildInstanceFromRegistry(si)
err = w.WriteJson(&InstanceWrapper{inst})
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to encode instance")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
return
}
}
func (routes *Routes) registerInstance(w rest.ResponseWriter, r *rest.Request) {
var err error
var req *InstanceRegistration
req, err = routes.parseInstanceRegistrationRequest(w, r)
if err != nil {
return // error to client already set
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to register instance %+v", req)
return
}
si := &store.ServiceInstance{
ServiceName: req.ServiceName,
Protocol: protocol.Amalgam8,
Endpoint: &store.Endpoint{Type: req.Endpoint.Type, Value: req.Endpoint.Value},
Status: strings.ToUpper(req.Status),
TTL: time.Duration(req.TTL) * time.Second,
Metadata: req.Metadata,
Tags: req.Tags}
var sir *store.ServiceInstance
if sir, err = catalog.Register(si); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, statusCodeFromError(err), i18n.ErrorInstanceRegistrationFailed)
return
} else if sir == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance is nil",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorNilObject)
return
} else if sir.ID == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is empty",
}).Warnf("Failed to register instance %s", sir)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceIdentifierMissing)
return
}
routes.sendRegistrationResponse(w, r, sir)
}
func (routes *Routes) listAppInstances(w rest.ResponseWriter, r *rest.Request) {
appid := r.PathParam(RouteParamAppID)
if appid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "application id is required",
}).Warn("Failed to lookup application")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorApplicationIdentifierMissing)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to lookup application %s", appid)
return
}
insts, err := catalog.List(appid, nil)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Errorf("Failed to lookup application %s", appid)
i18n.Error(r, w, http.StatusInternalServerError, i18n.EurekaErrorApplicationNotFound)
return
}
app := &Application{Name: appid, Instances: make([]*Instance, len(insts))}
for index, inst := range insts {
app.Instances[index] = buildInstanceFromRegistry(inst)
}
err = w.WriteJson(map[string]*Application{"application": app})
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to encode application")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("List application instances (%d)", len(app.Instances))
}
func (routes *Routes) deregisterInstance(w rest.ResponseWriter, r *rest.Request) {
appid := r.PathParam(RouteParamAppID)
if appid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "application id is required",
}).Warn("Failed to deregister instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorApplicationIdentifierMissing)
return
}
iid := r.PathParam(RouteParamInstanceID)
if iid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is required",
}).Warn("Failed to deregister instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceIdentifierMissing)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to deregister instance %s", iid)
return
}
uid := buildUniqueInstanceID(appid, iid)
if err := catalog.Deregister(uid); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to deregister instance %s", uid)
i18n.Error(r, w, http.StatusGone, i18n.ErrorInstanceNotFound)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("Instance id %s deregistered", uid)
w.WriteHeader(http.StatusOK)
}
func (routes *Routes) sendRegistrationResponse(w rest.ResponseWriter, r *rest.Request, sir *store.ServiceInstance) {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("Instance %s registered", sir)
ttl := uint32(sir.TTL / time.Second)
linksURL := r.BaseUrl()
if middleware.IsUsingSecureConnection(r) { // request came in over a secure connection, continue using it
linksURL.Scheme = "https"
}
links := BuildLinks(linksURL.String(), sir.ID)
instance := &ServiceInstance{
ID: sir.ID,
TTL: ttl,
Links: links,
}
w.Header().Set("Location", links.Self)
w.WriteHeader(http.StatusCreated)
if err := w.WriteJson(instance); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to write registration response for instance %s", sir)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
}
}
func (routes *Routes) catalog(w rest.ResponseWriter, r *rest.Request) store.Catalog {
if r.Env[middleware.NamespaceKey] == nil {
i18n.Error(r, w, http.StatusUnauthorized, i18n.ErrorNamespaceNotFound)
return nil
}
namespace := r.Env[middleware.NamespaceKey].(auth.Namespace)
if catalog, err := routes.registry.GetCatalog(namespace); err != nil {
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInternalServer)
return nil
} else if catalog == nil {
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorNamespaceNotFound)
return nil
} else {
return catalog
}
}
func (routes *Routes) listInstances(w rest.ResponseWriter, r *rest.Request) {
var fields []string
fields, err := extractFields(r)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to list instances")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorFilterBadFields)
return
}
sc, err := newSelectCriteria(r)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Error("Failed to list instances")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorFilterSelectionCriteria)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Error("Failed to list instances")
return
}
services := catalog.ListServices(nil)
if services == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "services list is nil",
}).Error("Failed to list instances")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceEnumeration)
return
}
var insts = []*ServiceInstance{}
for _, svc := range services {
instances, err := catalog.List(svc.ServiceName, sc.instanceFilter)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Errorf("Failed to list instances for service %s", svc.ServiceName)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceEnumeration)
return
}
for _, si := range instances {
inst, err := copyInstanceWithFilter(svc.ServiceName, si, fields)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to list instances")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceEnumeration)
return
}
insts = append(insts, inst)
}
}
if err = w.WriteJson(&InstancesList{Instances: insts}); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to encode instances list response")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("Lookup instances (%d)", len(insts))
}
func (routes *Routes) parseInstanceRegistrationRequest(w rest.ResponseWriter, r *rest.Request) (*InstanceRegistration, error) {
var req InstanceRegistration
var err error
if err = r.DecodeJsonPayload(&req); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to register instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceRegistrationFailed)
return nil, err
}
if req.ServiceName == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "service name is required",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorServiceNameMissing)
return nil, errors.New("Service name is required")
}
if req.Endpoint == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Endpoint is required",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceEndpointMissing)
return nil, errors.New("Endpoint is required")
}
if req.Endpoint.Type == "" || req.Endpoint.Value == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Endpoint type or value are missing or mismatched",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceEndpontMalformed)
return nil, errors.New("Endpoint type or value are missing or mismatched")
}
switch req.Endpoint.Type {
case EndpointTypeHTTP:
case EndpointTypeUDP:
case EndpointTypeTCP:
case EndpointTypeUser:
default:
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Endpoint type is of invalid value",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceEndpointInvalidType)
return nil, errors.New("Endpoint type is of invalid value")
}
metadataValid := true
if req.Metadata != nil {
metadataValid = validateJSON(req.Metadata)
}
if !metadataValid {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Metadata is invalid",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceMetadataInvalid)
return nil, errors.New("Metadata is invalid")
}
// If the status is not passed in, set it to UP
if req.Status == "" {
req.Status = store.Up
}
// Validate the status value
switch strings.ToUpper(req.Status) {
case store.Up:
case store.Starting:
case store.OutOfService:
default:
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Status field is not a valid value",
}).Warnf("Failed to register instance %+v", req)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceStatusInvalid,
map[string]interface{}{"Status": fmt.Sprintf("%s, %s, %s", store.Up, store.Starting, store.OutOfService)})
return nil, errors.New("Status field is not a valid value")
}
return &req, nil
}
func (routes *Routes) registerInstance(w rest.ResponseWriter, r *rest.Request) {
var err error
var reg InstanceWrapper
appid := r.PathParam(RouteParamAppID)
if appid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "application id is required",
}).Warn("Failed to register instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorApplicationIdentifierMissing)
return
}
if err = r.DecodeJsonPayload(®); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to register instance")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceRegistrationFailed)
return
}
inst := reg.Inst
if inst.Application == "" {
inst.Application = appid
}
if inst.HostName == "" || inst.Application == "" || inst.VIPAddr == "" || inst.IPAddr == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "hostname, application, vipaddress and IPaddress are required",
}).Warnf("Failed to register instance %+v", inst)
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorRequiredFieldsMissing)
return
}
metadataValid := true
if inst.Metadata != nil {
metadataValid = validateJSON(inst.Metadata)
}
if !metadataValid {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "metadata is not valid",
}).Warnf("Failed to register instance %+v", inst)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceMetadataInvalid)
return
}
// Get the instance ID
iid := inst.ID
if iid == "" {
iid = inst.HostName
}
ttl := defaultDurationInt
if inst.Lease != nil && inst.Lease.DurationInt > 0 {
ttl = inst.Lease.DurationInt
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to register instance %+v", inst)
return
}
si := &store.ServiceInstance{
ID: buildUniqueInstanceID(appid, iid),
Protocol: protocol.Eureka,
ServiceName: inst.Application,
Endpoint: &store.Endpoint{Type: "tcp", Value: fmt.Sprintf("%s:%v", inst.IPAddr, inst.Port.Value)},
Status: inst.Status,
TTL: time.Duration(ttl) * time.Second,
Metadata: inst.Metadata,
Extension: buildExtensionFromInstance(inst)}
var sir *store.ServiceInstance
if sir, err = catalog.Register(si); err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to register instance %+v", inst)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceRegistrationFailed)
return
} else if sir == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance is nil",
}).Warnf("Failed to register instance %+v", inst)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorNilObject)
return
} else if sir.ID == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is empty",
}).Warnf("Failed to register instance %s", sir)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceIdentifierMissing)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("Instance %s registered", sir)
w.WriteHeader(http.StatusNoContent)
}
func (routes *Routes) setStatus(w rest.ResponseWriter, r *rest.Request) {
appid := r.PathParam(RouteParamAppID)
if appid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "application id is required",
}).Warn("Failed to set instances status")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorApplicationIdentifierMissing)
return
}
iid := r.PathParam(RouteParamInstanceID)
if iid == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "instance id is required",
}).Warn("Failed to set instances status")
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceIdentifierMissing)
return
}
uid := buildUniqueInstanceID(appid, iid)
status := r.URL.Query().Get("value")
if status == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "status value is required",
}).Warn("Failed to set instances status")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorStatusMissing)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to set instance %s status", uid)
return
}
si, err := catalog.Instance(uid)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to set instance %s status", uid)
i18n.Error(r, w, http.StatusNotFound, i18n.ErrorInstanceNotFound)
return
}
if si.ServiceName != appid {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "Application id does not match",
}).Warnf("Failed to set instance %s status. service_name: %s", uid, si.ServiceName)
i18n.Error(r, w, http.StatusBadRequest, i18n.ErrorInstanceNotFound)
return
}
err = catalog.SetStatus(uid, status)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warnf("Failed to set instance %s status", uid)
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorInstanceNotFound)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("Instance %s status was changed. old: %s, new: %s", uid, si.Status, status)
w.WriteHeader(http.StatusOK)
}
func (routes *Routes) listApps(w rest.ResponseWriter, r *rest.Request) {
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Error("Failed to list applications")
return
}
services := catalog.ListServices(nil)
if services == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "services list is nil",
}).Error("Failed to list applications")
i18n.Error(r, w, http.StatusInternalServerError, i18n.EurekaErrorApplicationEnumeration)
return
}
var instsCount int
apps := &Applications{Application: make([]*Application, len(services))}
listRes := &ApplicationsList{Applications: apps}
for index, svc := range services {
insts, err := catalog.List(svc.ServiceName, nil)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Errorf("Failed to lookup application %s", svc.ServiceName)
i18n.Error(r, w, http.StatusInternalServerError, i18n.EurekaErrorApplicationEnumeration)
return
}
app := &Application{Name: svc.ServiceName, Instances: make([]*Instance, len(insts))}
for idx, inst := range insts {
app.Instances[idx] = buildInstanceFromRegistry(inst)
instsCount++
}
apps.Application[index] = app
}
err := w.WriteJson(listRes)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to encode applications list")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("List applications (%d apps, %d insts)", len(apps.Application), instsCount)
}
func (routes *Routes) listVips(w rest.ResponseWriter, r *rest.Request) {
vip := r.PathParam(RouterParamVip)
if vip == "" {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "vip is required",
}).Warn("Failed to list vip")
i18n.Error(r, w, http.StatusBadRequest, i18n.EurekaErrorVIPRequired)
return
}
catalog := routes.catalog(w, r)
if catalog == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "catalog is nil",
}).Errorf("Failed to list vip %s", vip)
return
}
services := catalog.ListServices(nil)
if services == nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": "services list is nil",
}).Errorf("Failed to list vip %s", vip)
i18n.Error(r, w, http.StatusInternalServerError, i18n.EurekaErrorVIPEnumeration)
return
}
var instsCount int
apps := &Applications{Application: make([]*Application, 0, len(services))}
listRes := &ApplicationsList{Applications: apps}
for _, svc := range services {
insts, err := catalog.List(svc.ServiceName, nil)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Errorf("Failed to list vips %s", vip)
i18n.Error(r, w, http.StatusInternalServerError, i18n.EurekaErrorVIPEnumeration)
return
}
app := &Application{Name: svc.ServiceName, Instances: make([]*Instance, 0, len(insts))}
for _, inst := range insts {
if vipaddr, ok := inst.Extension["VipAddress"]; ok {
if vipaddr == vip {
app.Instances = append(app.Instances, buildInstanceFromRegistry(inst))
instsCount++
}
}
}
if len(app.Instances) > 0 {
apps.Application = append(apps.Application, app)
}
}
err := w.WriteJson(listRes)
if err != nil {
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
"error": err,
}).Warn("Failed to encode vips list")
i18n.Error(r, w, http.StatusInternalServerError, i18n.ErrorEncoding)
return
}
routes.logger.WithFields(log.Fields{
"namespace": r.Env["REMOTE_USER"],
}).Infof("List vips (%d apps, %d insts)", len(apps.Application), instsCount)
}