diff --git a/registry/inmemory/service_discovery.go b/registry/inmemory/service_discovery.go index 73af948fc6aab56dd580937a4cc9e41ffa33f14b..3dac35cd381a7e0e1c0694d6376c85eb7762afc4 100644 --- a/registry/inmemory/service_discovery.go +++ b/registry/inmemory/service_discovery.go @@ -20,7 +20,9 @@ package inmemory import ( "github.com/dubbogo/gost/container/set" "github.com/dubbogo/gost/page" +) +import ( "github.com/apache/dubbo-go/common" "github.com/apache/dubbo-go/common/extension" "github.com/apache/dubbo-go/registry" @@ -34,6 +36,7 @@ func init() { instance := &InMemoryServiceDiscovery{ instances: make(map[string]registry.ServiceInstance, 4), + listeners: make([]*registry.ServiceInstancesChangedListener, 0, 2), } extension.SetServiceDiscovery(name, func(url *common.URL) (discovery registry.ServiceDiscovery, err error) { @@ -45,6 +48,7 @@ func init() { // Usually you will not use this implementation except for tests. type InMemoryServiceDiscovery struct { instances map[string]registry.ServiceInstance + listeners []*registry.ServiceInstancesChangedListener } func (i *InMemoryServiceDiscovery) String() string { @@ -55,6 +59,7 @@ func (i *InMemoryServiceDiscovery) String() string { func (i *InMemoryServiceDiscovery) Destroy() error { // reset to empty i.instances = make(map[string]registry.ServiceInstance, 4) + i.listeners = make([]*registry.ServiceInstancesChangedListener, 0, 2) return nil } @@ -100,31 +105,58 @@ func (i *InMemoryServiceDiscovery) GetInstances(serviceName string) []registry.S return result } -// +// GetInstancesByPage will return the part of instances func (i *InMemoryServiceDiscovery) GetInstancesByPage(serviceName string, offset int, pageSize int) gxpage.Pager { - panic("implement me") + instances := i.GetInstances(serviceName) + // we can not use []registry.ServiceInstance since New(...) received []interface{} as parameter + result := make([]interface{}, 0, pageSize) + for i := offset; i < len(instances) && i < offset+pageSize; i++ { + result = append(result, instances[i]) + } + return gxpage.New(offset, pageSize, result, len(instances)) } +// GetHealthyInstancesByPage will return the instances func (i *InMemoryServiceDiscovery) GetHealthyInstancesByPage(serviceName string, offset int, pageSize int, healthy bool) gxpage.Pager { - panic("implement me") + instances := i.GetInstances(serviceName) + // we can not use []registry.ServiceInstance since New(...) received []interface{} as parameter + result := make([]interface{}, 0, pageSize) + count := 0 + for i := offset; i < len(instances) && count < pageSize; i++ { + if instances[i].IsHealthy() == healthy { + result = append(result, instances[i]) + count++ + } + } + return gxpage.New(offset, pageSize, result, len(instances)) } +// GetRequestInstances will iterate the serviceName and aggregate them func (i *InMemoryServiceDiscovery) GetRequestInstances(serviceNames []string, offset int, requestedSize int) map[string]gxpage.Pager { - panic("implement me") + res := make(map[string]gxpage.Pager, len(serviceNames)) + for _, name := range serviceNames { + res[name] = i.GetInstancesByPage(name, offset, requestedSize) + } + return res } +// AddListener will save the listener inside the memory func (i *InMemoryServiceDiscovery) AddListener(listener *registry.ServiceInstancesChangedListener) error { - panic("implement me") + i.listeners = append(i.listeners, listener) + return nil } +// DispatchEventByServiceName will do nothing func (i *InMemoryServiceDiscovery) DispatchEventByServiceName(serviceName string) error { - panic("implement me") + return nil } +// DispatchEventForInstances will do nothing func (i *InMemoryServiceDiscovery) DispatchEventForInstances(serviceName string, instances []registry.ServiceInstance) error { - panic("implement me") + return nil } +// DispatchEvent will do nothing func (i *InMemoryServiceDiscovery) DispatchEvent(event *registry.ServiceInstancesChangedEvent) error { - panic("implement me") + return nil } diff --git a/registry/inmemory/service_discovery_test.go b/registry/inmemory/service_discovery_test.go new file mode 100644 index 0000000000000000000000000000000000000000..a934dbabfff7f4041df6dcca77ecc825b3ce391b --- /dev/null +++ b/registry/inmemory/service_discovery_test.go @@ -0,0 +1,98 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package inmemory + +import ( + "testing" +) + +import ( + "github.com/stretchr/testify/assert" +) + +import ( + "github.com/apache/dubbo-go/common/extension" + "github.com/apache/dubbo-go/registry" +) + +func TestInMemoryServiceDiscovery(t *testing.T) { + discovery, _ := extension.GetServiceDiscovery(name, nil) + serviceName := "my-service" + err := discovery.Register(®istry.DefaultServiceInstance{ + ServiceName: serviceName, + Id: "1", + Healthy: true, + }) + assert.Nil(t, err) + + err = discovery.Register(®istry.DefaultServiceInstance{ + Id: "2", + ServiceName: "mock-service", + Healthy: false, + }) + + assert.Nil(t, err) + + services := discovery.GetServices() + assert.Equal(t, 2, services.Size()) + assert.Equal(t, registry.DefaultPageSize, discovery.GetDefaultPageSize()) + + reqInstances := discovery.GetRequestInstances([]string{serviceName, "mock-service"}, 0, 10) + assert.Equal(t, 2, len(reqInstances)) + + page := discovery.GetInstancesByPage(serviceName, 0, 10) + assert.Equal(t, 1, page.GetDataSize()) + + discovery.GetHealthyInstancesByPage(serviceName, 0, 10, true) + page = discovery.GetInstancesByPage(serviceName, 0, 10) + assert.Equal(t, 1, page.GetDataSize()) + + err = discovery.AddListener(®istry.ServiceInstancesChangedListener{}) + assert.Nil(t, err) + + err = discovery.DispatchEvent(®istry.ServiceInstancesChangedEvent{}) + assert.Nil(t, err) + + err = discovery.DispatchEventForInstances(serviceName, nil) + assert.Nil(t, err) + + err = discovery.DispatchEventByServiceName(serviceName) + assert.Nil(t, err) + + err = discovery.Unregister(®istry.DefaultServiceInstance{ + Id: "2", + }) + assert.Nil(t, err) + + services = discovery.GetServices() + assert.Equal(t, 1, services.Size()) + + err = discovery.Update(®istry.DefaultServiceInstance{ + Id: "3", + }) + assert.Nil(t, err) + + services = discovery.GetServices() + assert.Equal(t, 2, services.Size()) + + err = discovery.Destroy() + assert.Nil(t, err) + + services = discovery.GetServices() + assert.Equal(t, 0, services.Size()) +}