154 lines
3.9 KiB
Markdown
154 lines
3.9 KiB
Markdown
# Anthrove Plug SDK
|
|
|
|
Anthrove Plug SDK is a Golang-based Software Development Kit (SDK) that provides a gRPC server implementation for the Anthrove system. This SDK enables users to easily set up a server, establish a database connection, and set a task execution function.
|
|
|
|
## Installation
|
|
|
|
To install the Anthrove Plug SDK, you will need to have Go installed on your system. You can then use the go get command to fetch the SDK:
|
|
|
|
```bash
|
|
go get git.anthrove.art/Anthrove/plug-sdk/v4
|
|
```
|
|
## Usage
|
|
|
|
Below is a basic example of how to use the SDK:
|
|
|
|
### proposed Plug structure
|
|
|
|
````
|
|
your-project/
|
|
│
|
|
├── cmd
|
|
│ └── your-plug
|
|
│ └── main.go
|
|
├── config
|
|
├── internal
|
|
│ ├── service
|
|
│ └── utils
|
|
└── go.mod
|
|
````
|
|
|
|
### config.go
|
|
|
|
````go
|
|
|
|
package config
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/caarlos0/env/v10"
|
|
"github.com/go-playground/validator/v10"
|
|
)
|
|
|
|
type CoreConfig struct {
|
|
LogLevel string `env:"LOG_LEVEL" envDefault:"INFO" validate:"eq_ignore_case=FATAL|eq_ignore_case=ERROR|eq_ignore_case=WARN|eq_ignore_case=INFO|eq_ignore_case=DEBUG|eq_ignore_case=TRACE"`
|
|
LogFormat string `env:"LOG_FORMAT" envDefault:"PLAIN" validate:"eq_ignore_case=PLAIN|eq_ignore_case=JSON"`
|
|
}
|
|
|
|
type PlugConfig struct {
|
|
PlugDomain string `env:"PLUG_DOMAIN" envDefault:"e621.net"`
|
|
PlugIcon string `env:"PLUG_ICON" envDefault:"https://e621.net/safari-pinned-tab.svg"`
|
|
PlugDisplayName string `env:"PLUG_DISPLAY_NAME" envDefault:"e621.net"`
|
|
PlugAPIKey string `env:"PLUG_API_KEY,required"`
|
|
PlugUsername string `env:"PLUG_USERNAME,required"`
|
|
}
|
|
|
|
// LoadConfig loads the configuration from environment variables and validates it.
|
|
func LoadConfig[T any](cfg T) (T, error) {
|
|
|
|
if err := env.Parse(&cfg); err != nil {
|
|
return cfg, fmt.Errorf("config: error parsing configuration: %w", err)
|
|
}
|
|
|
|
validate := validator.New()
|
|
if err := validate.Struct(cfg); err != nil {
|
|
return cfg, fmt.Errorf("config: validation error: %w", err)
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|
|
|
|
````
|
|
|
|
### main.go
|
|
|
|
````go
|
|
package main
|
|
|
|
import (
|
|
"context"
|
|
|
|
log "github.com/sirupsen/logrus"
|
|
"your-repo-path/config"
|
|
"your-repo-path/internal/service"
|
|
"your-repo-path/internal/utils"
|
|
"your-repo-path/pkg/database"
|
|
"your-repo-path/pkg/models"
|
|
"your-repo-path/pkg/plug"
|
|
)
|
|
|
|
// plugConfig holds the orchestrator configuration
|
|
var coreConfig config.CoreConfig
|
|
var plugConfig config.PlugConfig
|
|
var databaseConfig models.DatabaseConfig
|
|
|
|
// init is used to load the orchestrator configuration
|
|
func init() {
|
|
// Load the orchestrator configuration
|
|
localCoreConfig, err := config.LoadConfig[config.CoreConfig](coreConfig)
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
coreConfig = localCoreConfig
|
|
|
|
// Load the plug configuration
|
|
localPlugConfig, err := config.LoadConfig[config.PlugConfig](plugConfig)
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
plugConfig = localPlugConfig
|
|
|
|
// Load the database configuration
|
|
localDatabaseConfig, err := config.LoadConfig[models.DatabaseConfig](databaseConfig)
|
|
if err != nil {
|
|
log.Panic(err)
|
|
}
|
|
databaseConfig = localDatabaseConfig
|
|
}
|
|
|
|
func main() {
|
|
var err error
|
|
var ctx = context.Background()
|
|
// Initiate logging setup
|
|
utils.SetupLogger(coreConfig.LogLevel, coreConfig.LogFormat)
|
|
|
|
// Initiate database connection
|
|
err = database.Connect(ctx, databaseConfig)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
// Setup Source
|
|
source := models.Source{
|
|
DisplayName: plugConfig.DisplayName,
|
|
Domain: models.SourceDomain(plugConfig.Domain),
|
|
Icon: plugConfig.Icon,
|
|
}
|
|
|
|
err = plug.SetupOpenTelemetry(ctx, "your-plug")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
plug.SetTaskExecutionFunction(service.YourTaskFunction)
|
|
plug.SetGetMessageExecutionFunction(service.YourMessageFunction)
|
|
err = plug.Listen(ctx, ":8080", source)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
|
|
````
|