mentos1386/zdravko
1
0
Fork 0
mirror of https://github.com/mentos1386/zdravko.git synced 2024-11-21 23:33:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

feat: rename healthchecks/cronjobs to monitor

Browse source
This commit is contained in:
Tine 2024-02-24 12:57:53 +01:00
parent a65834bd8d
commit a9dd5a41b7
Signed by: mentos1386
SSH key fingerprint: SHA256:MNtTsLbihYaWF8j1fkOHfkKNlnN1JQfxEU/rBU8nCGw
30 changed files with 1389 additions and 1403 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
internal/activities/healthcheck.go → internal/activities/monitor.go
View file

@ -16,12 +16,12 @@ type HealtcheckParam struct {
Script string
}
type HealthcheckResult struct {
type MonitorResult struct {
Success bool
Note string
}
func (a *Activities) Healthcheck(ctx context.Context, param HealtcheckParam) (*HealthcheckResult, error) {
func (a *Activities) Monitor(ctx context.Context, param HealtcheckParam) (*MonitorResult, error) {
execution := k6.NewExecution(slog.Default(), param.Script)
result, err := execution.Run(ctx)
@ -29,7 +29,7 @@ func (a *Activities) Healthcheck(ctx context.Context, param HealtcheckParam) (*H
return nil, err
}
return &HealthcheckResult{Success: result.Success, Note: result.Note}, nil
return &MonitorResult{Success: result.Success, Note: result.Note}, nil
}
type HealtcheckAddToHistoryParam struct {
@ -38,13 +38,13 @@ type HealtcheckAddToHistoryParam struct {
Note string
}
type HealthcheckAddToHistoryResult struct {
type MonitorAddToHistoryResult struct {
}
func (a *Activities) HealthcheckAddToHistory(ctx context.Context, param HealtcheckAddToHistoryParam) (*HealthcheckAddToHistoryResult, error) {
url := fmt.Sprintf("%s/api/v1/healthchecks/%s/history", a.config.ApiUrl, param.Slug)
func (a *Activities) MonitorAddToHistory(ctx context.Context, param HealtcheckAddToHistoryParam) (*MonitorAddToHistoryResult, error) {
url := fmt.Sprintf("%s/api/v1/monitors/%s/history", a.config.ApiUrl, param.Slug)
body := api.ApiV1HealthchecksHistoryPOSTBody{
body := api.ApiV1MonitorsHistoryPOSTBody{
Status: param.Status,
Note: param.Note,
}
@ -69,5 +69,5 @@ func (a *Activities) HealthcheckAddToHistory(ctx context.Context, param Healtche
return nil, fmt.Errorf("unexpected status code: %d", response.StatusCode)
}
return &HealthcheckAddToHistoryResult{}, nil
return &MonitorAddToHistoryResult{}, nil
}

4
internal/database.go
View file

@ -16,8 +16,8 @@ func ConnectToDatabase(path string) (*gorm.DB, *query.Query, error) {
err = db.AutoMigrate(
models.Worker{},
models.Healthcheck{},
models.HealthcheckHistory{},
models.Monitor{},
models.MonitorHistory{},
models.Cronjob{},
models.CronjobHistory{},
models.OAuth2State{},

10
internal/handlers/api.go
View file

@ -42,24 +42,24 @@ func (h *BaseHandler) ApiV1WorkersConnectGET(c echo.Context) error {
// TODO: Can we instead get this from the Workflow outcome?
//
// To somehow listen for the outcomes and then store them automatically.
func (h *BaseHandler) ApiV1HealthchecksHistoryPOST(c echo.Context) error {
func (h *BaseHandler) ApiV1MonitorsHistoryPOST(c echo.Context) error {
ctx := context.Background()
slug := c.Param("slug")
var body api.ApiV1HealthchecksHistoryPOSTBody
var body api.ApiV1MonitorsHistoryPOSTBody
err := (&echo.DefaultBinder{}).BindBody(c, &body)
if err != nil {
return err
}
healthcheck, err := services.GetHealthcheck(ctx, h.query, slug)
monitor, err := services.GetMonitor(ctx, h.query, slug)
if err != nil {
return err
}
err = h.query.Healthcheck.History.Model(healthcheck).Append(
&models.HealthcheckHistory{
err = h.query.Monitor.History.Model(monitor).Append(
&models.MonitorHistory{
Status: body.Status,
Note: body.Note,
})

38
internal/handlers/index.go
View file

@ -14,7 +14,7 @@ import (
type IndexData struct {
*components.Base
HealthChecks []*HealthCheck
HealthchecksLength int
MonitorsLength int
TimeRange string
Status string
}
@ -39,7 +39,7 @@ func getHour(date time.Time) string {
return date.Format("2006-01-02T15:04")
}
func getDailyHistory(history []models.HealthcheckHistory) *History {
func getDailyHistory(history []models.MonitorHistory) *History {
numDays := 90
historyDailyMap := map[string]string{}
numOfSuccess := 0
@ -47,7 +47,7 @@ func getDailyHistory(history []models.HealthcheckHistory) *History {
for i := 0; i < numDays; i++ {
day := getDay(time.Now().AddDate(0, 0, -i).Truncate(time.Hour * 24))
historyDailyMap[day] = models.HealthcheckUnknown
historyDailyMap[day] = models.MonitorUnknown
}
for _, _history := range history {
@ -59,12 +59,12 @@ func getDailyHistory(history []models.HealthcheckHistory) *History {
}
numTotal++
if _history.Status == models.HealthcheckSuccess {
if _history.Status == models.MonitorSuccess {
numOfSuccess++
}
// skip if day is already set to failure
if historyDailyMap[day] == models.HealthcheckFailure {
if historyDailyMap[day] == models.MonitorFailure {
continue
}
@ -88,7 +88,7 @@ func getDailyHistory(history []models.HealthcheckHistory) *History {
}
}
func getHourlyHistory(history []models.HealthcheckHistory) *History {
func getHourlyHistory(history []models.MonitorHistory) *History {
numHours := 48
historyHourlyMap := map[string]string{}
numOfSuccess := 0
@ -96,7 +96,7 @@ func getHourlyHistory(history []models.HealthcheckHistory) *History {
for i := 0; i < numHours; i++ {
hour := getHour(time.Now().Add(time.Hour * time.Duration(-i)).Truncate(time.Hour))
historyHourlyMap[hour] = models.HealthcheckUnknown
historyHourlyMap[hour] = models.MonitorUnknown
}
for _, _history := range history {
@ -108,12 +108,12 @@ func getHourlyHistory(history []models.HealthcheckHistory) *History {
}
numTotal++
if _history.Status == models.HealthcheckSuccess {
if _history.Status == models.MonitorSuccess {
numOfSuccess++
}
// skip if day is already set to failure
if historyHourlyMap[hour] == models.HealthcheckFailure {
if historyHourlyMap[hour] == models.MonitorFailure {
continue
}
@ -139,7 +139,7 @@ func getHourlyHistory(history []models.HealthcheckHistory) *History {
func (h *BaseHandler) Index(c echo.Context) error {
ctx := context.Background()
healthchecks, err := services.GetHealthchecks(ctx, h.query)
monitors, err := services.GetMonitors(ctx, h.query)
if err != nil {
return err
}
@ -151,18 +151,18 @@ func (h *BaseHandler) Index(c echo.Context) error {
overallStatus := "SUCCESS"
healthchecksWithHistory := make([]*HealthCheck, len(healthchecks))
for i, healthcheck := range healthchecks {
historyDaily := getDailyHistory(healthcheck.History)
historyHourly := getHourlyHistory(healthcheck.History)
monitorsWithHistory := make([]*HealthCheck, len(monitors))
for i, monitor := range monitors {
historyDaily := getDailyHistory(monitor.History)
historyHourly := getHourlyHistory(monitor.History)
status := historyDaily.History[89]
if status != models.HealthcheckSuccess {
if status != models.MonitorSuccess {
overallStatus = status
}
healthchecksWithHistory[i] = &HealthCheck{
Name: healthcheck.Name,
monitorsWithHistory[i] = &HealthCheck{
Name: monitor.Name,
Status: status,
HistoryDaily: historyDaily,
HistoryHourly: historyHourly,
@ -174,8 +174,8 @@ func (h *BaseHandler) Index(c echo.Context) error {
NavbarActive: GetPageByTitle(Pages, "Status"),
Navbar: Pages,
},
HealthChecks: healthchecksWithHistory,
HealthchecksLength: len(healthchecks),
HealthChecks: monitorsWithHistory,
MonitorsLength: len(monitors),
TimeRange: timeRange,
Status: overallStatus,
})

8
internal/handlers/settings.go
View file

@ -30,9 +30,8 @@ func NewSettings(user *AuthenticatedUser, page *components.Page, breadCrumbs []*
var SettingsPages = []*components.Page{
{Path: "/settings", Title: "Overview", Breadcrumb: "Overview"},
{Path: "/settings/healthchecks", Title: "Healthchecks", Breadcrumb: "Healthchecks"},
{Path: "/settings/healthchecks/create", Title: "Healthchecks Create", Breadcrumb: "Create"},
{Path: "/settings/cronjobs", Title: "Cronjobs", Breadcrumb: "Cronjobs"},
{Path: "/settings/monitors", Title: "Monitors", Breadcrumb: "Monitors"},
{Path: "/settings/monitors/create", Title: "Monitors Create", Breadcrumb: "Create"},
{Path: "/settings/workers", Title: "Workers", Breadcrumb: "Workers"},
{Path: "/settings/workers/create", Title: "Workers Create", Breadcrumb: "Create"},
{Path: "/settings/notifications", Title: "Notifications", Breadcrumb: "Notifications"},
@ -42,8 +41,7 @@ var SettingsPages = []*components.Page{
var SettingsNavbar = []*components.Page{
GetPageByTitle(SettingsPages, "Overview"),
GetPageByTitle(SettingsPages, "Healthchecks"),
GetPageByTitle(SettingsPages, "Cronjobs"),
GetPageByTitle(SettingsPages, "Monitors"),
GetPageByTitle(SettingsPages, "Workers"),
GetPageByTitle(SettingsPages, "Notifications"),
GetPageByTitle(SettingsPages, "Temporal"),

157
internal/handlers/settingshealthchecks.go
View file

@ -1,157 +0,0 @@
package handlers
import (
"context"
"fmt"
"net/http"
"strings"
"code.tjo.space/mentos1386/zdravko/internal/models"
"code.tjo.space/mentos1386/zdravko/internal/services"
"code.tjo.space/mentos1386/zdravko/web/templates/components"
"github.com/go-playground/validator/v10"
"github.com/gosimple/slug"
"github.com/labstack/echo/v4"
)
type SettingsHealthchecks struct {
*Settings
Healthchecks []*models.Healthcheck
HealthchecksLength int
}
type SettingsHealthcheck struct {
*Settings
Healthcheck *models.Healthcheck
}
func (h *BaseHandler) SettingsHealthchecksGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
healthchecks, err := h.query.Healthcheck.WithContext(context.Background()).Find()
if err != nil {
return err
}
return c.Render(http.StatusOK, "settings_healthchecks.tmpl", &SettingsHealthchecks{
Settings: NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Healthchecks"),
[]*components.Page{GetPageByTitle(SettingsPages, "Healthchecks")},
),
Healthchecks: healthchecks,
HealthchecksLength: len(healthchecks),
})
}
func (h *BaseHandler) SettingsHealthchecksDescribeGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
slug := c.Param("slug")
healthcheck, err := services.GetHealthcheck(context.Background(), h.query, slug)
if err != nil {
return err
}
return c.Render(http.StatusOK, "settings_healthchecks_describe.tmpl", &SettingsHealthcheck{
Settings: NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Healthchecks"),
[]*components.Page{
GetPageByTitle(SettingsPages, "Healthchecks"),
{
Path: fmt.Sprintf("/settings/healthchecks/%s", slug),
Title: "Describe",
Breadcrumb: healthcheck.Name,
},
}),
Healthcheck: healthcheck,
})
}
func (h *BaseHandler) SettingsHealthchecksDescribePOST(c echo.Context) error {
ctx := context.Background()
slug := c.Param("slug")
healthcheck, err := services.GetHealthcheck(ctx, h.query, slug)
if err != nil {
return err
}
update := &models.Healthcheck{
Slug: healthcheck.Slug,
Name: healthcheck.Name,
Schedule: c.FormValue("schedule"),
WorkerGroups: strings.Split(c.FormValue("workergroups"), " "),
Script: c.FormValue("script"),
}
err = validator.New(validator.WithRequiredStructEnabled()).Struct(update)
if err != nil {
return err
}
err = services.UpdateHealthcheck(
ctx,
h.query,
update,
)
if err != nil {
return err
}
err = services.CreateOrUpdateHealthcheckSchedule(ctx, h.temporal, healthcheck)
if err != nil {
return err
}
return c.Redirect(http.StatusSeeOther, fmt.Sprintf("/settings/healthchecks/%s", slug))
}
func (h *BaseHandler) SettingsHealthchecksCreateGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
return c.Render(http.StatusOK, "settings_healthchecks_create.tmpl", NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Healthchecks"),
[]*components.Page{
GetPageByTitle(SettingsPages, "Healthchecks"),
GetPageByTitle(SettingsPages, "Healthchecks Create"),
},
))
}
func (h *BaseHandler) SettingsHealthchecksCreatePOST(c echo.Context) error {
ctx := context.Background()
healthcheckHttp := &models.Healthcheck{
Name: c.FormValue("name"),
Slug: slug.Make(c.FormValue("name")),
Schedule: c.FormValue("schedule"),
WorkerGroups: strings.Split(c.FormValue("workergroups"), " "),
Script: c.FormValue("script"),
}
err := validator.New(validator.WithRequiredStructEnabled()).Struct(healthcheckHttp)
if err != nil {
return err
}
err = services.CreateHealthcheck(
ctx,
h.query,
healthcheckHttp,
)
if err != nil {
return err
}
err = services.CreateOrUpdateHealthcheckSchedule(ctx, h.temporal, healthcheckHttp)
if err != nil {
return err
}
return c.Redirect(http.StatusSeeOther, "/settings/healthchecks")
}

157
internal/handlers/settingsmonitors.go Normal file
View file

@ -0,0 +1,157 @@
package handlers
import (
"context"
"fmt"
"net/http"
"strings"
"code.tjo.space/mentos1386/zdravko/internal/models"
"code.tjo.space/mentos1386/zdravko/internal/services"
"code.tjo.space/mentos1386/zdravko/web/templates/components"
"github.com/go-playground/validator/v10"
"github.com/gosimple/slug"
"github.com/labstack/echo/v4"
)
type SettingsMonitors struct {
*Settings
Monitors []*models.Monitor
MonitorsLength int
}
type SettingsMonitor struct {
*Settings
Monitor *models.Monitor
}
func (h *BaseHandler) SettingsMonitorsGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
monitors, err := h.query.Monitor.WithContext(context.Background()).Find()
if err != nil {
return err
}
return c.Render(http.StatusOK, "settings_monitors.tmpl", &SettingsMonitors{
Settings: NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Monitors"),
[]*components.Page{GetPageByTitle(SettingsPages, "Monitors")},
),
Monitors: monitors,
MonitorsLength: len(monitors),
})
}
func (h *BaseHandler) SettingsMonitorsDescribeGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
slug := c.Param("slug")
monitor, err := services.GetMonitor(context.Background(), h.query, slug)
if err != nil {
return err
}
return c.Render(http.StatusOK, "settings_monitors_describe.tmpl", &SettingsMonitor{
Settings: NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Monitors"),
[]*components.Page{
GetPageByTitle(SettingsPages, "Monitors"),
{
Path: fmt.Sprintf("/settings/monitors/%s", slug),
Title: "Describe",
Breadcrumb: monitor.Name,
},
}),
Monitor: monitor,
})
}
func (h *BaseHandler) SettingsMonitorsDescribePOST(c echo.Context) error {
ctx := context.Background()
slug := c.Param("slug")
monitor, err := services.GetMonitor(ctx, h.query, slug)
if err != nil {
return err
}
update := &models.Monitor{
Slug: monitor.Slug,
Name: monitor.Name,
Schedule: c.FormValue("schedule"),
WorkerGroups: strings.Split(c.FormValue("workergroups"), " "),
Script: c.FormValue("script"),
}
err = validator.New(validator.WithRequiredStructEnabled()).Struct(update)
if err != nil {
return err
}
err = services.UpdateMonitor(
ctx,
h.query,
update,
)
if err != nil {
return err
}
err = services.CreateOrUpdateMonitorSchedule(ctx, h.temporal, monitor)
if err != nil {
return err
}
return c.Redirect(http.StatusSeeOther, fmt.Sprintf("/settings/monitors/%s", slug))
}
func (h *BaseHandler) SettingsMonitorsCreateGET(c echo.Context) error {
cc := c.(AuthenticatedContext)
return c.Render(http.StatusOK, "settings_monitors_create.tmpl", NewSettings(
cc.Principal.User,
GetPageByTitle(SettingsPages, "Monitors"),
[]*components.Page{
GetPageByTitle(SettingsPages, "Monitors"),
GetPageByTitle(SettingsPages, "Monitors Create"),
},
))
}
func (h *BaseHandler) SettingsMonitorsCreatePOST(c echo.Context) error {
ctx := context.Background()
monitorHttp := &models.Monitor{
Name: c.FormValue("name"),
Slug: slug.Make(c.FormValue("name")),
Schedule: c.FormValue("schedule"),
WorkerGroups: strings.Split(c.FormValue("workergroups"), " "),
Script: c.FormValue("script"),
}
err := validator.New(validator.WithRequiredStructEnabled()).Struct(monitorHttp)
if err != nil {
return err
}
err = services.CreateMonitor(
ctx,
h.query,
monitorHttp,
)
if err != nil {
return err
}
err = services.CreateOrUpdateMonitorSchedule(ctx, h.temporal, monitorHttp)
if err != nil {
return err
}
return c.Redirect(http.StatusSeeOther, "/settings/monitors")
}

16
internal/models/models.go
View file

@ -21,13 +21,13 @@ type Worker struct {
}
const (
HealthcheckSuccess string = "SUCCESS"
HealthcheckFailure string = "FAILURE"
HealthcheckError string = "ERROR"
HealthcheckUnknown string = "UNKNOWN"
MonitorSuccess string = "SUCCESS"
MonitorFailure string = "FAILURE"
MonitorError string = "ERROR"
MonitorUnknown string = "UNKNOWN"
)
type Healthcheck struct {
type Monitor struct {
gorm.Model
Slug string `gorm:"unique"`
Name string `gorm:"unique" validate:"required"`
@ -37,7 +37,7 @@ type Healthcheck struct {
Script string `validate:"required"`
History []HealthcheckHistory `gorm:"foreignKey:Healthcheck"`
History []MonitorHistory `gorm:"foreignKey:Monitor"`
}
type Cronjob struct {
@ -48,9 +48,9 @@ type Cronjob struct {
Buffer int
}
type HealthcheckHistory struct {
type MonitorHistory struct {
gorm.Model
Healthcheck uint
Monitor uint
Status string
Note string
}

96
internal/models/query/gen.go
View file

@ -16,59 +16,59 @@ import (
)
var (
Q = new(Query)
Cronjob *cronjob
CronjobHistory *cronjobHistory
Healthcheck *healthcheck
HealthcheckHistory *healthcheckHistory
OAuth2State *oAuth2State
Worker *worker
Q = new(Query)
Cronjob *cronjob
CronjobHistory *cronjobHistory
Monitor *monitor
MonitorHistory *monitorHistory
OAuth2State *oAuth2State
Worker *worker
)
func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
Cronjob = &Q.Cronjob
CronjobHistory = &Q.CronjobHistory
Healthcheck = &Q.Healthcheck
HealthcheckHistory = &Q.HealthcheckHistory
Monitor = &Q.Monitor
MonitorHistory = &Q.MonitorHistory
OAuth2State = &Q.OAuth2State
Worker = &Q.Worker
}
func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
return &Query{
db: db,
Cronjob: newCronjob(db, opts...),
CronjobHistory: newCronjobHistory(db, opts...),
Healthcheck: newHealthcheck(db, opts...),
HealthcheckHistory: newHealthcheckHistory(db, opts...),
OAuth2State: newOAuth2State(db, opts...),
Worker: newWorker(db, opts...),
db: db,
Cronjob: newCronjob(db, opts...),
CronjobHistory: newCronjobHistory(db, opts...),
Monitor: newMonitor(db, opts...),
MonitorHistory: newMonitorHistory(db, opts...),
OAuth2State: newOAuth2State(db, opts...),
Worker: newWorker(db, opts...),
}
}
type Query struct {
db *gorm.DB
Cronjob cronjob
CronjobHistory cronjobHistory
Healthcheck healthcheck
HealthcheckHistory healthcheckHistory
OAuth2State oAuth2State
Worker worker
Cronjob cronjob
CronjobHistory cronjobHistory
Monitor monitor
MonitorHistory monitorHistory
OAuth2State oAuth2State
Worker worker
}
func (q *Query) Available() bool { return q.db != nil }
func (q *Query) clone(db *gorm.DB) *Query {
return &Query{
db: db,
Cronjob: q.Cronjob.clone(db),
CronjobHistory: q.CronjobHistory.clone(db),
Healthcheck: q.Healthcheck.clone(db),
HealthcheckHistory: q.HealthcheckHistory.clone(db),
OAuth2State: q.OAuth2State.clone(db),
Worker: q.Worker.clone(db),
db: db,
Cronjob: q.Cronjob.clone(db),
CronjobHistory: q.CronjobHistory.clone(db),
Monitor: q.Monitor.clone(db),
MonitorHistory: q.MonitorHistory.clone(db),
OAuth2State: q.OAuth2State.clone(db),
Worker: q.Worker.clone(db),
}
}
@ -82,33 +82,33 @@ func (q *Query) WriteDB() *Query {
func (q *Query) ReplaceDB(db *gorm.DB) *Query {
return &Query{
db: db,
Cronjob: q.Cronjob.replaceDB(db),
CronjobHistory: q.CronjobHistory.replaceDB(db),
Healthcheck: q.Healthcheck.replaceDB(db),
HealthcheckHistory: q.HealthcheckHistory.replaceDB(db),
OAuth2State: q.OAuth2State.replaceDB(db),
Worker: q.Worker.replaceDB(db),
db: db,
Cronjob: q.Cronjob.replaceDB(db),
CronjobHistory: q.CronjobHistory.replaceDB(db),
Monitor: q.Monitor.replaceDB(db),
MonitorHistory: q.MonitorHistory.replaceDB(db),
OAuth2State: q.OAuth2State.replaceDB(db),
Worker: q.Worker.replaceDB(db),
}
}
type queryCtx struct {
Cronjob ICronjobDo
CronjobHistory ICronjobHistoryDo
Healthcheck IHealthcheckDo
HealthcheckHistory IHealthcheckHistoryDo
OAuth2State IOAuth2StateDo
Worker IWorkerDo
Cronjob ICronjobDo
CronjobHistory ICronjobHistoryDo
Monitor IMonitorDo
MonitorHistory IMonitorHistoryDo
OAuth2State IOAuth2StateDo
Worker IWorkerDo
}
func (q *Query) WithContext(ctx context.Context) *queryCtx {
return &queryCtx{
Cronjob: q.Cronjob.WithContext(ctx),
CronjobHistory: q.CronjobHistory.WithContext(ctx),
Healthcheck: q.Healthcheck.WithContext(ctx),
HealthcheckHistory: q.HealthcheckHistory.WithContext(ctx),
OAuth2State: q.OAuth2State.WithContext(ctx),
Worker: q.Worker.WithContext(ctx),
Cronjob: q.Cronjob.WithContext(ctx),
CronjobHistory: q.CronjobHistory.WithContext(ctx),
Monitor: q.Monitor.WithContext(ctx),
MonitorHistory: q.MonitorHistory.WithContext(ctx),
OAuth2State: q.OAuth2State.WithContext(ctx),
Worker: q.Worker.WithContext(ctx),
}
}

416
internal/models/query/healthcheck_histories.gen.go
View file

@ -1,416 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"code.tjo.space/mentos1386/zdravko/internal/models"
)
func newHealthcheckHistory(db *gorm.DB, opts ...gen.DOOption) healthcheckHistory {
_healthcheckHistory := healthcheckHistory{}
_healthcheckHistory.healthcheckHistoryDo.UseDB(db, opts...)
_healthcheckHistory.healthcheckHistoryDo.UseModel(&models.HealthcheckHistory{})
tableName := _healthcheckHistory.healthcheckHistoryDo.TableName()
_healthcheckHistory.ALL = field.NewAsterisk(tableName)
_healthcheckHistory.ID = field.NewUint(tableName, "id")
_healthcheckHistory.CreatedAt = field.NewTime(tableName, "created_at")
_healthcheckHistory.UpdatedAt = field.NewTime(tableName, "updated_at")
_healthcheckHistory.DeletedAt = field.NewField(tableName, "deleted_at")
_healthcheckHistory.Healthcheck = field.NewUint(tableName, "healthcheck")
_healthcheckHistory.Status = field.NewString(tableName, "status")
_healthcheckHistory.Note = field.NewString(tableName, "note")
_healthcheckHistory.fillFieldMap()
return _healthcheckHistory
}
type healthcheckHistory struct {
healthcheckHistoryDo healthcheckHistoryDo
ALL field.Asterisk
ID field.Uint
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Healthcheck field.Uint
Status field.String
Note field.String
fieldMap map[string]field.Expr
}
func (h healthcheckHistory) Table(newTableName string) *healthcheckHistory {
h.healthcheckHistoryDo.UseTable(newTableName)
return h.updateTableName(newTableName)
}
func (h healthcheckHistory) As(alias string) *healthcheckHistory {
h.healthcheckHistoryDo.DO = *(h.healthcheckHistoryDo.As(alias).(*gen.DO))
return h.updateTableName(alias)
}
func (h *healthcheckHistory) updateTableName(table string) *healthcheckHistory {
h.ALL = field.NewAsterisk(table)
h.ID = field.NewUint(table, "id")
h.CreatedAt = field.NewTime(table, "created_at")
h.UpdatedAt = field.NewTime(table, "updated_at")
h.DeletedAt = field.NewField(table, "deleted_at")
h.Healthcheck = field.NewUint(table, "healthcheck")
h.Status = field.NewString(table, "status")
h.Note = field.NewString(table, "note")
h.fillFieldMap()
return h
}
func (h *healthcheckHistory) WithContext(ctx context.Context) IHealthcheckHistoryDo {
return h.healthcheckHistoryDo.WithContext(ctx)
}
func (h healthcheckHistory) TableName() string { return h.healthcheckHistoryDo.TableName() }
func (h healthcheckHistory) Alias() string { return h.healthcheckHistoryDo.Alias() }
func (h healthcheckHistory) Columns(cols ...field.Expr) gen.Columns {
return h.healthcheckHistoryDo.Columns(cols...)
}
func (h *healthcheckHistory) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := h.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (h *healthcheckHistory) fillFieldMap() {
h.fieldMap = make(map[string]field.Expr, 7)
h.fieldMap["id"] = h.ID
h.fieldMap["created_at"] = h.CreatedAt
h.fieldMap["updated_at"] = h.UpdatedAt
h.fieldMap["deleted_at"] = h.DeletedAt
h.fieldMap["healthcheck"] = h.Healthcheck
h.fieldMap["status"] = h.Status
h.fieldMap["note"] = h.Note
}
func (h healthcheckHistory) clone(db *gorm.DB) healthcheckHistory {
h.healthcheckHistoryDo.ReplaceConnPool(db.Statement.ConnPool)
return h
}
func (h healthcheckHistory) replaceDB(db *gorm.DB) healthcheckHistory {
h.healthcheckHistoryDo.ReplaceDB(db)
return h
}
type healthcheckHistoryDo struct{ gen.DO }
type IHealthcheckHistoryDo interface {
gen.SubQuery
Debug() IHealthcheckHistoryDo
WithContext(ctx context.Context) IHealthcheckHistoryDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IHealthcheckHistoryDo
WriteDB() IHealthcheckHistoryDo
As(alias string) gen.Dao
Session(config *gorm.Session) IHealthcheckHistoryDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IHealthcheckHistoryDo
Not(conds ...gen.Condition) IHealthcheckHistoryDo
Or(conds ...gen.Condition) IHealthcheckHistoryDo
Select(conds ...field.Expr) IHealthcheckHistoryDo
Where(conds ...gen.Condition) IHealthcheckHistoryDo
Order(conds ...field.Expr) IHealthcheckHistoryDo
Distinct(cols ...field.Expr) IHealthcheckHistoryDo
Omit(cols ...field.Expr) IHealthcheckHistoryDo
Join(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo
LeftJoin(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo
RightJoin(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo
Group(cols ...field.Expr) IHealthcheckHistoryDo
Having(conds ...gen.Condition) IHealthcheckHistoryDo
Limit(limit int) IHealthcheckHistoryDo
Offset(offset int) IHealthcheckHistoryDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IHealthcheckHistoryDo
Unscoped() IHealthcheckHistoryDo
Create(values ...*models.HealthcheckHistory) error
CreateInBatches(values []*models.HealthcheckHistory, batchSize int) error
Save(values ...*models.HealthcheckHistory) error
First() (*models.HealthcheckHistory, error)
Take() (*models.HealthcheckHistory, error)
Last() (*models.HealthcheckHistory, error)
Find() ([]*models.HealthcheckHistory, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.HealthcheckHistory, err error)
FindInBatches(result *[]*models.HealthcheckHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*models.HealthcheckHistory) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IHealthcheckHistoryDo
Assign(attrs ...field.AssignExpr) IHealthcheckHistoryDo
Joins(fields ...field.RelationField) IHealthcheckHistoryDo
Preload(fields ...field.RelationField) IHealthcheckHistoryDo
FirstOrInit() (*models.HealthcheckHistory, error)
FirstOrCreate() (*models.HealthcheckHistory, error)
FindByPage(offset int, limit int) (result []*models.HealthcheckHistory, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IHealthcheckHistoryDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (h healthcheckHistoryDo) Debug() IHealthcheckHistoryDo {
return h.withDO(h.DO.Debug())
}
func (h healthcheckHistoryDo) WithContext(ctx context.Context) IHealthcheckHistoryDo {
return h.withDO(h.DO.WithContext(ctx))
}
func (h healthcheckHistoryDo) ReadDB() IHealthcheckHistoryDo {
return h.Clauses(dbresolver.Read)
}
func (h healthcheckHistoryDo) WriteDB() IHealthcheckHistoryDo {
return h.Clauses(dbresolver.Write)
}
func (h healthcheckHistoryDo) Session(config *gorm.Session) IHealthcheckHistoryDo {
return h.withDO(h.DO.Session(config))
}
func (h healthcheckHistoryDo) Clauses(conds ...clause.Expression) IHealthcheckHistoryDo {
return h.withDO(h.DO.Clauses(conds...))
}
func (h healthcheckHistoryDo) Returning(value interface{}, columns ...string) IHealthcheckHistoryDo {
return h.withDO(h.DO.Returning(value, columns...))
}
func (h healthcheckHistoryDo) Not(conds ...gen.Condition) IHealthcheckHistoryDo {
return h.withDO(h.DO.Not(conds...))
}
func (h healthcheckHistoryDo) Or(conds ...gen.Condition) IHealthcheckHistoryDo {
return h.withDO(h.DO.Or(conds...))
}
func (h healthcheckHistoryDo) Select(conds ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Select(conds...))
}
func (h healthcheckHistoryDo) Where(conds ...gen.Condition) IHealthcheckHistoryDo {
return h.withDO(h.DO.Where(conds...))
}
func (h healthcheckHistoryDo) Order(conds ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Order(conds...))
}
func (h healthcheckHistoryDo) Distinct(cols ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Distinct(cols...))
}
func (h healthcheckHistoryDo) Omit(cols ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Omit(cols...))
}
func (h healthcheckHistoryDo) Join(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Join(table, on...))
}
func (h healthcheckHistoryDo) LeftJoin(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.LeftJoin(table, on...))
}
func (h healthcheckHistoryDo) RightJoin(table schema.Tabler, on ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.RightJoin(table, on...))
}
func (h healthcheckHistoryDo) Group(cols ...field.Expr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Group(cols...))
}
func (h healthcheckHistoryDo) Having(conds ...gen.Condition) IHealthcheckHistoryDo {
return h.withDO(h.DO.Having(conds...))
}
func (h healthcheckHistoryDo) Limit(limit int) IHealthcheckHistoryDo {
return h.withDO(h.DO.Limit(limit))
}
func (h healthcheckHistoryDo) Offset(offset int) IHealthcheckHistoryDo {
return h.withDO(h.DO.Offset(offset))
}
func (h healthcheckHistoryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IHealthcheckHistoryDo {
return h.withDO(h.DO.Scopes(funcs...))
}
func (h healthcheckHistoryDo) Unscoped() IHealthcheckHistoryDo {
return h.withDO(h.DO.Unscoped())
}
func (h healthcheckHistoryDo) Create(values ...*models.HealthcheckHistory) error {
if len(values) == 0 {
return nil
}
return h.DO.Create(values)
}
func (h healthcheckHistoryDo) CreateInBatches(values []*models.HealthcheckHistory, batchSize int) error {
return h.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (h healthcheckHistoryDo) Save(values ...*models.HealthcheckHistory) error {
if len(values) == 0 {
return nil
}
return h.DO.Save(values)
}
func (h healthcheckHistoryDo) First() (*models.HealthcheckHistory, error) {
if result, err := h.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.HealthcheckHistory), nil
}
}
func (h healthcheckHistoryDo) Take() (*models.HealthcheckHistory, error) {
if result, err := h.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.HealthcheckHistory), nil
}
}
func (h healthcheckHistoryDo) Last() (*models.HealthcheckHistory, error) {
if result, err := h.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.HealthcheckHistory), nil
}
}
func (h healthcheckHistoryDo) Find() ([]*models.HealthcheckHistory, error) {
result, err := h.DO.Find()
return result.([]*models.HealthcheckHistory), err
}
func (h healthcheckHistoryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.HealthcheckHistory, err error) {
buf := make([]*models.HealthcheckHistory, 0, batchSize)
err = h.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (h healthcheckHistoryDo) FindInBatches(result *[]*models.HealthcheckHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return h.DO.FindInBatches(result, batchSize, fc)
}
func (h healthcheckHistoryDo) Attrs(attrs ...field.AssignExpr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Attrs(attrs...))
}
func (h healthcheckHistoryDo) Assign(attrs ...field.AssignExpr) IHealthcheckHistoryDo {
return h.withDO(h.DO.Assign(attrs...))
}
func (h healthcheckHistoryDo) Joins(fields ...field.RelationField) IHealthcheckHistoryDo {
for _, _f := range fields {
h = *h.withDO(h.DO.Joins(_f))
}
return &h
}
func (h healthcheckHistoryDo) Preload(fields ...field.RelationField) IHealthcheckHistoryDo {
for _, _f := range fields {
h = *h.withDO(h.DO.Preload(_f))
}
return &h
}
func (h healthcheckHistoryDo) FirstOrInit() (*models.HealthcheckHistory, error) {
if result, err := h.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.HealthcheckHistory), nil
}
}
func (h healthcheckHistoryDo) FirstOrCreate() (*models.HealthcheckHistory, error) {
if result, err := h.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.HealthcheckHistory), nil
}
}
func (h healthcheckHistoryDo) FindByPage(offset int, limit int) (result []*models.HealthcheckHistory, count int64, err error) {
result, err = h.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = h.Offset(-1).Limit(-1).Count()
return
}
func (h healthcheckHistoryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = h.Count()
if err != nil {
return
}
err = h.Offset(offset).Limit(limit).Scan(result)
return
}
func (h healthcheckHistoryDo) Scan(result interface{}) (err error) {
return h.DO.Scan(result)
}
func (h healthcheckHistoryDo) Delete(models ...*models.HealthcheckHistory) (result gen.ResultInfo, err error) {
return h.DO.Delete(models)
}
func (h *healthcheckHistoryDo) withDO(do gen.Dao) *healthcheckHistoryDo {
h.DO = *do.(*gen.DO)
return h
}

500
internal/models/query/healthchecks.gen.go
View file

@ -1,500 +0,0 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"code.tjo.space/mentos1386/zdravko/internal/models"
)
func newHealthcheck(db *gorm.DB, opts ...gen.DOOption) healthcheck {
_healthcheck := healthcheck{}
_healthcheck.healthcheckDo.UseDB(db, opts...)
_healthcheck.healthcheckDo.UseModel(&models.Healthcheck{})
tableName := _healthcheck.healthcheckDo.TableName()
_healthcheck.ALL = field.NewAsterisk(tableName)
_healthcheck.ID = field.NewUint(tableName, "id")
_healthcheck.CreatedAt = field.NewTime(tableName, "created_at")
_healthcheck.UpdatedAt = field.NewTime(tableName, "updated_at")
_healthcheck.DeletedAt = field.NewField(tableName, "deleted_at")
_healthcheck.Slug = field.NewString(tableName, "slug")
_healthcheck.Name = field.NewString(tableName, "name")
_healthcheck.Schedule = field.NewString(tableName, "schedule")
_healthcheck.WorkerGroups = field.NewField(tableName, "worker_groups")
_healthcheck.Script = field.NewString(tableName, "script")
_healthcheck.History = healthcheckHasManyHistory{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("History", "models.HealthcheckHistory"),
}
_healthcheck.fillFieldMap()
return _healthcheck
}
type healthcheck struct {
healthcheckDo healthcheckDo
ALL field.Asterisk
ID field.Uint
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Slug field.String
Name field.String
Schedule field.String
WorkerGroups field.Field
Script field.String
History healthcheckHasManyHistory
fieldMap map[string]field.Expr
}
func (h healthcheck) Table(newTableName string) *healthcheck {
h.healthcheckDo.UseTable(newTableName)
return h.updateTableName(newTableName)
}
func (h healthcheck) As(alias string) *healthcheck {
h.healthcheckDo.DO = *(h.healthcheckDo.As(alias).(*gen.DO))
return h.updateTableName(alias)
}
func (h *healthcheck) updateTableName(table string) *healthcheck {
h.ALL = field.NewAsterisk(table)
h.ID = field.NewUint(table, "id")
h.CreatedAt = field.NewTime(table, "created_at")
h.UpdatedAt = field.NewTime(table, "updated_at")
h.DeletedAt = field.NewField(table, "deleted_at")
h.Slug = field.NewString(table, "slug")
h.Name = field.NewString(table, "name")
h.Schedule = field.NewString(table, "schedule")
h.WorkerGroups = field.NewField(table, "worker_groups")
h.Script = field.NewString(table, "script")
h.fillFieldMap()
return h
}
func (h *healthcheck) WithContext(ctx context.Context) IHealthcheckDo {
return h.healthcheckDo.WithContext(ctx)
}
func (h healthcheck) TableName() string { return h.healthcheckDo.TableName() }
func (h healthcheck) Alias() string { return h.healthcheckDo.Alias() }
func (h healthcheck) Columns(cols ...field.Expr) gen.Columns { return h.healthcheckDo.Columns(cols...) }
func (h *healthcheck) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := h.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (h *healthcheck) fillFieldMap() {
h.fieldMap = make(map[string]field.Expr, 10)
h.fieldMap["id"] = h.ID
h.fieldMap["created_at"] = h.CreatedAt
h.fieldMap["updated_at"] = h.UpdatedAt
h.fieldMap["deleted_at"] = h.DeletedAt
h.fieldMap["slug"] = h.Slug
h.fieldMap["name"] = h.Name
h.fieldMap["schedule"] = h.Schedule
h.fieldMap["worker_groups"] = h.WorkerGroups
h.fieldMap["script"] = h.Script
}
func (h healthcheck) clone(db *gorm.DB) healthcheck {
h.healthcheckDo.ReplaceConnPool(db.Statement.ConnPool)
return h
}
func (h healthcheck) replaceDB(db *gorm.DB) healthcheck {
h.healthcheckDo.ReplaceDB(db)
return h
}
type healthcheckHasManyHistory struct {
db *gorm.DB
field.RelationField
}
func (a healthcheckHasManyHistory) Where(conds ...field.Expr) *healthcheckHasManyHistory {
if len(conds) == 0 {
return &a
}
exprs := make([]clause.Expression, 0, len(conds))
for _, cond := range conds {
exprs = append(exprs, cond.BeCond().(clause.Expression))
}
a.db = a.db.Clauses(clause.Where{Exprs: exprs})
return &a
}
func (a healthcheckHasManyHistory) WithContext(ctx context.Context) *healthcheckHasManyHistory {
a.db = a.db.WithContext(ctx)
return &a
}
func (a healthcheckHasManyHistory) Session(session *gorm.Session) *healthcheckHasManyHistory {
a.db = a.db.Session(session)
return &a
}
func (a healthcheckHasManyHistory) Model(m *models.Healthcheck) *healthcheckHasManyHistoryTx {
return &healthcheckHasManyHistoryTx{a.db.Model(m).Association(a.Name())}
}
type healthcheckHasManyHistoryTx struct{ tx *gorm.Association }
func (a healthcheckHasManyHistoryTx) Find() (result []*models.HealthcheckHistory, err error) {
return result, a.tx.Find(&result)
}
func (a healthcheckHasManyHistoryTx) Append(values ...*models.HealthcheckHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a healthcheckHasManyHistoryTx) Replace(values ...*models.HealthcheckHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a healthcheckHasManyHistoryTx) Delete(values ...*models.HealthcheckHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a healthcheckHasManyHistoryTx) Clear() error {
return a.tx.Clear()
}
func (a healthcheckHasManyHistoryTx) Count() int64 {
return a.tx.Count()
}
type healthcheckDo struct{ gen.DO }
type IHealthcheckDo interface {
gen.SubQuery
Debug() IHealthcheckDo
WithContext(ctx context.Context) IHealthcheckDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IHealthcheckDo
WriteDB() IHealthcheckDo
As(alias string) gen.Dao
Session(config *gorm.Session) IHealthcheckDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IHealthcheckDo
Not(conds ...gen.Condition) IHealthcheckDo
Or(conds ...gen.Condition) IHealthcheckDo
Select(conds ...field.Expr) IHealthcheckDo
Where(conds ...gen.Condition) IHealthcheckDo
Order(conds ...field.Expr) IHealthcheckDo
Distinct(cols ...field.Expr) IHealthcheckDo
Omit(cols ...field.Expr) IHealthcheckDo
Join(table schema.Tabler, on ...field.Expr) IHealthcheckDo
LeftJoin(table schema.Tabler, on ...field.Expr) IHealthcheckDo
RightJoin(table schema.Tabler, on ...field.Expr) IHealthcheckDo
Group(cols ...field.Expr) IHealthcheckDo
Having(conds ...gen.Condition) IHealthcheckDo
Limit(limit int) IHealthcheckDo
Offset(offset int) IHealthcheckDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IHealthcheckDo
Unscoped() IHealthcheckDo
Create(values ...*models.Healthcheck) error
CreateInBatches(values []*models.Healthcheck, batchSize int) error
Save(values ...*models.Healthcheck) error
First() (*models.Healthcheck, error)
Take() (*models.Healthcheck, error)
Last() (*models.Healthcheck, error)
Find() ([]*models.Healthcheck, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Healthcheck, err error)
FindInBatches(result *[]*models.Healthcheck, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*models.Healthcheck) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IHealthcheckDo
Assign(attrs ...field.AssignExpr) IHealthcheckDo
Joins(fields ...field.RelationField) IHealthcheckDo
Preload(fields ...field.RelationField) IHealthcheckDo
FirstOrInit() (*models.Healthcheck, error)
FirstOrCreate() (*models.Healthcheck, error)
FindByPage(offset int, limit int) (result []*models.Healthcheck, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IHealthcheckDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (h healthcheckDo) Debug() IHealthcheckDo {
return h.withDO(h.DO.Debug())
}
func (h healthcheckDo) WithContext(ctx context.Context) IHealthcheckDo {
return h.withDO(h.DO.WithContext(ctx))
}
func (h healthcheckDo) ReadDB() IHealthcheckDo {
return h.Clauses(dbresolver.Read)
}
func (h healthcheckDo) WriteDB() IHealthcheckDo {
return h.Clauses(dbresolver.Write)
}
func (h healthcheckDo) Session(config *gorm.Session) IHealthcheckDo {
return h.withDO(h.DO.Session(config))
}
func (h healthcheckDo) Clauses(conds ...clause.Expression) IHealthcheckDo {
return h.withDO(h.DO.Clauses(conds...))
}
func (h healthcheckDo) Returning(value interface{}, columns ...string) IHealthcheckDo {
return h.withDO(h.DO.Returning(value, columns...))
}
func (h healthcheckDo) Not(conds ...gen.Condition) IHealthcheckDo {
return h.withDO(h.DO.Not(conds...))
}
func (h healthcheckDo) Or(conds ...gen.Condition) IHealthcheckDo {
return h.withDO(h.DO.Or(conds...))
}
func (h healthcheckDo) Select(conds ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Select(conds...))
}
func (h healthcheckDo) Where(conds ...gen.Condition) IHealthcheckDo {
return h.withDO(h.DO.Where(conds...))
}
func (h healthcheckDo) Order(conds ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Order(conds...))
}
func (h healthcheckDo) Distinct(cols ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Distinct(cols...))
}
func (h healthcheckDo) Omit(cols ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Omit(cols...))
}
func (h healthcheckDo) Join(table schema.Tabler, on ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Join(table, on...))
}
func (h healthcheckDo) LeftJoin(table schema.Tabler, on ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.LeftJoin(table, on...))
}
func (h healthcheckDo) RightJoin(table schema.Tabler, on ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.RightJoin(table, on...))
}
func (h healthcheckDo) Group(cols ...field.Expr) IHealthcheckDo {
return h.withDO(h.DO.Group(cols...))
}
func (h healthcheckDo) Having(conds ...gen.Condition) IHealthcheckDo {
return h.withDO(h.DO.Having(conds...))
}
func (h healthcheckDo) Limit(limit int) IHealthcheckDo {
return h.withDO(h.DO.Limit(limit))
}
func (h healthcheckDo) Offset(offset int) IHealthcheckDo {
return h.withDO(h.DO.Offset(offset))
}
func (h healthcheckDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IHealthcheckDo {
return h.withDO(h.DO.Scopes(funcs...))
}
func (h healthcheckDo) Unscoped() IHealthcheckDo {
return h.withDO(h.DO.Unscoped())
}
func (h healthcheckDo) Create(values ...*models.Healthcheck) error {
if len(values) == 0 {
return nil
}
return h.DO.Create(values)
}
func (h healthcheckDo) CreateInBatches(values []*models.Healthcheck, batchSize int) error {
return h.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (h healthcheckDo) Save(values ...*models.Healthcheck) error {
if len(values) == 0 {
return nil
}
return h.DO.Save(values)
}
func (h healthcheckDo) First() (*models.Healthcheck, error) {
if result, err := h.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.Healthcheck), nil
}
}
func (h healthcheckDo) Take() (*models.Healthcheck, error) {
if result, err := h.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.Healthcheck), nil
}
}
func (h healthcheckDo) Last() (*models.Healthcheck, error) {
if result, err := h.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.Healthcheck), nil
}
}
func (h healthcheckDo) Find() ([]*models.Healthcheck, error) {
result, err := h.DO.Find()
return result.([]*models.Healthcheck), err
}
func (h healthcheckDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Healthcheck, err error) {
buf := make([]*models.Healthcheck, 0, batchSize)
err = h.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (h healthcheckDo) FindInBatches(result *[]*models.Healthcheck, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return h.DO.FindInBatches(result, batchSize, fc)
}
func (h healthcheckDo) Attrs(attrs ...field.AssignExpr) IHealthcheckDo {
return h.withDO(h.DO.Attrs(attrs...))
}
func (h healthcheckDo) Assign(attrs ...field.AssignExpr) IHealthcheckDo {
return h.withDO(h.DO.Assign(attrs...))
}
func (h healthcheckDo) Joins(fields ...field.RelationField) IHealthcheckDo {
for _, _f := range fields {
h = *h.withDO(h.DO.Joins(_f))
}
return &h
}
func (h healthcheckDo) Preload(fields ...field.RelationField) IHealthcheckDo {
for _, _f := range fields {
h = *h.withDO(h.DO.Preload(_f))
}
return &h
}
func (h healthcheckDo) FirstOrInit() (*models.Healthcheck, error) {
if result, err := h.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.Healthcheck), nil
}
}
func (h healthcheckDo) FirstOrCreate() (*models.Healthcheck, error) {
if result, err := h.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.Healthcheck), nil
}
}
func (h healthcheckDo) FindByPage(offset int, limit int) (result []*models.Healthcheck, count int64, err error) {
result, err = h.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = h.Offset(-1).Limit(-1).Count()
return
}
func (h healthcheckDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = h.Count()
if err != nil {
return
}
err = h.Offset(offset).Limit(limit).Scan(result)
return
}
func (h healthcheckDo) Scan(result interface{}) (err error) {
return h.DO.Scan(result)
}
func (h healthcheckDo) Delete(models ...*models.Healthcheck) (result gen.ResultInfo, err error) {
return h.DO.Delete(models)
}
func (h *healthcheckDo) withDO(do gen.Dao) *healthcheckDo {
h.DO = *do.(*gen.DO)
return h
}

416
internal/models/query/monitor_histories.gen.go Normal file
View file

@ -0,0 +1,416 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"code.tjo.space/mentos1386/zdravko/internal/models"
)
func newMonitorHistory(db *gorm.DB, opts ...gen.DOOption) monitorHistory {
_monitorHistory := monitorHistory{}
_monitorHistory.monitorHistoryDo.UseDB(db, opts...)
_monitorHistory.monitorHistoryDo.UseModel(&models.MonitorHistory{})
tableName := _monitorHistory.monitorHistoryDo.TableName()
_monitorHistory.ALL = field.NewAsterisk(tableName)
_monitorHistory.ID = field.NewUint(tableName, "id")
_monitorHistory.CreatedAt = field.NewTime(tableName, "created_at")
_monitorHistory.UpdatedAt = field.NewTime(tableName, "updated_at")
_monitorHistory.DeletedAt = field.NewField(tableName, "deleted_at")
_monitorHistory.Monitor = field.NewUint(tableName, "monitor")
_monitorHistory.Status = field.NewString(tableName, "status")
_monitorHistory.Note = field.NewString(tableName, "note")
_monitorHistory.fillFieldMap()
return _monitorHistory
}
type monitorHistory struct {
monitorHistoryDo monitorHistoryDo
ALL field.Asterisk
ID field.Uint
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Monitor field.Uint
Status field.String
Note field.String
fieldMap map[string]field.Expr
}
func (m monitorHistory) Table(newTableName string) *monitorHistory {
m.monitorHistoryDo.UseTable(newTableName)
return m.updateTableName(newTableName)
}
func (m monitorHistory) As(alias string) *monitorHistory {
m.monitorHistoryDo.DO = *(m.monitorHistoryDo.As(alias).(*gen.DO))
return m.updateTableName(alias)
}
func (m *monitorHistory) updateTableName(table string) *monitorHistory {
m.ALL = field.NewAsterisk(table)
m.ID = field.NewUint(table, "id")
m.CreatedAt = field.NewTime(table, "created_at")
m.UpdatedAt = field.NewTime(table, "updated_at")
m.DeletedAt = field.NewField(table, "deleted_at")
m.Monitor = field.NewUint(table, "monitor")
m.Status = field.NewString(table, "status")
m.Note = field.NewString(table, "note")
m.fillFieldMap()
return m
}
func (m *monitorHistory) WithContext(ctx context.Context) IMonitorHistoryDo {
return m.monitorHistoryDo.WithContext(ctx)
}
func (m monitorHistory) TableName() string { return m.monitorHistoryDo.TableName() }
func (m monitorHistory) Alias() string { return m.monitorHistoryDo.Alias() }
func (m monitorHistory) Columns(cols ...field.Expr) gen.Columns {
return m.monitorHistoryDo.Columns(cols...)
}
func (m *monitorHistory) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := m.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (m *monitorHistory) fillFieldMap() {
m.fieldMap = make(map[string]field.Expr, 7)
m.fieldMap["id"] = m.ID
m.fieldMap["created_at"] = m.CreatedAt
m.fieldMap["updated_at"] = m.UpdatedAt
m.fieldMap["deleted_at"] = m.DeletedAt
m.fieldMap["monitor"] = m.Monitor
m.fieldMap["status"] = m.Status
m.fieldMap["note"] = m.Note
}
func (m monitorHistory) clone(db *gorm.DB) monitorHistory {
m.monitorHistoryDo.ReplaceConnPool(db.Statement.ConnPool)
return m
}
func (m monitorHistory) replaceDB(db *gorm.DB) monitorHistory {
m.monitorHistoryDo.ReplaceDB(db)
return m
}
type monitorHistoryDo struct{ gen.DO }
type IMonitorHistoryDo interface {
gen.SubQuery
Debug() IMonitorHistoryDo
WithContext(ctx context.Context) IMonitorHistoryDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IMonitorHistoryDo
WriteDB() IMonitorHistoryDo
As(alias string) gen.Dao
Session(config *gorm.Session) IMonitorHistoryDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IMonitorHistoryDo
Not(conds ...gen.Condition) IMonitorHistoryDo
Or(conds ...gen.Condition) IMonitorHistoryDo
Select(conds ...field.Expr) IMonitorHistoryDo
Where(conds ...gen.Condition) IMonitorHistoryDo
Order(conds ...field.Expr) IMonitorHistoryDo
Distinct(cols ...field.Expr) IMonitorHistoryDo
Omit(cols ...field.Expr) IMonitorHistoryDo
Join(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo
LeftJoin(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo
RightJoin(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo
Group(cols ...field.Expr) IMonitorHistoryDo
Having(conds ...gen.Condition) IMonitorHistoryDo
Limit(limit int) IMonitorHistoryDo
Offset(offset int) IMonitorHistoryDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IMonitorHistoryDo
Unscoped() IMonitorHistoryDo
Create(values ...*models.MonitorHistory) error
CreateInBatches(values []*models.MonitorHistory, batchSize int) error
Save(values ...*models.MonitorHistory) error
First() (*models.MonitorHistory, error)
Take() (*models.MonitorHistory, error)
Last() (*models.MonitorHistory, error)
Find() ([]*models.MonitorHistory, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.MonitorHistory, err error)
FindInBatches(result *[]*models.MonitorHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*models.MonitorHistory) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IMonitorHistoryDo
Assign(attrs ...field.AssignExpr) IMonitorHistoryDo
Joins(fields ...field.RelationField) IMonitorHistoryDo
Preload(fields ...field.RelationField) IMonitorHistoryDo
FirstOrInit() (*models.MonitorHistory, error)
FirstOrCreate() (*models.MonitorHistory, error)
FindByPage(offset int, limit int) (result []*models.MonitorHistory, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IMonitorHistoryDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (m monitorHistoryDo) Debug() IMonitorHistoryDo {
return m.withDO(m.DO.Debug())
}
func (m monitorHistoryDo) WithContext(ctx context.Context) IMonitorHistoryDo {
return m.withDO(m.DO.WithContext(ctx))
}
func (m monitorHistoryDo) ReadDB() IMonitorHistoryDo {
return m.Clauses(dbresolver.Read)
}
func (m monitorHistoryDo) WriteDB() IMonitorHistoryDo {
return m.Clauses(dbresolver.Write)
}
func (m monitorHistoryDo) Session(config *gorm.Session) IMonitorHistoryDo {
return m.withDO(m.DO.Session(config))
}
func (m monitorHistoryDo) Clauses(conds ...clause.Expression) IMonitorHistoryDo {
return m.withDO(m.DO.Clauses(conds...))
}
func (m monitorHistoryDo) Returning(value interface{}, columns ...string) IMonitorHistoryDo {
return m.withDO(m.DO.Returning(value, columns...))
}
func (m monitorHistoryDo) Not(conds ...gen.Condition) IMonitorHistoryDo {
return m.withDO(m.DO.Not(conds...))
}
func (m monitorHistoryDo) Or(conds ...gen.Condition) IMonitorHistoryDo {
return m.withDO(m.DO.Or(conds...))
}
func (m monitorHistoryDo) Select(conds ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Select(conds...))
}
func (m monitorHistoryDo) Where(conds ...gen.Condition) IMonitorHistoryDo {
return m.withDO(m.DO.Where(conds...))
}
func (m monitorHistoryDo) Order(conds ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Order(conds...))
}
func (m monitorHistoryDo) Distinct(cols ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Distinct(cols...))
}
func (m monitorHistoryDo) Omit(cols ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Omit(cols...))
}
func (m monitorHistoryDo) Join(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Join(table, on...))
}
func (m monitorHistoryDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.LeftJoin(table, on...))
}
func (m monitorHistoryDo) RightJoin(table schema.Tabler, on ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.RightJoin(table, on...))
}
func (m monitorHistoryDo) Group(cols ...field.Expr) IMonitorHistoryDo {
return m.withDO(m.DO.Group(cols...))
}
func (m monitorHistoryDo) Having(conds ...gen.Condition) IMonitorHistoryDo {
return m.withDO(m.DO.Having(conds...))
}
func (m monitorHistoryDo) Limit(limit int) IMonitorHistoryDo {
return m.withDO(m.DO.Limit(limit))
}
func (m monitorHistoryDo) Offset(offset int) IMonitorHistoryDo {
return m.withDO(m.DO.Offset(offset))
}
func (m monitorHistoryDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMonitorHistoryDo {
return m.withDO(m.DO.Scopes(funcs...))
}
func (m monitorHistoryDo) Unscoped() IMonitorHistoryDo {
return m.withDO(m.DO.Unscoped())
}
func (m monitorHistoryDo) Create(values ...*models.MonitorHistory) error {
if len(values) == 0 {
return nil
}
return m.DO.Create(values)
}
func (m monitorHistoryDo) CreateInBatches(values []*models.MonitorHistory, batchSize int) error {
return m.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (m monitorHistoryDo) Save(values ...*models.MonitorHistory) error {
if len(values) == 0 {
return nil
}
return m.DO.Save(values)
}
func (m monitorHistoryDo) First() (*models.MonitorHistory, error) {
if result, err := m.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.MonitorHistory), nil
}
}
func (m monitorHistoryDo) Take() (*models.MonitorHistory, error) {
if result, err := m.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.MonitorHistory), nil
}
}
func (m monitorHistoryDo) Last() (*models.MonitorHistory, error) {
if result, err := m.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.MonitorHistory), nil
}
}
func (m monitorHistoryDo) Find() ([]*models.MonitorHistory, error) {
result, err := m.DO.Find()
return result.([]*models.MonitorHistory), err
}
func (m monitorHistoryDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.MonitorHistory, err error) {
buf := make([]*models.MonitorHistory, 0, batchSize)
err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (m monitorHistoryDo) FindInBatches(result *[]*models.MonitorHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return m.DO.FindInBatches(result, batchSize, fc)
}
func (m monitorHistoryDo) Attrs(attrs ...field.AssignExpr) IMonitorHistoryDo {
return m.withDO(m.DO.Attrs(attrs...))
}
func (m monitorHistoryDo) Assign(attrs ...field.AssignExpr) IMonitorHistoryDo {
return m.withDO(m.DO.Assign(attrs...))
}
func (m monitorHistoryDo) Joins(fields ...field.RelationField) IMonitorHistoryDo {
for _, _f := range fields {
m = *m.withDO(m.DO.Joins(_f))
}
return &m
}
func (m monitorHistoryDo) Preload(fields ...field.RelationField) IMonitorHistoryDo {
for _, _f := range fields {
m = *m.withDO(m.DO.Preload(_f))
}
return &m
}
func (m monitorHistoryDo) FirstOrInit() (*models.MonitorHistory, error) {
if result, err := m.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.MonitorHistory), nil
}
}
func (m monitorHistoryDo) FirstOrCreate() (*models.MonitorHistory, error) {
if result, err := m.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.MonitorHistory), nil
}
}
func (m monitorHistoryDo) FindByPage(offset int, limit int) (result []*models.MonitorHistory, count int64, err error) {
result, err = m.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = m.Offset(-1).Limit(-1).Count()
return
}
func (m monitorHistoryDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = m.Count()
if err != nil {
return
}
err = m.Offset(offset).Limit(limit).Scan(result)
return
}
func (m monitorHistoryDo) Scan(result interface{}) (err error) {
return m.DO.Scan(result)
}
func (m monitorHistoryDo) Delete(models ...*models.MonitorHistory) (result gen.ResultInfo, err error) {
return m.DO.Delete(models)
}
func (m *monitorHistoryDo) withDO(do gen.Dao) *monitorHistoryDo {
m.DO = *do.(*gen.DO)
return m
}

498
internal/models/query/monitors.gen.go Normal file
View file

@ -0,0 +1,498 @@
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
package query
import (
"context"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"code.tjo.space/mentos1386/zdravko/internal/models"
)
func newMonitor(db *gorm.DB, opts ...gen.DOOption) monitor {
_monitor := monitor{}
_monitor.monitorDo.UseDB(db, opts...)
_monitor.monitorDo.UseModel(&models.Monitor{})
tableName := _monitor.monitorDo.TableName()
_monitor.ALL = field.NewAsterisk(tableName)
_monitor.ID = field.NewUint(tableName, "id")
_monitor.CreatedAt = field.NewTime(tableName, "created_at")
_monitor.UpdatedAt = field.NewTime(tableName, "updated_at")
_monitor.DeletedAt = field.NewField(tableName, "deleted_at")
_monitor.Slug = field.NewString(tableName, "slug")
_monitor.Name = field.NewString(tableName, "name")
_monitor.Schedule = field.NewString(tableName, "schedule")
_monitor.WorkerGroups = field.NewField(tableName, "worker_groups")
_monitor.Script = field.NewString(tableName, "script")
_monitor.History = monitorHasManyHistory{
db: db.Session(&gorm.Session{}),
RelationField: field.NewRelation("History", "models.MonitorHistory"),
}
_monitor.fillFieldMap()
return _monitor
}
type monitor struct {
monitorDo monitorDo
ALL field.Asterisk
ID field.Uint
CreatedAt field.Time
UpdatedAt field.Time
DeletedAt field.Field
Slug field.String
Name field.String
Schedule field.String
WorkerGroups field.Field
Script field.String
History monitorHasManyHistory
fieldMap map[string]field.Expr
}
func (m monitor) Table(newTableName string) *monitor {
m.monitorDo.UseTable(newTableName)
return m.updateTableName(newTableName)
}
func (m monitor) As(alias string) *monitor {
m.monitorDo.DO = *(m.monitorDo.As(alias).(*gen.DO))
return m.updateTableName(alias)
}
func (m *monitor) updateTableName(table string) *monitor {
m.ALL = field.NewAsterisk(table)
m.ID = field.NewUint(table, "id")
m.CreatedAt = field.NewTime(table, "created_at")
m.UpdatedAt = field.NewTime(table, "updated_at")
m.DeletedAt = field.NewField(table, "deleted_at")
m.Slug = field.NewString(table, "slug")
m.Name = field.NewString(table, "name")
m.Schedule = field.NewString(table, "schedule")
m.WorkerGroups = field.NewField(table, "worker_groups")
m.Script = field.NewString(table, "script")
m.fillFieldMap()
return m
}
func (m *monitor) WithContext(ctx context.Context) IMonitorDo { return m.monitorDo.WithContext(ctx) }
func (m monitor) TableName() string { return m.monitorDo.TableName() }
func (m monitor) Alias() string { return m.monitorDo.Alias() }
func (m monitor) Columns(cols ...field.Expr) gen.Columns { return m.monitorDo.Columns(cols...) }
func (m *monitor) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := m.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (m *monitor) fillFieldMap() {
m.fieldMap = make(map[string]field.Expr, 10)
m.fieldMap["id"] = m.ID
m.fieldMap["created_at"] = m.CreatedAt
m.fieldMap["updated_at"] = m.UpdatedAt
m.fieldMap["deleted_at"] = m.DeletedAt
m.fieldMap["slug"] = m.Slug
m.fieldMap["name"] = m.Name
m.fieldMap["schedule"] = m.Schedule
m.fieldMap["worker_groups"] = m.WorkerGroups
m.fieldMap["script"] = m.Script
}
func (m monitor) clone(db *gorm.DB) monitor {
m.monitorDo.ReplaceConnPool(db.Statement.ConnPool)
return m
}
func (m monitor) replaceDB(db *gorm.DB) monitor {
m.monitorDo.ReplaceDB(db)
return m
}
type monitorHasManyHistory struct {
db *gorm.DB
field.RelationField
}
func (a monitorHasManyHistory) Where(conds ...field.Expr) *monitorHasManyHistory {
if len(conds) == 0 {
return &a
}
exprs := make([]clause.Expression, 0, len(conds))
for _, cond := range conds {
exprs = append(exprs, cond.BeCond().(clause.Expression))
}
a.db = a.db.Clauses(clause.Where{Exprs: exprs})
return &a
}
func (a monitorHasManyHistory) WithContext(ctx context.Context) *monitorHasManyHistory {
a.db = a.db.WithContext(ctx)
return &a
}
func (a monitorHasManyHistory) Session(session *gorm.Session) *monitorHasManyHistory {
a.db = a.db.Session(session)
return &a
}
func (a monitorHasManyHistory) Model(m *models.Monitor) *monitorHasManyHistoryTx {
return &monitorHasManyHistoryTx{a.db.Model(m).Association(a.Name())}
}
type monitorHasManyHistoryTx struct{ tx *gorm.Association }
func (a monitorHasManyHistoryTx) Find() (result []*models.MonitorHistory, err error) {
return result, a.tx.Find(&result)
}
func (a monitorHasManyHistoryTx) Append(values ...*models.MonitorHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Append(targetValues...)
}
func (a monitorHasManyHistoryTx) Replace(values ...*models.MonitorHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Replace(targetValues...)
}
func (a monitorHasManyHistoryTx) Delete(values ...*models.MonitorHistory) (err error) {
targetValues := make([]interface{}, len(values))
for i, v := range values {
targetValues[i] = v
}
return a.tx.Delete(targetValues...)
}
func (a monitorHasManyHistoryTx) Clear() error {
return a.tx.Clear()
}
func (a monitorHasManyHistoryTx) Count() int64 {
return a.tx.Count()
}
type monitorDo struct{ gen.DO }
type IMonitorDo interface {
gen.SubQuery
Debug() IMonitorDo
WithContext(ctx context.Context) IMonitorDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IMonitorDo
WriteDB() IMonitorDo
As(alias string) gen.Dao
Session(config *gorm.Session) IMonitorDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IMonitorDo
Not(conds ...gen.Condition) IMonitorDo
Or(conds ...gen.Condition) IMonitorDo
Select(conds ...field.Expr) IMonitorDo
Where(conds ...gen.Condition) IMonitorDo
Order(conds ...field.Expr) IMonitorDo
Distinct(cols ...field.Expr) IMonitorDo
Omit(cols ...field.Expr) IMonitorDo
Join(table schema.Tabler, on ...field.Expr) IMonitorDo
LeftJoin(table schema.Tabler, on ...field.Expr) IMonitorDo
RightJoin(table schema.Tabler, on ...field.Expr) IMonitorDo
Group(cols ...field.Expr) IMonitorDo
Having(conds ...gen.Condition) IMonitorDo
Limit(limit int) IMonitorDo
Offset(offset int) IMonitorDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IMonitorDo
Unscoped() IMonitorDo
Create(values ...*models.Monitor) error
CreateInBatches(values []*models.Monitor, batchSize int) error
Save(values ...*models.Monitor) error
First() (*models.Monitor, error)
Take() (*models.Monitor, error)
Last() (*models.Monitor, error)
Find() ([]*models.Monitor, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Monitor, err error)
FindInBatches(result *[]*models.Monitor, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*models.Monitor) (info gen.ResultInfo, err error)
Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
Updates(value interface{}) (info gen.ResultInfo, err error)
UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
UpdateFrom(q gen.SubQuery) gen.Dao
Attrs(attrs ...field.AssignExpr) IMonitorDo
Assign(attrs ...field.AssignExpr) IMonitorDo
Joins(fields ...field.RelationField) IMonitorDo
Preload(fields ...field.RelationField) IMonitorDo
FirstOrInit() (*models.Monitor, error)
FirstOrCreate() (*models.Monitor, error)
FindByPage(offset int, limit int) (result []*models.Monitor, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IMonitorDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (m monitorDo) Debug() IMonitorDo {
return m.withDO(m.DO.Debug())
}
func (m monitorDo) WithContext(ctx context.Context) IMonitorDo {
return m.withDO(m.DO.WithContext(ctx))
}
func (m monitorDo) ReadDB() IMonitorDo {
return m.Clauses(dbresolver.Read)
}
func (m monitorDo) WriteDB() IMonitorDo {
return m.Clauses(dbresolver.Write)
}
func (m monitorDo) Session(config *gorm.Session) IMonitorDo {
return m.withDO(m.DO.Session(config))
}
func (m monitorDo) Clauses(conds ...clause.Expression) IMonitorDo {
return m.withDO(m.DO.Clauses(conds...))
}
func (m monitorDo) Returning(value interface{}, columns ...string) IMonitorDo {
return m.withDO(m.DO.Returning(value, columns...))
}
func (m monitorDo) Not(conds ...gen.Condition) IMonitorDo {
return m.withDO(m.DO.Not(conds...))
}
func (m monitorDo) Or(conds ...gen.Condition) IMonitorDo {
return m.withDO(m.DO.Or(conds...))
}
func (m monitorDo) Select(conds ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Select(conds...))
}
func (m monitorDo) Where(conds ...gen.Condition) IMonitorDo {
return m.withDO(m.DO.Where(conds...))
}
func (m monitorDo) Order(conds ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Order(conds...))
}
func (m monitorDo) Distinct(cols ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Distinct(cols...))
}
func (m monitorDo) Omit(cols ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Omit(cols...))
}
func (m monitorDo) Join(table schema.Tabler, on ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Join(table, on...))
}
func (m monitorDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMonitorDo {
return m.withDO(m.DO.LeftJoin(table, on...))
}
func (m monitorDo) RightJoin(table schema.Tabler, on ...field.Expr) IMonitorDo {
return m.withDO(m.DO.RightJoin(table, on...))
}
func (m monitorDo) Group(cols ...field.Expr) IMonitorDo {
return m.withDO(m.DO.Group(cols...))
}
func (m monitorDo) Having(conds ...gen.Condition) IMonitorDo {
return m.withDO(m.DO.Having(conds...))
}
func (m monitorDo) Limit(limit int) IMonitorDo {
return m.withDO(m.DO.Limit(limit))
}
func (m monitorDo) Offset(offset int) IMonitorDo {
return m.withDO(m.DO.Offset(offset))
}
func (m monitorDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMonitorDo {
return m.withDO(m.DO.Scopes(funcs...))
}
func (m monitorDo) Unscoped() IMonitorDo {
return m.withDO(m.DO.Unscoped())
}
func (m monitorDo) Create(values ...*models.Monitor) error {
if len(values) == 0 {
return nil
}
return m.DO.Create(values)
}
func (m monitorDo) CreateInBatches(values []*models.Monitor, batchSize int) error {
return m.DO.CreateInBatches(values, batchSize)
}
// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (m monitorDo) Save(values ...*models.Monitor) error {
if len(values) == 0 {
return nil
}
return m.DO.Save(values)
}
func (m monitorDo) First() (*models.Monitor, error) {
if result, err := m.DO.First(); err != nil {
return nil, err
} else {
return result.(*models.Monitor), nil
}
}
func (m monitorDo) Take() (*models.Monitor, error) {
if result, err := m.DO.Take(); err != nil {
return nil, err
} else {
return result.(*models.Monitor), nil
}
}
func (m monitorDo) Last() (*models.Monitor, error) {
if result, err := m.DO.Last(); err != nil {
return nil, err
} else {
return result.(*models.Monitor), nil
}
}
func (m monitorDo) Find() ([]*models.Monitor, error) {
result, err := m.DO.Find()
return result.([]*models.Monitor), err
}
func (m monitorDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*models.Monitor, err error) {
buf := make([]*models.Monitor, 0, batchSize)
err = m.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
defer func() { results = append(results, buf...) }()
return fc(tx, batch)
})
return results, err
}
func (m monitorDo) FindInBatches(result *[]*models.Monitor, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return m.DO.FindInBatches(result, batchSize, fc)
}
func (m monitorDo) Attrs(attrs ...field.AssignExpr) IMonitorDo {
return m.withDO(m.DO.Attrs(attrs...))
}
func (m monitorDo) Assign(attrs ...field.AssignExpr) IMonitorDo {
return m.withDO(m.DO.Assign(attrs...))
}
func (m monitorDo) Joins(fields ...field.RelationField) IMonitorDo {
for _, _f := range fields {
m = *m.withDO(m.DO.Joins(_f))
}
return &m
}
func (m monitorDo) Preload(fields ...field.RelationField) IMonitorDo {
for _, _f := range fields {
m = *m.withDO(m.DO.Preload(_f))
}
return &m
}
func (m monitorDo) FirstOrInit() (*models.Monitor, error) {
if result, err := m.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*models.Monitor), nil
}
}
func (m monitorDo) FirstOrCreate() (*models.Monitor, error) {
if result, err := m.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*models.Monitor), nil
}
}
func (m monitorDo) FindByPage(offset int, limit int) (result []*models.Monitor, count int64, err error) {
result, err = m.Offset(offset).Limit(limit).Find()
if err != nil {
return
}
if size := len(result); 0 < limit && 0 < size && size < limit {
count = int64(size + offset)
return
}
count, err = m.Offset(-1).Limit(-1).Count()
return
}
func (m monitorDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = m.Count()
if err != nil {
return
}
err = m.Offset(offset).Limit(limit).Scan(result)
return
}
func (m monitorDo) Scan(result interface{}) (err error) {
return m.DO.Scan(result)
}
func (m monitorDo) Delete(models ...*models.Monitor) (result gen.ResultInfo, err error) {
return m.DO.Delete(models)
}
func (m *monitorDo) withDO(do gen.Dao) *monitorDo {
m.DO = *do.(*gen.DO)
return m
}

114
internal/services/healthcheck.go
View file

@ -1,114 +0,0 @@
package services
import (
"context"
"log"
"time"
"code.tjo.space/mentos1386/zdravko/internal/models"
"code.tjo.space/mentos1386/zdravko/internal/models/query"
"code.tjo.space/mentos1386/zdravko/internal/workflows"
"go.temporal.io/sdk/client"
"go.temporal.io/sdk/temporal"
"gorm.io/gorm"
)
func getScheduleId(healthcheck *models.Healthcheck, group string) string {
return "healthcheck-" + healthcheck.Slug + "-" + group
}
func CreateHealthcheck(ctx context.Context, query *query.Query, healthcheck *models.Healthcheck) error {
return query.Healthcheck.WithContext(ctx).Create(healthcheck)
}
func UpdateHealthcheck(ctx context.Context, q *query.Query, healthcheck *models.Healthcheck) error {
_, err := q.Healthcheck.WithContext(ctx).Where(
q.Healthcheck.Slug.Eq(healthcheck.Slug),
).Updates(healthcheck)
return err
}
func GetHealthcheck(ctx context.Context, q *query.Query, slug string) (*models.Healthcheck, error) {
return q.Healthcheck.WithContext(ctx).Where(
q.Healthcheck.Slug.Eq(slug),
q.Healthcheck.DeletedAt.IsNull(),
).Preload(
q.Healthcheck.History,
).First()
}
func GetHealthchecks(ctx context.Context, q *query.Query) ([]*models.Healthcheck, error) {
return q.Healthcheck.WithContext(ctx).Preload(
q.Healthcheck.History,
).Where(
q.Healthcheck.DeletedAt.IsNull(),
).Find()
}
func CreateOrUpdateHealthcheckSchedule(ctx context.Context, t client.Client, healthcheck *models.Healthcheck) error {
log.Println("Creating or Updating Healthcheck Schedule")
args := make([]interface{}, 0)
args = append(args, workflows.HealthcheckWorkflowParam{Script: healthcheck.Script, Slug: healthcheck.Slug})
for _, group := range healthcheck.WorkerGroups {
options := client.ScheduleOptions{
ID: getScheduleId(healthcheck, group),
//SearchAttributes: map[string]interface{}{
// "worker-group": group,
// "healthcheck-slug": healthcheck.Slug,
//},
Spec: client.ScheduleSpec{
CronExpressions: []string{healthcheck.Schedule},
Jitter: time.Second * 10,
},
Action: &client.ScheduleWorkflowAction{
ID: getScheduleId(healthcheck, group),
Workflow: workflows.NewWorkflows(nil).HealthcheckWorkflowDefinition,
Args: args,
TaskQueue: group,
RetryPolicy: &temporal.RetryPolicy{
MaximumAttempts: 3,
},
},
}
schedule := t.ScheduleClient().GetHandle(ctx, getScheduleId(healthcheck, group))
// If exists, we update
_, err := schedule.Describe(ctx)
if err == nil {
err = schedule.Update(ctx, client.ScheduleUpdateOptions{
DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
return &client.ScheduleUpdate{
Schedule: &client.Schedule{
Spec: &options.Spec,
Action: options.Action,
Policy: input.Description.Schedule.Policy,
State: input.Description.Schedule.State,
},
}, nil
},
})
if err != nil {
return err
}
} else {
schedule, err = t.ScheduleClient().Create(ctx, options)
if err != nil {
return err
}
}
err = schedule.Trigger(ctx, client.ScheduleTriggerOptions{})
if err != nil {
return err
}
}
return nil
}
func CreateHealthcheckHistory(ctx context.Context, db *gorm.DB, healthcheckHistory *models.HealthcheckHistory) error {
return db.WithContext(ctx).Create(healthcheckHistory).Error
}

114
internal/services/monitor.go Normal file
View file

@ -0,0 +1,114 @@
package services
import (
"context"
"log"
"time"
"code.tjo.space/mentos1386/zdravko/internal/models"
"code.tjo.space/mentos1386/zdravko/internal/models/query"
"code.tjo.space/mentos1386/zdravko/internal/workflows"
"go.temporal.io/sdk/client"
"go.temporal.io/sdk/temporal"
"gorm.io/gorm"
)
func getScheduleId(monitor *models.Monitor, group string) string {
return "monitor-" + monitor.Slug + "-" + group
}
func CreateMonitor(ctx context.Context, query *query.Query, monitor *models.Monitor) error {
return query.Monitor.WithContext(ctx).Create(monitor)
}
func UpdateMonitor(ctx context.Context, q *query.Query, monitor *models.Monitor) error {
_, err := q.Monitor.WithContext(ctx).Where(
q.Monitor.Slug.Eq(monitor.Slug),
).Updates(monitor)
return err
}
func GetMonitor(ctx context.Context, q *query.Query, slug string) (*models.Monitor, error) {
return q.Monitor.WithContext(ctx).Where(
q.Monitor.Slug.Eq(slug),
q.Monitor.DeletedAt.IsNull(),
).Preload(
q.Monitor.History,
).First()
}
func GetMonitors(ctx context.Context, q *query.Query) ([]*models.Monitor, error) {
return q.Monitor.WithContext(ctx).Preload(
q.Monitor.History,
).Where(
q.Monitor.DeletedAt.IsNull(),
).Find()
}
func CreateOrUpdateMonitorSchedule(ctx context.Context, t client.Client, monitor *models.Monitor) error {
log.Println("Creating or Updating Monitor Schedule")
args := make([]interface{}, 0)
args = append(args, workflows.MonitorWorkflowParam{Script: monitor.Script, Slug: monitor.Slug})
for _, group := range monitor.WorkerGroups {
options := client.ScheduleOptions{
ID: getScheduleId(monitor, group),
//SearchAttributes: map[string]interface{}{
// "worker-group": group,
// "monitor-slug": monitor.Slug,
//},
Spec: client.ScheduleSpec{
CronExpressions: []string{monitor.Schedule},
Jitter: time.Second * 10,
},
Action: &client.ScheduleWorkflowAction{
ID: getScheduleId(monitor, group),
Workflow: workflows.NewWorkflows(nil).MonitorWorkflowDefinition,
Args: args,
TaskQueue: group,
RetryPolicy: &temporal.RetryPolicy{
MaximumAttempts: 3,
},
},
}
schedule := t.ScheduleClient().GetHandle(ctx, getScheduleId(monitor, group))
// If exists, we update
_, err := schedule.Describe(ctx)
if err == nil {
err = schedule.Update(ctx, client.ScheduleUpdateOptions{
DoUpdate: func(input client.ScheduleUpdateInput) (*client.ScheduleUpdate, error) {
return &client.ScheduleUpdate{
Schedule: &client.Schedule{
Spec: &options.Spec,
Action: options.Action,
Policy: input.Description.Schedule.Policy,
State: input.Description.Schedule.State,
},
}, nil
},
})
if err != nil {
return err
}
} else {
schedule, err = t.ScheduleClient().Create(ctx, options)
if err != nil {
return err
}
}
err = schedule.Trigger(ctx, client.ScheduleTriggerOptions{})
if err != nil {
return err
}
}
return nil
}
func CreateMonitorHistory(ctx context.Context, db *gorm.DB, monitorHistory *models.MonitorHistory) error {
return db.WithContext(ctx).Create(monitorHistory).Error
}

50
internal/workflows/healthcheck.go
View file

@ -1,50 +0,0 @@
package workflows
import (
"time"
"code.tjo.space/mentos1386/zdravko/internal/activities"
"code.tjo.space/mentos1386/zdravko/internal/models"
"go.temporal.io/sdk/workflow"
)
type HealthcheckWorkflowParam struct {
Script string
Slug string
}
func (w *Workflows) HealthcheckWorkflowDefinition(ctx workflow.Context, param HealthcheckWorkflowParam) error {
options := workflow.ActivityOptions{
StartToCloseTimeout: 10 * time.Second,
}
ctx = workflow.WithActivityOptions(ctx, options)
heatlcheckParam := activities.HealtcheckParam{
Script: param.Script,
}
var healthcheckResult *activities.HealthcheckResult
err := workflow.ExecuteActivity(ctx, w.activities.Healthcheck, heatlcheckParam).Get(ctx, &healthcheckResult)
if err != nil {
return err
}
status := models.HealthcheckFailure
if healthcheckResult.Success {
status = models.HealthcheckSuccess
}
historyParam := activities.HealtcheckAddToHistoryParam{
Slug: param.Slug,
Status: status,
Note: healthcheckResult.Note,
}
var historyResult *activities.HealthcheckAddToHistoryResult
err = workflow.ExecuteActivity(ctx, w.activities.HealthcheckAddToHistory, historyParam).Get(ctx, &historyResult)
if err != nil {
return err
}
return nil
}

50
internal/workflows/monitor.go Normal file
View file

@ -0,0 +1,50 @@
package workflows
import (
"time"
"code.tjo.space/mentos1386/zdravko/internal/activities"
"code.tjo.space/mentos1386/zdravko/internal/models"
"go.temporal.io/sdk/workflow"
)
type MonitorWorkflowParam struct {
Script string
Slug string
}
func (w *Workflows) MonitorWorkflowDefinition(ctx workflow.Context, param MonitorWorkflowParam) error {
options := workflow.ActivityOptions{
StartToCloseTimeout: 10 * time.Second,
}
ctx = workflow.WithActivityOptions(ctx, options)
heatlcheckParam := activities.HealtcheckParam{
Script: param.Script,
}
var monitorResult *activities.MonitorResult
err := workflow.ExecuteActivity(ctx, w.activities.Monitor, heatlcheckParam).Get(ctx, &monitorResult)
if err != nil {
return err
}
status := models.MonitorFailure
if monitorResult.Success {
status = models.MonitorSuccess
}
historyParam := activities.HealtcheckAddToHistoryParam{
Slug: param.Slug,
Status: status,
Note: monitorResult.Note,
}
var historyResult *activities.MonitorAddToHistoryResult
err = workflow.ExecuteActivity(ctx, w.activities.MonitorAddToHistory, historyParam).Get(ctx, &historyResult)
if err != nil {
return err
}
return nil
}

2
pkg/api/healthchecks.go → pkg/api/monitors.go
View file

@ -1,6 +1,6 @@
package api
type ApiV1HealthchecksHistoryPOSTBody struct {
type ApiV1MonitorsHistoryPOSTBody struct {
Status string `json:"status"`
Note string `json:"note"`
}

12
pkg/server/server.go
View file

@ -78,11 +78,11 @@ func (s *Server) Start() error {
settings := s.echo.Group("/settings")
settings.Use(h.Authenticated)
settings.GET("", h.SettingsOverviewGET)
settings.GET("/healthchecks", h.SettingsHealthchecksGET)
settings.GET("/healthchecks/create", h.SettingsHealthchecksCreateGET)
settings.POST("/healthchecks/create", h.SettingsHealthchecksCreatePOST)
settings.GET("/healthchecks/:slug", h.SettingsHealthchecksDescribeGET)
settings.POST("/healthchecks/:slug", h.SettingsHealthchecksDescribePOST)
settings.GET("/monitors", h.SettingsMonitorsGET)
settings.GET("/monitors/create", h.SettingsMonitorsCreateGET)
settings.POST("/monitors/create", h.SettingsMonitorsCreatePOST)
settings.GET("/monitors/:slug", h.SettingsMonitorsDescribeGET)
settings.POST("/monitors/:slug", h.SettingsMonitorsDescribePOST)
settings.GET("/workers", h.SettingsWorkersGET)
settings.GET("/workers/create", h.SettingsWorkersCreateGET)
settings.POST("/workers/create", h.SettingsWorkersCreatePOST)
@ -99,7 +99,7 @@ func (s *Server) Start() error {
apiv1 := s.echo.Group("/api/v1")
apiv1.Use(h.Authenticated)
apiv1.GET("/workers/connect", h.ApiV1WorkersConnectGET)
apiv1.POST("/healthchecks/:slug/history", h.ApiV1HealthchecksHistoryPOST)
apiv1.POST("/monitors/:slug/history", h.ApiV1MonitorsHistoryPOST)
// Error handler
s.echo.HTTPErrorHandler = func(err error, c echo.Context) {

6
pkg/worker/worker.go
View file

@ -94,11 +94,11 @@ func (w *Worker) Start() error {
workerWorkflows := workflows.NewWorkflows(workerActivities)
// Register Workflows
w.worker.RegisterWorkflow(workerWorkflows.HealthcheckWorkflowDefinition)
w.worker.RegisterWorkflow(workerWorkflows.MonitorWorkflowDefinition)
// Register Activities
w.worker.RegisterActivity(workerActivities.Healthcheck)
w.worker.RegisterActivity(workerActivities.HealthcheckAddToHistory)
w.worker.RegisterActivity(workerActivities.Monitor)
w.worker.RegisterActivity(workerActivities.MonitorAddToHistory)
return w.worker.Run(worker.InterruptCh())
}

4
tools/generate/main.go
View file

@ -30,8 +30,8 @@ func main() {
// Generate default DAO interface for those specified structs
g.ApplyBasic(
models.Worker{},
models.Healthcheck{},
models.HealthcheckHistory{},
models.Monitor{},
models.MonitorHistory{},
models.Cronjob{},
models.CronjobHistory{},
models.OAuth2State{},

12
web/static/css/main.css
View file

@ -56,23 +56,23 @@ code {
@apply bg-blue-700 text-white;
}
.healthchecks {
.monitors {
@apply grid justify-items-stretch justify-stretch items-center mt-20 bg-white shadow-md p-5 rounded-lg;
}
.healthchecks > div:not(:last-child) {
.monitors > div:not(:last-child) {
@apply mb-3;
}
.healthchecks .time-range > a {
.monitors .time-range > a {
@apply font-medium text-sm px-2.5 py-1;
@apply text-black bg-gray-100 hover:bg-gray-300 focus:outline-none focus:ring-2 focus:ring-blue-300;
}
.healthchecks .time-range > a.active {
.monitors .time-range > a.active {
@apply text-white bg-blue-700 hover:bg-blue-800;
}
.healthchecks .time-range > a:first-child {
.monitors .time-range > a:first-child {
@apply rounded-s-lg;
}
.healthchecks .time-range > a:last-child {
.monitors .time-range > a:last-child {
@apply rounded-e-lg;
}

22
web/static/css/tailwind.css
View file

@ -1297,7 +1297,7 @@ code {
color: rgb(255 255 255 / var(--tw-text-opacity));
}
.healthchecks {
.monitors {
margin-top: 5rem;
display: grid;
align-items: center;
@ -1312,11 +1312,11 @@ code {
box-shadow: var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000), var(--tw-shadow);
}
.healthchecks > div:not(:last-child) {
.monitors > div:not(:last-child) {
margin-bottom: 0.75rem;
}
.healthchecks .time-range > a {
.monitors .time-range > a {
padding-left: 0.625rem;
padding-right: 0.625rem;
padding-top: 0.25rem;
@ -1330,12 +1330,12 @@ code {
color: rgb(0 0 0 / var(--tw-text-opacity));
}
.healthchecks .time-range > a:hover {
.monitors .time-range > a:hover {
--tw-bg-opacity: 1;
background-color: rgb(209 213 219 / var(--tw-bg-opacity));
}
.healthchecks .time-range > a:focus {
.monitors .time-range > a:focus {
outline: 2px solid transparent;
outline-offset: 2px;
--tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
@ -1345,24 +1345,24 @@ code {
--tw-ring-color: rgb(147 197 253 / var(--tw-ring-opacity));
}
.healthchecks .time-range > a.active {
.monitors .time-range > a.active {
--tw-bg-opacity: 1;
background-color: rgb(29 78 216 / var(--tw-bg-opacity));
--tw-text-opacity: 1;
color: rgb(255 255 255 / var(--tw-text-opacity));
}
.healthchecks .time-range > a.active:hover {
.monitors .time-range > a.active:hover {
--tw-bg-opacity: 1;
background-color: rgb(30 64 175 / var(--tw-bg-opacity));
}
.healthchecks .time-range > a:first-child {
.monitors .time-range > a:first-child {
border-start-start-radius: 0.5rem;
border-end-start-radius: 0.5rem;
}
.healthchecks .time-range > a:last-child {
.monitors .time-range > a:last-child {
border-start-end-radius: 0.5rem;
border-end-end-radius: 0.5rem;
}
@ -1610,10 +1610,6 @@ code {
}
@media (min-width: 768px) {
.md\:grid-cols-4 {
grid-template-columns: repeat(4, minmax(0, 1fr));
}
.md\:px-40 {
padding-left: 10rem;
padding-right: 10rem;

14
web/templates/pages/index.tmpl
View file

@ -34,18 +34,18 @@
{{define "main"}}
<div class="container max-w-screen-md flex flex-col mt-20">
{{ if eq .HealthchecksLength 0 }}
{{ if eq .MonitorsLength 0 }}
<section>
<div class="py-8 px-4 mx-auto max-w-screen-xl text-center lg:py-16">
<h1 class="mb-4 text-2xl font-extrabold tracking-tight leading-none text-gray-900 md:text-3xl lg:text-4xl">
There are no healthchecks yet.
There are no monitors yet.
</h1>
<p class="mb-8 text-l font-normal text-gray-500 lg:text-l sm:px-8 lg:px-40">
Create a healthcheck to monitor your services and get notified when they are down.
Create a monitor to monitor your services and get notified when they are down.
</p>
<div class="flex flex-col space-y-4 sm:flex-row sm:justify-center sm:space-y-0">
<a href="/settings/healthchecks/create" class="inline-flex justify-center items-center py-3 px-5 text-base font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
Create First Healthcheck
<a href="/settings/monitors/create" class="inline-flex justify-center items-center py-3 px-5 text-base font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
Create First Monitor
<svg class="feather ml-1 h-5 w-5 overflow-visible"><use href="/static/icons/feather-sprite.svg#plus" /></svg>
</a>
</div>
@ -65,9 +65,9 @@
<p class="text-slate-500 text-sm">Last updated on Feb 10 at 10:55am UTC</p>
</div>
{{ end }}
<div class="healthchecks">
<div class="monitors">
<div class="grid grid-cols-1 sm:grid-cols-2 gap-2">
<p class="text-l font-normal text-gray-800 text-center sm:text-left">Healthchecks</p>
<p class="text-l font-normal text-gray-800 text-center sm:text-left">Monitors</p>
<div class="inline-flex rounded-md shadow-sm justify-self-center sm:justify-self-end time-range" role="group">
<a href="/?time-range=90days" class="{{ if eq .TimeRange "90days" }}active{{end}}" type="button">90 Days</a>
<a href="/?time-range=48hours" class="{{ if eq .TimeRange "48hours" }}active{{end}}" type="button">48 Hours</a>

18
web/templates/pages/settings_healthchecks.tmpl → web/templates/pages/settings_monitors.tmpl
View file

@ -1,18 +1,18 @@
{{define "settings"}}
{{ $description := "Healthchecks represent periodicly the k6 script, to see if the monitored service is healthy." }}
{{ $description := "Monitors represent periodicly the k6 script, to see if the monitored service is healthy." }}
{{ if eq .HealthchecksLength 0 }}
{{ if eq .MonitorsLength 0 }}
<div class="py-8 px-4 mx-auto max-w-screen-xl text-center lg:py-16">
<h1 class="mb-4 text-2xl font-extrabold tracking-tight leading-none text-gray-900 md:text-3xl lg:text-4xl">
There are no healthchecks yet.
There are no monitors yet.
</h1>
<p class="mb-8 text-l font-normal text-gray-500 lg:text-l sm:px-8 lg:px-40">
{{ $description }}
</p>
<div class="flex flex-col space-y-4 sm:flex-row sm:justify-center sm:space-y-0">
<a href="/settings/healthchecks/create" class="inline-flex justify-center items-center py-3 px-5 text-base font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
Create First Healthcheck
<a href="/settings/monitors/create" class="inline-flex justify-center items-center py-3 px-5 text-base font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
Create First Monitor
<svg class="feather ml-1 h-5 w-5 overflow-visible"><use href="/static/icons/feather-sprite.svg#plus" /></svg>
</a>
</div>
@ -21,12 +21,12 @@
<section>
<table class="w-full text-sm text-left rtl:text-right text-gray-500">
<caption class="p-5 text-lg font-semibold text-left rtl:text-right text-gray-900 bg-white">
List of Healthchecks
List of Monitors
<div class="mt-1 gap-4 flex justify-between">
<p class="mt-1 text-sm font-normal text-gray-500">
{{ $description }}
</p>
<a href="/settings/healthchecks/create" class="inline-flex justify-center items-center py-1 px-2 text-sm font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
<a href="/settings/monitors/create" class="inline-flex justify-center items-center py-1 px-2 text-sm font-medium text-center text-white rounded-lg bg-blue-700 hover:bg-blue-800 focus:ring-4 focus:ring-blue-300">
Create New
<svg class="feather h-5 w-5 overflow-visible"><use href="/static/icons/feather-sprite.svg#plus" /></svg>
</a>
@ -51,7 +51,7 @@
</th>
</tr>
</thead>
{{range .Healthchecks}}
{{range .Monitors}}
<tbody>
<tr class="odd:bg-white even:bg-gray-50">
<th scope="row" class="px-6 py-4 font-medium text-gray-900 whitespace-nowrap">
@ -76,7 +76,7 @@
{{.Schedule}}
</td>
<td class="px-6 py-4">
<a href="/settings/healthchecks/{{.Slug}}" class="link">Details</a>
<a href="/settings/monitors/{{.Slug}}" class="link">Details</a>
</td>
</tr>
</tbody>

8
web/templates/pages/settings_healthchecks_create.tmpl → web/templates/pages/settings_monitors_create.tmpl
View file

@ -1,16 +1,16 @@
{{define "settings"}}
<section class="p-5">
<form action="/settings/healthchecks/create" method="post">
<form action="/settings/monitors/create" method="post">
<label for="name">Name</label>
<input type="name" name="name" id="name" placeholder="Github.com">
<p>Name of the healthcheck can be anything.</p>
<p>Name of the monitor can be anything.</p>
<label for="workergroups">Worker Groups</label>
<input type="text" name="workergroups" id="workergroups" placeholder="NA EU"/>
<p>Worker groups are used to distribute the healthcheck to specific workers.</p>
<p>Worker groups are used to distribute the monitor to specific workers.</p>
<label for="schedule">Schedule</label>
<input type="text" name="schedule" id="schedule" placeholder="@every 1m"/>
<p>
Schedule is a cron expression that defines when the healthcheck should be executed.
Schedule is a cron expression that defines when the monitor should be executed.
</br>
You can also use <code>@every [interval]</code> where interval is a duration like 5m, 1h, 60s.
Or use <code>@hourly</code>, <code>@daily</code>, <code>@weekly</code>, <code>@monthly</code>, <code>@yearly</code>.

16
web/templates/pages/settings_healthchecks_describe.tmpl → web/templates/pages/settings_monitors_describe.tmpl
View file

@ -1,16 +1,16 @@
{{define "settings"}}
<section class="p-5">
<form action="/settings/healthchecks/{{ .Healthcheck.Slug }}" method="post">
<form action="/settings/monitors/{{ .Monitor.Slug }}" method="post">
<h2>
Configuration
</h2>
<label for="workergroups">Worker Groups</label>
<input type="text" name="workergroups" id="workergroups" value="{{ StringsJoin .Healthcheck.WorkerGroups " " }}"/>
<p>Worker groups are used to distribute the healthcheck to specific workers.</p>
<input type="text" name="workergroups" id="workergroups" value="{{ StringsJoin .Monitor.WorkerGroups " " }}"/>
<p>Worker groups are used to distribute the monitor to specific workers.</p>
<label for="schedule">Schedule</label>
<input type="text" name="schedule" id="schedule" value="{{ .Healthcheck.Schedule }}"/>
<input type="text" name="schedule" id="schedule" value="{{ .Monitor.Schedule }}"/>
<p>
Schedule is a cron expression that defines when the healthcheck should be executed.
Schedule is a cron expression that defines when the monitor should be executed.
</br>
You can also use <code>@every [interval]</code> where interval is a duration like 5m, 1h, 60s.
Or use <code>@hourly</code>, <code>@daily</code>, <code>@weekly</code>, <code>@monthly</code>, <code>@yearly</code>.
@ -31,7 +31,7 @@
<caption class="p-5 text-lg font-semibold text-left rtl:text-right text-gray-900 bg-white">
History
<p class="mt-1 text-sm font-normal text-gray-500">
Last executions of healthcheck script.
Last executions of monitor script.
</p>
</caption>
<thead>
@ -43,7 +43,7 @@
</tr>
</thead>
<tbody>
{{range .Healthcheck.History}}
{{range .Monitor.History}}
<tr>
<td class="px-6 py-4 whitespace-nowrap">
<span class="px-2 inline-flex text-xs leading-5 font-semibold rounded-full {{if eq .Status "SUCCESS"}}bg-green-100 text-green-800{{else}}bg-red-100 text-red-800{{end}}">
@ -72,7 +72,7 @@
document.getElementById('script').value = script;
}
script = `{{ .Healthcheck.Script }}`
script = `{{ .Monitor.Script }}`
require.config({ paths: { vs: '/static/monaco/vs' } });
require(['vs/editor/editor.main'], function () {

10
web/templates/pages/settings_overview.tmpl
View file

@ -8,7 +8,7 @@
</p>
</div>
<div class="mx-auto max-w-screen-xl text-center grid grid-cols-1 sm:grid-cols-2 md:grid-cols-4 gap-4">
<div class="mx-auto max-w-screen-xl flex flex-col sm:flex-row gap-4">
<div class="inline-block bg-white rounded-lg shadow p-5 w-full">
<div class="text-center sm:mt-0 sm:ml-2 sm:text-left">
<h3 class="text-sm leading-6 font-medium text-gray-400">Total Workers</h3>
@ -17,13 +17,7 @@
</div>
<div class="inline-block bg-white rounded-lg shadow p-5 w-full">
<div class="text-center sm:mt-0 sm:ml-2 sm:text-left">
<h3 class="text-sm leading-6 font-medium text-gray-400">Total Healthchecks</h3>
<p class="text-3xl font-bold text-black">42</p>
</div>
</div>
<div class="inline-block bg-white rounded-lg shadow p-5 w-full">
<div class="text-center sm:mt-0 sm:ml-2 sm:text-left">
<h3 class="text-sm leading-6 font-medium text-gray-400">Total Cronjobs</h3>
<h3 class="text-sm leading-6 font-medium text-gray-400">Total Monitors</h3>
<p class="text-3xl font-bold text-black">42</p>
</div>
</div>

2
web/templates/pages/settings_workers.tmpl
View file

@ -1,6 +1,6 @@
{{define "settings"}}
{{ $description := "Workers are executing healthchecks. You can deploy multiple of thems to multiple regions for wider coverage." }}
{{ $description := "Workers are executing monitors. You can deploy multiple of thems to multiple regions for wider coverage." }}
{{ if eq .WorkersLength 0 }}
<div class="py-8 px-4 mx-auto max-w-screen-xl text-center lg:py-16">

6
web/templates/tempaltes.go
View file

@ -45,9 +45,9 @@ func NewTemplates() *Templates {
"settings_workers.tmpl": loadSettings("pages/settings_workers.tmpl"),
"settings_workers_create.tmpl": loadSettings("pages/settings_workers_create.tmpl"),
"settings_workers_describe.tmpl": loadSettings("pages/settings_workers_describe.tmpl"),
"settings_healthchecks.tmpl": loadSettings("pages/settings_healthchecks.tmpl"),
"settings_healthchecks_create.tmpl": loadSettings("pages/settings_healthchecks_create.tmpl"),
"settings_healthchecks_describe.tmpl": loadSettings("pages/settings_healthchecks_describe.tmpl"),
"settings_monitors.tmpl": loadSettings("pages/settings_monitors.tmpl"),
"settings_monitors_create.tmpl": loadSettings("pages/settings_monitors_create.tmpl"),
"settings_monitors_describe.tmpl": loadSettings("pages/settings_monitors_describe.tmpl"),
},
}
}