Esempio n. 1
0
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)
}
Esempio n. 2
0
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
	}
}
Esempio n. 3
0
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)
}
Esempio n. 4
0
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))
}
Esempio n. 5
0
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)
}
Esempio n. 6
0
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)
	}
}
Esempio n. 7
0
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
	}
}
Esempio n. 8
0
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))
}
Esempio n. 9
0
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
}
Esempio n. 10
0
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(&reg); 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)
}
Esempio n. 11
0
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)
}
Esempio n. 12
0
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)
}
Esempio n. 13
0
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)
}