object

Documentation

Index

• Constants
• func SerializeUploadUnit(u interface{}) ([]byte, error)
• type BindingConfigPart
• type ClazzServiceDTO
• type ClazzUploadUnit
  • func DeserializeClazzUploadUnit(data []byte) (*ClazzUploadUnit, error)
• type DriverType
• type ExecuteConfig
  • func DefaultExecuteConfig() ExecuteConfig
  • func (config *ExecuteConfig) ToJson() (string, error)
  • func (config *ExecuteConfig) ToMap() (map[string]any, error)
• type FuncCtxServiceDTO
• type FuncTag
• type FunctionContextSlim
  • func CompressFunctionContext(f *sibyl2.FunctionContext) *FunctionContextSlim
• type FunctionContextUploadUnit
  • func DeserializeFuncCtxUploadUnit(data []byte) (*FunctionContextUploadUnit, error)
• type FunctionServiceDTO
• type FunctionUploadUnit
  • func DeserializeFuncUploadUnit(data []byte) (*FunctionUploadUnit, error)
• type FunctionWithTag
  • func (fwt *FunctionWithTag) AddTag(tag FuncTag)
• type QueueConfigPart
• type QueueType
• type RevInfo
  • func NewRevInfo(hash string) *RevInfo
• type ServerConfigPart
• type ServerType
• type WorkerConfigPart
• type WorkspaceConfig
  • func (wc *WorkspaceConfig) Key() (string, error)
  • func (wc *WorkspaceConfig) Verify() error

Constants

const BodyTypeMsgpack = "application/msgpack"

Functions

func SerializeUploadUnit

func SerializeUploadUnit(u interface{}) ([]byte, error)

Types

type BindingConfigPart

type BindingConfigPart struct {
	// binding
	DbType      DriverType `mapstructure:"dbType"`
	BadgerPath  string     `mapstructure:"badgerPath"`
	TikvAddrs   string     `mapstructure:"tikvAddrs"`
	MongoURI    string     `mapstructure:"mongoUri"`
	MongoDbName string     `mapstructure:"mongoDbName"`
}

type ClazzServiceDTO

type ClazzServiceDTO struct {
	*extractor.ClazzWithPath `bson:",inline"`
	Signature                string `json:"signature" bson:"signature"`
}

type ClazzUploadUnit

type ClazzUploadUnit struct {
	WorkspaceConfig *WorkspaceConfig           `json:"workspace"`
	ClazzFileResult *extractor.ClazzFileResult `json:"clazzFileResult"`
}

func DeserializeClazzUploadUnit

func DeserializeClazzUploadUnit(data []byte) (*ClazzUploadUnit, error)

type DriverType

type DriverType = string

const (
	DriverTypeInMemory DriverType = "INMEM"
	DriverTypeBadger   DriverType = "BADGER"
	DriverTypeTikv     DriverType = "TIKV"
	DriverTypeMongoDB  DriverType = "MONGO"

	FlagWcKeySplit = "|,,|"
)

type ExecuteConfig

type ExecuteConfig struct {
	*ServerConfigPart  `mapstructure:"server"`
	*BindingConfigPart `mapstructure:"binding"`
	*WorkerConfigPart  `mapstructure:"worker"`
	*QueueConfigPart   `mapstructure:"queue"`
}

func DefaultExecuteConfig

func DefaultExecuteConfig() ExecuteConfig

func (*ExecuteConfig) ToJson

func (config *ExecuteConfig) ToJson() (string, error)

func (*ExecuteConfig) ToMap

func (config *ExecuteConfig) ToMap() (map[string]any, error)

type FuncCtxServiceDTO

type FuncCtxServiceDTO struct {
	*FunctionContextSlim `bson:",inline"`
	Signature            string `json:"signature" bson:"signature"`
}

type FuncTag

type FuncTag = string

type FunctionContextSlim

type FunctionContextSlim struct {
	*extractor.FunctionWithPath `bson:",inline"`
	Calls                       []string `json:"calls" bson:"calls"`
	ReverseCalls                []string `json:"reverseCalls" bson:"reverseCalls"`
}

FunctionContextSlim instead of whole object, slim will only keep the signature

func CompressFunctionContext

func CompressFunctionContext(f *sibyl2.FunctionContext) *FunctionContextSlim

type FunctionContextUploadUnit

type FunctionContextUploadUnit struct {
	WorkspaceConfig  *WorkspaceConfig          `json:"workspace"`
	FunctionContexts []*sibyl2.FunctionContext `json:"functionContext"`
}

func DeserializeFuncCtxUploadUnit

func DeserializeFuncCtxUploadUnit(data []byte) (*FunctionContextUploadUnit, error)

type FunctionServiceDTO

type FunctionServiceDTO struct {
	*FunctionWithTag `bson:",inline"`
	Signature        string `json:"signature" bson:"signature"`
}

type FunctionUploadUnit

type FunctionUploadUnit struct {
	WorkspaceConfig *WorkspaceConfig              `json:"workspace"`
	FunctionResult  *extractor.FunctionFileResult `json:"funcResult"`
}

func DeserializeFuncUploadUnit

func DeserializeFuncUploadUnit(data []byte) (*FunctionUploadUnit, error)

type FunctionWithTag

type FunctionWithTag struct {
	*extractor.FunctionWithPath `bson:",inline"`
	Tags                        []FuncTag `json:"tags" bson:"tags"`
}

func (*FunctionWithTag) AddTag

func (fwt *FunctionWithTag) AddTag(tag FuncTag)

type QueueConfigPart

type QueueConfigPart struct {
	// queue
	QueueType                 QueueType `mapstructure:"queueType"`
	KafkaAddrs                string    `mapstructure:"kafkaAddrs"`
	KafkaFuncTopic            string    `mapstructure:"kafkaFuncTopic"`
	KafkaFuncConsumerGroup    string    `mapstructure:"kafkaFuncConsumerGroup"`
	KafkaFuncCtxTopic         string    `mapstructure:"kafkaFuncCtxTopic"`
	KafkaFuncCtxConsumerGroup string    `mapstructure:"kafkaFuncCtxConsumerGroup"`
	KafkaClazzTopic           string    `mapstructure:"kafkaClazzTopic"`
	KafkaClazzConsumerGroup   string    `mapstructure:"kafkaClazzConsumerGroup"`
}

type QueueType

type QueueType = string

const QueueTypeKafka QueueType = "KAFKA"

const QueueTypeMemory QueueType = "MEMORY"

type RevInfo

type RevInfo struct {
	Hash       string                 `json:"hash"`
	CreateTime int64                  `json:"createTime"`
	Extras     map[string]interface{} `json:"extras"`
}

func NewRevInfo

func NewRevInfo(hash string) *RevInfo

type ServerConfigPart

type ServerConfigPart struct {
	// server
	Port      int        `mapstructure:"port"`
	Mode      ServerType `mapstructure:"mode"`
	EnableLog bool       `mapstructure:"enableLog"`
}

type ServerType

type ServerType = string

const (
	ServerTypeAll     ServerType = "ALL"
	ServerTypeWorker  ServerType = "WORKER"
	ServerTypeGateway ServerType = "GATEWAY"
)

type WorkerConfigPart

type WorkerConfigPart struct {
	// worker
	WorkerCount     int `mapstructure:"workerCount"`
	WorkerQueueSize int `mapstructure:"workerQueueSize"`
}

type WorkspaceConfig

type WorkspaceConfig struct {
	RepoId  string `json:"repoId"`
	RevHash string `json:"revHash"`
}

WorkspaceConfig

as an infra lib, it will not assume what kind of repo you used.

just two fields: - repoId: unique id of your repo, no matter git or svn, even appId. - revHash: unique id of your version.

func (*WorkspaceConfig) Key

func (wc *WorkspaceConfig) Key() (string, error)

func (*WorkspaceConfig) Verify

func (wc *WorkspaceConfig) Verify() error