registry

type CacheIndex interface {
	Get(service string, tags map[string]string) ([]*MicroServiceInstance, bool)
	//Set will overwrite all instances correspond to a service name
	Set(service string, instances []*MicroServiceInstance)
	FullCache() *cache.Cache
	Delete(service string)
}

type ContractDiscovery interface {
	GetMicroServicesByInterface(interfaceName string) (microservices []*MicroService)
	GetSchemaContentByInterface(interfaceName string) SchemaContent
	GetSchemaContentByServiceName(svcName, version, appID, env string) []*SchemaContent
	Close() error
}

type DataCenterInfo struct {
	Name          string `json:"name"`
	Region        string `json:"region"`
	AvailableZone string `json:"availableZone"`
}

type Definition struct {
	Types      string                 `yaml:"type"`
	XJavaClass string                 `yaml:"x-java-class"`
	Properties map[string]interface{} `yaml:"properties"`
}

type Endpoint struct {
	SSLEnabled bool   `json:"sslEnabled"`
	Address    string `json:"address"`
}

type Framework struct {
	Name    string
	Version string
}

type HeartbeatService struct {
	HeartbeatMode string

	Interval time.Duration
	// contains filtered or unexported fields
}

type HeartbeatTask struct {
	ServiceID  string
	InstanceID string
	Time       time.Time
	Running    bool
}

type IndexCache struct {
	CriteriaStore []map[string]string //all criteria need to be saved in here so that we can update indexedCache, during Set process
	// contains filtered or unexported fields
}

type Item struct {
	Type string                 `yaml:"type"`
	XML  map[string]interface{} `yaml:"xml"`
}

type MethodInfo struct {
	OperationID string              `yaml:"operationId"`
	Parameters  []Parameter         `yaml:"parameters"`
	Response    map[string]Response `yaml:"responses"`
}

type MicroService struct {
	ServiceID   string
	AppID       string
	ServiceName string
	Version     string
	Paths       []ServicePath
	Environment string
	Status      string
	Level       string
	Schemas     []string
	Metadata    map[string]string
	Framework   *Framework
	RegisterBy  string
	Alias       string
}

type MicroServiceDependency struct {
	Consumer  *MicroService
	Providers []*MicroService
}

type MicroServiceInstance struct {
	App             string
	ServiceName     string
	Version         string
	InstanceID      string               `json:"instanceID"`
	HostName        string               `json:"hostName"`
	ServiceID       string               `json:"serviceID"`
	DefaultProtocol string               `json:"defaultProtocol"`
	DefaultEndpoint string               `json:"defaultEndpoint"`
	Status          string               `json:"status"`
	EndpointsMap    map[string]*Endpoint `json:"endpointsMap"`
	Metadata        map[string]string    `json:"metadata"`
	DataCenterInfo  *DataCenterInfo      `json:"dataCenterInfo"`
}

type Options struct {
	Addrs      []string
	EnableSSL  bool
	Timeout    time.Duration
	TLSConfig  *tls.Config
	Compressed bool
	Verbose    bool
	Version    string
	ConfigPath string
}

type Parameter struct {
	Name      string      `yaml:"name"`
	In        string      `yaml:"in"`
	Required  bool        `yaml:"required"`
	Type      string      `yaml:"type"`
	Format    string      `yaml:"format"`
	Items     Item        `yaml:"items"`
	ColFormat string      `yaml:"collectionFormat"`
	Schema    SchemaValue `yaml:"schema"`
}

type Registrator interface {
	//Close destroy connection between the registry client and server
	Close() error
	//RegisterService register a microservice to registry, if it is duplicated in registry, it returns error
	RegisterService(microService *MicroService) (string, error)
	//RegisterServiceInstance register a microservice instance to registry
	RegisterServiceInstance(sid string, instance *MicroServiceInstance) (string, error)
	RegisterServiceAndInstance(microService *MicroService, instance *MicroServiceInstance) (string, string, error)
	Heartbeat(microServiceID, microServiceInstanceID string) (bool, error)
	WSHeartbeat(microServiceID, microServiceInstanceID string, callback func()) (bool, error)
	UnRegisterMicroServiceInstance(microServiceID, microServiceInstanceID string) error
	UpdateMicroServiceInstanceStatus(microServiceID, microServiceInstanceID, status string) error
	UpdateMicroServiceProperties(microServiceID string, properties map[string]string) error
	UpdateMicroServiceInstanceProperties(microServiceID, microServiceInstanceID string, properties map[string]string) error
	AddSchemas(microServiceID, schemaName, schemaInfo string) error
}

type Response struct {
	Description string            `yaml:"description"`
	Schema      map[string]string `yaml:"schema"`
}

type Schema struct {
	Schema string `json:"schema"`
}

type SchemaContent struct {
	Swagger    string                           `yaml:"swagger"`
	Info       map[string]string                `yaml:"info"`
	BasePath   string                           `yaml:"basePath"`
	Produces   []string                         `yaml:"produces"`
	Paths      map[string]map[string]MethodInfo `yaml:"paths"`
	Definition map[string]Definition            `yaml:"definitions"`
}

type SchemaContents struct {
	Schemas []*SchemaContent
}

type SchemaValue struct {
	Reference            string                 `yaml:"$ref"`
	Format               string                 `yaml:"format"`
	Title                string                 `yaml:"title"`
	Description          string                 `yaml:"description"`
	Default              string                 `yaml:"default"`
	MultipleOf           int                    `yaml:"multipleOf"`
	ExclusiveMaximum     int                    `yaml:"exclusiveMaximum"`
	Minimum              int                    `yaml:"minimum"`
	ExclusiveMinimum     int                    `yaml:"exclusiveMinimum"`
	MaxLength            int                    `yaml:"maxLength"`
	MinLength            int                    `yaml:"minLength"`
	Pattern              int                    `yaml:"pattern"`
	MaxItems             int                    `yaml:"maxItems"`
	MinItems             int                    `yaml:"minItems"`
	UniqueItems          bool                   `yaml:"uniqueItems"`
	MaxProperties        int                    `yaml:"maxProperties"`
	MinProperties        int                    `yaml:"minProperties"`
	Required             bool                   `yaml:"required"`
	Enum                 []interface{}          `yaml:"enum"`
	Type                 string                 `yaml:"type"`
	Items                Item                   `yaml:"items"`
	Properties           map[string]interface{} `yaml:"properties"`
	AdditionalProperties map[string]string      `yaml:"additionalProperties"`
}

type ServiceDiscovery interface {
	GetMicroService(microServiceID string) (*MicroService, error)
	FindMicroServiceInstances(consumerID, microServiceName string, tags utiltags.Tags) ([]*MicroServiceInstance, error)
	AutoSync()
	Close() error
}

type ServicePath struct {
	Path     string
	Property map[string]string
}

type SourceInfo struct {
	Name string
	Tags map[string]string
}