import (
    ...
	"github.com/polarismesh/polaris-go"
)


func main() {
    provider, err := polaris.NewProviderAPI()
}

// InstanceRegisterRequest 注册服务请求
type InstanceRegisterRequest struct {
	// 必选，服务名
	Service string
	// 必选，命名空间
	Namespace string
	// 必选，服务监听host，支持IPv6地址
	Host string
	// 必选，服务实例监听port
	Port int
	// 可选，资源访问Token，即用户/用户组访问凭据，仅当服务端开启客户端鉴权时才需配置
	ServiceToken string
	// 以下字段可选，默认nil表示客户端不配置，使用服务端配置
	// 服务协议
	Protocol *string
	// 服务权重，默认100，范围0-10000
	Weight *int
	// 实例提供服务版本号
	Version *string
	// 用户自定义metadata信息
	Metadata map[string]string
	// 该服务实例是否健康，默认健康
	Healthy *bool
	// 该服务实例是否隔离，默认不隔离
	Isolate *bool
    // 设置心跳健康检查ttl，单位为s，不填默认为5s，TTL的取值范围为 (0s, 60s]
    // 开启了心跳健康检查，客户端必须以TTL间隔上报心跳
    // 健康检查服务器3个TTL未受到心跳则将实例置为不健康
	TTL *int
    // Location 当前注册实例的地理位置信息，主要用于就近路由
	Location *Location
	// 可选，单次查询超时时间，默认直接获取全局的超时配置
	// 用户总最大超时时间为(1+RetryCount) * Timeout
	Timeout *time.Duration
	// 可选，重试次数，默认直接获取全局的超时配置
	RetryCount *int
}

resp, err := provider.RegisterInstance(registerRequest)

consumer, err := polaris.NewConsumerAPI()

// GetAllInstancesRequest 获取所有实例的请求
type GetAllInstancesRequest struct {
	// 必选，服务名
	Service string
	// 必选，命名空间
	Namespace string
	// 可选，单次查询超时时间，默认直接获取全局的超时配置
	// 用户总最大超时时间为(1+RetryCount) * Timeout
	Timeout *time.Duration
	// 可选，重试次数，默认直接获取全局的超时配置
	RetryCount *int
}

// 调用该方法执行请求
consumer.GetAllInstances()

// GetInstancesRequest 批量服务实例查询请求
type GetInstancesRequest struct {
	// 必选，服务名
	Service string
	// 必选，命名空间
	Namespace string
	// 可选，元数据信息，仅用于dstMetadata路由插件的过滤
	Metadata map[string]string
	// 主调方服务信息，只用于路由规则匹配
	SourceService *ServiceInfo
	// 可选，是否跳过服务路由筛选，默认false
	SkipRouteFilter bool
	// 可选，单次查询超时时间，默认直接获取全局的超时配置
	// 用户总最大超时时间为(1+RetryCount) * Timeout
	Timeout *time.Duration
	// 可选，重试次数，默认直接获取全局的超时配置
	RetryCount *int
}

// 调用该方法执行请求
consumer.GetInstances()

// GetOneInstanceRequest 单个服务实例查询请求
type GetOneInstanceRequest struct {
	// 必选，服务名
	Service string
	// 必选，命名空间
	Namespace string
	// 可选，元数据信息，仅用于dstMetadata路由插件的过滤
	Metadata map[string]string
	// 是否开启元数据匹配不到时启用自定义匹配规则，仅用于dstMetadata路由插件
	EnableFailOverDefaultMeta bool
	// 自定义匹配规则，仅当EnableFailOverDefaultMeta为true时生效
	FailOverDefaultMeta FailOverDefaultMetaConfig
	// 用户计算hash值的key
	HashKey []byte
	// 主调方服务信息
	SourceService *ServiceInfo
	// 可选，单次查询超时时间，默认直接获取全局的超时配置
	// 用户总最大超时时间为(1+RetryCount) * Timeout
	Timeout *time.Duration
	// 可选，重试次数，默认直接获取全局的超时配置
	RetryCount *int
	// 可选，备份节点数
	// 对于一致性hash等有状态的负载均衡方式
	ReplicateCount int
	// 可选，负载均衡算法
	LbPolicy string
}

// 调用该方法执行请求
consumer.GetOneInstance()

router, err := polaris.NewRouterAPI()

// ProcessRoutersRequest 执行路由请求结构体
type ProcessRoutersRequest struct {
	// 可选参数，设置本次路由请求期望执行的路由插件
    // 当前支持的路由插件如下
    // - 自定义路由：ruleBasedRouter
    // - 就近路由：nearbyBasedRouter
    // - 元数据路由：dstMetaRouter
	Routers []string
	// 可选参数，主调服务信息，你可以通过 ServiceInfo.Metadata 设置本次请求的流量标签信息
	SourceService ServiceInfo
	// 必选参数，待执行服务路由的实例列表
	// 1. InstancesResponse, returned from ConsumerAPI.GetAllInstances.
	// 2. DefaultServiceInstances, for user to construct manually.
	DstInstances ServiceInstances
	// 可选参数，对应路由规则中的方法($method)标签
	Method string
	// 可选，单次查询超时时间，默认直接获取全局的超时配置
	// 用户总最大超时时间为(1+RetryCount) * Timeout
	Timeout *time.Duration
	// 可选，重试次数，默认直接获取全局的超时配置
	RetryCount *int
}

resp, err := router.ProcessRouters(routerRequest)
instances := resp.GetInstances()

router, err := polaris.NewRouterAPI()

// ProcessRoutersRequest 执行负载均衡请求结构体
type ProcessLoadBalanceRequest struct {
	// 必选参数，待执行负载均衡的实例列表
	// 1. InstancesResponse, returned from ConsumerAPI.GetAllInstances.
	// 2. DefaultServiceInstances, for user to construct manually.
	DstInstances ServiceInstances
	// 可选参数，负载均衡策略
    // 当前支持的负载均衡策略如下
    // - 权重随机: weightedRandom
    // - 一致性hash环: ringHash
    // - maglev hash: maglev
    // - 普通hash: hash
	LbPolicy string
	// 可选参数，对于有状态的负载均衡方式，用户可以设置用于 hash 计算的 Key
	HashKey []byte
}

resp, err := router.ProcessLoadBalance(loadbalanceRequest)
instance := resp.GetInstance()

import (
    ...
	"github.com/polarismesh/polaris-go"
)

func main() {
    circuitbreakerAPI, err := polaris.NewCircuitBreakerAPI()
}

// @param ctx: 当前调用上下文信息
// @param args: 方法入参
// @return interface{}: 用户方法实际执行的返回结果
// @return *CallAborted: 如果方法调用、服务调用被熔断, 则会返回 CallAborted 结构题指针
// @return error: 返回用户方法调用的 error 或者内部熔断执行逻辑的内部错误
type DecoratorFunction func(ctx context.Context, args interface{}) (interface{}, *CallAborted, error)

// 创建CircuitBreakAPI实例
circuitbreakerAPI, err := polaris.NewCircuitBreakerAPI()

dealF := circuitbreakerAPI.MakeFunctionDecorator(func(ctx context.Context, args interface{}) (interface{}, error) {
	// 用户业务逻辑函数
}, &api.RequestContext{
	RequestContext: model.RequestContext{
		Callee: &model.ServiceKey{
			Namespace: "被调服务所在命名空间",
			Service:   "被调服务名称",
		},
        Caller: &model.ServiceKey{
			Namespace: "主调服务所在命名空间",
			Service:   "主调服务名称",
		},
	},
})

ret, abort, err := dealF(context.Background(), endpoint)

circuitbreakerAPI, err := polaris.NewCircuitBreakerAPI()

dealF := circuitbreakerAPI.MakeFunctionDecorator(func(ctx context.Context, args interface{}) (interface{}, error) {
	resp, err := http.Get(fmt.Sprintf("http://%+v/echo", args))
	if resp != nil {
		defer resp.Body.Close()
	}
	if err != nil {
		return nil, err
	}
	data, _ := ioutil.ReadAll(resp.Body)
	return string(data), nil
}, &api.RequestContext{
	RequestContext: model.RequestContext{
		Callee: &model.ServiceKey{
			Namespace: "被调服务所在命名空间",
			Service:   "被调服务名称",
		},
        Caller: &model.ServiceKey{
			Namespace: "主调服务所在命名空间",
			Service:   "主调服务名称",
		},
		Method: "接口名称",
	},
})

ret, abort, err := dealF(context.Background(), endpoint)

// model.ResourceStat 中 RetStatus 字段的取值
// RetSuccess 调用成功
RetSuccess RetStatus = "success"
// RetFail 调用失败
RetFail RetStatus = "fail"
// RetTimeout 调用超时
RetTimeout RetStatus = "timeout"
// RetFlowControl 限流
RetFlowControl RetStatus = "flow_control"
// RetReject 被熔断
RetReject RetStatus = "reject"
// RetUnknown
RetUnknown RetStatus = "unknown"

circuitbreakerAPI, err := polaris.NewCircuitBreakerAPI()

// 构造 model.InstanceResource 对象
insRes, _ := model.NewInstanceResource(&model.ServiceKey{
	Namespace: "被调服务所在命名空间",
	Service:   "被调服务名称",
}, &model.ServiceKey{
	Namespace: "主调服务所在命名空间",
	Service:   "主调服务名称",
}, "协议信息, 比如 http/grpc/dubbo/tcp 等等", "被调实例的 IP", {被调实例端口信息})

// 上报每次的调用结果
circuitbreakerAPI.Report(&model.ResourceStat{
	Delay:     time.Since(start),
	RetStatus: model.RetFail, // 
	RetCode:   "响应码, string 类型",
	Resource:  insRes,
})

// 获取一个服务实例进行调用
getOneRequest := &polaris.GetOneInstanceRequest{}
getOneRequest.Namespace = namespace
getOneRequest.Service = service
getOneRequest.IncludeCircuitBreakInstances = true
oneInstResp, err := svr.consumer.GetOneInstance(getOneRequest)

import (
    ...
	"github.com/polarismesh/polaris-go"
)


func main() {
    limiter, err := polaris.NewLimitAPI()
}

type QuotaRequest interface {
	// SetNamespace 设置命名空间
	SetNamespace(string)
	// SetService 设置服务名
	SetService(string)
	// SetLabels 设置业务标签信息
	// Deprecated: please use AddArgument instead
	SetLabels(map[string]string)
	// SetMethod set method
	SetMethod(method string)
	// AddArgument add the match argument
	AddArgument(argument model.Argument)
	// SetToken set token to acquire
	SetToken(uint32)
	// SetTimeout 设置单次请求超时时间
	SetTimeout(timeout time.Duration)
	// SetRetryCount 设置最大重试次数
	SetRetryCount(retryCount int)
}

ret, err := limiter.GetQuota(QuotaRequest)

// QuotaFuture 实时/延时分配future
type QuotaFuture interface {
	// Done 标识分配是否结束
	Done() <-chan struct{}
	// Get 等待一段时间后，获取分配结果，用于匀速排队
	Get() *model.QuotaResponse
	// GetImmediately 立刻获取分配结果，不等待
	GetImmediately() *model.QuotaResponse
	// Release 释放资源，仅用于并发数限流的场景
	Release()
}

provider:
  rateLimit:
    enable: true
	limiterNamespace: Polaris
	limiterService: polaris.limiter

import (
    ...
	"github.com/polarismesh/polaris-go"
)


func main() {
    configAPI, err := polaris.NewConfigAPI()
}

// namespace: 命名空间
// fileGroup: 配置分组名称
// fileName: 配置文件名称
GetConfigFile(namespace, fileGroup, fileName string) (model.ConfigFile, error)

func changeListener(event model.ConfigFileChangeEvent) {
}

func main() {
    configFile, err := configAPI.GetConfigFile(namespace, fileGroup, fileName)
    configFile.AddChangeListener(changeListener)
}

// namespace: 命名空间
// fileGroup: 配置分组名称
// fileName: 配置文件名称
GetConfigFile(namespace, fileGroup, fileName string) (model.ConfigFile, error)

# 配置中心默认配置
config:
  # 配置过滤器
  configFilter:
    enable: true
    chain:
      # 启用配置解密插件
      - crypto
    plugin:
      crypto:
        # 配置解密插件的算法插件类型
        entries:
          - name: AES

// namespace: 命名空间
// group: 配置分组名称
GetConfigGroup(namesapce, group string) (model.ConfigFileGroup, error)

group.AddChangeListener(func(event *model.ConfigGroupChangeEvent) {
	before, _ := json.Marshal(event.Before)
	after, _ := json.Marshal(event.After)
	log.Printf("receive config_group change event\nbefore: %s\nafter: %s", string(before), string(after))
})

type SimpleConfigFile struct {
  // 配置文件命名空间
	Namespace   string
  // 配置文件所在分组名称
	FileGroup   string
  // 配置文件名称
	FileName    string
  // 配置文件的发布版本号，由服务端
	Version     uint64
	Md5         string
	ReleaseTime time.Time
}

// ConfigGroupChangeEvent 配置文件变更事件
type ConfigGroupChangeEvent struct {
  // Before 该配置分组之前所有已发布的配置文件列表信息
	Before []*SimpleConfigFile
  // After 该配置分组当前已发布的所有配置文件列表信息
	After  []*SimpleConfigFile
}

#描述:全局配置项
global:
  #统计上报设置
  statReporter:
    #描述：是否将统计信息上报至monitor
    #类型：bool
    enable: true
    #描述：启用的统计上报插件类型
    #类型：list
    #范围：已经注册的统计上报插件的名字
    chain:
      - prometheus
    plugin:
      prometheus:
        type: pull
        #描述: 设置 prometheus http-server 的监听IP
        #类型:string
        #默认使用SDK的绑定IP
        metricHost: 
        #描述: 设置 prometheus http-server 的监听端口
        #类型:int
        #默认值: 28080
        #如果设置为负数，则不会开启默认的http-server
        #如果设置为0，则随机选择一个可用端口进行启动 http-server
        metricPort: 28080

#描述:全局配置项
global:
  #统计上报设置
  statReporter:
    #描述：是否将统计信息上报至monitor
    #类型：bool
    enable: true
    #描述：启用的统计上报插件类型
    #类型：list
    #范围：已经注册的统计上报插件的名字
    chain:
      - prometheus
    plugin:
      prometheus:
        type: push
        #描述: 设置 pushgateway 的地址, 仅 type == push 时生效
        #类型:string
        #默认 ${global.serverConnector.addresses[0]}:9091
        address: 127.0.0.1:9091
        #描述:设置metric数据推送到pushgateway的执行周期, 仅 type == push 时生效
        #类型:string
        #格式:^\d+(ms|s|m|h)$
        #范围:[1m:...]
        #默认值:10m
        interval: 10s

cfg := config.NewDefaultConfiguration([]string{"127.0.0.1:8091"})
cfg.GetGlobal().GetStatReporter().SetEnable(true)
cfg.GetGlobal().GetStatReporter().SetChain([]string{"prometheus"})
cfg.GetGlobal().GetStatReporter().SetPluginConfig("prometheus", &prometheus.Config{
  Type: "pull",
	PortStr: "28080",
  IP: "",
})

cfg := config.NewDefaultConfiguration([]string{"127.0.0.1:8091"})
cfg.GetGlobal().GetStatReporter().SetEnable(true)
cfg.GetGlobal().GetStatReporter().SetChain([]string{"prometheus"})
cfg.GetGlobal().GetStatReporter().SetPluginConfig("prometheus", &prometheus.Config{
  Type: "push",
	Interval: 10 * time.Second,
  Address: "",
})

import (
    ...
	"github.com/polarismesh/polaris-go"
)

func main() {
    consumer, err := polaris.NewConsumerAPI()
}

type ServiceCallResult struct {
	// 上报的服务实例
	CalledInstance Instance
	// 调用接口方法
	Method string
	// 必选，本地服务调用的状态，正常or异常
	RetStatus RetStatus
	// 必选，本地服务调用的返回码
	RetCode *int32
	// 必选，被调服务实例获取接口的最大时延
	Delay *time.Duration
	// 可选，主调服务实例的服务信息
	SourceService *ServiceInfo
}

consumer.UpdateServiceCallResult(ServiceCallResult)

#描述:全局配置项
global:
  #描述系统相关配置
  system:
    #服务发现集群
    discoverCluster:
      namespace: Polaris
      service: polaris.discover
      #可选：服务刷新间隔
      refreshInterval: 10m
    #健康检查集群
    healthCheckCluster:
      namespace: Polaris
      service: polaris.healthcheck
      #可选：服务刷新间隔
      refreshInterval: 10m

dubbo:
  registries:
    polaris-1:
      protocol: polaris 
      address: ${北极星服务端IP}:8091
      namespace: ${北极星命名空间信息}
      token: ${北极星资源鉴权 token}   # 如果北极星服务端开启了针对客户端的鉴权，则需要配置该参数

func init() {
	config.SetProviderService(&UserProvider{})
	hessian.RegisterPOJO(&User{})
}

type UserProvider struct {}

func (u *UserProvider) GetUser(ctx context.Context, req *User) (*User, error) {
	rsp := User{"A001", "Alex Stocks", 18, time.Now()}
	return &rsp, nil
}

func main() {
	if err := config.Load(); err != nil {
		panic(err)
	}

	initSignal()
}

dubbo:
  registries:
    polaris-1:
      protocol: polaris 
      address: ${北极星服务端IP}:8091
      namespace: ${北极星命名空间信息}
      token: ${北极星资源鉴权 token}   # 如果北极星服务端开启了针对客户端的鉴权，则需要配置该参数

func main() {
    var userProvider = &UserProvider{}
    config.SetConsumerService(userProvider)
    hessian.RegisterPOJO(&User{})
    if err := config.Load(); err != nil {
        panic(err)
    }

    user, err := userProvider.GetUser(context.TODO(), &User{Name: "Alex001"})
    if err != nil {
        panic(err)
    }
    logger.Infof("response result: %v\n", user)
}

dubbo:
  registries:
    polaris-1:
      protocol: polaris 
      address: ${北极星服务端IP}:8091
      namespace: ${北极星命名空间信息}
      token: ${北极星资源鉴权 token}   # 如果北极星服务端开启了针对客户端的鉴权，则需要配置该参数

func (s *Service) GetUser(uid string) {
	atta := make(map[string]interface{})
	atta["uid"] = uid
    // 通过这种方式往 attachement 传入路由条件
	reqContext := context.WithValue(context.Background(), constant.DubboCtxKey("attachment"), atta)
	for i := 0; i < 5; i++ {
		time.Sleep(200 * time.Millisecond)
		user, err := userProvider.GetUser(reqContext, &User{Name: "Alex001"})
		if err != nil {
			logger.Errorf("error: %v\n", err)
		}
		logger.Infof("response: %v\n", user)
	}
}

dubbo:
  registries:
    polaris-1:
      protocol: polaris 
      address: ${北极星服务端IP}:8091
      namespace: ${北极星命名空间信息}
      token: ${北极星资源鉴权 token}   # 如果北极星服务端开启了针对客户端的鉴权，则需要配置该参数
  provider:
    services:
      UserProvider:
        interface: org.apache.dubbo.UserProvider.Test
        tps.limiter: polaris-limit  # 配置 tps.limiter 为 polaris-limiter 即可

// 完成 grpc Server 的创建以及注册 grpc service
srv := grpc.NewServer()
listen, err := net.Listen("tcp", "0.0.0.0:8080")
if err != nil {
	log.Fatal(err)
}
pb.RegisterEchoServerServer(srv, &EchoQuickStartService{
	actualPort: listen.Addr().(*net.TCPAddr).Port,
})

// 将 使用 polaris.Serve 方法启动 grpc server
if err := polaris.Serve(srv, listen,
	polaris.WithServiceName("QuickStartEchoServerGRPC"),
); nil != err {
	log.Printf("listen err: %v", err)
}

// 使用 grpc-go-polaris 提供的 DialContext 即可
conn, err := polaris.DialContext(ctx, "polaris://QuickStartEchoServerGRPC",
	polaris.WithGRPCDialOptions(grpc.WithTransportCredentials(insecure.NewCredentials())),
	polaris.WithDisableRouter(),
)

// 使用 grpc-go-polaris 提供的 DialContext 即可
conn, err := polaris.DialContext(ctx, "polaris://QuickStartEchoServerGRPC",
	polaris.WithGRPCDialOptions(grpc.WithTransportCredentials(insecure.NewCredentials())),
	polaris.WithEnableRouter(),
)

func (s *Service) GetUser(uid, value string) {
	md := metadata.Pairs("uid", uid)
	ctx := metadata.NewOutgoingContext(context.Background(), md)

	for i := 0; i < 5; i++ {
		time.Sleep(200 * time.Millisecond)
		resp, err := s.echoClient.Echo(ctx, &pb.EchoRequest{Value: value})
		if err != nil {
			logger.Errorf("error: %v\n", err)
		}
		logger.Infof("response: %v\n", user)
	}
}

#描述:主调端配置
consumer:
  ...
  #描述:负载均衡相关配置
  loadbalancer:
    #描述:负载均衡类型
    #范围:已注册的负载均衡插件名
    #默认值：权重随机负载均衡
	#支持参数：ringHash(一致性hash环)/maglev(maglev算法一致性hash)/hash(普通一致性hash)
    type: weightedRandom
    plugin:
      #描述:虚拟节点的数量
      #类型:int
      #默认值:500
      #ringHash:
      #  vnodeCount: 500
	  #maglev:
	  #  # 初始化表向量区间
	  #  tableSize: 65537

ctx := metadata.NewIncomingContext(context.Background(), metadata.MD{})
// 请求时设置本次请求的负载均衡算法
ctx = polaris.RequestScopeLbPolicy(ctx, api.LBPolicyRingHash)
ctx = polaris.RequestScopeLbHashKey(ctx, r.Header.Get("uid"))
resp, err := echoClient.Echo(ctx, &pb.EchoRequest{Value: value})

listen, err := net.Listen("tcp", "0.0.0.0:0")
if err != nil {
	log.Fatal(err)
}
listenAddr := listen.Addr().String()
interceptor := polaris.NewRateLimitInterceptor().WithServiceName("RateLimitEchoServerGRPC")
// 注册 polaris 服务限流拦截器
srv := grpc.NewServer(grpc.UnaryInterceptor(interceptor.UnaryInterceptor))
pb.RegisterEchoServerServer(srv, &EchoRateLimitService{})
// 启动服务
if err := polaris.Serve(srv, listen,
	polaris.WithServiceName("RateLimitEchoServerGRPC"),
); nil != err {
	log.Printf("listen err: %v", err)
}