service

type AppCombinedService struct {
	App    ApplicationService
	Config ConfigService
	Secret SecretService
}

type AppServiceImpl struct {
	Config       plugin.Configuration
	Secret       plugin.Secret
	App          plugin.Application
	IndexService IndexService
}

type ApplicationService interface {
	Get(namespace, name, version string) (*specV1.Application, error)
	Create(tx interface{}, namespace string, app *specV1.Application) (*specV1.Application, error)
	Update(tx interface{}, namespace string, app *specV1.Application) (*specV1.Application, error)
	Delete(tx interface{}, namespace, name, version string) error
	List(namespace string, listOptions *models.ListOptions) (*models.ApplicationList, error)
	ListByNames(ns string, names []string) ([]models.AppItem, error)
	CreateWithBase(tx interface{}, namespace string, app, base *specV1.Application) (*specV1.Application, error)
}

type AuthService interface {
	plugin.Auth
}

type CacheService interface {
	Get(key string, load func(string) (string, error)) (string, error)
	GetProperty(key string) (string, error)
	GetFileData(file string) (string, error)
}

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

type CheckResourceDependencyFunc func(tx any, ns, nodeName string) error

type ConfigService interface {
	Get(tx interface{}, namespace, name, version string) (*specV1.Configuration, error)
	List(namespace string, listOptions *models.ListOptions) (*models.ConfigurationList, error)
	Create(tx interface{}, namespace string, config *specV1.Configuration) (*specV1.Configuration, error)
	Update(tx interface{}, namespace string, config *specV1.Configuration) (*specV1.Configuration, error)
	Upsert(tx interface{}, namespace string, config *specV1.Configuration) (*specV1.Configuration, error)
	Delete(tx interface{}, namespace, name string) error
}

type CreateExtraNamespaceResourcesFunc func(namespace string) error

type CreateNodeFunc func(tx interface{}, namespace string, node *specV1.Node) (*specV1.Node, error)

type CronService interface {
	GetCron(name, namespace string) (*models.Cron, error)
	CreateCron(*models.Cron) error
	UpdateCron(*models.Cron) error
	DeleteCron(name, namespace string) error
	ListExpiredApps() ([]models.Cron, error)
	DeleteExpiredApps([]uint64) error
}

type DeleteCoreExtResource func(tx any, ns string, node *specV1.Node) error

type DeleteExtraNamespaceResourcesFunc func(namespace string) error

type FunctionService interface {
	List(userID, source string) ([]models.Function, error)
	ListFunctionVersions(userID, name, source string) ([]models.Function, error)
	ListSources() []models.FunctionSource
	ListRuntimes() (map[string]string, error)
	GetFunction(userID, name, version, source string) (*models.Function, error)
}

type GenAppFunc func(tx interface{}, ns string, node *specV1.Node, params map[string]interface{}) (*specV1.Application, error)

type GenAppsByOption func(tx interface{}, ns string, node *specV1.Node, params map[string]interface{}) ([]*specV1.Application, error)

type GenSyncExtResource func(tx interface{}, ns string, node *specV1.Node, params map[string]interface{}) error

type GetInitResource func(ns, nodeName string, params map[string]interface{}) ([]byte, error)

type HandlerPopulateConfig func(cfg *specV1.Configuration, metadata map[string]string) error

type HandlerPopulateOptAppsParams func(tx interface{}, ns string, params map[string]interface{}, appAlias []string) error

type HandlerPopulateParams func(tx interface{}, ns string, params map[string]interface{}) error

type IndexService interface {
	// comment
	RefreshIndex(tx interface{}, namespace string, keyA, keyB common.Resource, valueA string, valueBs []string) error
	ListIndex(namespace string, keyA, byKeyB common.Resource, valueB string) ([]string, error)
	// app and config
	RefreshAppIndexByConfig(tx interface{}, namespace, config string, apps []string) error
	RefreshConfigIndexByApp(tx interface{}, namespace, app string, configs []string) error
	ListAppIndexByConfig(namespace, config string) ([]string, error)
	ListConfigIndexByApp(namespace, app string) ([]string, error)

	ListNodesByApp(namespace, app string) ([]string, error)
	ListAppsByNode(namespace, node string) ([]string, error)
	ListAppIndexBySecret(namespace, secret string) ([]string, error)
	ListSecretIndexByApp(namespace, app string) ([]string, error)

	// app and secret
	RefreshSecretIndexByApp(tx interface{}, namespace, app string, secrets []string) error
	RefreshNodesIndexByApp(tx interface{}, namespace, appName string, nodes []string) error
	RefreshAppsIndexByNode(tx interface{}, namespace, node string, apps []string) error
}

type InitService interface {
	GetResource(ns, nodeName, resourceName string, params map[string]interface{}) (interface{}, error)
}

type InitServiceImpl struct {
	SignService     SignService
	NodeService     NodeService
	Property        PropertyService
	TemplateService TemplateService
	*AppCombinedService
	PKI             PKIService
	ResourceMapFunc map[string]GetInitResource
	Hooks           map[string]interface{}
	// contains filtered or unexported fields
}

type LicenseService interface {
	plugin.License
}

type LicenseServiceImpl struct {
	plugin.License
}

type LockerService interface {
	Lock(ctx context.Context, name string, ttl int64) (string, error)
	Unlock(ctx context.Context, name, value string)
}

type ModuleService interface {
	GetModules(name string) ([]models.Module, error)
	GetModuleByVersion(name, version string) (*models.Module, error)
	GetModuleByImage(name, image string) (*models.Module, error)
	GetLatestModule(name string) (*models.Module, error)
	CreateModule(module *models.Module) (*models.Module, error)
	UpdateModuleByVersion(module *models.Module) (*models.Module, error)
	DeleteModules(name string) error
	DeleteModuleByVersion(name, version string) error
	ListModules(filter *models.Filter, tp common.ModuleType) ([]models.Module, error)

	GetLatestModuleImage(name string) (string, error)
	GetLatestModuleProgram(name, platform string) (string, error)
}

type NamespaceService interface {
	Get(namespace string) (*models.Namespace, error)
	Create(namespace *models.Namespace) (*models.Namespace, error)
	List(listOptions *models.ListOptions) (*models.NamespaceList, error)
	Delete(namespace *models.Namespace) error
}

type NamespaceServiceImpl struct {
	Hooks map[string]interface{}
	// contains filtered or unexported fields
}

type NodeService interface {
	Get(tx interface{}, namespace, name string) (*specV1.Node, error)
	List(namespace string, listOptions *models.ListOptions) (*models.NodeList, error)
	Count(namespace string) (map[string]int, error)
	CountAll() (map[string]int, error)

	Create(tx interface{}, namespace string, node *specV1.Node) (*specV1.Node, error)
	Update(namespace string, node *specV1.Node) (*specV1.Node, error)
	Delete(tx interface{}, namespace string, node *specV1.Node) error

	UpdateReport(namespace, name string, report specV1.Report) (*models.Shadow, error)
	UpdateDesire(tx interface{}, namespace string, names []string, app *specV1.Application, f func(*models.Shadow, *specV1.Application)) error

	GetDesire(namespace, name string) (*specV1.Desire, error)

	UpdateNodeAppVersion(tx interface{}, namespace string, app *specV1.Application) ([]string, error)
	DeleteNodeAppVersion(tx interface{}, namespace string, app *specV1.Application) ([]string, error)

	GetNodeProperties(ns, name string) (*models.NodeProperties, error)
	UpdateNodeProperties(ns, name string, props *models.NodeProperties) (*models.NodeProperties, error)
	UpdateNodeMode(ns, name, mode string) error
}

type NodeServiceImpl struct {
	IndexService  IndexService
	App           plugin.Application
	Node          plugin.Node
	Shadow        plugin.Shadow
	Cache         plugin.DataCache
	SysAppService SystemAppService
	Hooks         map[string]interface{}
	// contains filtered or unexported fields
}

type ObjectService interface {
	ListSources() map[string]models.ObjectStorageSourceV2

	ListInternalBuckets(userID, source string) ([]models.Bucket, error)
	ListInternalBucketObjects(userID, bucket, source string) (*models.ListObjectsResult, error)
	CreateInternalBucketIfNotExist(userID, bucket, permission, source string) (*models.Bucket, error)
	PutInternalObjectFromURLIfNotExist(userID, bucket, object, url, source string) error
	GenInternalObjectURL(userID string, bucket, object, source string) (*models.ObjectURL, error)
	GenInternalObjectPutURL(userID string, bucket, object, source string) (*models.ObjectURL, error)
	PutInternalObject(userID, bucket, name, source string, b []byte) error
	HeadInternalObject(userID, bucket, name, source string) (*models.ObjectMeta, error)

	ListExternalBuckets(info models.ExternalObjectInfo, source string) ([]models.Bucket, error)
	ListExternalBucketObjects(info models.ExternalObjectInfo, bucket, source string) (*models.ListObjectsResult, error)
	GenExternalObjectURL(info models.ExternalObjectInfo, bucket, object, source string) (*models.ObjectURL, error)
	CreateExternalBucket(info models.ExternalObjectInfo, bucket, permission, source string) error
	PutExternalObject(info models.ExternalObjectInfo, bucket, name, source string, b []byte) error
	PutExternalObjectFromURL(info models.ExternalObjectInfo, bucket, name, url, source string) error
	GetExternalObject(info models.ExternalObjectInfo, bucket, name, source string) (*models.Object, error)
	HeadExternalObject(info models.ExternalObjectInfo, bucket, name, source string) (*models.ObjectMeta, error)
	DeleteExternalObject(info models.ExternalObjectInfo, bucket, name, source string) error
}

type PKIService interface {
	// GetCA get ca
	GetCA() ([]byte, error)
	// SignServerCertificate sign a certificate which can be used to connect to cloud
	SignServerCertificate(cn string, altNames models.AltNames) (*models.PEMCredential, error)
	// SignNodeCertificate sign a certificate which can be used to connect to cloud
	SignClientCertificate(cn string, altNames models.AltNames) (*models.PEMCredential, error)
	// DeleteServerCertificate delete a server certificate by certId
	DeleteServerCertificate(certId string) error
	// DeleteClientCertificate delete a server certificate by certId
	DeleteClientCertificate(certId string) error
}

type PopulateExtParams func(ns string, node *specV1.Node, app *specV1.Application, params map[string]interface{}) error

type PropertyService interface {
	GetProperty(name string) (*models.Property, error)
	CreateProperty(property *models.Property) error
	DeleteProperty(name string) error
	ListProperty(page *models.Filter) ([]models.Property, error) //Pagination
	CountProperty(name string) (int, error)
	UpdateProperty(property *models.Property) error

	GetPropertyValue(name string) (string, error)
}

type QuotaService interface {
	plugin.Quota
	CheckQuota(namespace string, collector plugin.QuotaCollector) error
}

type QuotaServiceImpl struct {
	plugin.Quota
}

type SecretService interface {
	Get(namespace, name, version string) (*specV1.Secret, error)
	GetTx(tx interface{}, namespace, name, version string) (*specV1.Secret, error)
	List(namespace string, listOptions *models.ListOptions) (*models.SecretList, error)
	Create(tx interface{}, namespace string, secret *specV1.Secret) (*specV1.Secret, error)
	Update(namespace string, secret *specV1.Secret) (*specV1.Secret, error)
	Delete(tx interface{}, namespace, name string) error
}

type SignService interface {
	plugin.Sign
	GenToken(map[string]interface{}) (string, error)
}

type SyncService interface {
	Report(namespace, name string, report specV1.Report) (specV1.Delta, error)
	Desire(namespace string, infos []specV1.ResourceInfo, metadata map[string]string) ([]specV1.ResourceValue, error)
}

type SyncServiceImpl struct {
	ConfigService ConfigService
	NodeService   NodeService
	AppService    ApplicationService
	SecretService SecretService
	ObjectService ObjectService
	Hooks         map[string]interface{}
}

type SystemAppService interface {
	GenApps(tx interface{}, ns string, nodeName *specV1.Node) ([]*specV1.Application, error)
	GetOptionalApps() []string
	GenOptionalApps(tx interface{}, ns string, node *specV1.Node, apps []string) ([]*specV1.Application, error)
}

type SystemAppServiceImpl struct {
	Property        PropertyService
	TemplateService TemplateService
	PKI             PKIService
	*AppCombinedService
	Hooks            map[string]interface{}
	OptionalAppFuncs map[string]GenAppFunc
	// contains filtered or unexported fields
}

type TaskService interface {
	task.TaskProducer
	task.TaskWorker
}

type TemplateService interface {
	Execute(name, text string, params map[string]interface{}) ([]byte, error)
	GetTemplate(filename string) (string, error)
	ParseTemplate(filename string, params map[string]interface{}) ([]byte, error)
	UnmarshalTemplate(filename string, params map[string]interface{}, out interface{}) error
}

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

type WrapperService interface {
	CreateNodeTx(CreateNodeFunc) CreateNodeFunc
}

type WrapperServiceImpl struct {
	plugin.TransactionFactory
}