code
stringlengths 1
1.05M
| repo_name
stringlengths 6
83
| path
stringlengths 3
242
| language
stringclasses 222
values | license
stringclasses 20
values | size
int64 1
1.05M
|
|---|---|---|---|---|---|
package interfaces
type ColorService interface {
Injectable
GetByName(name string) (res Color, err error)
GetRandom() (res Color, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/color_service.go
|
Go
|
bsd-3-clause
| 147
|
package interfaces
type ControllerParams interface {
IsZero() (ok bool)
IsDefault() (ok bool)
}
|
2302_79757062/crawlab
|
core/interfaces/controller_params.go
|
Go
|
bsd-3-clause
| 99
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type DataSourceService interface {
ChangePassword(id primitive.ObjectID, password string) (err error)
Monitor()
CheckStatus(id primitive.ObjectID) (err error)
SetTimeout(duration time.Duration)
SetMonitorInterval(duration time.Duration)
}
|
2302_79757062/crawlab
|
core/interfaces/data_source_service.go
|
Go
|
bsd-3-clause
| 330
|
package interfaces
type Entity interface {
Value() interface{}
}
|
2302_79757062/crawlab
|
core/interfaces/entity.go
|
Go
|
bsd-3-clause
| 67
|
package interfaces
type EventData interface {
GetEvent() string
GetData() interface{}
}
|
2302_79757062/crawlab
|
core/interfaces/event_data.go
|
Go
|
bsd-3-clause
| 91
|
package interfaces
type EventFn func(data ...interface{}) (err error)
type EventService interface {
Register(key, include, exclude string, ch *chan EventData)
Unregister(key string)
SendEvent(eventName string, data ...interface{})
}
|
2302_79757062/crawlab
|
core/interfaces/event_service.go
|
Go
|
bsd-3-clause
| 238
|
package interfaces
import "time"
type Export interface {
GetId() string
GetType() string
GetTarget() string
GetFilter() Filter
GetStatus() string
GetStartTs() time.Time
GetEndTs() time.Time
GetDownloadPath() string
}
|
2302_79757062/crawlab
|
core/interfaces/export.go
|
Go
|
bsd-3-clause
| 227
|
package interfaces
type ExportService interface {
GenerateId() (exportId string, err error)
Export(exportType, target string, filter Filter) (exportId string, err error)
GetExport(exportId string) (export Export, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/export_service.go
|
Go
|
bsd-3-clause
| 230
|
package interfaces
type Filter interface {
GetIsOr() (isOr bool)
SetIsOr(isOr bool)
GetConditions() (conditions []FilterCondition)
SetConditions(conditions []FilterCondition)
IsNil() (ok bool)
}
|
2302_79757062/crawlab
|
core/interfaces/filter.go
|
Go
|
bsd-3-clause
| 201
|
package interfaces
type FilterCondition interface {
GetKey() (key string)
SetKey(key string)
GetOp() (op string)
SetOp(op string)
GetValue() (value interface{})
SetValue(value interface{})
}
|
2302_79757062/crawlab
|
core/interfaces/filter_condition.go
|
Go
|
bsd-3-clause
| 198
|
package interfaces
import (
"os"
"time"
)
type FsFileInfo interface {
GetName() string
GetPath() string
GetFullPath() string
GetExtension() string
GetIsDir() bool
GetFileSize() int64
GetModTime() time.Time
GetMode() os.FileMode
GetHash() string
GetChildren() []FsFileInfo
}
|
2302_79757062/crawlab
|
core/interfaces/fs_file_info.go
|
Go
|
bsd-3-clause
| 288
|
package interfaces
import (
cfs "github.com/crawlab-team/crawlab/fs"
vcs "github.com/crawlab-team/crawlab/vcs"
)
type FsService interface {
WithConfigPath
List(path string, opts ...ServiceCrudOption) (files []FsFileInfo, err error)
GetFile(path string, opts ...ServiceCrudOption) (data []byte, err error)
GetFileInfo(path string, opts ...ServiceCrudOption) (file FsFileInfo, err error)
Save(path string, data []byte, opts ...ServiceCrudOption) (err error)
Rename(path, newPath string, opts ...ServiceCrudOption) (err error)
Delete(path string, opts ...ServiceCrudOption) (err error)
Copy(path, newPath string, opts ...ServiceCrudOption) (err error)
Commit(msg string) (err error)
SyncToFs(opts ...ServiceCrudOption) (err error)
SyncToWorkspace() (err error)
GetFsPath() (path string)
SetFsPath(path string)
GetWorkspacePath() (path string)
SetWorkspacePath(path string)
GetRepoPath() (path string)
SetRepoPath(path string)
GetFs() (fs cfs.Manager)
GetGitClient() (c *vcs.GitClient)
}
|
2302_79757062/crawlab
|
core/interfaces/fs_service.go
|
Go
|
bsd-3-clause
| 1,007
|
package interfaces
type ServiceCrudOptions struct {
IsAbsolute bool // whether the path is absolute
OnlyFromWorkspace bool // whether only sync from workspace
NotSyncToWorkspace bool // whether not sync to workspace
}
type ServiceCrudOption func(o *ServiceCrudOptions)
func WithOnlyFromWorkspace() ServiceCrudOption {
return func(o *ServiceCrudOptions) {
o.OnlyFromWorkspace = true
}
}
func WithNotSyncToWorkspace() ServiceCrudOption {
return func(o *ServiceCrudOptions) {
o.NotSyncToWorkspace = true
}
}
|
2302_79757062/crawlab
|
core/interfaces/fs_service_options.go
|
Go
|
bsd-3-clause
| 529
|
package interfaces
type FsServiceV2 interface {
List(path string) (files []FsFileInfo, err error)
GetFile(path string) (data []byte, err error)
GetFileInfo(path string) (file FsFileInfo, err error)
Save(path string, data []byte) (err error)
CreateDir(path string) (err error)
Rename(path, newPath string) (err error)
Delete(path string) (err error)
Copy(path, newPath string) (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/fs_service_v2.go
|
Go
|
bsd-3-clause
| 399
|
package interfaces
type GrpcBase interface {
WithConfigPath
Init() (err error)
Start() (err error)
Stop() (err error)
Register() (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_base.go
|
Go
|
bsd-3-clause
| 149
|
package interfaces
type GrpcBaseServiceParams interface {
Entity
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_base_service_params.go
|
Go
|
bsd-3-clause
| 69
|
package interfaces
import (
"context"
grpc "github.com/crawlab-team/crawlab/grpc"
"time"
)
type GrpcClient interface {
GrpcBase
WithConfigPath
GetModelDelegateClient() grpc.ModelDelegateClient
GetModelBaseServiceClient() grpc.ModelBaseServiceClient
GetNodeClient() grpc.NodeServiceClient
GetTaskClient() grpc.TaskServiceClient
GetMessageClient() grpc.MessageServiceClient
SetAddress(Address)
SetTimeout(time.Duration)
SetSubscribeType(string)
SetHandleMessage(bool)
Context() (context.Context, context.CancelFunc)
NewRequest(interface{}) *grpc.Request
GetMessageChannel() chan *grpc.StreamMessage
Restart() error
NewModelBaseServiceRequest(ModelId, GrpcBaseServiceParams) (*grpc.Request, error)
IsStarted() bool
IsClosed() bool
Err() error
GetStream() grpc.NodeService_SubscribeClient
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client.go
|
Go
|
bsd-3-clause
| 812
|
package interfaces
type GrpcClientModelBaseService interface {
WithModelId
WithConfigPath
ModelBaseService
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_base_service.go
|
Go
|
bsd-3-clause
| 113
|
package interfaces
type GrpcClientModelDelegate interface {
ModelDelegate
WithConfigPath
Close() error
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_delegate.go
|
Go
|
bsd-3-clause
| 109
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcClientModelEnvironmentService interface {
ModelBaseService
GetEnvironmentById(id primitive.ObjectID) (s Environment, err error)
GetEnvironment(query bson.M, opts *mongo.FindOptions) (s Environment, err error)
GetEnvironmentList(query bson.M, opts *mongo.FindOptions) (res []Environment, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_environment_service.go
|
Go
|
bsd-3-clause
| 471
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcClientModelNodeService interface {
ModelBaseService
GetNodeById(id primitive.ObjectID) (n Node, err error)
GetNode(query bson.M, opts *mongo.FindOptions) (n Node, err error)
GetNodeByKey(key string) (n Node, err error)
GetNodeList(query bson.M, opts *mongo.FindOptions) (res []Node, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_node_service.go
|
Go
|
bsd-3-clause
| 468
|
package interfaces
type GrpcClientModelService interface {
WithConfigPath
NewBaseServiceDelegate(id ModelId) (GrpcClientModelBaseService, error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_service.go
|
Go
|
bsd-3-clause
| 150
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcClientModelSpiderService interface {
ModelBaseService
GetSpiderById(id primitive.ObjectID) (s Spider, err error)
GetSpider(query bson.M, opts *mongo.FindOptions) (s Spider, err error)
GetSpiderList(query bson.M, opts *mongo.FindOptions) (res []Spider, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_spider_service.go
|
Go
|
bsd-3-clause
| 436
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcClientModelTaskService interface {
ModelBaseService
GetTaskById(id primitive.ObjectID) (s Task, err error)
GetTask(query bson.M, opts *mongo.FindOptions) (s Task, err error)
GetTaskList(query bson.M, opts *mongo.FindOptions) (res []Task, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_task_service.go
|
Go
|
bsd-3-clause
| 422
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcClientModelTaskStatService interface {
ModelBaseService
GetTaskStatById(id primitive.ObjectID) (s TaskStat, err error)
GetTaskStat(query bson.M, opts *mongo.FindOptions) (s TaskStat, err error)
GetTaskStatList(query bson.M, opts *mongo.FindOptions) (res []TaskStat, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_model_task_stat_service.go
|
Go
|
bsd-3-clause
| 450
|
package interfaces
type GrpcClientPool interface {
WithConfigPath
Init() error
NewClient() error
GetClient() (GrpcClient, error)
SetSize(int)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_client_pool.go
|
Go
|
bsd-3-clause
| 150
|
package interfaces
type GrpcModelBaseServiceMessage interface {
GetModelId() ModelId
GetData() []byte
ToBytes() (data []byte)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_model_base_service_message.go
|
Go
|
bsd-3-clause
| 132
|
package interfaces
type GrpcModelBinder interface {
ModelBinder
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_model_binder.go
|
Go
|
bsd-3-clause
| 68
|
package interfaces
type GrpcModelDelegateMessage interface {
GetModelId() ModelId
GetMethod() ModelDelegateMethod
GetData() []byte
ToBytes() (data []byte)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_model_delegate_message.go
|
Go
|
bsd-3-clause
| 162
|
package interfaces
type GrpcModelListBinder interface {
ModelListBinder
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_model_list_binder.go
|
Go
|
bsd-3-clause
| 76
|
package interfaces
import (
grpc "github.com/crawlab-team/crawlab/grpc"
)
type GrpcServer interface {
GrpcBase
SetAddress(Address)
GetSubscribe(key string) (sub GrpcSubscribe, err error)
SetSubscribe(key string, sub GrpcSubscribe)
DeleteSubscribe(key string)
SendStreamMessage(key string, code grpc.StreamMessageCode) (err error)
SendStreamMessageWithData(nodeKey string, code grpc.StreamMessageCode, d interface{}) (err error)
IsStopped() (res bool)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_server.go
|
Go
|
bsd-3-clause
| 464
|
package interfaces
import grpc "github.com/crawlab-team/crawlab/grpc"
type GrpcStream interface {
Send(msg *grpc.StreamMessage) (err error)
}
type GrpcStreamBidirectional interface {
GrpcStream
Recv() (msg *grpc.StreamMessage, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_stream.go
|
Go
|
bsd-3-clause
| 246
|
package interfaces
type GrpcSubscribe interface {
GetStream() GrpcStream
GetStreamBidirectional() GrpcStreamBidirectional
GetFinished() chan bool
}
|
2302_79757062/crawlab
|
core/interfaces/grpc_subscribe.go
|
Go
|
bsd-3-clause
| 152
|
package interfaces
type I18nService interface {
AddTranslations(t []Translation)
GetTranslations() (t []Translation)
}
|
2302_79757062/crawlab
|
core/interfaces/i18n_service.go
|
Go
|
bsd-3-clause
| 122
|
package interfaces
type Injectable interface {
Inject() error
}
|
2302_79757062/crawlab
|
core/interfaces/injectable.go
|
Go
|
bsd-3-clause
| 66
|
package interfaces
type List interface {
GetModels() (res []Model)
}
|
2302_79757062/crawlab
|
core/interfaces/list.go
|
Go
|
bsd-3-clause
| 71
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Model interface {
GetId() (id primitive.ObjectID)
SetId(id primitive.ObjectID)
}
type ModelV2 interface {
GetId() (id primitive.ObjectID)
SetId(id primitive.ObjectID)
SetCreated(by primitive.ObjectID)
SetUpdated(by primitive.ObjectID)
}
type ModelId int
const (
ModelIdArtifact = iota
ModelIdTag
ModelIdNode
ModelIdProject
ModelIdSpider
ModelIdTask
ModelIdJob
ModelIdSchedule
ModelIdUser
ModelIdSetting
ModelIdToken
ModelIdVariable
ModelIdTaskQueue
ModelIdTaskStat
ModelIdSpiderStat
ModelIdDataSource
ModelIdDataCollection
ModelIdResult
ModelIdPassword
ModelIdExtraValue
ModelIdGit
ModelIdRole
ModelIdUserRole
ModelIdPermission
ModelIdRolePermission
ModelIdEnvironment
ModelIdDependencySetting
)
const (
ModelColNameArtifact = "artifacts"
ModelColNameTag = "tags"
ModelColNameNode = "nodes"
ModelColNameProject = "projects"
ModelColNameSpider = "spiders"
ModelColNameTask = "tasks"
ModelColNameJob = "jobs"
ModelColNameSchedule = "schedules"
ModelColNameUser = "users"
ModelColNameSetting = "settings"
ModelColNameToken = "tokens"
ModelColNameVariable = "variables"
ModelColNameTaskQueue = "task_queue"
ModelColNameTaskStat = "task_stats"
ModelColNameSpiderStat = "spider_stats"
ModelColNameDataSource = "data_sources"
ModelColNameDataCollection = "data_collections"
ModelColNamePasswords = "passwords"
ModelColNameExtraValues = "extra_values"
ModelColNameGit = "gits"
ModelColNameRole = "roles"
ModelColNameUserRole = "user_roles"
ModelColNamePermission = "permissions"
ModelColNameRolePermission = "role_permissions"
ModelColNameEnvironment = "environments"
ModelColNameDependencySetting = "dependency_settings"
)
type ModelWithTags interface {
Model
SetTags(tags []Tag)
GetTags() (tags []Tag)
}
type ModelWithNameDescription interface {
Model
GetName() (name string)
SetName(name string)
GetDescription() (description string)
SetDescription(description string)
}
type ModelWithKey interface {
Model
GetKey() (key string)
SetKey(key string)
}
|
2302_79757062/crawlab
|
core/interfaces/model.go
|
Go
|
bsd-3-clause
| 2,342
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type ModelArtifact interface {
Model
GetSys() (sys ModelArtifactSys)
GetTagIds() (ids []primitive.ObjectID)
SetTagIds(ids []primitive.ObjectID)
SetObj(obj Model)
SetDel(del bool)
}
|
2302_79757062/crawlab
|
core/interfaces/model_artifact.go
|
Go
|
bsd-3-clause
| 260
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type ModelArtifactSys interface {
GetCreateTs() time.Time
SetCreateTs(ts time.Time)
GetUpdateTs() time.Time
SetUpdateTs(ts time.Time)
GetDeleteTs() time.Time
SetDeleteTs(ts time.Time)
GetCreateUid() primitive.ObjectID
SetCreateUid(id primitive.ObjectID)
GetUpdateUid() primitive.ObjectID
SetUpdateUid(id primitive.ObjectID)
GetDeleteUid() primitive.ObjectID
SetDeleteUid(id primitive.ObjectID)
}
|
2302_79757062/crawlab
|
core/interfaces/model_artifact_sys.go
|
Go
|
bsd-3-clause
| 494
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type ModelBaseService interface {
GetModelId() (id ModelId)
SetModelId(id ModelId)
GetById(id primitive.ObjectID) (res Model, err error)
Get(query bson.M, opts *mongo.FindOptions) (res Model, err error)
GetList(query bson.M, opts *mongo.FindOptions) (res List, err error)
DeleteById(id primitive.ObjectID, args ...interface{}) (err error)
Delete(query bson.M, args ...interface{}) (err error)
DeleteList(query bson.M, args ...interface{}) (err error)
ForceDeleteList(query bson.M, args ...interface{}) (err error)
UpdateById(id primitive.ObjectID, update bson.M, args ...interface{}) (err error)
Update(query bson.M, update bson.M, fields []string, args ...interface{}) (err error)
UpdateDoc(query bson.M, doc Model, fields []string, args ...interface{}) (err error)
Insert(u User, docs ...interface{}) (err error)
Count(query bson.M) (total int, err error)
}
type ModelService interface {
GetBaseService(id ModelId) (svc ModelBaseService)
}
|
2302_79757062/crawlab
|
core/interfaces/model_base_service.go
|
Go
|
bsd-3-clause
| 1,116
|
package interfaces
type ModelBinder interface {
Bind() (res Model, err error)
Process(d Model) (res Model, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/model_binder.go
|
Go
|
bsd-3-clause
| 123
|
package interfaces
type ModelDelegateMethod string
type ModelDelegate interface {
Add() error
Save() error
Delete() error
GetArtifact() (ModelArtifact, error)
GetModel() Model
Refresh() error
ToBytes(interface{}) ([]byte, error)
}
const (
ModelDelegateMethodAdd = "add"
ModelDelegateMethodSave = "save"
ModelDelegateMethodDelete = "delete"
ModelDelegateMethodGetArtifact = "get-artifact"
ModelDelegateMethodRefresh = "refresh"
ModelDelegateMethodChange = "change"
)
|
2302_79757062/crawlab
|
core/interfaces/model_delegate.go
|
Go
|
bsd-3-clause
| 511
|
package interfaces
type Environment interface {
Model
GetKey() (key string)
SetKey(key string)
GetValue() (value string)
SetValue(value string)
}
|
2302_79757062/crawlab
|
core/interfaces/model_environment.go
|
Go
|
bsd-3-clause
| 152
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type ExtraValue interface {
Model
GetValue() (v interface{})
SetValue(v interface{})
GetObjectId() (oid primitive.ObjectID)
SetObjectId(oid primitive.ObjectID)
GetModel() (m string)
SetModel(m string)
GetType() (t string)
SetType(t string)
}
|
2302_79757062/crawlab
|
core/interfaces/model_extra_value.go
|
Go
|
bsd-3-clause
| 329
|
package interfaces
// Git interface
type Git interface {
Model
GetUrl() (url string)
SetUrl(url string)
GetAuthType() (authType string)
SetAuthType(authType string)
GetUsername() (username string)
SetUsername(username string)
GetPassword() (password string)
SetPassword(password string)
GetCurrentBranch() (currentBranch string)
SetCurrentBranch(currentBranch string)
GetAutoPull() (autoPull bool)
SetAutoPull(autoPull bool)
}
|
2302_79757062/crawlab
|
core/interfaces/model_git.go
|
Go
|
bsd-3-clause
| 441
|
package interfaces
type ModelListBinder interface {
Bind() (l List, err error)
Process(d interface{}) (l List, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/model_list_binder.go
|
Go
|
bsd-3-clause
| 127
|
package interfaces
import "time"
type Node interface {
ModelWithNameDescription
GetKey() (key string)
GetIsMaster() (ok bool)
GetActive() (active bool)
SetActive(active bool)
SetActiveTs(activeTs time.Time)
GetStatus() (status string)
SetStatus(status string)
GetEnabled() (enabled bool)
SetEnabled(enabled bool)
GetAvailableRunners() (runners int)
SetAvailableRunners(runners int)
GetMaxRunners() (runners int)
SetMaxRunners(runners int)
IncrementAvailableRunners()
DecrementAvailableRunners()
}
|
2302_79757062/crawlab
|
core/interfaces/model_node.go
|
Go
|
bsd-3-clause
| 515
|
package interfaces
import "time"
type ModelNodeDelegate interface {
ModelDelegate
UpdateStatus(active bool, activeTs *time.Time, status string) (err error)
UpdateStatusOnline() (err error)
UpdateStatusOffline() (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/model_node_delegate.go
|
Go
|
bsd-3-clause
| 231
|
package interfaces
type Permission interface {
ModelWithKey
ModelWithNameDescription
GetType() (t string)
SetType(t string)
GetTarget() (target []string)
SetTarget(target []string)
GetAllow() (allow []string)
SetAllow(allow []string)
GetDeny() (deny []string)
SetDeny(deny []string)
}
|
2302_79757062/crawlab
|
core/interfaces/model_permission.go
|
Go
|
bsd-3-clause
| 296
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type Result interface {
Value() map[string]interface{}
SetValue(key string, value interface{})
GetValue(key string) (value interface{})
GetTaskId() (id primitive.ObjectID)
SetTaskId(id primitive.ObjectID)
}
|
2302_79757062/crawlab
|
core/interfaces/model_result.go
|
Go
|
bsd-3-clause
| 285
|
package interfaces
type Role interface {
ModelWithKey
ModelWithNameDescription
}
|
2302_79757062/crawlab
|
core/interfaces/model_role.go
|
Go
|
bsd-3-clause
| 84
|
package interfaces
import (
"github.com/robfig/cron/v3"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Schedule interface {
Model
GetEnabled() (enabled bool)
SetEnabled(enabled bool)
GetEntryId() (id cron.EntryID)
SetEntryId(id cron.EntryID)
GetCron() (c string)
SetCron(c string)
GetSpiderId() (id primitive.ObjectID)
SetSpiderId(id primitive.ObjectID)
GetMode() (mode string)
SetMode(mode string)
GetNodeIds() (ids []primitive.ObjectID)
SetNodeIds(ids []primitive.ObjectID)
GetCmd() (cmd string)
SetCmd(cmd string)
GetParam() (param string)
SetParam(param string)
GetPriority() (p int)
SetPriority(p int)
}
|
2302_79757062/crawlab
|
core/interfaces/model_schedule.go
|
Go
|
bsd-3-clause
| 637
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type ModelServiceV2[T any] interface {
GetById(id primitive.ObjectID) (model *T, err error)
Get(query bson.M, options *mongo.FindOptions) (model *T, err error)
GetList(query bson.M, options *mongo.FindOptions) (models []T, err error)
DeleteById(id primitive.ObjectID) (err error)
Delete(query bson.M) (err error)
DeleteList(query bson.M) (err error)
UpdateById(id primitive.ObjectID, update bson.M) (err error)
UpdateOne(query bson.M, update bson.M) (err error)
UpdateMany(query bson.M, update bson.M) (err error)
ReplaceById(id primitive.ObjectID, model T) (err error)
Replace(query bson.M, model T) (err error)
InsertOne(model T) (id primitive.ObjectID, err error)
InsertMany(models []T) (ids []primitive.ObjectID, err error)
Count(query bson.M) (total int, err error)
GetCol() (col *mongo.Col)
}
|
2302_79757062/crawlab
|
core/interfaces/model_service_v2.go
|
Go
|
bsd-3-clause
| 972
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type Spider interface {
ModelWithNameDescription
GetType() (ty string)
GetMode() (mode string)
SetMode(mode string)
GetNodeIds() (ids []primitive.ObjectID)
SetNodeIds(ids []primitive.ObjectID)
GetCmd() (cmd string)
SetCmd(cmd string)
GetParam() (param string)
SetParam(param string)
GetPriority() (p int)
SetPriority(p int)
GetColId() (id primitive.ObjectID)
SetColId(id primitive.ObjectID)
GetIncrementalSync() (incrementalSync bool)
SetIncrementalSync(incrementalSync bool)
GetAutoInstall() (autoInstall bool)
SetAutoInstall(autoInstall bool)
}
|
2302_79757062/crawlab
|
core/interfaces/model_spider.go
|
Go
|
bsd-3-clause
| 638
|
package interfaces
type Tag interface {
Model
GetName() string
GetColor() string
SetCol(string)
}
|
2302_79757062/crawlab
|
core/interfaces/model_tag.go
|
Go
|
bsd-3-clause
| 103
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type Task interface {
Model
GetNodeId() (id primitive.ObjectID)
SetNodeId(id primitive.ObjectID)
GetNodeIds() (ids []primitive.ObjectID)
GetStatus() (status string)
SetStatus(status string)
GetError() (error string)
SetError(error string)
GetPid() (pid int)
SetPid(pid int)
GetSpiderId() (id primitive.ObjectID)
GetType() (ty string)
GetCmd() (cmd string)
GetParam() (param string)
GetPriority() (p int)
GetUserId() (id primitive.ObjectID)
SetUserId(id primitive.ObjectID)
}
|
2302_79757062/crawlab
|
core/interfaces/model_task.go
|
Go
|
bsd-3-clause
| 565
|
package interfaces
import "time"
type TaskStat interface {
Model
GetCreateTs() (ts time.Time)
SetCreateTs(ts time.Time)
GetStartTs() (ts time.Time)
SetStartTs(ts time.Time)
GetEndTs() (ts time.Time)
SetEndTs(ts time.Time)
GetWaitDuration() (d int64)
SetWaitDuration(d int64)
GetRuntimeDuration() (d int64)
SetRuntimeDuration(d int64)
GetTotalDuration() (d int64)
SetTotalDuration(d int64)
GetResultCount() (c int64)
SetResultCount(c int64)
GetErrorLogCount() (c int64)
SetErrorLogCount(c int64)
}
|
2302_79757062/crawlab
|
core/interfaces/model_task_stat.go
|
Go
|
bsd-3-clause
| 516
|
package interfaces
type User interface {
Model
GetUsername() (name string)
GetPassword() (p string)
GetRole() (r string)
GetEmail() (email string)
}
|
2302_79757062/crawlab
|
core/interfaces/model_user.go
|
Go
|
bsd-3-clause
| 155
|
package interfaces
type UserGroup interface {
Model
GetUsers() (users []User, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/model_user_group.go
|
Go
|
bsd-3-clause
| 94
|
package interfaces
type ModuleId int
type Module interface {
Init() error
Start()
Wait()
Stop()
}
|
2302_79757062/crawlab
|
core/interfaces/module.go
|
Go
|
bsd-3-clause
| 104
|
package interfaces
type NodeConfigService interface {
WithConfigPath
Init() error
Reload() error
GetBasicNodeInfo() Entity
GetNodeKey() string
GetNodeName() string
IsMaster() bool
GetAuthKey() string
GetMaxRunners() int
}
|
2302_79757062/crawlab
|
core/interfaces/node_config_service.go
|
Go
|
bsd-3-clause
| 232
|
package interfaces
import (
"time"
)
type NodeMasterService interface {
NodeService
Monitor()
SetMonitorInterval(duration time.Duration)
Register() error
StopOnError()
GetServer() GrpcServer
}
|
2302_79757062/crawlab
|
core/interfaces/node_master_service.go
|
Go
|
bsd-3-clause
| 202
|
package interfaces
type NodeService interface {
Module
WithConfigPath
WithAddress
GetConfigService() NodeConfigService
}
|
2302_79757062/crawlab
|
core/interfaces/node_service.go
|
Go
|
bsd-3-clause
| 126
|
package interfaces
type NodeServiceOption interface {
}
|
2302_79757062/crawlab
|
core/interfaces/node_service_option.go
|
Go
|
bsd-3-clause
| 57
|
package interfaces
import "time"
type NodeWorkerService interface {
NodeService
Register()
Recv()
ReportStatus()
SetHeartbeatInterval(duration time.Duration)
}
|
2302_79757062/crawlab
|
core/interfaces/node_worker_service.go
|
Go
|
bsd-3-clause
| 167
|
package interfaces
|
2302_79757062/crawlab
|
core/interfaces/options.go
|
Go
|
bsd-3-clause
| 19
|
package interfaces
import (
"os/exec"
"time"
)
type ProcessDaemon interface {
Start() (err error)
Stop()
GetMaxErrors() (maxErrors int)
SetMaxErrors(maxErrors int)
GetExitTimeout() (timeout time.Duration)
SetExitTimeout(timeout time.Duration)
GetCmd() (cmd *exec.Cmd)
GetCh() (ch chan int)
}
|
2302_79757062/crawlab
|
core/interfaces/process_daemon.go
|
Go
|
bsd-3-clause
| 304
|
package interfaces
type Provide func(env string)
|
2302_79757062/crawlab
|
core/interfaces/provide.go
|
Go
|
bsd-3-clause
| 50
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/generic"
"time"
)
type ResultService interface {
Insert(records ...interface{}) (err error)
List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error)
Count(query generic.ListQuery) (n int, err error)
Index(fields []string)
SetTime(t time.Time)
GetTime() (t time.Time)
}
|
2302_79757062/crawlab
|
core/interfaces/result_service.go
|
Go
|
bsd-3-clause
| 378
|
package interfaces
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type ResultServiceMongo interface {
GetId() (id primitive.ObjectID)
SetId(id primitive.ObjectID)
List(query bson.M, opts *mongo.FindOptions) (results []Result, err error)
Count(query bson.M) (total int, err error)
Insert(docs ...interface{}) (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/result_service_mongo.go
|
Go
|
bsd-3-clause
| 419
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type ResultServiceRegistry interface {
Register(key string, fn ResultServiceRegistryFn)
Unregister(key string)
Get(key string) (fn ResultServiceRegistryFn)
}
type ResultServiceRegistryFn func(colId primitive.ObjectID, dsId primitive.ObjectID) (ResultService, error)
|
2302_79757062/crawlab
|
core/interfaces/result_service_registry.go
|
Go
|
bsd-3-clause
| 343
|
package interfaces
import (
"github.com/robfig/cron/v3"
"time"
)
type ScheduleService interface {
WithConfigPath
Module
GetLocation() (loc *time.Location)
SetLocation(loc *time.Location)
GetDelay() (delay bool)
SetDelay(delay bool)
GetSkip() (skip bool)
SetSkip(skip bool)
GetUpdateInterval() (interval time.Duration)
SetUpdateInterval(interval time.Duration)
Enable(s Schedule, args ...interface{}) (err error)
Disable(s Schedule, args ...interface{}) (err error)
Update()
GetCron() (c *cron.Cron)
}
|
2302_79757062/crawlab
|
core/interfaces/schedule_service.go
|
Go
|
bsd-3-clause
| 519
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
)
type SpiderAdminService interface {
WithConfigPath
Start() (err error)
// Schedule a new task of the spider
Schedule(id primitive.ObjectID, opts *SpiderRunOptions) (taskIds []primitive.ObjectID, err error)
// Clone the spider
Clone(id primitive.ObjectID, opts *SpiderCloneOptions) (err error)
// Delete the spider
Delete(id primitive.ObjectID) (err error)
// SyncGit syncs all git repositories
SyncGit() (err error)
// SyncGitOne syncs one git repository
SyncGitOne(g Git) (err error)
// Export exports the spider and return zip file path
Export(id primitive.ObjectID) (filePath string, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/spider_admin_service.go
|
Go
|
bsd-3-clause
| 692
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type SpiderRunOptions struct {
Mode string `json:"mode"`
NodeIds []primitive.ObjectID `json:"node_ids"`
Cmd string `json:"cmd"`
Param string `json:"param"`
ScheduleId primitive.ObjectID `json:"schedule_id"`
Priority int `json:"priority"`
UserId primitive.ObjectID `json:"-"`
}
type SpiderCloneOptions struct {
Name string
}
|
2302_79757062/crawlab
|
core/interfaces/spider_service_options.go
|
Go
|
bsd-3-clause
| 496
|
package interfaces
import "go.mongodb.org/mongo-driver/bson"
type StatsService interface {
GetOverviewStats(query bson.M) (data interface{}, err error)
GetDailyStats(query bson.M) (data interface{}, err error)
GetTaskStats(query bson.M) (data interface{}, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/stats_service.go
|
Go
|
bsd-3-clause
| 274
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type TaskBaseService interface {
WithConfigPath
Module
SaveTask(t Task, status string) (err error)
IsStopped() (res bool)
GetQueue(nodeId primitive.ObjectID) (queue string)
}
|
2302_79757062/crawlab
|
core/interfaces/task_base_service.go
|
Go
|
bsd-3-clause
| 253
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type TaskHandlerService interface {
TaskBaseService
// Run task and execute locally
Run(taskId primitive.ObjectID) (err error)
// Cancel task locally
Cancel(taskId primitive.ObjectID) (err error)
// Fetch tasks and run
Fetch()
// ReportStatus periodically report handler status to master
ReportStatus()
// Reset reset internals to default
Reset()
// IsSyncLocked whether the given task is locked for files sync
IsSyncLocked(path string) (ok bool)
// LockSync lock files sync for given task
LockSync(path string)
// UnlockSync unlock files sync for given task
UnlockSync(path string)
// GetExitWatchDuration get max runners
GetExitWatchDuration() (duration time.Duration)
// SetExitWatchDuration set max runners
SetExitWatchDuration(duration time.Duration)
// GetFetchInterval get report interval
GetFetchInterval() (interval time.Duration)
// SetFetchInterval set report interval
SetFetchInterval(interval time.Duration)
// GetReportInterval get report interval
GetReportInterval() (interval time.Duration)
// SetReportInterval set report interval
SetReportInterval(interval time.Duration)
// GetCancelTimeout get report interval
GetCancelTimeout() (timeout time.Duration)
// SetCancelTimeout set report interval
SetCancelTimeout(timeout time.Duration)
// GetModelService get model service
GetModelService() (modelSvc GrpcClientModelService)
// GetModelSpiderService get model spider service
GetModelSpiderService() (modelSpiderSvc GrpcClientModelSpiderService)
// GetModelTaskService get model task service
GetModelTaskService() (modelTaskSvc GrpcClientModelTaskService)
// GetModelTaskStatService get model task stat service
GetModelTaskStatService() (modelTaskStatSvc GrpcClientModelTaskStatService)
// GetModelEnvironmentService get model environment service
GetModelEnvironmentService() (modelEnvironmentSvc GrpcClientModelEnvironmentService)
// GetNodeConfigService get node config service
GetNodeConfigService() (cfgSvc NodeConfigService)
// GetCurrentNode get node of the handler
GetCurrentNode() (n Node, err error)
// GetTaskById get task by id
GetTaskById(id primitive.ObjectID) (t Task, err error)
// GetSpiderById get task by id
GetSpiderById(id primitive.ObjectID) (t Spider, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/task_handler_service.go
|
Go
|
bsd-3-clause
| 2,340
|
package interfaces
type TaskHookService interface {
PreActions(Task, Spider, FsServiceV2, TaskHandlerService) (err error)
PostActions(Task, Spider, FsServiceV2, TaskHandlerService) (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/task_hook_service.go
|
Go
|
bsd-3-clause
| 198
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type TaskRunner interface {
Init() (err error)
Run() (err error)
Cancel() (err error)
SetSubscribeTimeout(timeout time.Duration)
GetTaskId() (id primitive.ObjectID)
CleanUp() (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/task_runner.go
|
Go
|
bsd-3-clause
| 281
|
package interfaces
import (
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type TaskSchedulerService interface {
TaskBaseService
// Enqueue task into the task queue
Enqueue(t Task) (t2 Task, err error)
// Cancel task to corresponding node
Cancel(id primitive.ObjectID, args ...interface{}) (err error)
// SetInterval set the interval or duration between two adjacent fetches
SetInterval(interval time.Duration)
}
|
2302_79757062/crawlab
|
core/interfaces/task_scheduler_service.go
|
Go
|
bsd-3-clause
| 431
|
package interfaces
import "go.mongodb.org/mongo-driver/bson/primitive"
type TaskStatsService interface {
TaskBaseService
InsertData(id primitive.ObjectID, records ...interface{}) (err error)
InsertLogs(id primitive.ObjectID, logs ...string) (err error)
}
|
2302_79757062/crawlab
|
core/interfaces/task_stats_service.go
|
Go
|
bsd-3-clause
| 260
|
package interfaces
import "testing"
type Test interface {
Setup(*testing.T)
Cleanup()
}
|
2302_79757062/crawlab
|
core/interfaces/test.go
|
Go
|
bsd-3-clause
| 92
|
package interfaces
type Translation interface {
GetLang() (l string)
}
|
2302_79757062/crawlab
|
core/interfaces/translation.go
|
Go
|
bsd-3-clause
| 73
|
package interfaces
import (
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type UserService interface {
Init() (err error)
SetJwtSecret(secret string)
SetJwtSigningMethod(method jwt.SigningMethod)
Create(opts *UserCreateOptions, args ...interface{}) (err error)
Login(opts *UserLoginOptions) (token string, u User, err error)
CheckToken(token string) (u User, err error)
ChangePassword(id primitive.ObjectID, password string, args ...interface{}) (err error)
MakeToken(user User) (tokenStr string, err error)
GetCurrentUser(c *gin.Context) (u User, err error)
}
|
2302_79757062/crawlab
|
core/interfaces/user_service.go
|
Go
|
bsd-3-clause
| 634
|
package interfaces
type UserCreateOptions struct {
Username string
Password string
Email string
Role string
}
type UserLoginOptions struct {
Username string
Password string
}
|
2302_79757062/crawlab
|
core/interfaces/user_service_options.go
|
Go
|
bsd-3-clause
| 190
|
package interfaces
type WithAddress interface {
GetAddress() (address Address)
SetAddress(address Address)
}
|
2302_79757062/crawlab
|
core/interfaces/with_address.go
|
Go
|
bsd-3-clause
| 112
|
package interfaces
type WithConfigPath interface {
GetConfigPath() (path string)
SetConfigPath(path string)
}
|
2302_79757062/crawlab
|
core/interfaces/with_config_path.go
|
Go
|
bsd-3-clause
| 113
|
package interfaces
type WithModelId interface {
GetModelId() (id ModelId)
SetModelId(id ModelId)
}
|
2302_79757062/crawlab
|
core/interfaces/with_model_id.go
|
Go
|
bsd-3-clause
| 102
|
package main
func main() {
}
|
2302_79757062/crawlab
|
core/main.go
|
Go
|
bsd-3-clause
| 30
|
package middlewares
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/user"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
)
func AuthorizationMiddleware() gin.HandlerFunc {
userSvc, _ := user.GetUserService()
return func(c *gin.Context) {
// disable auth for test
if viper.GetBool("auth.disabled") {
modelSvc, err := service.GetService()
if err != nil {
utils.HandleErrorInternalServerError(c, err)
return
}
u, err := modelSvc.GetUserByUsername(constants.DefaultAdminUsername, nil)
if err != nil {
utils.HandleErrorInternalServerError(c, err)
return
}
c.Set(constants.UserContextKey, u)
c.Next()
return
}
// token string
tokenStr := c.GetHeader("Authorization")
// validate token
u, err := userSvc.CheckToken(tokenStr)
if err != nil {
// validation failed, return error response
utils.HandleErrorUnauthorized(c, errors.ErrorHttpUnauthorized)
return
}
// set user in context
c.Set(constants.UserContextKey, u)
// validation success
c.Next()
}
}
|
2302_79757062/crawlab
|
core/middlewares/auth.go
|
Go
|
bsd-3-clause
| 1,235
|
package middlewares
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/user"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
)
func AuthorizationMiddlewareV2() gin.HandlerFunc {
userSvc, _ := user.GetUserServiceV2()
return func(c *gin.Context) {
// disable auth for test
if viper.GetBool("auth.disabled") {
modelSvc, err := service.GetService()
if err != nil {
utils.HandleErrorInternalServerError(c, err)
return
}
u, err := modelSvc.GetUserByUsername(constants.DefaultAdminUsername, nil)
if err != nil {
utils.HandleErrorInternalServerError(c, err)
return
}
c.Set(constants.UserContextKey, u)
c.Next()
return
}
// token string
tokenStr := c.GetHeader("Authorization")
// validate token
u, err := userSvc.CheckToken(tokenStr)
if err != nil {
// validation failed, return error response
utils.HandleErrorUnauthorized(c, errors.ErrorHttpUnauthorized)
return
}
// set user in context
c.Set(constants.UserContextKey, u)
// validation success
c.Next()
}
}
|
2302_79757062/crawlab
|
core/middlewares/auth_v2.go
|
Go
|
bsd-3-clause
| 1,239
|
package middlewares
import "github.com/gin-gonic/gin"
func CORSMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
c.Writer.Header().Set("Access-Control-Allow-Methods", "DELETE, POST, OPTIONS, GET, PUT")
if c.Request.Method == "OPTIONS" {
c.AbortWithStatus(204)
return
}
c.Next()
}
}
|
2302_79757062/crawlab
|
core/middlewares/cors.go
|
Go
|
bsd-3-clause
| 624
|
package middlewares
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/gin-gonic/gin"
"github.com/spf13/viper"
)
func FilerAuthorizationMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
// auth key
authKey := c.GetHeader("Authorization")
// server auth key
svrAuthKey := viper.GetString("fs.filer.authKey")
// skip to next if no server auth key is provided
if svrAuthKey == "" {
c.Next()
return
}
// validate
if authKey != svrAuthKey {
// validation failed, return error response
utils.HandleErrorUnauthorized(c, errors.ErrorHttpUnauthorized)
return
}
// validation success
c.Next()
}
}
|
2302_79757062/crawlab
|
core/middlewares/filer_auth.go
|
Go
|
bsd-3-clause
| 710
|
package middlewares
import "github.com/gin-gonic/gin"
func InitMiddlewares(app *gin.Engine) (err error) {
// default logger
app.Use(gin.Logger())
// recovery from panics
app.Use(gin.Recovery())
// cors
app.Use(CORSMiddleware())
return nil
}
|
2302_79757062/crawlab
|
core/middlewares/middlewares.go
|
Go
|
bsd-3-clause
| 253
|
package client
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
)
func NewBasicBinder(id interfaces.ModelId, res *grpc.Response) (b interfaces.GrpcModelBinder) {
return &BasicBinder{
id: id,
res: res,
}
}
type BasicBinder struct {
id interfaces.ModelId
res *grpc.Response
}
func (b *BasicBinder) Bind() (res interfaces.Model, err error) {
m := models.NewModelMap()
switch b.id {
case interfaces.ModelIdArtifact:
return b.Process(&m.Artifact)
case interfaces.ModelIdTag:
return b.Process(&m.Tag)
case interfaces.ModelIdNode:
return b.Process(&m.Node)
case interfaces.ModelIdProject:
return b.Process(&m.Project)
case interfaces.ModelIdSpider:
return b.Process(&m.Spider)
case interfaces.ModelIdTask:
return b.Process(&m.Task)
case interfaces.ModelIdJob:
return b.Process(&m.Job)
case interfaces.ModelIdSchedule:
return b.Process(&m.Schedule)
case interfaces.ModelIdUser:
return b.Process(&m.User)
case interfaces.ModelIdSetting:
return b.Process(&m.Setting)
case interfaces.ModelIdToken:
return b.Process(&m.Token)
case interfaces.ModelIdVariable:
return b.Process(&m.Variable)
case interfaces.ModelIdTaskQueue:
return b.Process(&m.TaskQueueItem)
case interfaces.ModelIdTaskStat:
return b.Process(&m.TaskStat)
case interfaces.ModelIdSpiderStat:
return b.Process(&m.SpiderStat)
case interfaces.ModelIdDataSource:
return b.Process(&m.DataSource)
case interfaces.ModelIdDataCollection:
return b.Process(&m.DataCollection)
case interfaces.ModelIdResult:
return b.Process(&m.Result)
case interfaces.ModelIdPassword:
return b.Process(&m.Password)
case interfaces.ModelIdExtraValue:
return b.Process(&m.ExtraValue)
case interfaces.ModelIdGit:
return b.Process(&m.Git)
case interfaces.ModelIdRole:
return b.Process(&m.Role)
case interfaces.ModelIdUserRole:
return b.Process(&m.UserRole)
case interfaces.ModelIdPermission:
return b.Process(&m.Permission)
case interfaces.ModelIdRolePermission:
return b.Process(&m.RolePermission)
case interfaces.ModelIdEnvironment:
return b.Process(&m.Environment)
case interfaces.ModelIdDependencySetting:
return b.Process(&m.DependencySetting)
default:
return nil, errors.ErrorModelInvalidModelId
}
}
func (b *BasicBinder) Process(d interfaces.Model) (res interfaces.Model, err error) {
if err := json.Unmarshal(b.res.Data, d); err != nil {
return nil, trace.TraceError(err)
}
return d, nil
}
|
2302_79757062/crawlab
|
core/models/client/binder_basic.go
|
Go
|
bsd-3-clause
| 2,642
|
package client
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
)
func NewListBinder(id interfaces.ModelId, res *grpc.Response) (b interfaces.GrpcModelListBinder) {
return &ListBinder{
id: id,
res: res,
}
}
type ListBinder struct {
id interfaces.ModelId
res *grpc.Response
}
func (b *ListBinder) Bind() (l interfaces.List, err error) {
m := models.NewModelListMap()
switch b.id {
case interfaces.ModelIdArtifact:
return b.Process(&m.Artifacts)
case interfaces.ModelIdTag:
return b.Process(&m.Tags)
case interfaces.ModelIdNode:
return b.Process(&m.Nodes)
case interfaces.ModelIdProject:
return b.Process(&m.Projects)
case interfaces.ModelIdSpider:
return b.Process(&m.Spiders)
case interfaces.ModelIdTask:
return b.Process(&m.Tasks)
case interfaces.ModelIdJob:
return b.Process(&m.Jobs)
case interfaces.ModelIdSchedule:
return b.Process(&m.Schedules)
case interfaces.ModelIdUser:
return b.Process(&m.Users)
case interfaces.ModelIdSetting:
return b.Process(&m.Settings)
case interfaces.ModelIdToken:
return b.Process(&m.Tokens)
case interfaces.ModelIdVariable:
return b.Process(&m.Variables)
case interfaces.ModelIdTaskQueue:
return b.Process(&m.TaskQueueItems)
case interfaces.ModelIdTaskStat:
return b.Process(&m.TaskStats)
case interfaces.ModelIdSpiderStat:
return b.Process(&m.SpiderStats)
case interfaces.ModelIdDataSource:
return b.Process(&m.DataSources)
case interfaces.ModelIdDataCollection:
return b.Process(&m.DataCollections)
case interfaces.ModelIdResult:
return b.Process(&m.Results)
case interfaces.ModelIdPassword:
return b.Process(&m.Passwords)
case interfaces.ModelIdExtraValue:
return b.Process(&m.ExtraValues)
case interfaces.ModelIdGit:
return b.Process(&m.Gits)
case interfaces.ModelIdRole:
return b.Process(&m.Roles)
case interfaces.ModelIdUserRole:
return b.Process(&m.UserRoles)
case interfaces.ModelIdPermission:
return b.Process(&m.PermissionList)
case interfaces.ModelIdRolePermission:
return b.Process(&m.RolePermissionList)
case interfaces.ModelIdEnvironment:
return b.Process(&m.Environments)
case interfaces.ModelIdDependencySetting:
return b.Process(&m.DependencySettings)
default:
return l, errors.ErrorModelInvalidModelId
}
}
func (b *ListBinder) MustBind() (res interface{}) {
res, err := b.Bind()
if err != nil {
panic(err)
}
return res
}
func (b *ListBinder) Process(d interface{}) (l interfaces.List, err error) {
if err := json.Unmarshal(b.res.Data, d); err != nil {
return l, trace.TraceError(err)
}
return d.(interfaces.List), nil
}
|
2302_79757062/crawlab
|
core/models/client/binder_list.go
|
Go
|
bsd-3-clause
| 2,803
|
package client
import (
"encoding/json"
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
errors2 "github.com/pkg/errors"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type BaseServiceDelegate struct {
// settings
cfgPath string
// internals
id interfaces.ModelId
c interfaces.GrpcClient
}
func (d *BaseServiceDelegate) GetModelId() (id interfaces.ModelId) {
return d.id
}
func (d *BaseServiceDelegate) SetModelId(id interfaces.ModelId) {
d.id = id
}
func (d *BaseServiceDelegate) GetConfigPath() (path string) {
return d.cfgPath
}
func (d *BaseServiceDelegate) SetConfigPath(path string) {
d.cfgPath = path
}
func (d *BaseServiceDelegate) GetById(id primitive.ObjectID) (doc interfaces.Model, err error) {
log.Debugf("[BaseServiceDelegate] get by id[%s]", id.Hex())
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Id: id})
c := d.getModelBaseServiceClient()
if c == nil {
return nil, trace.TraceError(errors.ErrorModelNilPointer)
}
log.Debugf("[BaseServiceDelegate] get by id[%s] req: %v", id.Hex(), req)
res, err := c.GetById(ctx, req)
if err != nil {
return nil, trace.TraceError(err)
}
log.Debugf("[BaseServiceDelegate] get by id[%s] res: %v", id.Hex(), res)
return NewBasicBinder(d.id, res).Bind()
}
func (d *BaseServiceDelegate) Get(query bson.M, opts *mongo.FindOptions) (doc interfaces.Model, err error) {
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, FindOptions: opts})
res, err := d.getModelBaseServiceClient().Get(ctx, req)
if err != nil {
return nil, err
}
return NewBasicBinder(d.id, res).Bind()
}
func (d *BaseServiceDelegate) GetList(query bson.M, opts *mongo.FindOptions) (l interfaces.List, err error) {
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, FindOptions: opts})
res, err := d.getModelBaseServiceClient().GetList(ctx, req)
if err != nil {
return l, err
}
return NewListBinder(d.id, res).Bind()
}
func (d *BaseServiceDelegate) DeleteById(id primitive.ObjectID, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Id: id, User: u})
_, err = d.getModelBaseServiceClient().DeleteById(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) Delete(query bson.M, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, User: u})
_, err = d.getModelBaseServiceClient().Delete(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) DeleteList(query bson.M, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, User: u})
_, err = d.getModelBaseServiceClient().DeleteList(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) ForceDeleteList(query bson.M, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, User: u})
_, err = d.getModelBaseServiceClient().ForceDeleteList(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) UpdateById(id primitive.ObjectID, update bson.M, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Id: id, Update: update, User: u})
_, err = d.getModelBaseServiceClient().UpdateById(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) Update(query bson.M, update bson.M, fields []string, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, Update: update, Fields: fields, User: u})
_, err = d.getModelBaseServiceClient().Update(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) UpdateDoc(query bson.M, doc interfaces.Model, fields []string, args ...interface{}) (err error) {
u := utils.GetUserFromArgs(args...)
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query, Doc: doc, Fields: fields, User: u})
_, err = d.getModelBaseServiceClient().UpdateDoc(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) Insert(u interfaces.User, docs ...interface{}) (err error) {
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Docs: docs, User: u})
_, err = d.getModelBaseServiceClient().Insert(ctx, req)
if err != nil {
return err
}
return nil
}
func (d *BaseServiceDelegate) Count(query bson.M) (total int, err error) {
ctx, cancel := d.c.Context()
defer cancel()
req := d.mustNewRequest(&entity.GrpcBaseServiceParams{Query: query})
res, err := d.getModelBaseServiceClient().Count(ctx, req)
if err != nil {
return total, err
}
if err := json.Unmarshal(res.Data, &total); err != nil {
return total, err
}
return total, nil
}
func (d *BaseServiceDelegate) newRequest(params interfaces.GrpcBaseServiceParams) (req *grpc.Request, err error) {
return d.c.NewModelBaseServiceRequest(d.id, params)
}
func (d *BaseServiceDelegate) mustNewRequest(params *entity.GrpcBaseServiceParams) (req *grpc.Request) {
req, err := d.newRequest(params)
if err != nil {
panic(err)
}
return req
}
func (d *BaseServiceDelegate) getModelBaseServiceClient() (c grpc.ModelBaseServiceClient) {
if err := backoff.Retry(func() (err error) {
c = d.c.GetModelBaseServiceClient()
if c == nil {
err = errors2.New("unable to get model base service client")
log.Debugf("[BaseServiceDelegate] err: %v", err)
return err
}
return nil
}, backoff.NewConstantBackOff(1*time.Second)); err != nil {
trace.PrintError(err)
}
return c
}
func NewBaseServiceDelegate(opts ...ModelBaseServiceDelegateOption) (svc2 interfaces.GrpcClientModelBaseService, err error) {
// base service
svc := &BaseServiceDelegate{}
// apply options
for _, opt := range opts {
opt(svc)
}
// config path
if viper.GetString("config.path") != "" {
svc.cfgPath = viper.GetString("config.path")
}
// dependency injection
if err := container.GetContainer().Invoke(func(client interfaces.GrpcClient) {
svc.c = client
}); err != nil {
return nil, err
}
return svc, nil
}
func ProvideBaseServiceDelegate(id interfaces.ModelId) func() (svc interfaces.GrpcClientModelBaseService, err error) {
return func() (svc interfaces.GrpcClientModelBaseService, err error) {
return NewBaseServiceDelegate(WithBaseServiceModelId(id))
}
}
|
2302_79757062/crawlab
|
core/models/client/model_base_service.go
|
Go
|
bsd-3-clause
| 7,490
|
package client
import (
"encoding/json"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/grpc/client"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/utils"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
)
func NewModelDelegate(doc interfaces.Model, opts ...ModelDelegateOption) interfaces.GrpcClientModelDelegate {
switch doc.(type) {
case *models.Artifact:
return newModelDelegate(interfaces.ModelIdArtifact, doc, opts...)
case *models.Tag:
return newModelDelegate(interfaces.ModelIdTag, doc, opts...)
case *models.Node:
return newModelDelegate(interfaces.ModelIdNode, doc, opts...)
case *models.Project:
return newModelDelegate(interfaces.ModelIdProject, doc, opts...)
case *models.Spider:
return newModelDelegate(interfaces.ModelIdSpider, doc, opts...)
case *models.Task:
return newModelDelegate(interfaces.ModelIdTask, doc, opts...)
case *models.Job:
return newModelDelegate(interfaces.ModelIdJob, doc, opts...)
case *models.Schedule:
return newModelDelegate(interfaces.ModelIdSchedule, doc, opts...)
case *models.User:
return newModelDelegate(interfaces.ModelIdUser, doc, opts...)
case *models.Setting:
return newModelDelegate(interfaces.ModelIdSetting, doc, opts...)
case *models.Token:
return newModelDelegate(interfaces.ModelIdToken, doc, opts...)
case *models.Variable:
return newModelDelegate(interfaces.ModelIdVariable, doc, opts...)
case *models.TaskQueueItem:
return newModelDelegate(interfaces.ModelIdTaskQueue, doc, opts...)
case *models.TaskStat:
return newModelDelegate(interfaces.ModelIdTaskStat, doc, opts...)
case *models.SpiderStat:
return newModelDelegate(interfaces.ModelIdSpiderStat, doc, opts...)
case *models.DataSource:
return newModelDelegate(interfaces.ModelIdDataSource, doc, opts...)
case *models.DataCollection:
return newModelDelegate(interfaces.ModelIdDataCollection, doc, opts...)
case *models.Result:
return newModelDelegate(interfaces.ModelIdResult, doc, opts...)
case *models.Password:
return newModelDelegate(interfaces.ModelIdPassword, doc, opts...)
case *models.ExtraValue:
return newModelDelegate(interfaces.ModelIdExtraValue, doc, opts...)
case *models.Git:
return newModelDelegate(interfaces.ModelIdGit, doc, opts...)
case *models.UserRole:
return newModelDelegate(interfaces.ModelIdUserRole, doc, opts...)
case *models.Permission:
return newModelDelegate(interfaces.ModelIdPermission, doc, opts...)
case *models.RolePermission:
return newModelDelegate(interfaces.ModelIdRolePermission, doc, opts...)
case *models.Environment:
return newModelDelegate(interfaces.ModelIdEnvironment, doc, opts...)
case *models.DependencySetting:
return newModelDelegate(interfaces.ModelIdDependencySetting, doc, opts...)
default:
_ = trace.TraceError(errors.ErrorModelInvalidType)
return nil
}
}
func newModelDelegate(id interfaces.ModelId, doc interfaces.Model, opts ...ModelDelegateOption) interfaces.GrpcClientModelDelegate {
var err error
// collection name
colName := models.GetModelColName(id)
// model delegate
d := &ModelDelegate{
id: id,
colName: colName,
doc: doc,
cfgPath: config2.GetConfigPath(),
a: &models.Artifact{
Col: colName,
},
}
// config path
if viper.GetString("config.path") != "" {
d.cfgPath = viper.GetString("config.path")
}
// apply options
for _, opt := range opts {
opt(d)
}
// grpc client
d.c, err = client.GetClient()
if err != nil {
trace.PrintError(errors.ErrorModelInvalidType)
return nil
}
if !d.c.IsStarted() {
if err := d.c.Start(); err != nil {
trace.PrintError(err)
return nil
}
} else if d.c.IsClosed() {
if err := d.c.Restart(); err != nil {
trace.PrintError(err)
return nil
}
}
return d
}
type ModelDelegate struct {
// settings
cfgPath string
// internals
id interfaces.ModelId
colName string
c interfaces.GrpcClient
doc interfaces.Model
a interfaces.ModelArtifact
}
func (d *ModelDelegate) Add() (err error) {
return d.do(interfaces.ModelDelegateMethodAdd)
}
func (d *ModelDelegate) Save() (err error) {
return d.do(interfaces.ModelDelegateMethodSave)
}
func (d *ModelDelegate) Delete() (err error) {
return d.do(interfaces.ModelDelegateMethodDelete)
}
func (d *ModelDelegate) GetArtifact() (res interfaces.ModelArtifact, err error) {
if err := d.do(interfaces.ModelDelegateMethodGetArtifact); err != nil {
return nil, err
}
return d.a, nil
}
func (d *ModelDelegate) GetModel() (res interfaces.Model) {
return d.doc
}
func (d *ModelDelegate) Refresh() (err error) {
return d.refresh()
}
func (d *ModelDelegate) GetConfigPath() (path string) {
return d.cfgPath
}
func (d *ModelDelegate) SetConfigPath(path string) {
d.cfgPath = path
}
func (d *ModelDelegate) Close() (err error) {
return d.c.Stop()
}
func (d *ModelDelegate) ToBytes(m interface{}) (bytes []byte, err error) {
if m != nil {
return utils.JsonToBytes(m)
}
return json.Marshal(d.doc)
}
func (d *ModelDelegate) do(method interfaces.ModelDelegateMethod) (err error) {
switch method {
case interfaces.ModelDelegateMethodAdd:
err = d.add()
case interfaces.ModelDelegateMethodSave:
err = d.save()
case interfaces.ModelDelegateMethodDelete:
err = d.delete()
case interfaces.ModelDelegateMethodGetArtifact, interfaces.ModelDelegateMethodRefresh:
return d.refresh()
default:
return trace.TraceError(errors.ErrorModelInvalidType)
}
if err != nil {
return err
}
return nil
}
func (d *ModelDelegate) add() (err error) {
ctx, cancel := d.c.Context()
defer cancel()
method := interfaces.ModelDelegateMethod(interfaces.ModelDelegateMethodAdd)
res, err := d.c.GetModelDelegateClient().Do(ctx, d.c.NewRequest(entity.GrpcDelegateMessage{
ModelId: d.id,
Method: method,
Data: d.mustGetData(),
}))
if err != nil {
return trace.TraceError(err)
}
if err := d.deserialize(res, method); err != nil {
return err
}
return d.refreshArtifact()
}
func (d *ModelDelegate) save() (err error) {
ctx, cancel := d.c.Context()
defer cancel()
method := interfaces.ModelDelegateMethod(interfaces.ModelDelegateMethodSave)
res, err := d.c.GetModelDelegateClient().Do(ctx, d.c.NewRequest(entity.GrpcDelegateMessage{
ModelId: d.id,
Method: method,
Data: d.mustGetData(),
}))
if err != nil {
return trace.TraceError(err)
}
if err := d.deserialize(res, method); err != nil {
return err
}
return d.refreshArtifact()
}
func (d *ModelDelegate) delete() (err error) {
ctx, cancel := d.c.Context()
defer cancel()
method := interfaces.ModelDelegateMethod(interfaces.ModelDelegateMethodDelete)
res, err := d.c.GetModelDelegateClient().Do(ctx, d.c.NewRequest(entity.GrpcDelegateMessage{
ModelId: d.id,
Method: method,
Data: d.mustGetData(),
}))
if err != nil {
return trace.TraceError(err)
}
if err := d.deserialize(res, method); err != nil {
return err
}
return d.refreshArtifact()
}
func (d *ModelDelegate) refresh() (err error) {
ctx, cancel := d.c.Context()
defer cancel()
method := interfaces.ModelDelegateMethod(interfaces.ModelDelegateMethodRefresh)
res, err := d.c.GetModelDelegateClient().Do(ctx, d.c.NewRequest(entity.GrpcDelegateMessage{
ModelId: d.id,
Method: method,
Data: d.mustGetData(),
}))
if err != nil {
return trace.TraceError(err)
}
if err := d.deserialize(res, method); err != nil {
return err
}
return nil
}
func (d *ModelDelegate) refreshArtifact() (err error) {
_, err = d.getArtifact()
return err
}
func (d *ModelDelegate) getArtifact() (res2 interfaces.ModelArtifact, err error) {
ctx, cancel := d.c.Context()
defer cancel()
method := interfaces.ModelDelegateMethod(interfaces.ModelDelegateMethodGetArtifact)
res, err := d.c.GetModelDelegateClient().Do(ctx, d.c.NewRequest(entity.GrpcDelegateMessage{
ModelId: d.id,
Method: method,
Data: d.mustGetData(),
}))
if err != nil {
return nil, err
}
if err := d.deserialize(res, method); err != nil {
return nil, err
}
return d.a, nil
}
func (d *ModelDelegate) mustGetData() (data []byte) {
data, err := d.getData()
if err != nil {
panic(err)
}
return data
}
func (d *ModelDelegate) getData() (data []byte, err error) {
return json.Marshal(d.doc)
}
func (d *ModelDelegate) deserialize(res *grpc.Response, method interfaces.ModelDelegateMethod) (err error) {
if method == interfaces.ModelDelegateMethodGetArtifact {
res, err := NewBasicBinder(interfaces.ModelIdArtifact, res).Bind()
if err != nil {
return err
}
a, ok := res.(interfaces.ModelArtifact)
if !ok {
return trace.TraceError(errors.ErrorModelInvalidType)
}
d.a = a
} else {
d.doc, err = NewBasicBinder(d.id, res).Bind()
if err != nil {
return err
}
}
return nil
}
|
2302_79757062/crawlab
|
core/models/client/model_delegate.go
|
Go
|
bsd-3-clause
| 8,998
|
package client
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type EnvironmentServiceDelegate struct {
interfaces.GrpcClientModelBaseService
}
func (svc *EnvironmentServiceDelegate) GetEnvironmentById(id primitive.ObjectID) (e interfaces.Environment, err error) {
res, err := svc.GetById(id)
if err != nil {
return nil, err
}
s, ok := res.(interfaces.Environment)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return s, nil
}
func (svc *EnvironmentServiceDelegate) GetEnvironment(query bson.M, opts *mongo.FindOptions) (e interfaces.Environment, err error) {
res, err := svc.Get(query, opts)
if err != nil {
return nil, err
}
s, ok := res.(interfaces.Environment)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return s, nil
}
func (svc *EnvironmentServiceDelegate) GetEnvironmentList(query bson.M, opts *mongo.FindOptions) (res []interfaces.Environment, err error) {
list, err := svc.GetList(query, opts)
if err != nil {
return nil, err
}
for _, item := range list.GetModels() {
s, ok := item.(interfaces.Environment)
if !ok {
return nil, errors.ErrorModelInvalidType
}
res = append(res, s)
}
return res, nil
}
func NewEnvironmentServiceDelegate() (svc2 interfaces.GrpcClientModelEnvironmentService, err error) {
var opts []ModelBaseServiceDelegateOption
// apply options
opts = append(opts, WithBaseServiceModelId(interfaces.ModelIdEnvironment))
// base service
baseSvc, err := NewBaseServiceDelegate(opts...)
if err != nil {
return nil, err
}
// service
svc := &EnvironmentServiceDelegate{baseSvc}
return svc, nil
}
|
2302_79757062/crawlab
|
core/models/client/model_environment_service.go
|
Go
|
bsd-3-clause
| 1,782
|
package client
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type ModelNodeDelegate struct {
n interfaces.Node
interfaces.GrpcClientModelDelegate
}
func (d *ModelNodeDelegate) UpdateStatus(active bool, activeTs *time.Time, status string) (err error) {
d.n.SetActive(active)
if activeTs != nil {
d.n.SetActiveTs(*activeTs)
}
d.n.SetStatus(status)
return d.Save()
}
func (d *ModelNodeDelegate) UpdateStatusOnline() (err error) {
now := time.Now()
return d.UpdateStatus(true, &now, constants.NodeStatusOnline)
}
func (d *ModelNodeDelegate) UpdateStatusOffline() (err error) {
return d.UpdateStatus(false, nil, constants.NodeStatusOffline)
}
func NewModelNodeDelegate(n interfaces.Node) interfaces.ModelNodeDelegate {
return &ModelNodeDelegate{
n: n,
GrpcClientModelDelegate: NewModelDelegate(n),
}
}
|
2302_79757062/crawlab
|
core/models/client/model_node_delegate.go
|
Go
|
bsd-3-clause
| 917
|