service

package
v0.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 21, 2021 License: AGPL-3.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	CT_K8S  = "kubernetes"
	CT_DCOS = "dcos"
	CT_EDAS = "edas"
)
View Source 
const (
	ZONE_TYPE_DICE_APP    = "diceApp" //已废弃
	ZONE_TYPE_PACKAGE     = "package" // 老的入口
	ZONE_TYPE_PACKAGE_NEW = "packageNew"
	ZONE_TYPE_PACKAGE_API = "packageApi"
	ZONE_TYPE_UNITY       = "unity"
)

Variables

View Source 
var GLOBAL_REGIONS = []string{"option", "main", "http", "server"}
View Source 
var ZONE_REGIONS = []string{"annotation", "location"}

Functions

This section is empty.

Types

type AdminProjectDto 

type AdminProjectDto struct {
	Name          string            `json:"name"`
	ClusterConfig map[string]string `json:"clusterConfig"`
}

type AdminRespDto 

type AdminRespDto struct {
	Success bool            `json:"success"`
	Data    AdminProjectDto `json:"data"`
}

type ClusterInfoDto 

type ClusterInfoDto struct {
	DiceClusterType string `json:"DICE_CLUSTER_TYPE"`
	DiceRootDomain  string `json:"DICE_ROOT_DOMAIN"`
	MasterAddr      string `json:"MASTER_VIP_ADDR"`
	NetportalUrl    string `json:"NETPORTAL_URL"`
}

type ClusterRespDto 

type ClusterRespDto struct {
	Success bool           `json:"success"`
	Data    ClusterInfoDto `json:"data"`
}

type ConfigInfo 

type ConfigInfo struct {
	ConfigItem
	IsolationConfig ConfigItem `json:"ISOLATION_CONFIG"`
	IsolationEnvs   []string   `json:"ISOLATION_ENVS"`
	ProjectName     string     `json:"PROJECT_NAME"`
}

type ConfigItem 

type ConfigItem struct {
	GatewayEndpoint string `json:"GATEWAY_ENDPOINT"`
	VipKongHost     string `json:"VIP_KONG_HOST"`
	ProxyKongPort   string `json:"PROXY_KONG_PORT"`
	AdminEndpoint   string `json:"ADMIN_ENDPOINT"`
	DiceAddon       string `json:"GATEWAY_INSTANCE_ID"`
}

type GatewayApiInPackageService 

type GatewayApiInPackageService interface {
	NewSession(...*SessionHelper) (GatewayApiInPackageService, error)
	Insert(*GatewayApiInPackage) error
	Delete(packageId, apiId string) error
	DeleteByPackageId(string) error
	// use for delete or update api check
	SelectByApi(string) ([]GatewayApiInPackage, error)
}

type GatewayApiInPackageServiceImpl 

type GatewayApiInPackageServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayApiInPackageServiceImpl 

func NewGatewayApiInPackageServiceImpl() (*GatewayApiInPackageServiceImpl, error)

func (*GatewayApiInPackageServiceImpl) Delete 

func (impl *GatewayApiInPackageServiceImpl) Delete(packageId, apiId string) error

func (*GatewayApiInPackageServiceImpl) DeleteByPackageId 

func (impl *GatewayApiInPackageServiceImpl) DeleteByPackageId(packageId string) error

func (*GatewayApiInPackageServiceImpl) Get 

func (impl *GatewayApiInPackageServiceImpl) Get(id string) (*orm.GatewayApiInPackage, error)

func (*GatewayApiInPackageServiceImpl) GetByAny 

func (impl *GatewayApiInPackageServiceImpl) GetByAny(cond *orm.GatewayApiInPackage) (*orm.GatewayApiInPackage, error)

func (*GatewayApiInPackageServiceImpl) Insert 

func (impl *GatewayApiInPackageServiceImpl) Insert(dao *orm.GatewayApiInPackage) error

func (*GatewayApiInPackageServiceImpl) NewSession 

func (impl *GatewayApiInPackageServiceImpl) NewSession(helper ...*SessionHelper) (GatewayApiInPackageService, error)

func (*GatewayApiInPackageServiceImpl) SelectByAny 

func (impl *GatewayApiInPackageServiceImpl) SelectByAny(cond *orm.GatewayApiInPackage) ([]orm.GatewayApiInPackage, error)

func (*GatewayApiInPackageServiceImpl) SelectByApi 

func (impl *GatewayApiInPackageServiceImpl) SelectByApi(id string) ([]orm.GatewayApiInPackage, error)

func (*GatewayApiInPackageServiceImpl) Update 

func (impl *GatewayApiInPackageServiceImpl) Update(dao *orm.GatewayApiInPackage) error

type GatewayApiService 

type GatewayApiService interface {
	NewSession(...*SessionHelper) (GatewayApiService, error)
	Insert(*GatewayApi) error
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	Count(options []SelectOption) (int64, error)
	GetPageByConsumerId(consumerId string, page *Page) (*PageQuery, error)
	CountByConsumerId(consumerId string) (int64, error)
	GetById(string) (*GatewayApi, error)
	GetByAny(*GatewayApi) (*GatewayApi, error)
	GetRawByAny(*GatewayApi) (*GatewayApi, error)
	SelectByGroupId(string) ([]GatewayApi, error)
	DeleteById(string) error
	Update(*GatewayApi) error
	SelectByOptions(options []SelectOption) ([]GatewayApi, error)
	SelectByAny(*GatewayApi) ([]GatewayApi, error)
}

type GatewayApiServiceImpl 

type GatewayApiServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayApiServiceImpl 

func NewGatewayApiServiceImpl() (*GatewayApiServiceImpl, error)

func (*GatewayApiServiceImpl) Count 

func (impl *GatewayApiServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayApiServiceImpl) CountByConsumerId 

func (impl *GatewayApiServiceImpl) CountByConsumerId(consumerId string) (int64, error)

func (*GatewayApiServiceImpl) DeleteById 

func (impl *GatewayApiServiceImpl) DeleteById(id string) error

func (*GatewayApiServiceImpl) GetByAny 

func (impl *GatewayApiServiceImpl) GetByAny(cond *orm.GatewayApi) (*orm.GatewayApi, error)

func (*GatewayApiServiceImpl) GetById 

func (impl *GatewayApiServiceImpl) GetById(id string) (*orm.GatewayApi, error)

func (*GatewayApiServiceImpl) GetPage 

func (impl *GatewayApiServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayApiServiceImpl) GetPageByConsumerId 

func (impl *GatewayApiServiceImpl) GetPageByConsumerId(consumerId string, page *common.Page) (*common.PageQuery, error)

func (*GatewayApiServiceImpl) GetRawByAny 

func (impl *GatewayApiServiceImpl) GetRawByAny(cond *orm.GatewayApi) (*orm.GatewayApi, error)

func (*GatewayApiServiceImpl) Insert 

func (impl *GatewayApiServiceImpl) Insert(api *orm.GatewayApi) error

func (*GatewayApiServiceImpl) NewSession 

func (impl *GatewayApiServiceImpl) NewSession(helper ...*SessionHelper) (GatewayApiService, error)

func (*GatewayApiServiceImpl) SelectByAny 

func (impl *GatewayApiServiceImpl) SelectByAny(cond *orm.GatewayApi) ([]orm.GatewayApi, error)

func (*GatewayApiServiceImpl) SelectByGroupId 

func (impl *GatewayApiServiceImpl) SelectByGroupId(id string) ([]orm.GatewayApi, error)

func (*GatewayApiServiceImpl) SelectByOptions 

func (impl *GatewayApiServiceImpl) SelectByOptions(options []orm.SelectOption) ([]orm.GatewayApi, error)

func (*GatewayApiServiceImpl) Update 

func (impl *GatewayApiServiceImpl) Update(api *orm.GatewayApi) error

type GatewayAzInfoService 

type GatewayAzInfoService interface {
	GetAz(*GatewayAzInfo) (string, error)
	GetAzInfoByClusterName(name string) (*orm.GatewayAzInfo, error)
	GetAzInfo(*GatewayAzInfo) (*GatewayAzInfo, error)
	SelectByAny(*GatewayAzInfo) ([]GatewayAzInfo, error)
	SelectValidAz() ([]GatewayAzInfo, error)
}

type GatewayAzInfoServiceImpl 

type GatewayAzInfoServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayAzInfoServiceImpl 

func NewGatewayAzInfoServiceImpl() (*GatewayAzInfoServiceImpl, error)

func (*GatewayAzInfoServiceImpl) GetAz 

func (impl *GatewayAzInfoServiceImpl) GetAz(cond *orm.GatewayAzInfo) (string, error)

func (*GatewayAzInfoServiceImpl) GetAzInfo 

func (impl *GatewayAzInfoServiceImpl) GetAzInfo(cond *orm.GatewayAzInfo) (*orm.GatewayAzInfo, error)

func (*GatewayAzInfoServiceImpl) GetAzInfoByClusterName 

func (impl *GatewayAzInfoServiceImpl) GetAzInfoByClusterName(name string) (*orm.GatewayAzInfo, error)

func (*GatewayAzInfoServiceImpl) SelectByAny 

func (impl *GatewayAzInfoServiceImpl) SelectByAny(cond *orm.GatewayAzInfo) ([]orm.GatewayAzInfo, error)

func (*GatewayAzInfoServiceImpl) SelectValidAz 

func (impl *GatewayAzInfoServiceImpl) SelectValidAz() ([]orm.GatewayAzInfo, error)

type GatewayConfig 

type GatewayConfig struct {
	Success bool       `json:"success"`
	Data    ConfigInfo `json:"data"`
}

type GatewayConsumerApiService 

type GatewayConsumerApiService interface {
	Insert(*GatewayConsumerApi) error
	Update(*GatewayConsumerApi) error
	DeleteById(id string) error
	GetByConsumerAndApi(string, string) (*GatewayConsumerApi, error)
	GetById(string) (*GatewayConsumerApi, error)
	SelectByConsumer(string) ([]GatewayConsumerApi, error)
	SelectByApi(string) ([]GatewayConsumerApi, error)
}

type GatewayConsumerApiServiceImpl 

type GatewayConsumerApiServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayConsumerApiServiceImpl 

func NewGatewayConsumerApiServiceImpl() (*GatewayConsumerApiServiceImpl, error)

func (*GatewayConsumerApiServiceImpl) DeleteById 

func (impl *GatewayConsumerApiServiceImpl) DeleteById(id string) error

func (*GatewayConsumerApiServiceImpl) GetByConsumerAndApi 

func (impl *GatewayConsumerApiServiceImpl) GetByConsumerAndApi(consumerId string, apiId string) (*orm.GatewayConsumerApi, error)

func (*GatewayConsumerApiServiceImpl) GetById 

func (impl *GatewayConsumerApiServiceImpl) GetById(id string) (*orm.GatewayConsumerApi, error)

func (*GatewayConsumerApiServiceImpl) Insert 

func (impl *GatewayConsumerApiServiceImpl) Insert(api *orm.GatewayConsumerApi) error

func (*GatewayConsumerApiServiceImpl) SelectByApi 

func (impl *GatewayConsumerApiServiceImpl) SelectByApi(apiId string) ([]orm.GatewayConsumerApi, error)

func (*GatewayConsumerApiServiceImpl) SelectByConsumer 

func (impl *GatewayConsumerApiServiceImpl) SelectByConsumer(consumerId string) ([]orm.GatewayConsumerApi, error)

func (*GatewayConsumerApiServiceImpl) Update 

func (impl *GatewayConsumerApiServiceImpl) Update(api *orm.GatewayConsumerApi) error

type GatewayConsumerService 

type GatewayConsumerService interface {
	Get(*GatewayConsumer) (*GatewayConsumer, error)
	GetDefaultConsumerName(*GatewayConsumer) string
	GetDefaultConsumer(*GatewayConsumer) (*GatewayConsumer, error)
	GetByName(name string) (*GatewayConsumer, error)
	Insert(*GatewayConsumer) error
	Update(*GatewayConsumer) error
	GetById(string) (*GatewayConsumer, error)
	SelectByAny(*GatewayConsumer) ([]GatewayConsumer, error)
	GetByAny(*GatewayConsumer) (*GatewayConsumer, error)
	DeleteById(string) error
	CheckUnique(*GatewayConsumer) (bool, error)
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	Count(options []SelectOption) (int64, error)
	SelectByOptions(options []SelectOption) ([]GatewayConsumer, error)
}

type GatewayConsumerServiceImpl 

type GatewayConsumerServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayConsumerServiceImpl 

func NewGatewayConsumerServiceImpl() (*GatewayConsumerServiceImpl, error)

func (*GatewayConsumerServiceImpl) CheckUnique 

func (impl *GatewayConsumerServiceImpl) CheckUnique(consumer *orm.GatewayConsumer) (bool, error)

func (*GatewayConsumerServiceImpl) Count 

func (impl *GatewayConsumerServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayConsumerServiceImpl) DeleteById 

func (impl *GatewayConsumerServiceImpl) DeleteById(id string) error

func (*GatewayConsumerServiceImpl) Get 

func (impl *GatewayConsumerServiceImpl) Get(cond *orm.GatewayConsumer) (*orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) GetByAny 

func (impl *GatewayConsumerServiceImpl) GetByAny(cond *orm.GatewayConsumer) (*orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) GetById 

func (impl *GatewayConsumerServiceImpl) GetById(id string) (*orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) GetByName 

func (impl *GatewayConsumerServiceImpl) GetByName(name string) (*orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) GetDefaultConsumer 

func (impl *GatewayConsumerServiceImpl) GetDefaultConsumer(cond *orm.GatewayConsumer) (*orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) GetDefaultConsumerName 

func (impl *GatewayConsumerServiceImpl) GetDefaultConsumerName(dao *orm.GatewayConsumer) string

func (*GatewayConsumerServiceImpl) GetPage 

func (impl *GatewayConsumerServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayConsumerServiceImpl) Insert 

func (impl *GatewayConsumerServiceImpl) Insert(consumer *orm.GatewayConsumer) error

func (*GatewayConsumerServiceImpl) SelectByAny 

func (impl *GatewayConsumerServiceImpl) SelectByAny(cond *orm.GatewayConsumer) ([]orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) SelectByOptions 

func (impl *GatewayConsumerServiceImpl) SelectByOptions(options []orm.SelectOption) ([]orm.GatewayConsumer, error)

func (*GatewayConsumerServiceImpl) Update 

func (impl *GatewayConsumerServiceImpl) Update(consumer *orm.GatewayConsumer) error

type GatewayDefaultPolicyService 

type GatewayDefaultPolicyService interface {
	NewSession(...*SessionHelper) (GatewayDefaultPolicyService, error)
	CreateOrUpdate(*GatewayDefaultPolicy) error
	Insert(*GatewayDefaultPolicy) error
	GetByAny(*GatewayDefaultPolicy) (*GatewayDefaultPolicy, error)
	SelectByAny(*GatewayDefaultPolicy) ([]GatewayDefaultPolicy, error)
	Update(*GatewayDefaultPolicy) error
}

type GatewayDefaultPolicyServiceImpl 

type GatewayDefaultPolicyServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayDefaultPolicyServiceImpl 

func NewGatewayDefaultPolicyServiceImpl() (*GatewayDefaultPolicyServiceImpl, error)

func (*GatewayDefaultPolicyServiceImpl) CreateOrUpdate 

func (impl *GatewayDefaultPolicyServiceImpl) CreateOrUpdate(dao *orm.GatewayDefaultPolicy) error

func (*GatewayDefaultPolicyServiceImpl) GetByAny 

func (impl *GatewayDefaultPolicyServiceImpl) GetByAny(cond *orm.GatewayDefaultPolicy) (*orm.GatewayDefaultPolicy, error)

func (*GatewayDefaultPolicyServiceImpl) Insert 

func (impl *GatewayDefaultPolicyServiceImpl) Insert(defaultPolicy *orm.GatewayDefaultPolicy) error

func (*GatewayDefaultPolicyServiceImpl) NewSession 

func (impl *GatewayDefaultPolicyServiceImpl) NewSession(helper ...*SessionHelper) (GatewayDefaultPolicyService, error)

func (*GatewayDefaultPolicyServiceImpl) SelectByAny 

func (impl *GatewayDefaultPolicyServiceImpl) SelectByAny(cond *orm.GatewayDefaultPolicy) ([]orm.GatewayDefaultPolicy, error)

func (*GatewayDefaultPolicyServiceImpl) Update 

func (impl *GatewayDefaultPolicyServiceImpl) Update(policy *orm.GatewayDefaultPolicy) error

type GatewayDomainService 

type GatewayDomainService interface {
	NewSession(...*SessionHelper) (GatewayDomainService, error)
	Insert(*GatewayDomain) error
	Update(*GatewayDomain) error
	Delete(string) error
	Get(string) (*GatewayDomain, error)
	DeleteByAny(*GatewayDomain) (int64, error)
	SelectByAny(*GatewayDomain) ([]GatewayDomain, error)
	GetByAny(*GatewayDomain) (*GatewayDomain, error)
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	SelectByOptions(options []SelectOption) ([]GatewayDomain, error)
}

type GatewayDomainServiceImpl 

type GatewayDomainServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayDomainServiceImpl 

func NewGatewayDomainServiceImpl() (*GatewayDomainServiceImpl, error)

func (*GatewayDomainServiceImpl) Count 

func (impl *GatewayDomainServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayDomainServiceImpl) Delete 

func (impl *GatewayDomainServiceImpl) Delete(id string) error

func (*GatewayDomainServiceImpl) DeleteByAny 

func (impl *GatewayDomainServiceImpl) DeleteByAny(cond *orm.GatewayDomain) (int64, error)

func (*GatewayDomainServiceImpl) Get 

func (impl *GatewayDomainServiceImpl) Get(id string) (*orm.GatewayDomain, error)

func (*GatewayDomainServiceImpl) GetByAny 

func (impl *GatewayDomainServiceImpl) GetByAny(cond *orm.GatewayDomain) (*orm.GatewayDomain, error)

func (*GatewayDomainServiceImpl) GetPage 

func (impl *GatewayDomainServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayDomainServiceImpl) Insert 

func (impl *GatewayDomainServiceImpl) Insert(dao *orm.GatewayDomain) error

func (*GatewayDomainServiceImpl) NewSession 

func (impl *GatewayDomainServiceImpl) NewSession(helper ...*SessionHelper) (GatewayDomainService, error)

func (*GatewayDomainServiceImpl) SelectByAny 

func (impl *GatewayDomainServiceImpl) SelectByAny(cond *orm.GatewayDomain) ([]orm.GatewayDomain, error)

func (*GatewayDomainServiceImpl) SelectByOptions 

func (impl *GatewayDomainServiceImpl) SelectByOptions(options []orm.SelectOption) ([]orm.GatewayDomain, error)

func (*GatewayDomainServiceImpl) Update 

func (impl *GatewayDomainServiceImpl) Update(dao *orm.GatewayDomain) error

type GatewayExtraService 

type GatewayExtraService interface {
	GetByKeyAndField(key string, field string) (*GatewayExtra, error)
}

type GatewayExtraServiceImpl 

type GatewayExtraServiceImpl struct {
	// contains filtered or unexported fields
}

func (*GatewayExtraServiceImpl) GetByKeyAndField 

func (impl *GatewayExtraServiceImpl) GetByKeyAndField(key string, field string) (*orm.GatewayExtra, error)

type GatewayGroupService 

type GatewayGroupService interface {
	Insert(*GatewayGroup) error
	GetPageByConsumerId(consumerId string, page *Page) (*PageQuery, error)
	CountByConsumerId(consumerId string) (int64, error)
	DeleteById(groupId string) error
	Update(*GatewayGroup) error
	GetById(groupId string) (*GatewayGroup, error)
	GetByNameAndConsumerId(groupName string, consumerId string) (*GatewayGroup, error)
}

type GatewayGroupServiceImpl 

type GatewayGroupServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayGroupServiceImpl 

func NewGatewayGroupServiceImpl() (*GatewayGroupServiceImpl, error)

func (*GatewayGroupServiceImpl) CountByConsumerId 

func (impl *GatewayGroupServiceImpl) CountByConsumerId(consumerId string) (int64, error)

func (*GatewayGroupServiceImpl) DeleteById 

func (impl *GatewayGroupServiceImpl) DeleteById(id string) error

func (*GatewayGroupServiceImpl) GetById 

func (impl *GatewayGroupServiceImpl) GetById(id string) (*orm.GatewayGroup, error)

func (*GatewayGroupServiceImpl) GetByNameAndConsumerId 

func (impl *GatewayGroupServiceImpl) GetByNameAndConsumerId(name string, id string) (*orm.GatewayGroup, error)

func (*GatewayGroupServiceImpl) GetPageByConsumerId 

func (impl *GatewayGroupServiceImpl) GetPageByConsumerId(consumerId string, page *common.Page) (*common.PageQuery, error)

func (*GatewayGroupServiceImpl) Insert 

func (impl *GatewayGroupServiceImpl) Insert(group *orm.GatewayGroup) error

func (*GatewayGroupServiceImpl) Update 

func (impl *GatewayGroupServiceImpl) Update(group *orm.GatewayGroup) error

type GatewayIngressPolicyService 

type GatewayIngressPolicyService interface {
	NewSession(...*SessionHelper) (GatewayIngressPolicyService, error)
	Insert(*GatewayIngressPolicy) error
	GetByAny(*GatewayIngressPolicy) (*GatewayIngressPolicy, error)
	SelectByAny(*GatewayIngressPolicy) ([]GatewayIngressPolicy, error)
	Update(*GatewayIngressPolicy) error
	UpdatePartial(*GatewayIngressPolicy, ...string) error
	CreateOrUpdate(*GatewayIngressPolicy) error
	GetChangesByRegions(az, regions string, zoneId ...string) (*IngressChanges, error)
	GetChangesByRegionsImpl(az, regions string, zoneId ...string) (*IngressChanges, error)
}

type GatewayIngressPolicyServiceImpl 

type GatewayIngressPolicyServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayIngressPolicyServiceImpl 

func NewGatewayIngressPolicyServiceImpl() (*GatewayIngressPolicyServiceImpl, error)

func (*GatewayIngressPolicyServiceImpl) CreateOrUpdate 

func (impl *GatewayIngressPolicyServiceImpl) CreateOrUpdate(dao *orm.GatewayIngressPolicy) error

func (*GatewayIngressPolicyServiceImpl) GetByAny 

func (impl *GatewayIngressPolicyServiceImpl) GetByAny(cond *orm.GatewayIngressPolicy) (*orm.GatewayIngressPolicy, error)

func (*GatewayIngressPolicyServiceImpl) GetChangesByRegions 

func (impl *GatewayIngressPolicyServiceImpl) GetChangesByRegions(az, regions string, zoneId ...string) (*IngressChanges, error)

func (*GatewayIngressPolicyServiceImpl) GetChangesByRegionsImpl 

func (impl *GatewayIngressPolicyServiceImpl) GetChangesByRegionsImpl(az, regions string, zoneId ...string) (*IngressChanges, error)

func (*GatewayIngressPolicyServiceImpl) Insert 

func (impl *GatewayIngressPolicyServiceImpl) Insert(ingressPolicy *orm.GatewayIngressPolicy) error

func (*GatewayIngressPolicyServiceImpl) NewSession 

func (impl *GatewayIngressPolicyServiceImpl) NewSession(helper ...*SessionHelper) (GatewayIngressPolicyService, error)

func (*GatewayIngressPolicyServiceImpl) SelectByAny 

func (impl *GatewayIngressPolicyServiceImpl) SelectByAny(cond *orm.GatewayIngressPolicy) ([]orm.GatewayIngressPolicy, error)

func (*GatewayIngressPolicyServiceImpl) Update 

func (impl *GatewayIngressPolicyServiceImpl) Update(policy *orm.GatewayIngressPolicy) error

func (*GatewayIngressPolicyServiceImpl) UpdatePartial 

func (impl *GatewayIngressPolicyServiceImpl) UpdatePartial(policy *orm.GatewayIngressPolicy, fields ...string) error

type GatewayKongInfoService 

type GatewayKongInfoService interface {
	NewSession(...*SessionHelper) (GatewayKongInfoService, error)
	Update(*GatewayKongInfo) error
	Insert(*GatewayKongInfo) error
	GetTenantId(projectId, env, az string) (string, error)
	GetByAny(*GatewayKongInfo) (*GatewayKongInfo, error)
	GenK8SInfo(kongInfo *orm.GatewayKongInfo) (string, string, error)
	GetKongInfo(*GatewayKongInfo) (*GatewayKongInfo, error)
	GetK8SInfo(*GatewayKongInfo) (string, string, error)
	GetBelongTuples(instanceId string) ([]KongBelongTuple, error)
}

type GatewayKongInfoServiceImpl 

type GatewayKongInfoServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayKongInfoServiceImpl 

func NewGatewayKongInfoServiceImpl() (*GatewayKongInfoServiceImpl, error)

func (*GatewayKongInfoServiceImpl) GenK8SInfo 

func (impl *GatewayKongInfoServiceImpl) GenK8SInfo(kongInfo *orm.GatewayKongInfo) (string, string, error)

func (*GatewayKongInfoServiceImpl) GetBelongTuples 

func (impl *GatewayKongInfoServiceImpl) GetBelongTuples(instanceId string) ([]KongBelongTuple, error)

func (*GatewayKongInfoServiceImpl) GetByAny 

func (impl *GatewayKongInfoServiceImpl) GetByAny(cond *orm.GatewayKongInfo) (*orm.GatewayKongInfo, error)

func (*GatewayKongInfoServiceImpl) GetK8SInfo 

func (impl *GatewayKongInfoServiceImpl) GetK8SInfo(cond *orm.GatewayKongInfo) (string, string, error)

func (*GatewayKongInfoServiceImpl) GetKongInfo 

func (impl *GatewayKongInfoServiceImpl) GetKongInfo(cond *orm.GatewayKongInfo) (*orm.GatewayKongInfo, error)

func (*GatewayKongInfoServiceImpl) GetTenantId 

func (impl *GatewayKongInfoServiceImpl) GetTenantId(projectId, env, az string) (string, error)

func (*GatewayKongInfoServiceImpl) Insert 

func (impl *GatewayKongInfoServiceImpl) Insert(info *orm.GatewayKongInfo) error

func (*GatewayKongInfoServiceImpl) NewSession 

func (impl *GatewayKongInfoServiceImpl) NewSession(helper ...*SessionHelper) (GatewayKongInfoService, error)

func (*GatewayKongInfoServiceImpl) Update 

func (impl *GatewayKongInfoServiceImpl) Update(info *orm.GatewayKongInfo) error

type GatewayMockService 

type GatewayMockService interface {
	Update(*GatewayMock) error
	Insert(*GatewayMock) error
	GetMockByAny(*GatewayMock) (*GatewayMock, error)
}

type GatewayMockServiceImpl 

type GatewayMockServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayMockServiceImpl 

func NewGatewayMockServiceImpl() (*GatewayMockServiceImpl, error)

func (*GatewayMockServiceImpl) GetMockByAny 

func (impl *GatewayMockServiceImpl) GetMockByAny(cond *orm.GatewayMock) (*orm.GatewayMock, error)

func (*GatewayMockServiceImpl) Insert 

func (impl *GatewayMockServiceImpl) Insert(mock *orm.GatewayMock) error

func (*GatewayMockServiceImpl) Update 

func (impl *GatewayMockServiceImpl) Update(mock *orm.GatewayMock) error

type GatewayOrgClientService 

type GatewayOrgClientService interface {
	NewSession(...*SessionHelper) (GatewayOrgClientService, error)
	Insert(*GatewayOrgClient) error
	GetByAny(*GatewayOrgClient) (*GatewayOrgClient, error)
	GetById(string) (*GatewayOrgClient, error)
	Update(*GatewayOrgClient) error
	DeleteById(string) error
	SelectByAny(*GatewayOrgClient) ([]GatewayOrgClient, error)
	CheckUnique(*GatewayOrgClient) (bool, error)
}

type GatewayOrgClientServiceImpl 

type GatewayOrgClientServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayOrgClientServiceImpl 

func NewGatewayOrgClientServiceImpl() (*GatewayOrgClientServiceImpl, error)

func (*GatewayOrgClientServiceImpl) CheckUnique 

func (impl *GatewayOrgClientServiceImpl) CheckUnique(orgClient *orm.GatewayOrgClient) (bool, error)

func (*GatewayOrgClientServiceImpl) DeleteById 

func (impl *GatewayOrgClientServiceImpl) DeleteById(id string) error

func (*GatewayOrgClientServiceImpl) GetByAny 

func (impl *GatewayOrgClientServiceImpl) GetByAny(cond *orm.GatewayOrgClient) (*orm.GatewayOrgClient, error)

func (*GatewayOrgClientServiceImpl) GetById 

func (impl *GatewayOrgClientServiceImpl) GetById(id string) (*orm.GatewayOrgClient, error)

func (*GatewayOrgClientServiceImpl) Insert 

func (impl *GatewayOrgClientServiceImpl) Insert(orgClient *orm.GatewayOrgClient) error

func (*GatewayOrgClientServiceImpl) NewSession 

func (impl *GatewayOrgClientServiceImpl) NewSession(helper ...*SessionHelper) (GatewayOrgClientService, error)

func (*GatewayOrgClientServiceImpl) SelectByAny 

func (impl *GatewayOrgClientServiceImpl) SelectByAny(cond *orm.GatewayOrgClient) ([]orm.GatewayOrgClient, error)

func (*GatewayOrgClientServiceImpl) Update 

func (impl *GatewayOrgClientServiceImpl) Update(orgClient *orm.GatewayOrgClient) error

type GatewayPackageApiInConsumerService 

type GatewayPackageApiInConsumerService interface {
	NewSession(...*SessionHelper) (GatewayPackageApiInConsumerService, error)
	Insert(*GatewayPackageApiInConsumer) error
	Delete(packageId, packageApiId, consumerId string) error
	DeleteByConsumerId(string) error
	// use for show
	SelectByConsumer(string) ([]GatewayPackageApiInConsumer, error)
	SelectByPackageApi(string, string) ([]GatewayPackageApiInConsumer, error)
}

type GatewayPackageApiInConsumerServiceImpl 

type GatewayPackageApiInConsumerServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPackageApiInConsumerServiceImpl 

func NewGatewayPackageApiInConsumerServiceImpl() (*GatewayPackageApiInConsumerServiceImpl, error)

func (*GatewayPackageApiInConsumerServiceImpl) Delete 

func (impl *GatewayPackageApiInConsumerServiceImpl) Delete(packageId, packageApiId, consumerId string) error

func (*GatewayPackageApiInConsumerServiceImpl) DeleteByConsumerId 

func (impl *GatewayPackageApiInConsumerServiceImpl) DeleteByConsumerId(id string) error

func (*GatewayPackageApiInConsumerServiceImpl) Get 

func (impl *GatewayPackageApiInConsumerServiceImpl) Get(id string) (*orm.GatewayPackageApiInConsumer, error)

func (*GatewayPackageApiInConsumerServiceImpl) GetByAny 

func (impl *GatewayPackageApiInConsumerServiceImpl) GetByAny(cond *orm.GatewayPackageApiInConsumer) (*orm.GatewayPackageApiInConsumer, error)

func (*GatewayPackageApiInConsumerServiceImpl) Insert 

func (impl *GatewayPackageApiInConsumerServiceImpl) Insert(dao *orm.GatewayPackageApiInConsumer) error

func (*GatewayPackageApiInConsumerServiceImpl) NewSession 

func (impl *GatewayPackageApiInConsumerServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPackageApiInConsumerService, error)

func (*GatewayPackageApiInConsumerServiceImpl) SelectByAny 

func (impl *GatewayPackageApiInConsumerServiceImpl) SelectByAny(cond *orm.GatewayPackageApiInConsumer) ([]orm.GatewayPackageApiInConsumer, error)

func (*GatewayPackageApiInConsumerServiceImpl) SelectByConsumer 

func (impl *GatewayPackageApiInConsumerServiceImpl) SelectByConsumer(id string) ([]orm.GatewayPackageApiInConsumer, error)

func (*GatewayPackageApiInConsumerServiceImpl) SelectByPackageApi 

func (impl *GatewayPackageApiInConsumerServiceImpl) SelectByPackageApi(packageId, packageApiId string) ([]orm.GatewayPackageApiInConsumer, error)

func (*GatewayPackageApiInConsumerServiceImpl) Update 

func (impl *GatewayPackageApiInConsumerServiceImpl) Update(dao *orm.GatewayPackageApiInConsumer) error

type GatewayPackageApiService 

type GatewayPackageApiService interface {
	NewSession(...*SessionHelper) (GatewayPackageApiService, error)
	Insert(*GatewayPackageApi) error
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	Count(options []SelectOption) (int64, error)
	Update(*GatewayPackageApi, ...string) error
	Delete(string) error
	DeleteByPackageDiceApi(string, string) error
	Get(string) (*GatewayPackageApi, error)
	SelectByAny(*GatewayPackageApi) ([]GatewayPackageApi, error)
	GetByAny(*GatewayPackageApi) (*GatewayPackageApi, error)
	GetRawByAny(*GatewayPackageApi) (*GatewayPackageApi, error)
	DeleteByPackageId(string) error
	CheckUnique(*GatewayPackageApi) (bool, error)
}

type GatewayPackageApiServiceImpl 

type GatewayPackageApiServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPackageApiServiceImpl 

func NewGatewayPackageApiServiceImpl() (*GatewayPackageApiServiceImpl, error)

func (*GatewayPackageApiServiceImpl) CheckUnique 

func (impl *GatewayPackageApiServiceImpl) CheckUnique(dao *orm.GatewayPackageApi) (bool, error)

func (*GatewayPackageApiServiceImpl) Count 

func (impl *GatewayPackageApiServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayPackageApiServiceImpl) Delete 

func (impl *GatewayPackageApiServiceImpl) Delete(id string) error

func (*GatewayPackageApiServiceImpl) DeleteByPackageDiceApi 

func (impl *GatewayPackageApiServiceImpl) DeleteByPackageDiceApi(packageId, diceApiId string) error

func (*GatewayPackageApiServiceImpl) DeleteByPackageId 

func (impl *GatewayPackageApiServiceImpl) DeleteByPackageId(packageId string) error

func (*GatewayPackageApiServiceImpl) Get 

func (impl *GatewayPackageApiServiceImpl) Get(id string) (*orm.GatewayPackageApi, error)

func (*GatewayPackageApiServiceImpl) GetByAny 

func (impl *GatewayPackageApiServiceImpl) GetByAny(cond *orm.GatewayPackageApi) (*orm.GatewayPackageApi, error)

func (*GatewayPackageApiServiceImpl) GetPage 

func (impl *GatewayPackageApiServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayPackageApiServiceImpl) GetRawByAny 

func (impl *GatewayPackageApiServiceImpl) GetRawByAny(cond *orm.GatewayPackageApi) (*orm.GatewayPackageApi, error)

func (*GatewayPackageApiServiceImpl) Insert 

func (impl *GatewayPackageApiServiceImpl) Insert(dao *orm.GatewayPackageApi) error

func (*GatewayPackageApiServiceImpl) NewSession 

func (impl *GatewayPackageApiServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPackageApiService, error)

func (*GatewayPackageApiServiceImpl) SelectByAny 

func (impl *GatewayPackageApiServiceImpl) SelectByAny(cond *orm.GatewayPackageApi) ([]orm.GatewayPackageApi, error)

func (*GatewayPackageApiServiceImpl) Update 

func (impl *GatewayPackageApiServiceImpl) Update(dao *orm.GatewayPackageApi, columns ...string) error

type GatewayPackageInConsumerService 

type GatewayPackageInConsumerService interface {
	NewSession(...*SessionHelper) (GatewayPackageInConsumerService, error)
	Insert(*GatewayPackageInConsumer) error
	Delete(packageId, consumerId string) error
	DeleteByConsumerId(string) error
	DeleteByPackageId(string) error
	// use for show
	SelectByConsumer(string) ([]GatewayPackageInConsumer, error)
	// also used for delete package check
	SelectByPackage(string) ([]GatewayPackageInConsumer, error)
}

type GatewayPackageInConsumerServiceImpl 

type GatewayPackageInConsumerServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPackageInConsumerServiceImpl 

func NewGatewayPackageInConsumerServiceImpl() (*GatewayPackageInConsumerServiceImpl, error)

func (*GatewayPackageInConsumerServiceImpl) Delete 

func (impl *GatewayPackageInConsumerServiceImpl) Delete(packageId, consumerId string) error

func (*GatewayPackageInConsumerServiceImpl) DeleteByConsumerId 

func (impl *GatewayPackageInConsumerServiceImpl) DeleteByConsumerId(id string) error

func (*GatewayPackageInConsumerServiceImpl) DeleteByPackageId 

func (impl *GatewayPackageInConsumerServiceImpl) DeleteByPackageId(id string) error

func (*GatewayPackageInConsumerServiceImpl) Get 

func (impl *GatewayPackageInConsumerServiceImpl) Get(id string) (*orm.GatewayPackageInConsumer, error)

func (*GatewayPackageInConsumerServiceImpl) GetByAny 

func (impl *GatewayPackageInConsumerServiceImpl) GetByAny(cond *orm.GatewayPackageInConsumer) (*orm.GatewayPackageInConsumer, error)

func (*GatewayPackageInConsumerServiceImpl) Insert 

func (impl *GatewayPackageInConsumerServiceImpl) Insert(dao *orm.GatewayPackageInConsumer) error

func (*GatewayPackageInConsumerServiceImpl) NewSession 

func (impl *GatewayPackageInConsumerServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPackageInConsumerService, error)

func (*GatewayPackageInConsumerServiceImpl) SelectByAny 

func (impl *GatewayPackageInConsumerServiceImpl) SelectByAny(cond *orm.GatewayPackageInConsumer) ([]orm.GatewayPackageInConsumer, error)

func (*GatewayPackageInConsumerServiceImpl) SelectByConsumer 

func (impl *GatewayPackageInConsumerServiceImpl) SelectByConsumer(id string) ([]orm.GatewayPackageInConsumer, error)

func (*GatewayPackageInConsumerServiceImpl) SelectByPackage 

func (impl *GatewayPackageInConsumerServiceImpl) SelectByPackage(id string) ([]orm.GatewayPackageInConsumer, error)

func (*GatewayPackageInConsumerServiceImpl) Update 

func (impl *GatewayPackageInConsumerServiceImpl) Update(dao *orm.GatewayPackageInConsumer) error

type GatewayPackageRuleService 

type GatewayPackageRuleService interface {
	NewSession(...*SessionHelper) (GatewayPackageRuleService, error)
	Insert(*GatewayPackageRule) error
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	Count(options []SelectOption) (int64, error)
	Update(*GatewayPackageRule) error
	Delete(string) error
	Get(string) (*GatewayPackageRule, error)
	GetByAny(cond *GatewayPackageRule) (*GatewayPackageRule, error)
	SelectByAny(*GatewayPackageRule) ([]GatewayPackageRule, error)
	DeleteByPackageId(string) error
}

type GatewayPackageRuleServiceImpl 

type GatewayPackageRuleServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPackageRuleServiceImpl 

func NewGatewayPackageRuleServiceImpl() (*GatewayPackageRuleServiceImpl, error)

func (*GatewayPackageRuleServiceImpl) Count 

func (impl *GatewayPackageRuleServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayPackageRuleServiceImpl) Delete 

func (impl *GatewayPackageRuleServiceImpl) Delete(id string) error

func (*GatewayPackageRuleServiceImpl) DeleteByPackageId 

func (impl *GatewayPackageRuleServiceImpl) DeleteByPackageId(packageId string) error

func (*GatewayPackageRuleServiceImpl) Get 

func (impl *GatewayPackageRuleServiceImpl) Get(id string) (*orm.GatewayPackageRule, error)

func (*GatewayPackageRuleServiceImpl) GetByAny 

func (impl *GatewayPackageRuleServiceImpl) GetByAny(cond *orm.GatewayPackageRule) (*orm.GatewayPackageRule, error)

func (*GatewayPackageRuleServiceImpl) GetPage 

func (impl *GatewayPackageRuleServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayPackageRuleServiceImpl) Insert 

func (impl *GatewayPackageRuleServiceImpl) Insert(dao *orm.GatewayPackageRule) error

func (*GatewayPackageRuleServiceImpl) NewSession 

func (impl *GatewayPackageRuleServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPackageRuleService, error)

func (*GatewayPackageRuleServiceImpl) SelectByAny 

func (impl *GatewayPackageRuleServiceImpl) SelectByAny(cond *orm.GatewayPackageRule) ([]orm.GatewayPackageRule, error)

func (*GatewayPackageRuleServiceImpl) Update 

func (impl *GatewayPackageRuleServiceImpl) Update(dao *orm.GatewayPackageRule) error

type GatewayPackageService 

type GatewayPackageService interface {
	NewSession(...*SessionHelper) (GatewayPackageService, error)
	Insert(*GatewayPackage) error
	GetPage(options []SelectOption, page *Page) (*PageQuery, error)
	Count(options []SelectOption) (int64, error)
	Update(*GatewayPackage, ...string) error
	Delete(string, ...bool) error
	Get(string) (*GatewayPackage, error)
	GetByAny(cond *GatewayPackage) (*GatewayPackage, error)
	SelectByAny(*GatewayPackage) ([]GatewayPackage, error)
	//check id when update
	CheckUnique(*GatewayPackage) (bool, error)
}

type GatewayPackageServiceImpl 

type GatewayPackageServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPackageServiceImpl 

func NewGatewayPackageServiceImpl() (*GatewayPackageServiceImpl, error)

func (*GatewayPackageServiceImpl) CheckUnique 

func (impl *GatewayPackageServiceImpl) CheckUnique(dao *orm.GatewayPackage) (bool, error)

func (*GatewayPackageServiceImpl) Count 

func (impl *GatewayPackageServiceImpl) Count(options []orm.SelectOption) (int64, error)

func (*GatewayPackageServiceImpl) Delete 

func (impl *GatewayPackageServiceImpl) Delete(id string, realDelete ...bool) error

func (*GatewayPackageServiceImpl) Get 

func (impl *GatewayPackageServiceImpl) Get(id string) (*orm.GatewayPackage, error)

func (*GatewayPackageServiceImpl) GetByAny 

func (impl *GatewayPackageServiceImpl) GetByAny(cond *orm.GatewayPackage) (*orm.GatewayPackage, error)

func (*GatewayPackageServiceImpl) GetPage 

func (impl *GatewayPackageServiceImpl) GetPage(options []orm.SelectOption, page *common.Page) (*common.PageQuery, error)

func (*GatewayPackageServiceImpl) Insert 

func (impl *GatewayPackageServiceImpl) Insert(dao *orm.GatewayPackage) error

func (*GatewayPackageServiceImpl) NewSession 

func (impl *GatewayPackageServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPackageService, error)

func (*GatewayPackageServiceImpl) SelectByAny 

func (impl *GatewayPackageServiceImpl) SelectByAny(cond *orm.GatewayPackage) ([]orm.GatewayPackage, error)

func (*GatewayPackageServiceImpl) Update 

func (impl *GatewayPackageServiceImpl) Update(dao *orm.GatewayPackage, columns ...string) error

type GatewayPluginInstanceService 

type GatewayPluginInstanceService interface {
	NewSession(...*SessionHelper) (GatewayPluginInstanceService, error)
	Insert(*GatewayPluginInstance) error
	DeleteByRouteId(routeId string) error
	DeleteByApiId(routeId string) error
	DeleteByServiceId(serviceId string) error
	DeleteByConsumerId(consumerId string) error
	Update(*GatewayPluginInstance) error
	GetByPluginNameAndApiId(pluginName string, apiId string) (*GatewayPluginInstance, error)
	GetByAny(*GatewayPluginInstance) (*GatewayPluginInstance, error)
	DeleteById(string) error
	SelectByOnlyApiId(apiId string) ([]GatewayPluginInstance, error)
	SelectByPolicyId(policyId string) ([]GatewayPluginInstance, error)
}

type GatewayPluginInstanceServiceImpl 

type GatewayPluginInstanceServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayPluginInstanceServiceImpl 

func NewGatewayPluginInstanceServiceImpl() (*GatewayPluginInstanceServiceImpl, error)

func (*GatewayPluginInstanceServiceImpl) DeleteByApiId 

func (impl *GatewayPluginInstanceServiceImpl) DeleteByApiId(apiId string) error

func (*GatewayPluginInstanceServiceImpl) DeleteByConsumerId 

func (impl *GatewayPluginInstanceServiceImpl) DeleteByConsumerId(consumerId string) error

func (*GatewayPluginInstanceServiceImpl) DeleteById 

func (impl *GatewayPluginInstanceServiceImpl) DeleteById(id string) error

func (*GatewayPluginInstanceServiceImpl) DeleteByRouteId 

func (impl *GatewayPluginInstanceServiceImpl) DeleteByRouteId(routeId string) error

func (*GatewayPluginInstanceServiceImpl) DeleteByServiceId 

func (impl *GatewayPluginInstanceServiceImpl) DeleteByServiceId(serviceId string) error

func (*GatewayPluginInstanceServiceImpl) GetByAny 

func (impl *GatewayPluginInstanceServiceImpl) GetByAny(cond *orm.GatewayPluginInstance) (*orm.GatewayPluginInstance, error)

func (*GatewayPluginInstanceServiceImpl) GetByPluginNameAndApiId 

func (impl *GatewayPluginInstanceServiceImpl) GetByPluginNameAndApiId(name string, id string) (*orm.GatewayPluginInstance, error)

func (*GatewayPluginInstanceServiceImpl) Insert 

func (impl *GatewayPluginInstanceServiceImpl) Insert(instance *orm.GatewayPluginInstance) error

func (*GatewayPluginInstanceServiceImpl) NewSession 

func (impl *GatewayPluginInstanceServiceImpl) NewSession(helper ...*SessionHelper) (GatewayPluginInstanceService, error)

func (*GatewayPluginInstanceServiceImpl) SelectByOnlyApiId 

func (impl *GatewayPluginInstanceServiceImpl) SelectByOnlyApiId(id string) ([]orm.GatewayPluginInstance, error)

func (*GatewayPluginInstanceServiceImpl) SelectByPolicyId 

func (impl *GatewayPluginInstanceServiceImpl) SelectByPolicyId(id string) ([]orm.GatewayPluginInstance, error)

func (*GatewayPluginInstanceServiceImpl) Update 

func (impl *GatewayPluginInstanceServiceImpl) Update(instance *orm.GatewayPluginInstance) error

type GatewayPolicyService 

type GatewayPolicyService interface {
	GetById(policyId string) (*GatewayPolicy, error)
	SelectByCategory(category string) ([]GatewayPolicy, error)
	Insert(*GatewayPolicy) error
	Update(*GatewayPolicy) error
	GetByPolicyName(policyName string, consumerId string) (*GatewayPolicy, error)
	DeleteById(string) error
	SelectByCategoryAndConsumer(category string, consumerId string) ([]GatewayPolicy, error)
	SelectInIds(ids ...string) ([]GatewayPolicy, error)
	SelectByAny(*GatewayPolicy) ([]GatewayPolicy, error)
	GetByAny(*GatewayPolicy) (*GatewayPolicy, error)
}

type GatewayPolicyServiceImpl 

type GatewayPolicyServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayPolicyServiceImpl 

func NewGatewayPolicyServiceImpl() (*GatewayPolicyServiceImpl, error)

func (*GatewayPolicyServiceImpl) DeleteById 

func (impl *GatewayPolicyServiceImpl) DeleteById(id string) error

func (*GatewayPolicyServiceImpl) GetByAny 

func (impl *GatewayPolicyServiceImpl) GetByAny(cond *orm.GatewayPolicy) (*orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) GetById 

func (impl *GatewayPolicyServiceImpl) GetById(id string) (*orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) GetByPolicyName 

func (impl *GatewayPolicyServiceImpl) GetByPolicyName(name string, consumerId string) (*orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) Insert 

func (impl *GatewayPolicyServiceImpl) Insert(policy *orm.GatewayPolicy) error

func (*GatewayPolicyServiceImpl) SelectByAny 

func (impl *GatewayPolicyServiceImpl) SelectByAny(cond *orm.GatewayPolicy) ([]orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) SelectByCategory 

func (impl *GatewayPolicyServiceImpl) SelectByCategory(category string) ([]orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) SelectByCategoryAndConsumer 

func (impl *GatewayPolicyServiceImpl) SelectByCategoryAndConsumer(category string, consumerId string) ([]orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) SelectInIds 

func (impl *GatewayPolicyServiceImpl) SelectInIds(ids ...string) ([]orm.GatewayPolicy, error)

func (*GatewayPolicyServiceImpl) Update 

func (impl *GatewayPolicyServiceImpl) Update(policy *orm.GatewayPolicy) error

type GatewayRouteService 

type GatewayRouteService interface {
	NewSession(...*SessionHelper) (GatewayRouteService, error)
	GetById(string) (*GatewayRoute, error)
	Insert(*GatewayRoute) error
	GetByApiId(apiId string) (*GatewayRoute, error)
	DeleteById(string) error
	Update(*GatewayRoute) error
}

type GatewayRouteServiceImpl 

type GatewayRouteServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayRouteServiceImpl 

func NewGatewayRouteServiceImpl() (*GatewayRouteServiceImpl, error)

func (*GatewayRouteServiceImpl) DeleteById 

func (impl *GatewayRouteServiceImpl) DeleteById(id string) error

func (*GatewayRouteServiceImpl) GetByApiId 

func (impl *GatewayRouteServiceImpl) GetByApiId(id string) (*orm.GatewayRoute, error)

func (*GatewayRouteServiceImpl) GetById 

func (impl *GatewayRouteServiceImpl) GetById(id string) (*orm.GatewayRoute, error)

func (*GatewayRouteServiceImpl) Insert 

func (impl *GatewayRouteServiceImpl) Insert(route *orm.GatewayRoute) error

func (*GatewayRouteServiceImpl) NewSession 

func (impl *GatewayRouteServiceImpl) NewSession(helper ...*SessionHelper) (GatewayRouteService, error)

func (*GatewayRouteServiceImpl) Update 

func (impl *GatewayRouteServiceImpl) Update(route *orm.GatewayRoute) error

type GatewayRuntimeServiceService 

type GatewayRuntimeServiceService interface {
	NewSession(...*SessionHelper) (GatewayRuntimeServiceService, error)
	CreateIfNotExist(session *xorm.Session, dao *GatewayRuntimeService) (*GatewayRuntimeService, error)
	Insert(*GatewayRuntimeService) error
	Update(*GatewayRuntimeService) error
	Delete(string) error
	Get(string) (*GatewayRuntimeService, error)
	SelectByAny(*GatewayRuntimeService) ([]GatewayRuntimeService, error)
	GetByAny(*GatewayRuntimeService) (*GatewayRuntimeService, error)
}

type GatewayRuntimeServiceServiceImpl 

type GatewayRuntimeServiceServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayRuntimeServiceServiceImpl 

func NewGatewayRuntimeServiceServiceImpl() (*GatewayRuntimeServiceServiceImpl, error)

func (*GatewayRuntimeServiceServiceImpl) CreateIfNotExist 

func (impl *GatewayRuntimeServiceServiceImpl) CreateIfNotExist(session *xorm.Session, dao *orm.GatewayRuntimeService) (*orm.GatewayRuntimeService, error)

func (*GatewayRuntimeServiceServiceImpl) Delete 

func (impl *GatewayRuntimeServiceServiceImpl) Delete(id string) error

func (*GatewayRuntimeServiceServiceImpl) Get 

func (impl *GatewayRuntimeServiceServiceImpl) Get(id string) (*orm.GatewayRuntimeService, error)

func (*GatewayRuntimeServiceServiceImpl) GetByAny 

func (impl *GatewayRuntimeServiceServiceImpl) GetByAny(cond *orm.GatewayRuntimeService) (*orm.GatewayRuntimeService, error)

func (*GatewayRuntimeServiceServiceImpl) Insert 

func (impl *GatewayRuntimeServiceServiceImpl) Insert(dao *orm.GatewayRuntimeService) error

func (*GatewayRuntimeServiceServiceImpl) NewSession 

func (impl *GatewayRuntimeServiceServiceImpl) NewSession(helper ...*SessionHelper) (GatewayRuntimeServiceService, error)

func (*GatewayRuntimeServiceServiceImpl) SelectByAny 

func (impl *GatewayRuntimeServiceServiceImpl) SelectByAny(cond *orm.GatewayRuntimeService) ([]orm.GatewayRuntimeService, error)

func (*GatewayRuntimeServiceServiceImpl) Update 

func (impl *GatewayRuntimeServiceServiceImpl) Update(dao *orm.GatewayRuntimeService) error

type GatewayServiceService 

type GatewayServiceService interface {
	NewSession(...*SessionHelper) (GatewayServiceService, error)
	GetById(string) (*GatewayService, error)
	Insert(*GatewayService) error
	GetByApiId(apiId string) (*GatewayService, error)
	DeleteById(string) error
	Update(*GatewayService) error
}

type GatewayServiceServiceImpl 

type GatewayServiceServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayServiceServiceImpl 

func NewGatewayServiceServiceImpl() (*GatewayServiceServiceImpl, error)

func (*GatewayServiceServiceImpl) DeleteById 

func (impl *GatewayServiceServiceImpl) DeleteById(id string) error

func (*GatewayServiceServiceImpl) GetByApiId 

func (impl *GatewayServiceServiceImpl) GetByApiId(id string) (*orm.GatewayService, error)

func (*GatewayServiceServiceImpl) GetById 

func (impl *GatewayServiceServiceImpl) GetById(id string) (*orm.GatewayService, error)

func (*GatewayServiceServiceImpl) Insert 

func (impl *GatewayServiceServiceImpl) Insert(service *orm.GatewayService) error

func (*GatewayServiceServiceImpl) NewSession 

func (impl *GatewayServiceServiceImpl) NewSession(helper ...*SessionHelper) (GatewayServiceService, error)

func (*GatewayServiceServiceImpl) Update 

func (impl *GatewayServiceServiceImpl) Update(service *orm.GatewayService) error

type GatewayUpstreamApiService 

type GatewayUpstreamApiService interface {
	GetById(string) (*GatewayUpstreamApi, error)
	DeleteById(string) error
	Recover(string) error
	Insert(*xorm.Session, *GatewayUpstreamApi) (string, error)
	GetLastApiId(*GatewayUpstreamApi) string
	UpdateApiId(*GatewayUpstreamApi) error
	GetPage(ids []string, page *Page) (*PageQuery, error)
	SelectInIdsAndDeleted(ids []string) ([]GatewayUpstreamApi, error)
	SelectInIds(ids []string) ([]GatewayUpstreamApi, error)
}

type GatewayUpstreamApiServiceImpl 

type GatewayUpstreamApiServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayUpstreamApiServiceImpl 

func NewGatewayUpstreamApiServiceImpl() (*GatewayUpstreamApiServiceImpl, error)

func (*GatewayUpstreamApiServiceImpl) DeleteById 

func (impl *GatewayUpstreamApiServiceImpl) DeleteById(id string) error

func (*GatewayUpstreamApiServiceImpl) GetById 

func (impl *GatewayUpstreamApiServiceImpl) GetById(id string) (*orm.GatewayUpstreamApi, error)

func (*GatewayUpstreamApiServiceImpl) GetLastApiId 

func (impl *GatewayUpstreamApiServiceImpl) GetLastApiId(cond *orm.GatewayUpstreamApi) string

func (*GatewayUpstreamApiServiceImpl) GetPage 

func (impl *GatewayUpstreamApiServiceImpl) GetPage(ids []string, page *common.Page) (*common.PageQuery, error)

func (*GatewayUpstreamApiServiceImpl) Insert 

func (impl *GatewayUpstreamApiServiceImpl) Insert(session *xorm.Session, item *orm.GatewayUpstreamApi) (string, error)

func (*GatewayUpstreamApiServiceImpl) Recover 

func (impl *GatewayUpstreamApiServiceImpl) Recover(id string) error

func (*GatewayUpstreamApiServiceImpl) SelectInIds 

func (impl *GatewayUpstreamApiServiceImpl) SelectInIds(ids []string) ([]orm.GatewayUpstreamApi, error)

func (*GatewayUpstreamApiServiceImpl) SelectInIdsAndDeleted 

func (impl *GatewayUpstreamApiServiceImpl) SelectInIdsAndDeleted(ids []string) ([]orm.GatewayUpstreamApi, error)

func (*GatewayUpstreamApiServiceImpl) UpdateApiId 

func (impl *GatewayUpstreamApiServiceImpl) UpdateApiId(update *orm.GatewayUpstreamApi) error

type GatewayUpstreamLbService 

type GatewayUpstreamLbService interface {
	Get(*GatewayUpstreamLb) (*GatewayUpstreamLb, error)
	GetForUpdate(*xorm.Session, *GatewayUpstreamLb) (*GatewayUpstreamLb, error)
	Insert(*xorm.Session, *GatewayUpstreamLb) error
	UpdateDeploymentId(string, int) error
	GetById(string) (*GatewayUpstreamLb, error)
	GetByKongId(string) (*GatewayUpstreamLb, error)
}

type GatewayUpstreamLbServiceImpl 

type GatewayUpstreamLbServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayUpstreamLbServiceImpl 

func NewGatewayUpstreamLbServiceImpl() (*GatewayUpstreamLbServiceImpl, error)

func (GatewayUpstreamLbServiceImpl) Get 

func (impl GatewayUpstreamLbServiceImpl) Get(cond *orm.GatewayUpstreamLb) (*orm.GatewayUpstreamLb, error)

func (GatewayUpstreamLbServiceImpl) GetById 

func (impl GatewayUpstreamLbServiceImpl) GetById(id string) (*orm.GatewayUpstreamLb, error)

func (GatewayUpstreamLbServiceImpl) GetByKongId 

func (impl GatewayUpstreamLbServiceImpl) GetByKongId(id string) (*orm.GatewayUpstreamLb, error)

func (GatewayUpstreamLbServiceImpl) GetForUpdate 

func (impl GatewayUpstreamLbServiceImpl) GetForUpdate(session *xorm.Session, cond *orm.GatewayUpstreamLb) (*orm.GatewayUpstreamLb, error)

func (GatewayUpstreamLbServiceImpl) Insert 

func (impl GatewayUpstreamLbServiceImpl) Insert(session *xorm.Session, dao *orm.GatewayUpstreamLb) error

func (GatewayUpstreamLbServiceImpl) UpdateDeploymentId 

func (impl GatewayUpstreamLbServiceImpl) UpdateDeploymentId(id string, deploymentId int) error

type GatewayUpstreamLbTargetService 

type GatewayUpstreamLbTargetService interface {
	Insert(*GatewayUpstreamLbTarget) error
	SelectByDeploymentId(int) ([]GatewayUpstreamLbTarget, error)
	Select(lbId, target string) ([]GatewayUpstreamLbTarget, error)
	Delete(string) error
}

type GatewayUpstreamLbTargetServiceImpl 

type GatewayUpstreamLbTargetServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayUpstreamLbTargetServiceImpl 

func NewGatewayUpstreamLbTargetServiceImpl() (*GatewayUpstreamLbTargetServiceImpl, error)

func (GatewayUpstreamLbTargetServiceImpl) Delete 

func (impl GatewayUpstreamLbTargetServiceImpl) Delete(id string) error

func (GatewayUpstreamLbTargetServiceImpl) Insert 

func (impl GatewayUpstreamLbTargetServiceImpl) Insert(dao *orm.GatewayUpstreamLbTarget) error

func (GatewayUpstreamLbTargetServiceImpl) Select 

func (impl GatewayUpstreamLbTargetServiceImpl) Select(lbId, target string) ([]orm.GatewayUpstreamLbTarget, error)

func (GatewayUpstreamLbTargetServiceImpl) SelectByDeploymentId 

func (impl GatewayUpstreamLbTargetServiceImpl) SelectByDeploymentId(id int) ([]orm.GatewayUpstreamLbTarget, error)

type GatewayUpstreamRegisterRecordService 

type GatewayUpstreamRegisterRecordService interface {
	Insert(*xorm.Session, *GatewayUpstreamRegisterRecord) error
	GetPage(upstreamId string, page *Page) (*PageQuery, error)
	Get(upstreamId string, registerId string) (*GatewayUpstreamRegisterRecord, error)
}

type GatewayUpstreamRegisterRecordServiceImpl 

type GatewayUpstreamRegisterRecordServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayUpstreamRegisterRecordServiceImpl 

func NewGatewayUpstreamRegisterRecordServiceImpl() (*GatewayUpstreamRegisterRecordServiceImpl, error)

func (*GatewayUpstreamRegisterRecordServiceImpl) Get 

func (impl *GatewayUpstreamRegisterRecordServiceImpl) Get(upstreamId string, registerId string) (*orm.GatewayUpstreamRegisterRecord, error)

func (*GatewayUpstreamRegisterRecordServiceImpl) GetPage 

func (impl *GatewayUpstreamRegisterRecordServiceImpl) GetPage(upstreamId string, page *common.Page) (*common.PageQuery, error)

func (*GatewayUpstreamRegisterRecordServiceImpl) Insert 

func (impl *GatewayUpstreamRegisterRecordServiceImpl) Insert(session *xorm.Session, item *orm.GatewayUpstreamRegisterRecord) error

type GatewayUpstreamService 

type GatewayUpstreamService interface {
	UpdateRegister(*xorm.Session, *GatewayUpstream) (bool, bool, string, error)
	GetValidIdForUpdate(string, *xorm.Session) (string, error)
	UpdateValidId(*GatewayUpstream, ...*xorm.Session) error
	UpdateAutoBind(*GatewayUpstream) error
	SelectByAny(*GatewayUpstream) ([]GatewayUpstream, error)
}

type GatewayUpstreamServiceImpl 

type GatewayUpstreamServiceImpl struct {
	// contains filtered or unexported fields
}

func NewGatewayUpstreamServiceImpl 

func NewGatewayUpstreamServiceImpl() (*GatewayUpstreamServiceImpl, error)

func (*GatewayUpstreamServiceImpl) GetValidIdForUpdate 

func (impl *GatewayUpstreamServiceImpl) GetValidIdForUpdate(id string, session *xorm.Session) (string, error)

func (*GatewayUpstreamServiceImpl) SelectByAny 

func (impl *GatewayUpstreamServiceImpl) SelectByAny(cond *orm.GatewayUpstream) ([]orm.GatewayUpstream, error)

func (*GatewayUpstreamServiceImpl) UpdateAutoBind 

func (impl *GatewayUpstreamServiceImpl) UpdateAutoBind(update *orm.GatewayUpstream) error

func (*GatewayUpstreamServiceImpl) UpdateRegister 

func (impl *GatewayUpstreamServiceImpl) UpdateRegister(session *xorm.Session, dao *orm.GatewayUpstream) (bool, bool, string, error)

func (*GatewayUpstreamServiceImpl) UpdateValidId 

func (impl *GatewayUpstreamServiceImpl) UpdateValidId(update *orm.GatewayUpstream, session ...*xorm.Session) error

type GatewayZoneInPackageService 

type GatewayZoneInPackageService interface {
	NewSession(...*SessionHelper) (GatewayZoneInPackageService, error)
	Insert(*GatewayZoneInPackage) error
	Update(*GatewayZoneInPackage) error
	GetByAny(*GatewayZoneInPackage) (*GatewayZoneInPackage, error)
	DeleteByPackageId(string) error
	// use for create/update zone's domain binded ingress
	SelectByZoneId(string) ([]GatewayZoneInPackage, error)
	SelectByPackageId(string) ([]GatewayZoneInPackage, error)
}

type GatewayZoneInPackageServiceImpl 

type GatewayZoneInPackageServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayZoneInPackageServiceImpl 

func NewGatewayZoneInPackageServiceImpl() (*GatewayZoneInPackageServiceImpl, error)

func (*GatewayZoneInPackageServiceImpl) Delete 

func (impl *GatewayZoneInPackageServiceImpl) Delete(id string) error

func (*GatewayZoneInPackageServiceImpl) DeleteByPackageId 

func (impl *GatewayZoneInPackageServiceImpl) DeleteByPackageId(packageId string) error

func (*GatewayZoneInPackageServiceImpl) Get 

func (impl *GatewayZoneInPackageServiceImpl) Get(id string) (*orm.GatewayZoneInPackage, error)

func (*GatewayZoneInPackageServiceImpl) GetByAny 

func (impl *GatewayZoneInPackageServiceImpl) GetByAny(cond *orm.GatewayZoneInPackage) (*orm.GatewayZoneInPackage, error)

func (*GatewayZoneInPackageServiceImpl) Insert 

func (impl *GatewayZoneInPackageServiceImpl) Insert(dao *orm.GatewayZoneInPackage) error

func (*GatewayZoneInPackageServiceImpl) NewSession 

func (impl *GatewayZoneInPackageServiceImpl) NewSession(helper ...*SessionHelper) (GatewayZoneInPackageService, error)

func (*GatewayZoneInPackageServiceImpl) SelectByAny 

func (impl *GatewayZoneInPackageServiceImpl) SelectByAny(cond *orm.GatewayZoneInPackage) ([]orm.GatewayZoneInPackage, error)

func (*GatewayZoneInPackageServiceImpl) SelectByPackageId 

func (impl *GatewayZoneInPackageServiceImpl) SelectByPackageId(id string) ([]orm.GatewayZoneInPackage, error)

func (*GatewayZoneInPackageServiceImpl) SelectByZoneId 

func (impl *GatewayZoneInPackageServiceImpl) SelectByZoneId(id string) ([]orm.GatewayZoneInPackage, error)

func (*GatewayZoneInPackageServiceImpl) Update 

func (impl *GatewayZoneInPackageServiceImpl) Update(dao *orm.GatewayZoneInPackage) error

type GatewayZoneService 

type GatewayZoneService interface {
	NewSession(...*SessionHelper) (GatewayZoneService, error)
	Insert(*GatewayZone) error
	GetByAny(*GatewayZone) (*GatewayZone, error)
	GetById(string) (*GatewayZone, error)
	Update(*GatewayZone) error
	DeleteById(string) error
	SelectByAny(*GatewayZone) ([]GatewayZone, error)
	SelectPolicyZones(clusterName string) ([]GatewayZone, error)
}

type GatewayZoneServiceImpl 

type GatewayZoneServiceImpl struct {
	*SessionHelper
	// contains filtered or unexported fields
}

func NewGatewayZoneServiceImpl 

func NewGatewayZoneServiceImpl() (*GatewayZoneServiceImpl, error)

func (*GatewayZoneServiceImpl) DeleteById 

func (impl *GatewayZoneServiceImpl) DeleteById(id string) error

func (*GatewayZoneServiceImpl) GetByAny 

func (impl *GatewayZoneServiceImpl) GetByAny(cond *orm.GatewayZone) (*orm.GatewayZone, error)

func (*GatewayZoneServiceImpl) GetById 

func (impl *GatewayZoneServiceImpl) GetById(id string) (*orm.GatewayZone, error)

func (*GatewayZoneServiceImpl) Insert 

func (impl *GatewayZoneServiceImpl) Insert(zone *orm.GatewayZone) error

func (*GatewayZoneServiceImpl) NewSession 

func (impl *GatewayZoneServiceImpl) NewSession(helper ...*SessionHelper) (GatewayZoneService, error)

func (*GatewayZoneServiceImpl) SelectByAny 

func (impl *GatewayZoneServiceImpl) SelectByAny(cond *orm.GatewayZone) ([]orm.GatewayZone, error)

func (*GatewayZoneServiceImpl) SelectPolicyZones 

func (impl *GatewayZoneServiceImpl) SelectPolicyZones(clusterName string) ([]orm.GatewayZone, error)

func (*GatewayZoneServiceImpl) Update 

func (impl *GatewayZoneServiceImpl) Update(zone *orm.GatewayZone) error

type IngressChanges 

type IngressChanges struct {
	// use to merge configMap
	ConfigmapOptions []map[string]*string
	MainSnippets     *[]string
	HttpSnippets     *[]string
	ServerSnippets   *[]string

	// use to merge ingress
	Annotations      []map[string]*string
	LocationSnippets *[]string
}

type IniService 

type IniService interface {
	GetValueByName(name string) (string, error)
}

type IniServiceImpl 

type IniServiceImpl struct {
	// contains filtered or unexported fields
}

func NewIniServiceImpl 

func NewIniServiceImpl() (*IniServiceImpl, error)

func (*IniServiceImpl) GetValueByName 

func (impl *IniServiceImpl) GetValueByName(name string) (string, error)

type KongBelongTuple 

type KongBelongTuple struct {
	Az        string
	ProjectId string
	Env       string
}

type SessionHelper 

type SessionHelper struct {
	// contains filtered or unexported fields
}

func NewSessionHelper 

func NewSessionHelper() (*SessionHelper, error)

func (*SessionHelper) Begin 

func (impl *SessionHelper) Begin() error

func (*SessionHelper) Close 

func (impl *SessionHelper) Close()

func (*SessionHelper) Commit 

func (impl *SessionHelper) Commit() error

func (*SessionHelper) GetSessionHelper 

func (impl *SessionHelper) GetSessionHelper() *SessionHelper

func (*SessionHelper) Rollback 

func (impl *SessionHelper) Rollback() error

func (*SessionHelper) Session 

func (impl *SessionHelper) Session() *xorm.Session

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.