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 service
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
models2 "github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func convertTypeToken(d interface{}, err error) (res *models2.Token, err2 error) {
if err != nil {
return nil, err
}
res, ok := d.(*models2.Token)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return res, nil
}
func (svc *Service) GetTokenById(id primitive.ObjectID) (res *models2.Token, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdToken).GetById(id)
return convertTypeToken(d, err)
}
func (svc *Service) GetToken(query bson.M, opts *mongo.FindOptions) (res *models2.Token, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdToken).Get(query, opts)
return convertTypeToken(d, err)
}
func (svc *Service) GetTokenList(query bson.M, opts *mongo.FindOptions) (res []models2.Token, err error) {
l, err := svc.GetBaseService(interfaces.ModelIdToken).GetList(query, opts)
for _, doc := range l.GetModels() {
d := doc.(*models2.Token)
res = append(res, *d)
}
return res, nil
}
|
2302_79757062/crawlab
|
core/models/service/token_service.go
|
Go
|
bsd-3-clause
| 1,240
|
package service
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
models2 "github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func convertTypeUserRole(d interface{}, err error) (res *models2.UserRole, err2 error) {
if err != nil {
return nil, err
}
res, ok := d.(*models2.UserRole)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return res, nil
}
func (svc *Service) GetUserRoleById(id primitive.ObjectID) (res *models2.UserRole, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdUserRole).GetById(id)
return convertTypeUserRole(d, err)
}
func (svc *Service) GetUserRole(query bson.M, opts *mongo.FindOptions) (res *models2.UserRole, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdUserRole).Get(query, opts)
return convertTypeUserRole(d, err)
}
func (svc *Service) GetUserRoleList(query bson.M, opts *mongo.FindOptions) (res []models2.UserRole, err error) {
l, err := svc.GetBaseService(interfaces.ModelIdUserRole).GetList(query, opts)
if err != nil {
return nil, err
}
for _, doc := range l.GetModels() {
d := doc.(*models2.UserRole)
res = append(res, *d)
}
return res, nil
}
func (svc *Service) GetUserRoleListByUserId(id primitive.ObjectID, opts *mongo.FindOptions) (res []models2.UserRole, err error) {
return svc.GetUserRoleList(bson.M{"user_id": id}, opts)
}
func (svc *Service) GetUserRoleListByRoleId(id primitive.ObjectID, opts *mongo.FindOptions) (res []models2.UserRole, err error) {
return svc.GetUserRoleList(bson.M{"role_id": id}, opts)
}
|
2302_79757062/crawlab
|
core/models/service/user_role_service.go
|
Go
|
bsd-3-clause
| 1,703
|
package service
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
models2 "github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func convertTypeUser(d interface{}, err error) (res *models2.User, err2 error) {
if err != nil {
return nil, err
}
res, ok := d.(*models2.User)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return res, nil
}
func (svc *Service) GetUserById(id primitive.ObjectID) (res *models2.User, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdUser).GetById(id)
return convertTypeUser(d, err)
}
func (svc *Service) GetUser(query bson.M, opts *mongo.FindOptions) (res *models2.User, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdUser).Get(query, opts)
return convertTypeUser(d, err)
}
func (svc *Service) GetUserList(query bson.M, opts *mongo.FindOptions) (res []models2.User, err error) {
l, err := svc.GetBaseService(interfaces.ModelIdUser).GetList(query, opts)
for _, doc := range l.GetModels() {
d := doc.(*models2.User)
res = append(res, *d)
}
return res, nil
}
func (svc *Service) GetUserByUsername(username string, opts *mongo.FindOptions) (res *models2.User, err error) {
query := bson.M{"username": username}
return svc.GetUser(query, opts)
}
func (svc *Service) GetUserByUsernameWithPassword(username string, opts *mongo.FindOptions) (res *models2.User, err error) {
u, err := svc.GetUserByUsername(username, opts)
if err != nil {
return nil, err
}
p, err := svc.GetPasswordById(u.Id)
if err != nil {
return nil, err
}
u.Password = p.Password
return u, nil
}
|
2302_79757062/crawlab
|
core/models/service/user_service.go
|
Go
|
bsd-3-clause
| 1,743
|
package service
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
models2 "github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
func convertTypeVariable(d interface{}, err error) (res *models2.Variable, err2 error) {
if err != nil {
return nil, err
}
res, ok := d.(*models2.Variable)
if !ok {
return nil, errors.ErrorModelInvalidType
}
return res, nil
}
func (svc *Service) GetVariableById(id primitive.ObjectID) (res *models2.Variable, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdVariable).GetById(id)
return convertTypeVariable(d, err)
}
func (svc *Service) GetVariable(query bson.M, opts *mongo.FindOptions) (res *models2.Variable, err error) {
d, err := svc.GetBaseService(interfaces.ModelIdVariable).Get(query, opts)
return convertTypeVariable(d, err)
}
func (svc *Service) GetVariableList(query bson.M, opts *mongo.FindOptions) (res []models2.Variable, err error) {
l, err := svc.GetBaseService(interfaces.ModelIdVariable).GetList(query, opts)
for _, doc := range l.GetModels() {
d := doc.(*models2.Variable)
res = append(res, *d)
}
return res, nil
}
func (svc *Service) GetVariableByKey(key string, opts *mongo.FindOptions) (res *models2.Variable, err error) {
query := bson.M{"key": key}
return svc.GetVariable(query, opts)
}
|
2302_79757062/crawlab
|
core/models/service/variable_service.go
|
Go
|
bsd-3-clause
| 1,465
|
package config
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/spf13/viper"
)
type Config entity.NodeInfo
type Options struct {
Key string
Name string
IsMaster bool
AuthKey string
MaxRunners int
}
var DefaultMaxRunner = 8
var DefaultConfigOptions = &Options{
Key: utils.NewUUIDString(),
IsMaster: utils.IsMaster(),
AuthKey: constants.DefaultGrpcAuthKey,
MaxRunners: 0,
}
func NewConfig(opts *Options) (cfg *Config) {
if opts == nil {
opts = DefaultConfigOptions
}
if opts.Key == "" {
if viper.GetString("node.key") != "" {
opts.Key = viper.GetString("node.key")
} else {
opts.Key = utils.NewUUIDString()
}
}
if opts.Name == "" {
if viper.GetString("node.name") != "" {
opts.Name = viper.GetString("node.name")
} else {
opts.Name = opts.Key
}
}
if opts.AuthKey == "" {
if viper.GetString("grpc.authKey") != "" {
opts.AuthKey = viper.GetString("grpc.authKey")
} else {
opts.AuthKey = constants.DefaultGrpcAuthKey
}
}
if opts.MaxRunners == 0 {
if viper.GetInt("task.handler.maxRunners") != 0 {
opts.MaxRunners = viper.GetInt("task.handler.maxRunners")
} else {
opts.MaxRunners = DefaultMaxRunner
}
}
return &Config{
Key: opts.Key,
Name: opts.Name,
IsMaster: opts.IsMaster,
AuthKey: opts.AuthKey,
MaxRunners: opts.MaxRunners,
}
}
|
2302_79757062/crawlab
|
core/node/config/config.go
|
Go
|
bsd-3-clause
| 1,478
|
package config
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"os"
"path"
)
type Service struct {
cfg *Config
path string
}
func (svc *Service) Init() (err error) {
// check config directory path
configDirPath := path.Dir(svc.path)
if !utils.Exists(configDirPath) {
if err := os.MkdirAll(configDirPath, os.FileMode(0766)); err != nil {
return trace.TraceError(err)
}
}
if !utils.Exists(svc.path) {
// not exists, set to default config
// and create a config file for persistence
svc.cfg = NewConfig(nil)
data, err := json.Marshal(svc.cfg)
if err != nil {
return trace.TraceError(err)
}
if err := os.WriteFile(svc.path, data, os.FileMode(0766)); err != nil {
return trace.TraceError(err)
}
} else {
// exists, read and set to config
data, err := os.ReadFile(svc.path)
if err != nil {
return trace.TraceError(err)
}
if err := json.Unmarshal(data, svc.cfg); err != nil {
return trace.TraceError(err)
}
}
return nil
}
func (svc *Service) Reload() (err error) {
return svc.Init()
}
func (svc *Service) GetBasicNodeInfo() (res interfaces.Entity) {
return &entity.NodeInfo{
Key: svc.GetNodeKey(),
Name: svc.GetNodeName(),
IsMaster: svc.IsMaster(),
AuthKey: svc.GetAuthKey(),
MaxRunners: svc.GetMaxRunners(),
}
}
func (svc *Service) GetNodeKey() (res string) {
return svc.cfg.Key
}
func (svc *Service) GetNodeName() (res string) {
return svc.cfg.Name
}
func (svc *Service) IsMaster() (res bool) {
return svc.cfg.IsMaster
}
func (svc *Service) GetAuthKey() (res string) {
return svc.cfg.AuthKey
}
func (svc *Service) GetMaxRunners() (res int) {
return svc.cfg.MaxRunners
}
func (svc *Service) GetConfigPath() (path string) {
return svc.path
}
func (svc *Service) SetConfigPath(path string) {
svc.path = path
}
func NewNodeConfigService() (svc2 interfaces.NodeConfigService, err error) {
// cfg
cfg := NewConfig(nil)
// config service
svc := &Service{
cfg: cfg,
}
// normalize config path
cfgPath := config.GetConfigPath()
svc.SetConfigPath(cfgPath)
// init
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
var _service interfaces.NodeConfigService
func GetNodeConfigService() interfaces.NodeConfigService {
if _service != nil {
return _service
}
var err error
_service, err = NewNodeConfigService()
if err != nil {
panic(err)
}
return _service
}
|
2302_79757062/crawlab
|
core/node/config/config_service.go
|
Go
|
bsd-3-clause
| 2,618
|
package config
import (
"github.com/crawlab-team/crawlab/core/interfaces"
)
type Option func(svc interfaces.NodeConfigService)
func WithConfigPath(path string) Option {
return func(svc interfaces.NodeConfigService) {
svc.SetConfigPath(path)
}
}
|
2302_79757062/crawlab
|
core/node/config/options.go
|
Go
|
bsd-3-clause
| 253
|
package service
import (
"github.com/apex/log"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/grpc/server"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/common"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/core/notification"
"github.com/crawlab-team/crawlab/core/system"
"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"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
type MasterService struct {
// dependencies
modelSvc service.ModelService
cfgSvc interfaces.NodeConfigService
server interfaces.GrpcServer
schedulerSvc interfaces.TaskSchedulerService
handlerSvc interfaces.TaskHandlerService
scheduleSvc interfaces.ScheduleService
notificationSvc *notification.Service
spiderAdminSvc interfaces.SpiderAdminService
systemSvc *system.Service
// settings
cfgPath string
address interfaces.Address
monitorInterval time.Duration
stopOnError bool
}
func (svc *MasterService) Init() (err error) {
// do nothing
return nil
}
func (svc *MasterService) Start() {
// create indexes
common.CreateIndexes()
// start grpc server
if err := svc.server.Start(); err != nil {
panic(err)
}
// register to db
if err := svc.Register(); err != nil {
panic(err)
}
// start monitoring worker nodes
go svc.Monitor()
// start task handler
go svc.handlerSvc.Start()
// start task scheduler
go svc.schedulerSvc.Start()
// start schedule service
go svc.scheduleSvc.Start()
// start notification service
go svc.notificationSvc.Start()
// start spider admin service
go svc.spiderAdminSvc.Start()
// wait for quit signal
svc.Wait()
// stop
svc.Stop()
}
func (svc *MasterService) Wait() {
utils.DefaultWait()
}
func (svc *MasterService) Stop() {
_ = svc.server.Stop()
log.Infof("master[%s] service has stopped", svc.GetConfigService().GetNodeKey())
}
func (svc *MasterService) Monitor() {
log.Infof("master[%s] monitoring started", svc.GetConfigService().GetNodeKey())
for {
if err := svc.monitor(); err != nil {
trace.PrintError(err)
if svc.stopOnError {
log.Errorf("master[%s] monitor error, now stopping...", svc.GetConfigService().GetNodeKey())
svc.Stop()
return
}
}
time.Sleep(svc.monitorInterval)
}
}
func (svc *MasterService) GetConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *MasterService) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *MasterService) SetConfigPath(path string) {
svc.cfgPath = path
}
func (svc *MasterService) GetAddress() (address interfaces.Address) {
return svc.address
}
func (svc *MasterService) SetAddress(address interfaces.Address) {
svc.address = address
}
func (svc *MasterService) SetMonitorInterval(duration time.Duration) {
svc.monitorInterval = duration
}
func (svc *MasterService) Register() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
nodeName := svc.GetConfigService().GetNodeName()
node, err := svc.modelSvc.GetNodeByKey(nodeKey, nil)
if err != nil && err.Error() == mongo2.ErrNoDocuments.Error() {
// not exists
log.Infof("master[%s] does not exist in db", nodeKey)
node := &models.Node{
Key: nodeKey,
Name: nodeName,
MaxRunners: config.DefaultConfigOptions.MaxRunners,
IsMaster: true,
Status: constants.NodeStatusOnline,
Enabled: true,
Active: true,
ActiveTs: time.Now(),
}
if viper.GetInt("task.handler.maxRunners") > 0 {
node.MaxRunners = viper.GetInt("task.handler.maxRunners")
}
nodeD := delegate.NewModelNodeDelegate(node)
if err := nodeD.Add(); err != nil {
return err
}
log.Infof("added master[%s] in db. id: %s", nodeKey, nodeD.GetModel().GetId().Hex())
return nil
} else if err == nil {
// exists
log.Infof("master[%s] exists in db", nodeKey)
nodeD := delegate.NewModelNodeDelegate(node)
if err := nodeD.UpdateStatusOnline(); err != nil {
return err
}
log.Infof("updated master[%s] in db. id: %s", nodeKey, nodeD.GetModel().GetId().Hex())
return nil
} else {
// error
return err
}
}
func (svc *MasterService) StopOnError() {
svc.stopOnError = true
}
func (svc *MasterService) GetServer() (svr interfaces.GrpcServer) {
return svc.server
}
func (svc *MasterService) monitor() (err error) {
// update master node status in db
if err := svc.updateMasterNodeStatus(); err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
return nil
}
return err
}
// all worker nodes
nodes, err := svc.getAllWorkerNodes()
if err != nil {
return err
}
// error flag
isErr := false
// iterate all nodes
for _, n := range nodes {
// subscribe
if err := svc.subscribeNode(&n); err != nil {
isErr = true
continue
}
// ping client
if err := svc.pingNodeClient(&n); err != nil {
isErr = true
continue
}
// update node available runners
if err := svc.updateNodeAvailableRunners(&n); err != nil {
isErr = true
continue
}
}
if isErr {
return trace.TraceError(errors.ErrorNodeMonitorError)
}
return nil
}
func (svc *MasterService) getAllWorkerNodes() (nodes []models.Node, err error) {
query := bson.M{
"key": bson.M{"$ne": svc.cfgSvc.GetNodeKey()}, // not self
"active": true, // active
}
nodes, err = svc.modelSvc.GetNodeList(query, nil)
if err != nil {
if err == mongo2.ErrNoDocuments {
return nil, nil
}
return nil, trace.TraceError(err)
}
return nodes, nil
}
func (svc *MasterService) updateMasterNodeStatus() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
node, err := svc.modelSvc.GetNodeByKey(nodeKey, nil)
if err != nil {
return err
}
nodeD := delegate.NewModelNodeDelegate(node)
return nodeD.UpdateStatusOnline()
}
func (svc *MasterService) setWorkerNodeOffline(n interfaces.Node) (err error) {
return delegate.NewModelNodeDelegate(n).UpdateStatusOffline()
}
func (svc *MasterService) subscribeNode(n interfaces.Node) (err error) {
_, err = svc.server.GetSubscribe("node:" + n.GetKey())
if err != nil {
log.Errorf("cannot subscribe worker node[%s]: %v", n.GetKey(), err)
if err := svc.setWorkerNodeOffline(n); err != nil {
return trace.TraceError(err)
}
return trace.TraceError(err)
}
return nil
}
func (svc *MasterService) pingNodeClient(n interfaces.Node) (err error) {
if err := svc.server.SendStreamMessage("node:"+n.GetKey(), grpc.StreamMessageCode_PING); err != nil {
log.Errorf("cannot ping worker node client[%s]: %v", n.GetKey(), err)
if err := svc.setWorkerNodeOffline(n); err != nil {
return trace.TraceError(err)
}
return trace.TraceError(err)
}
return nil
}
func (svc *MasterService) updateNodeAvailableRunners(n interfaces.Node) (err error) {
query := bson.M{
"node_id": n.GetId(),
"status": constants.TaskStatusRunning,
}
runningTasksCount, err := mongo.GetMongoCol(interfaces.ModelColNameTask).Count(query)
if err != nil {
return trace.TraceError(err)
}
n.SetAvailableRunners(n.GetMaxRunners() - runningTasksCount)
return delegate.NewModelDelegate(n).Save()
}
func NewMasterService(opts ...Option) (res interfaces.NodeMasterService, err error) {
// master service
svc := &MasterService{
cfgPath: config2.GetConfigPath(),
monitorInterval: 15 * time.Second,
stopOnError: false,
}
// apply options
for _, opt := range opts {
opt(svc)
}
// server options
var serverOpts []server.Option
if svc.address != nil {
serverOpts = append(serverOpts, server.WithAddress(svc.address))
}
// dependency injection
if err := container.GetContainer().Invoke(func(
cfgSvc interfaces.NodeConfigService,
modelSvc service.ModelService,
server interfaces.GrpcServer,
schedulerSvc interfaces.TaskSchedulerService,
handlerSvc interfaces.TaskHandlerService,
scheduleSvc interfaces.ScheduleService,
spiderAdminSvc interfaces.SpiderAdminService,
) {
svc.cfgSvc = cfgSvc
svc.modelSvc = modelSvc
svc.server = server
svc.schedulerSvc = schedulerSvc
svc.handlerSvc = handlerSvc
svc.scheduleSvc = scheduleSvc
svc.spiderAdminSvc = spiderAdminSvc
}); err != nil {
return nil, err
}
// notification service
svc.notificationSvc = notification.GetService()
// system service
svc.systemSvc = system.GetService()
// init
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
func ProvideMasterService(path string, opts ...Option) func() (interfaces.NodeMasterService, error) {
// path
if path == "" || path == config2.GetConfigPath() {
if viper.GetString("config.path") != "" {
path = viper.GetString("config.path")
} else {
path = config2.GetConfigPath()
}
}
opts = append(opts, WithConfigPath(path))
return func() (interfaces.NodeMasterService, error) {
return NewMasterService(opts...)
}
}
|
2302_79757062/crawlab
|
core/node/service/master_service.go
|
Go
|
bsd-3-clause
| 9,410
|
package service
import (
"errors"
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/grpc/server"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/common"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/core/notification"
"github.com/crawlab-team/crawlab/core/schedule"
"github.com/crawlab-team/crawlab/core/spider/admin"
"github.com/crawlab-team/crawlab/core/system"
"github.com/crawlab-team/crawlab/core/task/handler"
"github.com/crawlab-team/crawlab/core/task/scheduler"
"github.com/crawlab-team/crawlab/core/utils"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"sync"
"time"
)
type MasterServiceV2 struct {
// dependencies
cfgSvc interfaces.NodeConfigService
server *server.GrpcServerV2
schedulerSvc *scheduler.ServiceV2
handlerSvc *handler.ServiceV2
scheduleSvc *schedule.ServiceV2
notificationSvc *notification.Service
spiderAdminSvc *admin.ServiceV2
systemSvc *system.Service
// settings
cfgPath string
address interfaces.Address
monitorInterval time.Duration
stopOnError bool
}
func (svc *MasterServiceV2) Init() (err error) {
// do nothing
return nil
}
func (svc *MasterServiceV2) Start() {
// create indexes
common.CreateIndexes()
// start grpc server
if err := svc.server.Start(); err != nil {
panic(err)
}
// register to db
if err := svc.Register(); err != nil {
panic(err)
}
// start monitoring worker nodes
go svc.Monitor()
// start task handler
go svc.handlerSvc.Start()
// start task scheduler
go svc.schedulerSvc.Start()
// start schedule service
go svc.scheduleSvc.Start()
// start notification service
go svc.notificationSvc.Start()
// start spider admin service
go svc.spiderAdminSvc.Start()
// wait for quit signal
svc.Wait()
// stop
svc.Stop()
}
func (svc *MasterServiceV2) Wait() {
utils.DefaultWait()
}
func (svc *MasterServiceV2) Stop() {
_ = svc.server.Stop()
log.Infof("master[%s] service has stopped", svc.GetConfigService().GetNodeKey())
}
func (svc *MasterServiceV2) Monitor() {
log.Infof("master[%s] monitoring started", svc.GetConfigService().GetNodeKey())
for {
if err := svc.monitor(); err != nil {
trace.PrintError(err)
if svc.stopOnError {
log.Errorf("master[%s] monitor error, now stopping...", svc.GetConfigService().GetNodeKey())
svc.Stop()
return
}
}
time.Sleep(svc.monitorInterval)
}
}
func (svc *MasterServiceV2) GetConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *MasterServiceV2) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *MasterServiceV2) SetConfigPath(path string) {
svc.cfgPath = path
}
func (svc *MasterServiceV2) GetAddress() (address interfaces.Address) {
return svc.address
}
func (svc *MasterServiceV2) SetAddress(address interfaces.Address) {
svc.address = address
}
func (svc *MasterServiceV2) SetMonitorInterval(duration time.Duration) {
svc.monitorInterval = duration
}
func (svc *MasterServiceV2) Register() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
nodeName := svc.GetConfigService().GetNodeName()
node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil && err.Error() == mongo2.ErrNoDocuments.Error() {
// not exists
log.Infof("master[%s] does not exist in db", nodeKey)
node := models.NodeV2{
Key: nodeKey,
Name: nodeName,
MaxRunners: config.DefaultConfigOptions.MaxRunners,
IsMaster: true,
Status: constants.NodeStatusOnline,
Enabled: true,
Active: true,
ActiveAt: time.Now(),
}
node.SetCreated(primitive.NilObjectID)
node.SetUpdated(primitive.NilObjectID)
id, err := service.NewModelServiceV2[models.NodeV2]().InsertOne(node)
if err != nil {
return err
}
log.Infof("added master[%s] in db. id: %s", nodeKey, id.Hex())
return nil
} else if err == nil {
// exists
log.Infof("master[%s] exists in db", nodeKey)
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}
log.Infof("updated master[%s] in db. id: %s", nodeKey, node.Id.Hex())
return nil
} else {
// error
return err
}
}
func (svc *MasterServiceV2) StopOnError() {
svc.stopOnError = true
}
func (svc *MasterServiceV2) GetServer() (svr interfaces.GrpcServer) {
return svc.server
}
func (svc *MasterServiceV2) monitor() (err error) {
// update master node status in db
if err := svc.updateMasterNodeStatus(); err != nil {
if err.Error() == mongo2.ErrNoDocuments.Error() {
return nil
}
return err
}
// all worker nodes
workerNodes, err := svc.getAllWorkerNodes()
if err != nil {
return err
}
// iterate all worker nodes
wg := sync.WaitGroup{}
wg.Add(len(workerNodes))
for _, n := range workerNodes {
go func(n *models.NodeV2) {
// subscribe
ok := svc.subscribeNode(n)
if !ok {
go svc.setWorkerNodeOffline(n)
wg.Done()
return
}
// ping client
ok = svc.pingNodeClient(n)
if !ok {
go svc.setWorkerNodeOffline(n)
wg.Done()
return
}
// update node available runners
if err := svc.updateNodeAvailableRunners(n); err != nil {
trace.PrintError(err)
wg.Done()
return
}
// done
wg.Done()
}(&n)
}
wg.Wait()
return nil
}
func (svc *MasterServiceV2) getAllWorkerNodes() (nodes []models.NodeV2, err error) {
query := bson.M{
"key": bson.M{"$ne": svc.cfgSvc.GetNodeKey()}, // not self
"active": true, // active
}
nodes, err = service.NewModelServiceV2[models.NodeV2]().GetMany(query, nil)
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
return nil, nil
}
return nil, trace.TraceError(err)
}
return nodes, nil
}
func (svc *MasterServiceV2) updateMasterNodeStatus() (err error) {
nodeKey := svc.GetConfigService().GetNodeKey()
node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil {
return err
}
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}
return nil
}
func (svc *MasterServiceV2) setWorkerNodeOffline(node *models.NodeV2) {
node.Status = constants.NodeStatusOffline
node.Active = false
err := backoff.Retry(func() error {
return service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
}, backoff.WithMaxRetries(backoff.NewConstantBackOff(1*time.Second), 3))
if err != nil {
trace.PrintError(err)
}
}
func (svc *MasterServiceV2) subscribeNode(n *models.NodeV2) (ok bool) {
_, err := svc.server.GetSubscribe("node:" + n.Key)
if err != nil {
log.Errorf("cannot subscribe worker node[%s]: %v", n.Key, err)
return false
}
return true
}
func (svc *MasterServiceV2) pingNodeClient(n *models.NodeV2) (ok bool) {
if err := svc.server.SendStreamMessage("node:"+n.Key, grpc.StreamMessageCode_PING); err != nil {
log.Errorf("cannot ping worker node client[%s]: %v", n.Key, err)
return false
}
return true
}
func (svc *MasterServiceV2) updateNodeAvailableRunners(node *models.NodeV2) (err error) {
query := bson.M{
"node_id": node.Id,
"status": constants.TaskStatusRunning,
}
runningTasksCount, err := service.NewModelServiceV2[models.TaskV2]().Count(query)
if err != nil {
return trace.TraceError(err)
}
node.AvailableRunners = node.MaxRunners - runningTasksCount
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return err
}
return nil
}
func NewMasterServiceV2() (res interfaces.NodeMasterService, err error) {
// master service
svc := &MasterServiceV2{
cfgPath: config2.GetConfigPath(),
monitorInterval: 15 * time.Second,
stopOnError: false,
}
// server options
var serverOpts []server.Option
if svc.address != nil {
serverOpts = append(serverOpts, server.WithAddress(svc.address))
}
// dependency injection
if err := container.GetContainer().Invoke(func(
cfgSvc interfaces.NodeConfigService,
) {
svc.cfgSvc = cfgSvc
}); err != nil {
return nil, err
}
// grpc server
svc.server, err = server.GetGrpcServerV2()
if err != nil {
return nil, err
}
// scheduler service
svc.schedulerSvc, err = scheduler.GetTaskSchedulerServiceV2()
if err != nil {
return nil, err
}
// handler service
svc.handlerSvc, err = handler.GetTaskHandlerServiceV2()
if err != nil {
return nil, err
}
// schedule service
svc.scheduleSvc, err = schedule.GetScheduleServiceV2()
if err != nil {
return nil, err
}
// notification service
svc.notificationSvc = notification.GetService()
// spider admin service
svc.spiderAdminSvc, err = admin.GetSpiderAdminServiceV2()
if err != nil {
return nil, err
}
// system service
svc.systemSvc = system.GetService()
// init
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
|
2302_79757062/crawlab
|
core/node/service/master_service_v2.go
|
Go
|
bsd-3-clause
| 9,601
|
package service
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Option func(svc interfaces.NodeService)
func WithConfigPath(path string) Option {
return func(svc interfaces.NodeService) {
svc.SetConfigPath(path)
}
}
func WithAddress(address interfaces.Address) Option {
return func(svc interfaces.NodeService) {
svc.SetAddress(address)
}
}
func WithMonitorInterval(duration time.Duration) Option {
return func(svc interfaces.NodeService) {
svc2, ok := svc.(interfaces.NodeMasterService)
if ok {
svc2.SetMonitorInterval(duration)
}
}
}
func WithStopOnError() Option {
return func(svc interfaces.NodeService) {
svc2, ok := svc.(interfaces.NodeMasterService)
if ok {
svc2.StopOnError()
}
}
}
func WithHeartbeatInterval(duration time.Duration) Option {
return func(svc interfaces.NodeService) {
svc2, ok := svc.(interfaces.NodeWorkerService)
if ok {
svc2.SetHeartbeatInterval(duration)
}
}
}
|
2302_79757062/crawlab
|
core/node/service/options.go
|
Go
|
bsd-3-clause
| 963
|
package service
import (
"context"
"encoding/json"
"github.com/apex/log"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/container"
"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"
"time"
)
type WorkerService struct {
// dependencies
cfgSvc interfaces.NodeConfigService
client interfaces.GrpcClient
handlerSvc interfaces.TaskHandlerService
// settings
cfgPath string
address interfaces.Address
heartbeatInterval time.Duration
// internals
n interfaces.Node
s grpc.NodeService_SubscribeClient
}
func (svc *WorkerService) Init() (err error) {
// do nothing
return nil
}
func (svc *WorkerService) Start() {
// start grpc client
if err := svc.client.Start(); err != nil {
panic(err)
}
// register to master
svc.Register()
// start receiving stream messages
go svc.Recv()
// start sending heartbeat to master
go svc.ReportStatus()
// start handler
go svc.handlerSvc.Start()
// wait for quit signal
svc.Wait()
// stop
svc.Stop()
}
func (svc *WorkerService) Wait() {
utils.DefaultWait()
}
func (svc *WorkerService) Stop() {
_ = svc.client.Stop()
log.Infof("worker[%s] service has stopped", svc.cfgSvc.GetNodeKey())
}
func (svc *WorkerService) Register() {
ctx, cancel := svc.client.Context()
defer cancel()
req := svc.client.NewRequest(svc.GetConfigService().GetBasicNodeInfo())
res, err := svc.client.GetNodeClient().Register(ctx, req)
if err != nil {
panic(err)
}
if err := json.Unmarshal(res.Data, svc.n); err != nil {
panic(err)
}
log.Infof("worker[%s] registered to master. id: %s", svc.GetConfigService().GetNodeKey(), svc.n.GetId().Hex())
return
}
func (svc *WorkerService) Recv() {
msgCh := svc.client.GetMessageChannel()
for {
// return if client is closed
if svc.client.IsClosed() {
return
}
// receive message from channel
msg := <-msgCh
// handle message
if err := svc.handleStreamMessage(msg); err != nil {
continue
}
}
}
func (svc *WorkerService) handleStreamMessage(msg *grpc.StreamMessage) (err error) {
log.Debugf("[WorkerService] handle msg: %v", msg)
switch msg.Code {
case grpc.StreamMessageCode_PING:
if _, err := svc.client.GetNodeClient().SendHeartbeat(context.Background(), svc.client.NewRequest(svc.cfgSvc.GetBasicNodeInfo())); err != nil {
return trace.TraceError(err)
}
case grpc.StreamMessageCode_RUN_TASK:
var t models.Task
if err := json.Unmarshal(msg.Data, &t); err != nil {
return trace.TraceError(err)
}
if err := svc.handlerSvc.Run(t.Id); err != nil {
return trace.TraceError(err)
}
case grpc.StreamMessageCode_CANCEL_TASK:
var t models.Task
if err := json.Unmarshal(msg.Data, &t); err != nil {
return trace.TraceError(err)
}
if err := svc.handlerSvc.Cancel(t.Id); err != nil {
return trace.TraceError(err)
}
}
return nil
}
func (svc *WorkerService) ReportStatus() {
for {
// return if client is closed
if svc.client.IsClosed() {
return
}
// report status
svc.reportStatus()
// sleep
time.Sleep(svc.heartbeatInterval)
}
}
func (svc *WorkerService) GetConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *WorkerService) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *WorkerService) SetConfigPath(path string) {
svc.cfgPath = path
}
func (svc *WorkerService) GetAddress() (address interfaces.Address) {
return svc.address
}
func (svc *WorkerService) SetAddress(address interfaces.Address) {
svc.address = address
}
func (svc *WorkerService) SetHeartbeatInterval(duration time.Duration) {
svc.heartbeatInterval = duration
}
func (svc *WorkerService) reportStatus() {
ctx, cancel := context.WithTimeout(context.Background(), svc.heartbeatInterval)
defer cancel()
_, err := svc.client.GetNodeClient().SendHeartbeat(ctx, &grpc.Request{
NodeKey: svc.cfgSvc.GetNodeKey(),
})
if err != nil {
trace.PrintError(err)
}
}
func NewWorkerService(opts ...Option) (res *WorkerService, err error) {
svc := &WorkerService{
cfgPath: config2.GetConfigPath(),
heartbeatInterval: 15 * time.Second,
n: &models.Node{},
}
// apply options
for _, opt := range opts {
opt(svc)
}
// dependency options
var clientOpts []client.Option
if svc.address != nil {
clientOpts = append(clientOpts, client.WithAddress(svc.address))
}
// dependency injection
if err := container.GetContainer().Invoke(func(
cfgSvc interfaces.NodeConfigService,
client interfaces.GrpcClient,
taskHandlerSvc interfaces.TaskHandlerService,
) {
svc.cfgSvc = cfgSvc
svc.client = client
svc.handlerSvc = taskHandlerSvc
}); err != nil {
return nil, err
}
// init
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
func ProvideWorkerService(path string, opts ...Option) func() (interfaces.NodeWorkerService, error) {
// path
if path == "" || path == config2.GetConfigPath() {
if viper.GetString("config.path") != "" {
path = viper.GetString("config.path")
} else {
path = config2.GetConfigPath()
}
}
opts = append(opts, WithConfigPath(path))
return func() (interfaces.NodeWorkerService, error) {
return NewWorkerService(opts...)
}
}
|
2302_79757062/crawlab
|
core/node/service/worker_service.go
|
Go
|
bsd-3-clause
| 5,491
|
package service
import (
"context"
"encoding/json"
"github.com/apex/log"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/container"
"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/task/handler"
"github.com/crawlab-team/crawlab/core/utils"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"time"
)
type WorkerServiceV2 struct {
// dependencies
cfgSvc interfaces.NodeConfigService
client *client.GrpcClientV2
handlerSvc *handler.ServiceV2
// settings
cfgPath string
address interfaces.Address
heartbeatInterval time.Duration
// internals
n interfaces.Node
s grpc.NodeService_SubscribeClient
}
func (svc *WorkerServiceV2) Init() (err error) {
// do nothing
return nil
}
func (svc *WorkerServiceV2) Start() {
// start grpc client
if err := svc.client.Start(); err != nil {
panic(err)
}
// register to master
svc.Register()
// start receiving stream messages
go svc.Recv()
// start sending heartbeat to master
go svc.ReportStatus()
// start handler
go svc.handlerSvc.Start()
// wait for quit signal
svc.Wait()
// stop
svc.Stop()
}
func (svc *WorkerServiceV2) Wait() {
utils.DefaultWait()
}
func (svc *WorkerServiceV2) Stop() {
_ = svc.client.Stop()
log.Infof("worker[%s] service has stopped", svc.cfgSvc.GetNodeKey())
}
func (svc *WorkerServiceV2) Register() {
ctx, cancel := svc.client.Context()
defer cancel()
req := svc.client.NewRequest(svc.GetConfigService().GetBasicNodeInfo())
res, err := svc.client.NodeClient.Register(ctx, req)
if err != nil {
panic(err)
}
if err := json.Unmarshal(res.Data, svc.n); err != nil {
panic(err)
}
log.Infof("worker[%s] registered to master. id: %s", svc.GetConfigService().GetNodeKey(), svc.n.GetId().Hex())
return
}
func (svc *WorkerServiceV2) Recv() {
msgCh := svc.client.GetMessageChannel()
for {
// return if client is closed
if svc.client.IsClosed() {
return
}
// receive message from channel
msg := <-msgCh
// handle message
if err := svc.handleStreamMessage(msg); err != nil {
continue
}
}
}
func (svc *WorkerServiceV2) handleStreamMessage(msg *grpc.StreamMessage) (err error) {
log.Debugf("[WorkerServiceV2] handle msg: %v", msg)
switch msg.Code {
case grpc.StreamMessageCode_PING:
if _, err := svc.client.NodeClient.SendHeartbeat(context.Background(), svc.client.NewRequest(svc.cfgSvc.GetBasicNodeInfo())); err != nil {
return trace.TraceError(err)
}
case grpc.StreamMessageCode_RUN_TASK:
var t models.Task
if err := json.Unmarshal(msg.Data, &t); err != nil {
return trace.TraceError(err)
}
if err := svc.handlerSvc.Run(t.Id); err != nil {
return trace.TraceError(err)
}
case grpc.StreamMessageCode_CANCEL_TASK:
var t models.Task
if err := json.Unmarshal(msg.Data, &t); err != nil {
return trace.TraceError(err)
}
if err := svc.handlerSvc.Cancel(t.Id); err != nil {
return trace.TraceError(err)
}
}
return nil
}
func (svc *WorkerServiceV2) ReportStatus() {
for {
// return if client is closed
if svc.client.IsClosed() {
return
}
// report status
svc.reportStatus()
// sleep
time.Sleep(svc.heartbeatInterval)
}
}
func (svc *WorkerServiceV2) GetConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *WorkerServiceV2) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *WorkerServiceV2) SetConfigPath(path string) {
svc.cfgPath = path
}
func (svc *WorkerServiceV2) GetAddress() (address interfaces.Address) {
return svc.address
}
func (svc *WorkerServiceV2) SetAddress(address interfaces.Address) {
svc.address = address
}
func (svc *WorkerServiceV2) SetHeartbeatInterval(duration time.Duration) {
svc.heartbeatInterval = duration
}
func (svc *WorkerServiceV2) reportStatus() {
ctx, cancel := context.WithTimeout(context.Background(), svc.heartbeatInterval)
defer cancel()
_, err := svc.client.NodeClient.SendHeartbeat(ctx, &grpc.Request{
NodeKey: svc.cfgSvc.GetNodeKey(),
})
if err != nil {
trace.PrintError(err)
}
}
func NewWorkerServiceV2() (res *WorkerServiceV2, err error) {
svc := &WorkerServiceV2{
cfgPath: config2.GetConfigPath(),
heartbeatInterval: 15 * time.Second,
n: &models.Node{},
}
// dependency options
var clientOpts []client.Option
if svc.address != nil {
clientOpts = append(clientOpts, client.WithAddress(svc.address))
}
// dependency injection
if err := container.GetContainer().Invoke(func(
cfgSvc interfaces.NodeConfigService,
) {
svc.cfgSvc = cfgSvc
}); err != nil {
return nil, err
}
// grpc client
svc.client, err = client.NewGrpcClientV2()
if err != nil {
return nil, err
}
// handler service
svc.handlerSvc, err = handler.GetTaskHandlerServiceV2()
if err != nil {
return nil, err
}
// init
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
|
2302_79757062/crawlab
|
core/node/service/worker_service_v2.go
|
Go
|
bsd-3-clause
| 5,095
|
package test
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
service2 "github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/node/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/spf13/viper"
"go.uber.org/dig"
"io/ioutil"
"os"
"path"
"testing"
"time"
)
func init() {
var err error
T, err = NewTest()
if err != nil {
panic(err)
}
}
var T *Test
type Test struct {
DefaultSvc interfaces.NodeMasterService
MasterSvc interfaces.NodeMasterService
WorkerSvc interfaces.NodeWorkerService
MasterSvcMonitor interfaces.NodeMasterService
WorkerSvcMonitor interfaces.NodeWorkerService
ModelSvc service2.ModelService
}
func NewTest() (res *Test, err error) {
// test
t := &Test{}
// recreate config directory path
_ = os.RemoveAll(viper.GetString("metadata"))
_ = os.MkdirAll(viper.GetString("metadata"), os.FileMode(0766))
// master config and settings
masterNodeConfigName := "config-master.json"
masterNodeConfigPath := path.Join(viper.GetString("metadata"), masterNodeConfigName)
if err := ioutil.WriteFile(masterNodeConfigPath, []byte("{\"key\":\"master\",\"is_master\":true}"), os.FileMode(0766)); err != nil {
return nil, err
}
masterHost := "0.0.0.0"
masterPort := "9667"
// worker config and settings
workerNodeConfigName := "config-worker.json"
workerNodeConfigPath := path.Join(viper.GetString("metadata"), workerNodeConfigName)
if err = ioutil.WriteFile(workerNodeConfigPath, []byte("{\"key\":\"worker\",\"is_master\":false}"), os.FileMode(0766)); err != nil {
return nil, err
}
workerHost := "localhost"
workerPort := masterPort
// master for monitor config and settings
masterNodeMonitorConfigName := "config-master-monitor.json"
masterNodeMonitorConfigPath := path.Join(viper.GetString("metadata"), masterNodeMonitorConfigName)
if err := ioutil.WriteFile(masterNodeMonitorConfigPath, []byte("{\"key\":\"master-monitor\",\"is_master\":true}"), os.FileMode(0766)); err != nil {
return nil, err
}
masterMonitorHost := masterHost
masterMonitorPort := "9668"
// worker for monitor config and settings
workerNodeMonitorConfigName := "config-worker-monitor.json"
workerNodeMonitorConfigPath := path.Join(viper.GetString("metadata"), workerNodeMonitorConfigName)
if err := ioutil.WriteFile(workerNodeMonitorConfigPath, []byte("{\"key\":\"worker-monitor\",\"is_master\":false}"), os.FileMode(0766)); err != nil {
return nil, err
}
workerMonitorHost := workerHost
workerMonitorPort := masterMonitorPort
// dependency injection
c := dig.New()
if err := c.Provide(service.ProvideMasterService(
masterNodeConfigPath,
service.WithMonitorInterval(3*time.Second),
service.WithAddress(entity.NewAddress(&entity.AddressOptions{
Host: masterHost,
Port: masterPort,
})),
)); err != nil {
return nil, err
}
if err := c.Provide(service.ProvideWorkerService(
workerNodeConfigPath,
service.WithHeartbeatInterval(1*time.Second),
service.WithAddress(entity.NewAddress(&entity.AddressOptions{
Host: workerHost,
Port: workerPort,
})),
)); err != nil {
return nil, err
}
if err := c.Provide(service2.NewService); err != nil {
return nil, err
}
if err := c.Invoke(func(masterSvc interfaces.NodeMasterService, workerSvc interfaces.NodeWorkerService, modelSvc service2.ModelService) {
t.MasterSvc = masterSvc
t.WorkerSvc = workerSvc
t.ModelSvc = modelSvc
}); err != nil {
return nil, err
}
// default service
t.DefaultSvc, err = service.NewMasterService()
if err != nil {
return nil, err
}
// master and worker for monitor
t.MasterSvcMonitor, err = service.NewMasterService(
service.WithConfigPath(masterNodeMonitorConfigPath),
service.WithAddress(entity.NewAddress(&entity.AddressOptions{
Host: masterMonitorHost,
Port: masterMonitorPort,
})),
service.WithMonitorInterval(3*time.Second),
service.WithStopOnError(),
)
if err != nil {
return nil, err
}
t.WorkerSvcMonitor, err = service.NewWorkerService(
service.WithConfigPath(workerNodeMonitorConfigPath),
service.WithAddress(entity.NewAddress(&entity.AddressOptions{
Host: workerMonitorHost,
Port: workerMonitorPort,
})),
service.WithHeartbeatInterval(1*time.Second),
service.WithStopOnError(),
)
if err != nil {
return nil, err
}
// removed all data in db
_ = t.ModelSvc.DropAll()
// visualize dependencies
if err := utils.VisualizeContainer(c); err != nil {
return nil, err
}
return t, nil
}
func (t *Test) Setup(t2 *testing.T) {
if err := t.ModelSvc.DropAll(); err != nil {
panic(err)
}
_ = os.RemoveAll(viper.GetString("metadata"))
t2.Cleanup(t.Cleanup)
}
func (t *Test) Cleanup() {
if err := t.ModelSvc.DropAll(); err != nil {
panic(err)
}
_ = os.RemoveAll(viper.GetString("metadata"))
}
func (t *Test) StartMasterWorker() {
startMasterWorker()
}
func (t *Test) StopMasterWorker() {
stopMasterWorker()
}
func startMasterWorker() {
go T.MasterSvc.Start()
time.Sleep(1 * time.Second)
go T.WorkerSvc.Start()
time.Sleep(1 * time.Second)
}
func stopMasterWorker() {
go T.MasterSvc.Stop()
time.Sleep(1 * time.Second)
go T.WorkerSvc.Stop()
time.Sleep(1 * time.Second)
}
func startMasterWorkerMonitor() {
go T.MasterSvcMonitor.Start()
time.Sleep(1 * time.Second)
go T.WorkerSvcMonitor.Start()
time.Sleep(1 * time.Second)
}
func stopMasterWorkerMonitor() {
go T.MasterSvcMonitor.Stop()
time.Sleep(1 * time.Second)
go T.WorkerSvcMonitor.Stop()
time.Sleep(1 * time.Second)
}
|
2302_79757062/crawlab
|
core/node/test/base.go
|
Go
|
bsd-3-clause
| 5,561
|
package notification
const (
TypeMail = "mail"
TypeMobile = "mobile"
)
const (
SettingsColName = "notification_settings"
)
|
2302_79757062/crawlab
|
core/notification/constants.go
|
Go
|
bsd-3-clause
| 130
|
package notification
import (
"errors"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/matcornic/hermes/v2"
"gopkg.in/gomail.v2"
"net/mail"
"runtime/debug"
"strconv"
"strings"
)
func SendMail(m *models.NotificationSettingMail, to, cc, title, content string) error {
// theme
theme := new(MailThemeFlat)
// hermes instance
h := hermes.Hermes{
Theme: theme,
Product: hermes.Product{
Logo: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMzAwIiBoZWlnaHQ9IjMwMCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGZpbGw9Im5vbmUiPgogICAgICAgIDxjaXJjbGUgY3g9IjE1MCIgY3k9IjE1MCIgcj0iMTMwIiBmaWxsPSJub25lIiBzdHJva2Utd2lkdGg9IjQwIiBzdHJva2U9IiM0MDllZmYiPgogICAgICAgIDwvY2lyY2xlPgogICAgICAgIDxjaXJjbGUgY3g9IjE1MCIgY3k9IjE1MCIgcj0iMTEwIiBmaWxsPSJ3aGl0ZSI+CiAgICAgICAgPC9jaXJjbGU+CiAgICAgICAgPGNpcmNsZSBjeD0iMTUwIiBjeT0iMTUwIiByPSI3MCIgZmlsbD0iIzQwOWVmZiI+CiAgICAgICAgPC9jaXJjbGU+CiAgICAgICAgPHBhdGggZD0iCiAgICAgICAgICAgIE0gMTUwLDE1MAogICAgICAgICAgICBMIDI4MCwyMjUKICAgICAgICAgICAgQSAxNTAsMTUwIDkwIDAgMCAyODAsNzUKICAgICAgICAgICAgIiBmaWxsPSIjNDA5ZWZmIj4KICAgICAgICA8L3BhdGg+CiAgICA8L2c+Cjwvc3ZnPgo=",
Name: "Crawlab",
Copyright: "© 2024 Crawlab-Team",
},
}
// config
port, _ := strconv.Atoi(m.Port)
password := m.Password // test password: ALWVDPRHBEXOENXD
SMTPUser := m.User
smtpConfig := smtpAuthentication{
Server: m.Server,
Port: port,
SenderEmail: m.SenderEmail,
SenderIdentity: m.SenderIdentity,
SMTPPassword: password,
SMTPUser: SMTPUser,
}
options := sendOptions{
To: to,
Cc: cc,
Subject: title,
}
// add style
content += theme.GetStyle()
// markdown
markdown := hermes.Markdown(content + GetFooter())
// email instance
email := hermes.Email{
Body: hermes.Body{
Signature: "Happy Crawling ☺",
FreeMarkdown: markdown,
},
}
// generate html
html, err := h.GenerateHTML(email)
if err != nil {
log.Errorf(err.Error())
debug.PrintStack()
return err
}
// generate text
text, err := h.GeneratePlainText(email)
if err != nil {
log.Errorf(err.Error())
debug.PrintStack()
return err
}
// send the email
if err := send(smtpConfig, options, html, text); err != nil {
log.Errorf(err.Error())
debug.PrintStack()
return err
}
return nil
}
type smtpAuthentication struct {
Server string
Port int
SenderEmail string
SenderIdentity string
SMTPUser string
SMTPPassword string
}
// sendOptions are options for sending an email
type sendOptions struct {
To string
Subject string
Cc string
}
// send email
func send(smtpConfig smtpAuthentication, options sendOptions, htmlBody string, txtBody string) error {
if smtpConfig.Server == "" {
return errors.New("SMTP server config is empty")
}
if smtpConfig.Port == 0 {
return errors.New("SMTP port config is empty")
}
if smtpConfig.SMTPUser == "" {
return errors.New("SMTP user is empty")
}
if smtpConfig.SenderIdentity == "" {
return errors.New("SMTP sender identity is empty")
}
if smtpConfig.SenderEmail == "" {
return errors.New("SMTP sender email is empty")
}
if options.To == "" {
return errors.New("no receiver emails configured")
}
from := mail.Address{
Name: smtpConfig.SenderIdentity,
Address: smtpConfig.SenderEmail,
}
var toList []string
if strings.Contains(options.To, ";") {
toList = strings.Split(options.To, ";")
// trim space
for i, to := range toList {
toList[i] = strings.TrimSpace(to)
}
} else {
toList = []string{options.To}
}
m := gomail.NewMessage()
m.SetHeader("From", from.String())
m.SetHeader("To", getRecipientList(options.To)...)
m.SetHeader("Subject", options.Subject)
if options.Cc != "" {
m.SetHeader("Cc", getRecipientList(options.Cc)...)
}
m.SetBody("text/plain", txtBody)
m.AddAlternative("text/html", htmlBody)
d := gomail.NewDialer(smtpConfig.Server, smtpConfig.Port, smtpConfig.SMTPUser, smtpConfig.SMTPPassword)
return d.DialAndSend(m)
}
func getRecipientList(value string) (values []string) {
if strings.Contains(value, ";") {
values = strings.Split(value, ";")
// trim space
for i, v := range values {
values[i] = strings.TrimSpace(v)
}
} else {
values = []string{value}
}
return values
}
func GetFooter() string {
return `
[Github](https://github.com/crawlab-team/crawlab) | [Documentation](http://docs.crawlab.cn) | [Docker](https://hub.docker.com/r/tikazyq/crawlab)
`
}
|
2302_79757062/crawlab
|
core/notification/mail.go
|
Go
|
bsd-3-clause
| 4,485
|
package notification
import "github.com/matcornic/hermes/v2"
type MailTheme interface {
hermes.Theme
GetStyle() string
}
|
2302_79757062/crawlab
|
core/notification/mail_theme.go
|
Go
|
bsd-3-clause
| 125
|
package notification
// MailThemeFlat is a theme
type MailThemeFlat struct{}
// Name returns the name of the flat theme
func (dt *MailThemeFlat) Name() string {
return "flat"
}
// HTMLTemplate returns a Golang template that will generate an HTML email.
func (dt *MailThemeFlat) HTMLTemplate() string {
return `
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body dir="{{.Hermes.TextDirection}}">
<table class="email-wrapper" width="100%" cellpadding="0" cellspacing="0">
<tr>
<td class="content">
<table class="email-content" width="100%" cellpadding="0" cellspacing="0">
<!-- Logo -->
<tr>
<td class="email-masthead">
<a class="email-masthead_name" href="{{.Hermes.Product.Link}}" target="_blank">
{{ if .Hermes.Product.Logo }}
<img src="{{.Hermes.Product.Logo | url }}" class="email-logo" style="height: 48px"/>
<span style="font-size:36px;font-weight:600;margin-left:12px;color:#409eff">{{ .Hermes.Product.Name}} </span>
{{ else }}
{{ .Hermes.Product.Name }}
{{ end }}
</a>
</td>
</tr>
<!-- Email Body -->
<tr>
<td class="email-body" width="100%">
<table class="email-body_inner" align="center" width="570" cellpadding="0" cellspacing="0">
<!-- Body content -->
<tr>
<td class="content-cell">
{{ if (ne .Email.Body.FreeMarkdown "") }}
{{ .Email.Body.FreeMarkdown.ToHTML }}
{{ else }}
{{ with .Email.Body.Dictionary }}
{{ if gt (len .) 0 }}
<dl class="body-dictionary">
{{ range $entry := . }}
<dt>{{ $entry.Key }}:</dt>
<dd>{{ $entry.Value }}</dd>
{{ end }}
</dl>
{{ end }}
{{ end }}
<!-- Table -->
{{ with .Email.Body.Table }}
{{ $data := .Data }}
{{ $columns := .Columns }}
{{ if gt (len $data) 0 }}
<table class="data-wrapper" width="100%" cellpadding="0" cellspacing="0">
<tr>
<td colspan="2">
<table class="data-table" width="100%" cellpadding="0" cellspacing="0">
<tr>
{{ $col := index $data 0 }}
{{ range $entry := $col }}
<th
{{ with $columns }}
{{ $width := index .CustomWidth $entry.Key }}
{{ with $width }}
width="{{ . }}"
{{ end }}
{{ $align := index .CustomAlignment $entry.Key }}
{{ with $align }}
style="text-align:{{ . }}"
{{ end }}
{{ end }}
>
<p>{{ $entry.Key }}</p>
</th>
{{ end }}
</tr>
{{ range $row := $data }}
<tr>
{{ range $cell := $row }}
<td
{{ with $columns }}
{{ $align := index .CustomAlignment $cell.Key }}
{{ with $align }}
style="text-align:{{ . }}"
{{ end }}
{{ end }}
>
{{ $cell.Value }}
</td>
{{ end }}
</tr>
{{ end }}
</table>
</td>
</tr>
</table>
{{ end }}
{{ end }}
<!-- Action -->
{{ with .Email.Body.Actions }}
{{ if gt (len .) 0 }}
{{ range $action := . }}
<p>{{ $action.Instructions }}</p>
<table class="body-action" align="center" width="100%" cellpadding="0" cellspacing="0">
<tr>
<td align="center">
<div>
<a href="{{ $action.Button.Link }}" class="button" style="background-color: {{ $action.Button.Color }}; color: {{ $action.Button.TextColor }}" target="_blank">
{{ $action.Button.Text }}
</a>
</div>
</td>
</tr>
</table>
{{ end }}
{{ end }}
{{ end }}
{{ end }}
{{ with .Email.Body.Outros }}
{{ if gt (len .) 0 }}
{{ range $line := . }}
<p>{{ $line }}</p>
{{ end }}
{{ end }}
{{ end }}
<p>
{{.Email.Body.Signature}}
</p>
{{ if (eq .Email.Body.FreeMarkdown "") }}
{{ with .Email.Body.Actions }}
<table class="body-sub">
<tbody>
{{ range $action := . }}
<tr>
<td>
<p class="sub">{{$.Hermes.Product.TroubleText | replace "{ACTION}" $action.Button.Text}}</p>
<p class="sub"><a href="{{ $action.Button.Link }}">{{ $action.Button.Link }}</a></p>
</td>
</tr>
{{ end }}
</tbody>
</table>
{{ end }}
{{ end }}
</td>
</tr>
</table>
</td>
</tr>
<tr>
<td>
<table class="email-footer" align="center" width="570" cellpadding="0" cellspacing="0">
<tr>
<td class="content-cell">
<p class="sub center">
{{.Hermes.Product.Copyright}}
</p>
</td>
</tr>
</table>
</td>
</tr>
</table>
</td>
</tr>
</table>
</body>
</html>
`
}
// PlainTextTemplate returns a Golang template that will generate an plain text email.
func (dt *MailThemeFlat) PlainTextTemplate() string {
return `{{ with .Email.Body.Intros }}
{{ range $line := . }}
<p>{{ $line }}</p>
{{ end }}
{{ end }}
{{ if (ne .Email.Body.FreeMarkdown "") }}
{{ .Email.Body.FreeMarkdown.ToHTML }}
{{ else }}
{{ with .Email.Body.Dictionary }}
<ul>
{{ range $entry := . }}
<li>{{ $entry.Key }}: {{ $entry.Value }}</li>
{{ end }}
</ul>
{{ end }}
{{ with .Email.Body.Table }}
{{ $data := .Data }}
{{ $columns := .Columns }}
{{ if gt (len $data) 0 }}
<table class="data-table" width="100%" cellpadding="0" cellspacing="0">
<tr>
{{ $col := index $data 0 }}
{{ range $entry := $col }}
<th>{{ $entry.Key }} </th>
{{ end }}
</tr>
{{ range $row := $data }}
<tr>
{{ range $cell := $row }}
<td>
{{ $cell.Value }}
</td>
{{ end }}
</tr>
{{ end }}
</table>
{{ end }}
{{ end }}
{{ with .Email.Body.Actions }}
{{ range $action := . }}
<p>{{ $action.Instructions }} {{ $action.Button.Link }}</p>
{{ end }}
{{ end }}
{{ end }}
{{ with .Email.Body.Outros }}
{{ range $line := . }}
<p>{{ $line }}<p>
{{ end }}
{{ end }}
<p>{{.Email.Body.Signature}},<br>{{.Hermes.Product.Name}} - {{.Hermes.Product.Link}}</p>
<p>{{.Hermes.Product.Copyright}}</p>
`
}
func (dt *MailThemeFlat) GetStyle() string {
return `
<style>
.content-cell table {
width: 100%;
border-collapse: collapse;
}
.content-cell table,
.content-cell th,
.content-cell td {
border: 1px solid #EDEFF2;
}
.content-cell th,
.content-cell td {
padding: 10px;
font-size: 14px;
line-height: 18px;
}
.content-cell th {
background: #409eff;
color: white;
}
.content-cell td {
color: #606266;
}
.content-cell p {
color: #606266;
}
.content-cell a {
color: #409eff;
}
.email-masthead .email-masthead_name {
display: flex;
justify-content: center;
align-items: center;
text-decoration: none;
color: #409eff;
margin-bottom: 20px;
}
</style>
`
}
|
2302_79757062/crawlab
|
core/notification/mail_theme_flat.go
|
Go
|
bsd-3-clause
| 10,192
|
package notification
import (
"errors"
"github.com/crawlab-team/crawlab/trace"
"github.com/imroc/req"
"strings"
)
type ResBody struct {
ErrCode int `json:"errcode"`
ErrMsg string `json:"errmsg"`
}
func SendMobileNotification(webhook string, title string, content string) error {
// request header
header := req.Header{
"Content-Type": "application/json; charset=utf-8",
}
// request data
data := req.Param{
"msgtype": "markdown",
"markdown": req.Param{
"title": title,
"text": content,
"content": content,
},
"at": req.Param{
"atMobiles": []string{},
"isAtAll": false,
},
"text": content,
}
if strings.Contains(strings.ToLower(webhook), "feishu") {
data = req.Param{
"msg_type": "text",
"content": req.Param{
"text": content,
},
}
}
// perform request
res, err := req.Post(webhook, header, req.BodyJSON(&data))
if err != nil {
return trace.TraceError(err)
}
// parse response
var resBody ResBody
if err := res.ToJSON(&resBody); err != nil {
return trace.TraceError(err)
}
// validate response code
if resBody.ErrCode != 0 {
return errors.New(resBody.ErrMsg)
}
return nil
}
|
2302_79757062/crawlab
|
core/notification/mobile.go
|
Go
|
bsd-3-clause
| 1,170
|
package notification
import "go.mongodb.org/mongo-driver/bson/primitive"
type NotificationSetting struct {
Id primitive.ObjectID `json:"_id" bson:"_id"`
Type string `json:"type" bson:"type"`
Name string `json:"name" bson:"name"`
Description string `json:"description" bson:"description"`
Enabled bool `json:"enabled" bson:"enabled"`
Global bool `json:"global" bson:"global"`
Title string `json:"title,omitempty" bson:"title,omitempty"`
Template string `json:"template,omitempty" bson:"template,omitempty"`
TaskTrigger string `json:"task_trigger" bson:"task_trigger"`
Mail NotificationSettingMail `json:"mail,omitempty" bson:"mail,omitempty"`
Mobile NotificationSettingMobile `json:"mobile,omitempty" bson:"mobile,omitempty"`
}
type NotificationSettingMail struct {
Server string `json:"server" bson:"server"`
Port string `json:"port,omitempty" bson:"port,omitempty"`
User string `json:"user,omitempty" bson:"user,omitempty"`
Password string `json:"password,omitempty" bson:"password,omitempty"`
SenderEmail string `json:"sender_email,omitempty" bson:"sender_email,omitempty"`
SenderIdentity string `json:"sender_identity,omitempty" bson:"sender_identity,omitempty"`
To string `json:"to,omitempty" bson:"to,omitempty"`
Cc string `json:"cc,omitempty" bson:"cc,omitempty"`
}
type NotificationSettingMobile struct {
Webhook string `json:"webhook" bson:"webhook"`
}
|
2302_79757062/crawlab
|
core/notification/models.go
|
Go
|
bsd-3-clause
| 1,664
|
package notification
import "go.mongodb.org/mongo-driver/bson/primitive"
type SendPayload struct {
TaskId primitive.ObjectID `json:"task_id"`
Data string `json:"data"`
}
|
2302_79757062/crawlab
|
core/notification/payload.go
|
Go
|
bsd-3-clause
| 188
|
package notification
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
mongo2 "github.com/crawlab-team/crawlab/db/mongo"
parser "github.com/crawlab-team/crawlab/template-parser"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
)
type Service struct {
col *mongo2.Col // notification settings
modelSvc service.ModelService
}
func (svc *Service) Init() (err error) {
if !utils.IsPro() {
return nil
}
return nil
}
func (svc *Service) Start() (err error) {
// initialize data
if err := svc.initData(); err != nil {
return err
}
return nil
}
func (svc *Service) Stop() (err error) {
return nil
}
func (svc *Service) initData() (err error) {
total, err := svc.col.Count(nil)
if err != nil {
return err
}
if total > 0 {
return nil
}
// data to initialize
settings := []NotificationSetting{
{
Id: primitive.NewObjectID(),
Type: TypeMail,
Enabled: true,
Name: "任务通知（邮件）",
Description: "这是默认的邮件通知。您可以使用您自己的设置进行编辑。",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] 爬虫任务更新: {{$.status}}",
Template: `尊敬的 {{$.user.username}},
请查看下面的任务数据。
|键|值|
|:-:|:--|
|任务状态|{{$.status}}|
|任务优先级|{{$.priority}}|
|任务模式|{{$.mode}}|
|执行命令|{{$.cmd}}|
|执行参数|{{$.param}}|
|错误信息|{{$.error}}|
|节点|{{$.node.name}}|
|爬虫|{{$.spider.name}}|
|项目|{{$.spider.project.name}}|
|定时任务|{{$.schedule.name}}|
|结果数|{{$.:task_stat.result_count}}|
|等待时间（秒）|{#{{$.:task_stat.wait_duration}}/1000#}|
|运行时间（秒）|{#{{$.:task_stat.runtime_duration}}/1000#}|
|总时间（秒）|{#{{$.:task_stat.total_duration}}/1000#}|
|平均结果数/秒|{#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}|
`,
Mail: NotificationSettingMail{
Server: "smtp.163.com",
Port: "465",
To: "{{$.user[create].email}}",
},
},
{
Id: primitive.NewObjectID(),
Type: TypeMail,
Enabled: true,
Name: "Task Change (Mail)",
Description: "This is the default mail notification. You can edit it with your own settings",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] Task Update: {{$.status}}",
Template: `Dear {{$.user.username}},
Please find the task data as below.
|Key|Value|
|:-:|:--|
|Task Status|{{$.status}}|
|Task Priority|{{$.priority}}|
|Task Mode|{{$.mode}}|
|Task Command|{{$.cmd}}|
|Task Params|{{$.param}}|
|Error Message|{{$.error}}|
|Node|{{$.node.name}}|
|Spider|{{$.spider.name}}|
|Project|{{$.spider.project.name}}|
|Schedule|{{$.schedule.name}}|
|Result Count|{{$.:task_stat.result_count}}|
|Wait Duration (sec)|{#{{$.:task_stat.wait_duration}}/1000#}|
|Runtime Duration (sec)|{#{{$.:task_stat.runtime_duration}}/1000#}|
|Total Duration (sec)|{#{{$.:task_stat.total_duration}}/1000#}|
|Avg Results / Sec|{#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}|
`,
Mail: NotificationSettingMail{
Server: "smtp.163.com",
Port: "465",
To: "{{$.user[create].email}}",
},
},
{
Id: primitive.NewObjectID(),
Type: TypeMobile,
Enabled: true,
Name: "任务通知（移动端）",
Description: "这是默认的手机通知。您可以使用您自己的设置进行编辑。",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] 任务更新: {{$.status}}",
Template: `尊敬的 {{$.user.username}},
请查看下面的任务数据。
- **任务状态**: {{$.status}}
- **任务优先级**: {{$.priority}}
- **任务模式**: {{$.mode}}
- **执行命令**: {{$.cmd}}
- **执行参数**: {{$.param}}
- **错误信息**: {{$.error}}
- **节点**: {{$.node.name}}
- **爬虫**: {{$.spider.name}}
- **项目**: {{$.spider.project.name}}
- **定时任务**: {{$.schedule.name}}
- **结果数**: {{$.:task_stat.result_count}}
- **等待时间（秒）**: {#{{$.:task_stat.wait_duration}}/1000#}
- **运行时间（秒）**: {#{{$.:task_stat.runtime_duration}}/1000#}
- **总时间（秒）**: {#{{$.:task_stat.total_duration}}/1000#}
- **平均结果数/秒**: {#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}`,
Mobile: NotificationSettingMobile{},
},
{
Id: primitive.NewObjectID(),
Type: TypeMobile,
Enabled: true,
Name: "Task Change (Mobile)",
Description: "This is the default mobile notification. You can edit it with your own settings",
TaskTrigger: constants.NotificationTriggerTaskError,
Title: "[Crawlab] Task Update: {{$.status}}",
Template: `Dear {{$.user.username}},
Please find the task data as below.
- **Task Status**: {{$.status}}
- **Task Priority**: {{$.priority}}
- **Task Mode**: {{$.mode}}
- **Task Command**: {{$.cmd}}
- **Task Params**: {{$.param}}
- **Error Message**: {{$.error}}
- **Node**: {{$.node.name}}
- **Spider**: {{$.spider.name}}
- **Project**: {{$.spider.project.name}}
- **Schedule**: {{$.schedule.name}}
- **Result Count**: {{$.:task_stat.result_count}}
- **Wait Duration (sec)**: {#{{$.:task_stat.wait_duration}}/1000#}
- **Runtime Duration (sec)**: {#{{$.:task_stat.runtime_duration}}/1000#}
- **Total Duration (sec)**: {#{{$.:task_stat.total_duration}}/1000#}
- **Avg Results / Sec**: {#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}`,
Mobile: NotificationSettingMobile{},
},
}
var data []interface{}
for _, s := range settings {
data = append(data, s)
}
_, err = svc.col.InsertMany(data)
if err != nil {
return err
}
return nil
}
func (svc *Service) Send(s NotificationSetting, entity bson.M) (err error) {
switch s.Type {
case TypeMail:
return svc.SendMail(s, entity)
case TypeMobile:
return svc.SendMobile(s, entity)
}
return nil
}
func (svc *Service) SendMail(s NotificationSetting, entity bson.M) (err error) {
// to
to, err := parser.Parse(s.Mail.To, entity)
if err != nil {
log.Warnf("parsing 'to' error: %v", err)
}
if to == "" {
return nil
}
// cc
cc, err := parser.Parse(s.Mail.Cc, entity)
if err != nil {
log.Warnf("parsing 'cc' error: %v", err)
}
// title
title, err := parser.Parse(s.Title, entity)
if err != nil {
log.Warnf("parsing 'title' error: %v", err)
}
// content
content, err := parser.Parse(s.Template, entity)
if err != nil {
log.Warnf("parsing 'content' error: %v", err)
}
// send mail
if err := SendMail(&models.NotificationSettingMail{
Server: s.Mail.Server,
Port: s.Mail.Port,
User: s.Mail.User,
Password: s.Mail.Password,
SenderEmail: s.Mail.SenderEmail,
SenderIdentity: s.Mail.SenderIdentity,
To: s.Mail.To,
Cc: s.Mail.Cc,
}, to, cc, title, content); err != nil {
return err
}
return nil
}
func (svc *Service) SendMobile(s NotificationSetting, entity bson.M) (err error) {
// webhook
webhook, err := parser.Parse(s.Mobile.Webhook, entity)
if err != nil {
log.Warnf("parsing 'webhook' error: %v", err)
}
if webhook == "" {
return nil
}
// title
title, err := parser.Parse(s.Title, entity)
if err != nil {
log.Warnf("parsing 'title' error: %v", err)
}
// content
content, err := parser.Parse(s.Template, entity)
if err != nil {
log.Warnf("parsing 'content' error: %v", err)
}
// send
if err := SendMobileNotification(webhook, title, content); err != nil {
return err
}
return nil
}
func (svc *Service) GetSettingList(query bson.M, pagination *entity.Pagination, sort bson.D) (res []NotificationSetting, total int, err error) {
// options
var options *mongo2.FindOptions
if pagination != nil || sort != nil {
options = new(mongo2.FindOptions)
if pagination != nil {
options.Skip = pagination.Size * (pagination.Page - 1)
options.Limit = pagination.Size
}
if sort != nil {
options.Sort = sort
}
}
// get list
var list []NotificationSetting
if err := svc.col.Find(query, options).All(&list); err != nil {
if err.Error() == mongo.ErrNoDocuments.Error() {
return nil, 0, nil
} else {
return nil, 0, err
}
}
// total count
total, err = svc.col.Count(query)
if err != nil {
return nil, 0, err
}
return list, total, nil
}
func (svc *Service) GetSetting(id primitive.ObjectID) (res *NotificationSetting, err error) {
var s NotificationSetting
if err := svc.col.FindId(id).One(&s); err != nil {
return nil, err
}
return &s, nil
}
func (svc *Service) PosSetting(s *NotificationSetting) (err error) {
s.Id = primitive.NewObjectID()
if _, err := svc.col.Insert(s); err != nil {
return err
}
return nil
}
func (svc *Service) PutSetting(id primitive.ObjectID, s NotificationSetting) (err error) {
if err := svc.col.ReplaceId(id, s); err != nil {
return err
}
return nil
}
func (svc *Service) DeleteSetting(id primitive.ObjectID) (err error) {
if err := svc.col.DeleteId(id); err != nil {
return err
}
return nil
}
func (svc *Service) EnableSetting(id primitive.ObjectID) (err error) {
return svc._toggleSettingFunc(true)(id)
}
func (svc *Service) DisableSetting(id primitive.ObjectID) (err error) {
return svc._toggleSettingFunc(false)(id)
}
func (svc *Service) _toggleSettingFunc(value bool) func(id primitive.ObjectID) error {
return func(id primitive.ObjectID) (err error) {
var s NotificationSetting
if err := svc.col.FindId(id).One(&s); err != nil {
return err
}
s.Enabled = value
if err := svc.col.ReplaceId(id, s); err != nil {
return err
}
return nil
}
}
func NewService() *Service {
// service
svc := &Service{
col: mongo2.GetMongoCol(SettingsColName),
}
// model service
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
svc.modelSvc = modelSvc
if err := svc.Init(); err != nil {
panic(err)
}
return svc
}
var _service *Service
func GetService() *Service {
if _service == nil {
_service = NewService()
}
return _service
}
|
2302_79757062/crawlab
|
core/notification/service.go
|
Go
|
bsd-3-clause
| 10,340
|
package notification
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
mongo2 "github.com/crawlab-team/crawlab/db/mongo"
parser "github.com/crawlab-team/crawlab/template-parser"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
)
type ServiceV2 struct {
}
func (svc *ServiceV2) Start() (err error) {
// initialize data
if err := svc.initData(); err != nil {
return err
}
return nil
}
func (svc *ServiceV2) Stop() (err error) {
return nil
}
func (svc *ServiceV2) initData() (err error) {
total, err := service.NewModelServiceV2[models.NotificationSettingV2]().Count(nil)
if err != nil {
return err
}
if total > 0 {
return nil
}
// data to initialize
settings := []models.NotificationSettingV2{
{
Id: primitive.NewObjectID(),
Type: TypeMail,
Enabled: true,
Name: "任务通知（邮件）",
Description: "这是默认的邮件通知。您可以使用您自己的设置进行编辑。",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] 爬虫任务更新: {{$.status}}",
Template: `尊敬的 {{$.user.username}},
请查看下面的任务数据。
|键|值|
|:-:|:--|
|任务状态|{{$.status}}|
|任务优先级|{{$.priority}}|
|任务模式|{{$.mode}}|
|执行命令|{{$.cmd}}|
|执行参数|{{$.param}}|
|错误信息|{{$.error}}|
|节点|{{$.node.name}}|
|爬虫|{{$.spider.name}}|
|项目|{{$.spider.project.name}}|
|定时任务|{{$.schedule.name}}|
|结果数|{{$.:task_stat.result_count}}|
|等待时间（秒）|{#{{$.:task_stat.wait_duration}}/1000#}|
|运行时间（秒）|{#{{$.:task_stat.runtime_duration}}/1000#}|
|总时间（秒）|{#{{$.:task_stat.total_duration}}/1000#}|
|平均结果数/秒|{#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}|
`,
Mail: models.NotificationSettingMail{
Server: "smtp.163.com",
Port: "465",
To: "{{$.user[create].email}}",
},
},
{
Id: primitive.NewObjectID(),
Type: TypeMail,
Enabled: true,
Name: "Task Change (Mail)",
Description: "This is the default mail notification. You can edit it with your own settings",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] Task Update: {{$.status}}",
Template: `Dear {{$.user.username}},
Please find the task data as below.
|Key|Value|
|:-:|:--|
|Task Status|{{$.status}}|
|Task Priority|{{$.priority}}|
|Task Mode|{{$.mode}}|
|Task Command|{{$.cmd}}|
|Task Params|{{$.param}}|
|Error Message|{{$.error}}|
|Node|{{$.node.name}}|
|Spider|{{$.spider.name}}|
|Project|{{$.spider.project.name}}|
|Schedule|{{$.schedule.name}}|
|Result Count|{{$.:task_stat.result_count}}|
|Wait Duration (sec)|{#{{$.:task_stat.wait_duration}}/1000#}|
|Runtime Duration (sec)|{#{{$.:task_stat.runtime_duration}}/1000#}|
|Total Duration (sec)|{#{{$.:task_stat.total_duration}}/1000#}|
|Avg Results / Sec|{#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}|
`,
Mail: models.NotificationSettingMail{
Server: "smtp.163.com",
Port: "465",
To: "{{$.user[create].email}}",
},
},
{
Id: primitive.NewObjectID(),
Type: TypeMobile,
Enabled: true,
Name: "任务通知（移动端）",
Description: "这是默认的手机通知。您可以使用您自己的设置进行编辑。",
TaskTrigger: constants.NotificationTriggerTaskFinish,
Title: "[Crawlab] 任务更新: {{$.status}}",
Template: `尊敬的 {{$.user.username}},
请查看下面的任务数据。
- **任务状态**: {{$.status}}
- **任务优先级**: {{$.priority}}
- **任务模式**: {{$.mode}}
- **执行命令**: {{$.cmd}}
- **执行参数**: {{$.param}}
- **错误信息**: {{$.error}}
- **节点**: {{$.node.name}}
- **爬虫**: {{$.spider.name}}
- **项目**: {{$.spider.project.name}}
- **定时任务**: {{$.schedule.name}}
- **结果数**: {{$.:task_stat.result_count}}
- **等待时间（秒）**: {#{{$.:task_stat.wait_duration}}/1000#}
- **运行时间（秒）**: {#{{$.:task_stat.runtime_duration}}/1000#}
- **总时间（秒）**: {#{{$.:task_stat.total_duration}}/1000#}
- **平均结果数/秒**: {#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}`,
Mobile: models.NotificationSettingMobile{},
},
{
Id: primitive.NewObjectID(),
Type: TypeMobile,
Enabled: true,
Name: "Task Change (Mobile)",
Description: "This is the default mobile notification. You can edit it with your own settings",
TaskTrigger: constants.NotificationTriggerTaskError,
Title: "[Crawlab] Task Update: {{$.status}}",
Template: `Dear {{$.user.username}},
Please find the task data as below.
- **Task Status**: {{$.status}}
- **Task Priority**: {{$.priority}}
- **Task Mode**: {{$.mode}}
- **Task Command**: {{$.cmd}}
- **Task Params**: {{$.param}}
- **Error Message**: {{$.error}}
- **Node**: {{$.node.name}}
- **Spider**: {{$.spider.name}}
- **Project**: {{$.spider.project.name}}
- **Schedule**: {{$.schedule.name}}
- **Result Count**: {{$.:task_stat.result_count}}
- **Wait Duration (sec)**: {#{{$.:task_stat.wait_duration}}/1000#}
- **Runtime Duration (sec)**: {#{{$.:task_stat.runtime_duration}}/1000#}
- **Total Duration (sec)**: {#{{$.:task_stat.total_duration}}/1000#}
- **Avg Results / Sec**: {#{{$.:task_stat.result_count}}/({{$.:task_stat.total_duration}}/1000)#}`,
Mobile: models.NotificationSettingMobile{},
},
}
_, err = service.NewModelServiceV2[models.NotificationSettingV2]().InsertMany(settings)
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) Send(s *models.NotificationSettingV2, entity bson.M) (err error) {
switch s.Type {
case TypeMail:
return svc.SendMail(s, entity)
case TypeMobile:
return svc.SendMobile(s, entity)
}
return nil
}
func (svc *ServiceV2) SendMail(s *models.NotificationSettingV2, entity bson.M) (err error) {
// to
to, err := parser.Parse(s.Mail.To, entity)
if err != nil {
log.Warnf("parsing 'to' error: %v", err)
}
if to == "" {
return nil
}
// cc
cc, err := parser.Parse(s.Mail.Cc, entity)
if err != nil {
log.Warnf("parsing 'cc' error: %v", err)
}
// title
title, err := parser.Parse(s.Title, entity)
if err != nil {
log.Warnf("parsing 'title' error: %v", err)
}
// content
content, err := parser.Parse(s.Template, entity)
if err != nil {
log.Warnf("parsing 'content' error: %v", err)
}
// send mail
if err := SendMail(&s.Mail, to, cc, title, content); err != nil {
return err
}
return nil
}
func (svc *ServiceV2) SendMobile(s *models.NotificationSettingV2, entity bson.M) (err error) {
// webhook
webhook, err := parser.Parse(s.Mobile.Webhook, entity)
if err != nil {
log.Warnf("parsing 'webhook' error: %v", err)
}
if webhook == "" {
return nil
}
// title
title, err := parser.Parse(s.Title, entity)
if err != nil {
log.Warnf("parsing 'title' error: %v", err)
}
// content
content, err := parser.Parse(s.Template, entity)
if err != nil {
log.Warnf("parsing 'content' error: %v", err)
}
// send
if err := SendMobileNotification(webhook, title, content); err != nil {
return err
}
return nil
}
func (svc *ServiceV2) GetSettingList(query bson.M, pagination *entity.Pagination, sort bson.D) (res []models.NotificationSettingV2, total int, err error) {
// options
var options *mongo2.FindOptions
if pagination != nil || sort != nil {
options = new(mongo2.FindOptions)
if pagination != nil {
options.Skip = pagination.Size * (pagination.Page - 1)
options.Limit = pagination.Size
}
if sort != nil {
options.Sort = sort
}
}
// get list
list, err := service.NewModelServiceV2[models.NotificationSettingV2]().GetMany(query, options)
if err != nil {
if err.Error() == mongo.ErrNoDocuments.Error() {
return nil, 0, nil
} else {
return nil, 0, err
}
}
// total count
total, err = service.NewModelServiceV2[models.NotificationSettingV2]().Count(query)
if err != nil {
return nil, 0, err
}
return list, total, nil
}
func (svc *ServiceV2) GetSetting(id primitive.ObjectID) (res *models.NotificationSettingV2, err error) {
s, err := service.NewModelServiceV2[models.NotificationSettingV2]().GetById(id)
if err != nil {
return nil, err
}
return s, nil
}
func (svc *ServiceV2) PosSetting(s *models.NotificationSettingV2) (err error) {
s.Id = primitive.NewObjectID()
_, err = service.NewModelServiceV2[models.NotificationSettingV2]().InsertOne(*s)
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) PutSetting(id primitive.ObjectID, s models.NotificationSettingV2) (err error) {
err = service.NewModelServiceV2[models.NotificationSettingV2]().ReplaceById(id, s)
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) DeleteSetting(id primitive.ObjectID) (err error) {
err = service.NewModelServiceV2[models.NotificationSettingV2]().DeleteById(id)
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) EnableSetting(id primitive.ObjectID) (err error) {
return svc._toggleSettingFunc(true)(id)
}
func (svc *ServiceV2) DisableSetting(id primitive.ObjectID) (err error) {
return svc._toggleSettingFunc(false)(id)
}
func (svc *ServiceV2) _toggleSettingFunc(value bool) func(id primitive.ObjectID) error {
return func(id primitive.ObjectID) (err error) {
s, err := service.NewModelServiceV2[models.NotificationSettingV2]().GetById(id)
if err != nil {
return err
}
s.Enabled = value
err = service.NewModelServiceV2[models.NotificationSettingV2]().ReplaceById(id, *s)
if err != nil {
return err
}
return nil
}
}
func NewServiceV2() *ServiceV2 {
// service
svc := &ServiceV2{}
return svc
}
var _serviceV2 *ServiceV2
func GetServiceV2() *ServiceV2 {
if _serviceV2 == nil {
_serviceV2 = NewServiceV2()
}
return _serviceV2
}
|
2302_79757062/crawlab
|
core/notification/service_v2.go
|
Go
|
bsd-3-clause
| 10,100
|
package process
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/sys_exec"
"github.com/crawlab-team/crawlab/trace"
"math/rand"
"os/exec"
"time"
)
const (
SignalCreate = iota
SignalStart
SignalStopped
SignalError
SignalExited
SignalReachedMaxErrors
)
type Daemon struct {
// settings
maxErrors int
exitTimeout time.Duration
// internals
errors int
errMsg string
exitCode int
newCmdFn func() *exec.Cmd
cmd *exec.Cmd
stopped bool
ch chan int
}
func (d *Daemon) Start() (err error) {
go d.handleSignal()
for {
// command
d.cmd = d.newCmdFn()
d.ch <- SignalCreate
// attempt to run
_ = d.cmd.Start()
d.ch <- SignalStart
if err := d.cmd.Wait(); err != nil {
// stopped
d.ch <- SignalStopped
if d.stopped {
log.Infof("daemon stopped")
return nil
}
// error
d.ch <- SignalError
d.errMsg = err.Error()
trace.PrintError(err)
}
// exited
d.ch <- SignalExited
// exit code
d.exitCode = d.cmd.ProcessState.ExitCode()
// check exit code
if d.exitCode == 0 {
log.Infof("process exited with code 0")
return
}
// error message
d.errMsg = errors.ErrorProcessDaemonProcessExited.Error()
// increment errors
d.errors++
// validate if error count exceeds max errors
if d.errors >= d.maxErrors {
log.Infof("reached max errors: %d", d.maxErrors)
d.ch <- SignalReachedMaxErrors
return errors.ErrorProcessReachedMaxErrors
}
// re-attempt
waitSec := rand.Intn(5)
log.Infof("re-attempt to start process in %d seconds...", waitSec)
time.Sleep(time.Duration(waitSec) * time.Second)
}
}
func (d *Daemon) Stop() {
d.stopped = true
opts := &sys_exec.KillProcessOptions{
Timeout: d.exitTimeout,
Force: false,
}
_ = sys_exec.KillProcess(d.cmd, opts)
}
func (d *Daemon) GetMaxErrors() (maxErrors int) {
return d.maxErrors
}
func (d *Daemon) SetMaxErrors(maxErrors int) {
d.maxErrors = maxErrors
}
func (d *Daemon) GetExitTimeout() (timeout time.Duration) {
return d.exitTimeout
}
func (d *Daemon) SetExitTimeout(timeout time.Duration) {
d.exitTimeout = timeout
}
func (d *Daemon) GetCmd() (cmd *exec.Cmd) {
return d.cmd
}
func (d *Daemon) GetCh() (ch chan int) {
return d.ch
}
func (d *Daemon) handleSignal() {
for {
select {
case signal := <-d.ch:
switch signal {
case SignalCreate:
log.Infof("process created")
case SignalStart:
log.Infof("process started")
case SignalStopped:
log.Infof("process stopped")
case SignalError:
trace.PrintError(errors.NewProcessError(d.errMsg))
case SignalExited:
log.Infof("process exited")
case SignalReachedMaxErrors:
log.Infof("reached max errors")
return
}
}
}
}
func NewProcessDaemon(newCmdFn func() *exec.Cmd, opts ...DaemonOption) (d interfaces.ProcessDaemon) {
// daemon
d = &Daemon{
maxErrors: 5,
exitTimeout: 15 * time.Second,
errors: 0,
errMsg: "",
newCmdFn: newCmdFn,
stopped: false,
ch: make(chan int),
}
// apply options
for _, opt := range opts {
opt(d)
}
return d
}
|
2302_79757062/crawlab
|
core/process/daemon.go
|
Go
|
bsd-3-clause
| 3,196
|
package process
import (
"github.com/crawlab-team/crawlab/trace"
"os/exec"
"regexp"
"runtime"
"strings"
)
var pidRegexp, _ = regexp.Compile("(?:^|\\s+)\\d+(?:$|\\s+)")
func ProcessIdExists(id int) (ok bool) {
lines, err := ListProcess(string(rune(id)))
if err != nil {
return false
}
for _, line := range lines {
matched := pidRegexp.MatchString(line)
if matched {
return true
}
}
return false
}
func ListProcess(text string) (lines []string, err error) {
if runtime.GOOS == "windows" {
return listProcessWindow(text)
} else {
return listProcessLinuxMac(text)
}
}
func listProcessWindow(text string) (lines []string, err error) {
cmd := exec.Command("tasklist", "/fi", text)
out, err := cmd.CombinedOutput()
_, ok := err.(*exec.ExitError)
if !ok {
return nil, trace.TraceError(err)
}
lines = strings.Split(string(out), "\n")
return lines, nil
}
func listProcessLinuxMac(text string) (lines []string, err error) {
cmd := exec.Command("ps", "aux")
out, err := cmd.CombinedOutput()
_, ok := err.(*exec.ExitError)
if !ok {
return nil, trace.TraceError(err)
}
_lines := strings.Split(string(out), "\n")
for _, l := range _lines {
if strings.Contains(l, text) {
lines = append(lines, l)
}
}
return lines, nil
}
|
2302_79757062/crawlab
|
core/process/manage.go
|
Go
|
bsd-3-clause
| 1,267
|
package process
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type DaemonOption func(d interfaces.ProcessDaemon)
func WithDaemonMaxErrors(maxErrors int) DaemonOption {
return func(d interfaces.ProcessDaemon) {
d.SetMaxErrors(maxErrors)
}
}
func WithExitTimeout(timeout time.Duration) DaemonOption {
return func(d interfaces.ProcessDaemon) {
}
}
|
2302_79757062/crawlab
|
core/process/options.go
|
Go
|
bsd-3-clause
| 380
|
package result
import "go.mongodb.org/mongo-driver/bson/primitive"
type Option func(opts *Options)
type Options struct {
registryKey string // registry key
SpiderId primitive.ObjectID // data source id
}
func WithRegistryKey(key string) Option {
return func(opts *Options) {
opts.registryKey = key
}
}
|
2302_79757062/crawlab
|
core/result/options.go
|
Go
|
bsd-3-clause
| 327
|
package result
import (
"fmt"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
)
func NewResultService(registryKey string, s *models.Spider) (svc2 interfaces.ResultService, err error) {
// result service function
var fn interfaces.ResultServiceRegistryFn
if registryKey == "" {
// default
fn = NewResultServiceMongo
} else {
// from registry
reg := GetResultServiceRegistry()
fn = reg.Get(registryKey)
if fn == nil {
return nil, errors.NewResultError(fmt.Sprintf("%s is not implemented", registryKey))
}
}
// generate result service
svc, err := fn(s.ColId, s.DataSourceId)
if err != nil {
return nil, trace.TraceError(err)
}
return svc, nil
}
var store = sync.Map{}
func GetResultService(spiderId primitive.ObjectID, opts ...Option) (svc2 interfaces.ResultService, err error) {
// model service
modelSvc, err := service.GetService()
if err != nil {
return nil, trace.TraceError(err)
}
// spider
s, err := modelSvc.GetSpiderById(spiderId)
if err != nil {
return nil, trace.TraceError(err)
}
// apply options
_opts := &Options{}
for _, opt := range opts {
opt(_opts)
}
// store key
storeKey := s.ColId.Hex() + ":" + s.DataSourceId.Hex()
// attempt to load result service from store
res, _ := store.Load(storeKey)
if res != nil {
svc, ok := res.(interfaces.ResultService)
if ok {
return svc, nil
}
}
// registry key
var registryKey string
ds, _ := modelSvc.GetDataSourceById(s.DataSourceId)
if ds != nil {
registryKey = ds.Type
}
// create a new result service if not exists
svc, err := NewResultService(registryKey, s)
if err != nil {
return nil, err
}
// save into store
store.Store(storeKey, svc)
return svc, nil
}
|
2302_79757062/crawlab
|
core/result/service.go
|
Go
|
bsd-3-clause
| 1,962
|
package result
import (
"github.com/crawlab-team/crawlab/trace"
"time"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
type ServiceMongo struct {
// dependencies
modelSvc service.ModelService
modelColSvc interfaces.ModelBaseService
// internals
colId primitive.ObjectID // _id of models.DataCollection
dc *models.DataCollection // models.DataCollection
t time.Time
}
func (svc *ServiceMongo) List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error) {
_query := svc.getQuery(query)
_opts := svc.getOpts(opts)
return svc.getList(_query, _opts)
}
func (svc *ServiceMongo) Count(query generic.ListQuery) (n int, err error) {
_query := svc.getQuery(query)
return svc.modelColSvc.Count(_query)
}
func (svc *ServiceMongo) Insert(docs ...interface{}) (err error) {
if svc.dc.Dedup.Enabled && len(svc.dc.Dedup.Keys) > 0 {
for _, doc := range docs {
hash, err := utils.GetResultHash(doc, svc.dc.Dedup.Keys)
if err != nil {
return err
}
doc.(interfaces.Result).SetValue(constants.HashKey, hash)
query := bson.M{constants.HashKey: hash}
switch svc.dc.Dedup.Type {
case constants.DedupTypeOverwrite:
err = mongo.GetMongoCol(svc.dc.Name).ReplaceWithOptions(query, doc, &options.ReplaceOptions{Upsert: &[]bool{true}[0]})
if err != nil {
return trace.TraceError(err)
}
default:
var o bson.M
err := mongo.GetMongoCol(svc.dc.Name).Find(query, &mongo.FindOptions{Limit: 1}).One(&o)
if err == nil {
// exists, ignore
continue
}
if err != mongo2.ErrNoDocuments {
// error
return trace.TraceError(err)
}
// not exists, insert
_, err = mongo.GetMongoCol(svc.dc.Name).Insert(doc)
if err != nil {
return trace.TraceError(err)
}
}
}
} else {
_, err = mongo.GetMongoCol(svc.dc.Name).InsertMany(docs)
if err != nil {
return trace.TraceError(err)
}
}
return nil
}
func (svc *ServiceMongo) Index(fields []string) {
for _, field := range fields {
_ = mongo.GetMongoCol(svc.dc.Name).CreateIndex(mongo2.IndexModel{Keys: bson.M{field: 1}})
}
}
func (svc *ServiceMongo) SetTime(t time.Time) {
svc.t = t
}
func (svc *ServiceMongo) GetTime() (t time.Time) {
return svc.t
}
func (svc *ServiceMongo) getList(query bson.M, opts *mongo.FindOptions) (results []interface{}, err error) {
list, err := svc.modelColSvc.GetList(query, opts)
if err != nil {
return nil, err
}
for _, d := range list.GetModels() {
r, ok := d.(interfaces.Result)
if ok {
results = append(results, r)
}
}
return results, nil
}
func (svc *ServiceMongo) getQuery(query generic.ListQuery) (res bson.M) {
return utils.GetMongoQuery(query)
}
func (svc *ServiceMongo) getOpts(opts *generic.ListOptions) (res *mongo.FindOptions) {
return utils.GetMongoOpts(opts)
}
func NewResultServiceMongo(colId primitive.ObjectID, _ primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &ServiceMongo{
colId: colId,
t: time.Now(),
}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
// data collection
svc.dc, _ = svc.modelSvc.GetDataCollectionById(colId)
go func() {
for {
time.Sleep(1 * time.Second)
svc.dc, _ = svc.modelSvc.GetDataCollectionById(colId)
}
}()
// data collection model service
svc.modelColSvc = service.GetBaseServiceByColName(interfaces.ModelIdResult, svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/result/service_mongo.go
|
Go
|
bsd-3-clause
| 3,934
|
package result
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"sync"
)
type ServiceRegistry struct {
// internals
services sync.Map
}
func (r *ServiceRegistry) Register(key string, fn interfaces.ResultServiceRegistryFn) {
r.services.Store(key, fn)
}
func (r *ServiceRegistry) Unregister(key string) {
r.services.Delete(key)
}
func (r *ServiceRegistry) Get(key string) (fn interfaces.ResultServiceRegistryFn) {
res, ok := r.services.Load(key)
if ok {
fn, ok = res.(interfaces.ResultServiceRegistryFn)
if !ok {
return nil
}
return fn
}
return nil
}
func NewResultServiceRegistry() (r interfaces.ResultServiceRegistry) {
r = &ServiceRegistry{
services: sync.Map{},
}
return r
}
var _svc interfaces.ResultServiceRegistry
func GetResultServiceRegistry() (r interfaces.ResultServiceRegistry) {
if _svc != nil {
return _svc
}
_svc = NewResultServiceRegistry()
return _svc
}
|
2302_79757062/crawlab
|
core/result/service_registry.go
|
Go
|
bsd-3-clause
| 919
|
package test
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/db/mongo"
"go.uber.org/dig"
"testing"
)
func init() {
T = NewTest()
}
var T *Test
type Test struct {
// dependencies
modelSvc service.ModelService
resultSvc interfaces.ResultService
// test data
TestColName string
TestCol *mongo.Col
TestDc *models.DataCollection
}
func (t *Test) Setup(t2 *testing.T) {
t2.Cleanup(t.Cleanup)
}
func (t *Test) Cleanup() {
_ = t.modelSvc.DropAll()
}
func NewTest() *Test {
var err error
// test
t := &Test{
TestColName: "test_results",
}
// dependency injection
c := dig.New()
if err := c.Provide(service.NewService); err != nil {
panic(err)
}
if err := c.Invoke(func(
modelSvc service.ModelService,
) {
t.modelSvc = modelSvc
}); err != nil {
panic(err)
}
// data collection
t.TestDc = &models.DataCollection{
Name: t.TestColName,
}
if err := delegate.NewModelDelegate(t.TestDc).Add(); err != nil {
panic(err)
}
t.TestCol = mongo.GetMongoCol(t.TestColName)
// result service
t.resultSvc, err = result.GetResultService(t.TestDc.GetId())
if err != nil {
panic(err)
}
return t
}
|
2302_79757062/crawlab
|
core/result/test/base.go
|
Go
|
bsd-3-clause
| 1,400
|
package routes
import (
"github.com/crawlab-team/crawlab/core/middlewares"
"github.com/gin-gonic/gin"
)
type RouterGroups struct {
AuthGroup *gin.RouterGroup
AnonymousGroup *gin.RouterGroup
FilerGroup *gin.RouterGroup
}
func NewRouterGroups(app *gin.Engine) (groups *RouterGroups) {
return &RouterGroups{
AuthGroup: app.Group("/", middlewares.AuthorizationMiddleware()),
AnonymousGroup: app.Group("/"),
FilerGroup: app.Group("/filer", middlewares.FilerAuthorizationMiddleware()),
}
}
|
2302_79757062/crawlab
|
core/routes/group.go
|
Go
|
bsd-3-clause
| 518
|
package routes
import (
"fmt"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/controllers"
"github.com/gin-gonic/gin"
"net/http"
"path"
)
type RouterServiceInterface interface {
RegisterControllerToGroup(group *gin.RouterGroup, basePath string, ctr controllers.ListController)
RegisterHandlerToGroup(group *gin.RouterGroup, path string, method string, handler gin.HandlerFunc)
}
type RouterService struct {
app *gin.Engine
}
func NewRouterService(app *gin.Engine) (svc *RouterService) {
return &RouterService{
app: app,
}
}
func (svc *RouterService) RegisterControllerToGroup(group *gin.RouterGroup, basePath string, ctr controllers.BasicController) {
group.GET(basePath, ctr.Get)
group.POST(basePath, ctr.Post)
group.PUT(basePath, ctr.Put)
group.DELETE(basePath, ctr.Delete)
}
func (svc *RouterService) RegisterListControllerToGroup(group *gin.RouterGroup, basePath string, ctr controllers.ListController) {
group.GET(basePath+"/:id", ctr.Get)
group.GET(basePath, ctr.GetList)
group.POST(basePath, ctr.Post)
group.POST(basePath+"/batch", ctr.PostList)
group.PUT(basePath+"/:id", ctr.Put)
group.PUT(basePath, ctr.PutList)
group.DELETE(basePath+"/:id", ctr.Delete)
group.DELETE(basePath, ctr.DeleteList)
}
func (svc *RouterService) RegisterActionControllerToGroup(group *gin.RouterGroup, basePath string, ctr controllers.ActionController) {
for _, action := range ctr.Actions() {
routerPath := path.Join(basePath, action.Path)
switch action.Method {
case http.MethodGet:
group.GET(routerPath, action.HandlerFunc)
case http.MethodPost:
group.POST(routerPath, action.HandlerFunc)
case http.MethodPut:
group.PUT(routerPath, action.HandlerFunc)
case http.MethodDelete:
group.DELETE(routerPath, action.HandlerFunc)
}
}
}
func (svc *RouterService) RegisterListActionControllerToGroup(group *gin.RouterGroup, basePath string, ctr controllers.ListActionController) {
svc.RegisterListControllerToGroup(group, basePath, ctr)
svc.RegisterActionControllerToGroup(group, basePath, ctr)
}
func (svc *RouterService) RegisterHandlerToGroup(group *gin.RouterGroup, path string, method string, handler gin.HandlerFunc) {
switch method {
case http.MethodGet:
group.GET(path, handler)
case http.MethodPost:
group.POST(path, handler)
case http.MethodPut:
group.PUT(path, handler)
case http.MethodDelete:
group.DELETE(path, handler)
default:
log.Warn(fmt.Sprintf("%s is not a valid http method", method))
}
}
func InitRoutes(app *gin.Engine) (err error) {
// routes groups
groups := NewRouterGroups(app)
// router service
svc := NewRouterService(app)
// register routes
registerRoutesAnonymousGroup(svc, groups)
registerRoutesAuthGroup(svc, groups)
registerRoutesFilterGroup(svc, groups)
return nil
}
func registerRoutesAnonymousGroup(svc *RouterService, groups *RouterGroups) {
// login
svc.RegisterActionControllerToGroup(groups.AnonymousGroup, "/", controllers.LoginController)
// version
svc.RegisterActionControllerToGroup(groups.AnonymousGroup, "/version", controllers.VersionController)
// system info
svc.RegisterActionControllerToGroup(groups.AnonymousGroup, "/system-info", controllers.SystemInfoController)
// demo
svc.RegisterActionControllerToGroup(groups.AnonymousGroup, "/demo", controllers.DemoController)
// sync
svc.RegisterActionControllerToGroup(groups.AnonymousGroup, "/sync", controllers.SyncController)
}
func registerRoutesAuthGroup(svc *RouterService, groups *RouterGroups) {
// node
svc.RegisterListControllerToGroup(groups.AuthGroup, "/nodes", controllers.NodeController)
// project
svc.RegisterListControllerToGroup(groups.AuthGroup, "/projects", controllers.ProjectController)
// user
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/users", controllers.UserController)
// spider
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/spiders", controllers.SpiderController)
// task
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/tasks", controllers.TaskController)
// tag
svc.RegisterListControllerToGroup(groups.AuthGroup, "/tags", controllers.TagController)
// setting
svc.RegisterListControllerToGroup(groups.AuthGroup, "/settings", controllers.SettingController)
// data collection
svc.RegisterListControllerToGroup(groups.AuthGroup, "/data/collections", controllers.DataCollectionController)
// result
svc.RegisterActionControllerToGroup(groups.AuthGroup, "/results", controllers.ResultController)
// schedule
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/schedules", controllers.ScheduleController)
// stats
svc.RegisterActionControllerToGroup(groups.AuthGroup, "/stats", controllers.StatsController)
// token
svc.RegisterListControllerToGroup(groups.AuthGroup, "/tokens", controllers.TokenController)
// git
svc.RegisterListControllerToGroup(groups.AuthGroup, "/gits", controllers.GitController)
// role
svc.RegisterListControllerToGroup(groups.AuthGroup, "/roles", controllers.RoleController)
// permission
svc.RegisterListControllerToGroup(groups.AuthGroup, "/permissions", controllers.PermissionController)
// export
svc.RegisterActionControllerToGroup(groups.AuthGroup, "/export", controllers.ExportController)
// notification
svc.RegisterActionControllerToGroup(groups.AuthGroup, "/notifications", controllers.NotificationController)
// filter
svc.RegisterActionControllerToGroup(groups.AuthGroup, "/filters", controllers.FilterController)
// data sources
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/data-sources", controllers.DataSourceController)
// environments
svc.RegisterListActionControllerToGroup(groups.AuthGroup, "/environments", controllers.EnvironmentController)
}
func registerRoutesFilterGroup(svc *RouterService, groups *RouterGroups) {
// filer
svc.RegisterActionControllerToGroup(groups.FilerGroup, "", controllers.FilerController)
}
|
2302_79757062/crawlab
|
core/routes/router.go
|
Go
|
bsd-3-clause
| 5,913
|
package schedule
import (
"fmt"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/trace"
"github.com/robfig/cron/v3"
"strings"
)
type Logger struct {
}
func (l *Logger) Info(msg string, keysAndValues ...interface{}) {
p := l.getPlaceholder(len(keysAndValues))
log.Infof(fmt.Sprintf("cron: %s %s", msg, p), keysAndValues...)
}
func (l *Logger) Error(err error, msg string, keysAndValues ...interface{}) {
p := l.getPlaceholder(len(keysAndValues))
log.Errorf(fmt.Sprintf("cron: %s %s", msg, p), keysAndValues...)
trace.PrintError(err)
}
func (l *Logger) getPlaceholder(n int) (s string) {
var arr []string
for i := 0; i < n; i++ {
arr = append(arr, "%v")
}
return strings.Join(arr, " ")
}
func NewLogger() cron.Logger {
return &Logger{}
}
|
2302_79757062/crawlab
|
core/schedule/logger.go
|
Go
|
bsd-3-clause
| 765
|
package schedule
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Option func(svc interfaces.ScheduleService)
func WithConfigPath(path string) Option {
return func(svc interfaces.ScheduleService) {
svc.SetConfigPath(path)
}
}
func WithLocation(loc *time.Location) Option {
return func(svc interfaces.ScheduleService) {
svc.SetLocation(loc)
}
}
func WithDelayIfStillRunning() Option {
return func(svc interfaces.ScheduleService) {
svc.SetDelay(true)
}
}
func WithSkipIfStillRunning() Option {
return func(svc interfaces.ScheduleService) {
svc.SetSkip(true)
}
}
func WithUpdateInterval(interval time.Duration) Option {
return func(svc interfaces.ScheduleService) {
}
}
|
2302_79757062/crawlab
|
core/schedule/options.go
|
Go
|
bsd-3-clause
| 718
|
package schedule
import (
"github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/robfig/cron/v3"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
"time"
)
type Service struct {
// dependencies
interfaces.WithConfigPath
modelSvc service.ModelService
adminSvc interfaces.SpiderAdminService
// settings variables
loc *time.Location
delay bool
skip bool
updateInterval time.Duration
// internals
cron *cron.Cron
logger cron.Logger
schedules []models.Schedule
stopped bool
mu sync.Mutex
}
func (svc *Service) GetLocation() (loc *time.Location) {
return svc.loc
}
func (svc *Service) SetLocation(loc *time.Location) {
svc.loc = loc
}
func (svc *Service) GetDelay() (delay bool) {
return svc.delay
}
func (svc *Service) SetDelay(delay bool) {
svc.delay = delay
}
func (svc *Service) GetSkip() (skip bool) {
return svc.skip
}
func (svc *Service) SetSkip(skip bool) {
svc.skip = skip
}
func (svc *Service) GetUpdateInterval() (interval time.Duration) {
return svc.updateInterval
}
func (svc *Service) SetUpdateInterval(interval time.Duration) {
svc.updateInterval = interval
}
func (svc *Service) Init() (err error) {
return svc.fetch()
}
func (svc *Service) Start() {
svc.cron.Start()
go svc.Update()
}
func (svc *Service) Wait() {
utils.DefaultWait()
svc.Stop()
}
func (svc *Service) Stop() {
svc.stopped = true
svc.cron.Stop()
}
func (svc *Service) Enable(s interfaces.Schedule, args ...interface{}) (err error) {
svc.mu.Lock()
defer svc.mu.Unlock()
id, err := svc.cron.AddFunc(s.GetCron(), svc.schedule(s.GetId()))
if err != nil {
return trace.TraceError(err)
}
s.SetEnabled(true)
s.SetEntryId(id)
u := utils.GetUserFromArgs(args...)
return delegate.NewModelDelegate(s, u).Save()
}
func (svc *Service) Disable(s interfaces.Schedule, args ...interface{}) (err error) {
svc.mu.Lock()
defer svc.mu.Unlock()
svc.cron.Remove(s.GetEntryId())
s.SetEnabled(false)
s.SetEntryId(-1)
u := utils.GetUserFromArgs(args...)
return delegate.NewModelDelegate(s, u).Save()
}
func (svc *Service) Update() {
for {
if svc.stopped {
return
}
svc.update()
time.Sleep(svc.updateInterval)
}
}
func (svc *Service) GetCron() (c *cron.Cron) {
return svc.cron
}
func (svc *Service) update() {
// fetch enabled schedules
if err := svc.fetch(); err != nil {
trace.PrintError(err)
return
}
// entry id map
entryIdsMap := svc.getEntryIdsMap()
// iterate enabled schedules
for _, s := range svc.schedules {
_, ok := entryIdsMap[s.EntryId]
if ok {
entryIdsMap[s.EntryId] = true
} else {
if err := svc.Enable(&s); err != nil {
trace.PrintError(err)
continue
}
}
}
// remove non-existent entries
for id, ok := range entryIdsMap {
if !ok {
svc.cron.Remove(id)
}
}
}
func (svc *Service) getEntryIdsMap() (res map[cron.EntryID]bool) {
res = map[cron.EntryID]bool{}
for _, e := range svc.cron.Entries() {
res[e.ID] = false
}
return res
}
func (svc *Service) fetch() (err error) {
query := bson.M{
"enabled": true,
}
svc.schedules, err = svc.modelSvc.GetScheduleList(query, nil)
if err != nil {
return err
}
return nil
}
func (svc *Service) schedule(id primitive.ObjectID) (fn func()) {
return func() {
// schedule
s, err := svc.modelSvc.GetScheduleById(id)
if err != nil {
trace.PrintError(err)
return
}
// spider
spider, err := svc.modelSvc.GetSpiderById(s.GetSpiderId())
if err != nil {
trace.PrintError(err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: s.GetMode(),
NodeIds: s.GetNodeIds(),
Cmd: s.GetCmd(),
Param: s.GetParam(),
Priority: s.GetPriority(),
ScheduleId: s.GetId(),
UserId: s.UserId,
}
// normalize options
if opts.Mode == "" {
opts.Mode = spider.Mode
}
if len(opts.NodeIds) == 0 {
opts.NodeIds = spider.NodeIds
}
if opts.Cmd == "" {
opts.Cmd = spider.Cmd
}
if opts.Param == "" {
opts.Param = spider.Param
}
if opts.Priority == 0 {
if spider.Priority > 0 {
opts.Priority = spider.Priority
} else {
opts.Priority = 5
}
}
// schedule or assign a task in the task queue
if _, err := svc.adminSvc.Schedule(s.GetSpiderId(), opts); err != nil {
trace.PrintError(err)
}
}
}
func NewScheduleService() (svc2 interfaces.ScheduleService, err error) {
// service
svc := &Service{
WithConfigPath: config.NewConfigPathService(),
loc: time.Local,
// TODO: implement delay and skip
delay: false,
skip: false,
updateInterval: 1 * time.Minute,
}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
adminSvc interfaces.SpiderAdminService,
) {
svc.modelSvc = modelSvc
svc.adminSvc = adminSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// logger
svc.logger = NewLogger()
// cron
svc.cron = cron.New(
cron.WithLogger(svc.logger),
cron.WithLocation(svc.loc),
cron.WithChain(cron.Recover(svc.logger)),
)
// initialize
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
var svc interfaces.ScheduleService
func GetScheduleService() (res interfaces.ScheduleService, err error) {
if svc != nil {
return svc, nil
}
svc, err = NewScheduleService()
if err != nil {
return nil, err
}
return svc, nil
}
|
2302_79757062/crawlab
|
core/schedule/service.go
|
Go
|
bsd-3-clause
| 5,786
|
package schedule
import (
"github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/spider/admin"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/robfig/cron/v3"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
"time"
)
type ServiceV2 struct {
// dependencies
interfaces.WithConfigPath
modelSvc *service.ModelServiceV2[models.ScheduleV2]
adminSvc *admin.ServiceV2
// settings variables
loc *time.Location
delay bool
skip bool
updateInterval time.Duration
// internals
cron *cron.Cron
logger cron.Logger
schedules []models.ScheduleV2
stopped bool
mu sync.Mutex
}
func (svc *ServiceV2) GetLocation() (loc *time.Location) {
return svc.loc
}
func (svc *ServiceV2) SetLocation(loc *time.Location) {
svc.loc = loc
}
func (svc *ServiceV2) GetDelay() (delay bool) {
return svc.delay
}
func (svc *ServiceV2) SetDelay(delay bool) {
svc.delay = delay
}
func (svc *ServiceV2) GetSkip() (skip bool) {
return svc.skip
}
func (svc *ServiceV2) SetSkip(skip bool) {
svc.skip = skip
}
func (svc *ServiceV2) GetUpdateInterval() (interval time.Duration) {
return svc.updateInterval
}
func (svc *ServiceV2) SetUpdateInterval(interval time.Duration) {
svc.updateInterval = interval
}
func (svc *ServiceV2) Init() (err error) {
return svc.fetch()
}
func (svc *ServiceV2) Start() {
svc.cron.Start()
go svc.Update()
}
func (svc *ServiceV2) Wait() {
utils.DefaultWait()
svc.Stop()
}
func (svc *ServiceV2) Stop() {
svc.stopped = true
svc.cron.Stop()
}
func (svc *ServiceV2) Enable(s models.ScheduleV2, by primitive.ObjectID) (err error) {
svc.mu.Lock()
defer svc.mu.Unlock()
id, err := svc.cron.AddFunc(s.Cron, svc.schedule(s.Id))
if err != nil {
return trace.TraceError(err)
}
s.Enabled = true
s.EntryId = id
s.SetUpdated(by)
return svc.modelSvc.ReplaceById(s.Id, s)
}
func (svc *ServiceV2) Disable(s models.ScheduleV2, by primitive.ObjectID) (err error) {
svc.mu.Lock()
defer svc.mu.Unlock()
svc.cron.Remove(s.EntryId)
s.Enabled = false
s.EntryId = -1
s.SetUpdated(by)
return svc.modelSvc.ReplaceById(s.Id, s)
}
func (svc *ServiceV2) Update() {
for {
if svc.stopped {
return
}
svc.update()
time.Sleep(svc.updateInterval)
}
}
func (svc *ServiceV2) GetCron() (c *cron.Cron) {
return svc.cron
}
func (svc *ServiceV2) update() {
// fetch enabled schedules
if err := svc.fetch(); err != nil {
trace.PrintError(err)
return
}
// entry id map
entryIdsMap := svc.getEntryIdsMap()
// iterate enabled schedules
for _, s := range svc.schedules {
_, ok := entryIdsMap[s.EntryId]
if ok {
entryIdsMap[s.EntryId] = true
} else {
if !s.Enabled {
err := svc.Enable(s, s.GetCreatedBy())
if err != nil {
trace.PrintError(err)
continue
}
}
}
}
// remove non-existent entries
for id, ok := range entryIdsMap {
if !ok {
svc.cron.Remove(id)
}
}
}
func (svc *ServiceV2) getEntryIdsMap() (res map[cron.EntryID]bool) {
res = map[cron.EntryID]bool{}
for _, e := range svc.cron.Entries() {
res[e.ID] = false
}
return res
}
func (svc *ServiceV2) fetch() (err error) {
query := bson.M{
"enabled": true,
}
svc.schedules, err = svc.modelSvc.GetMany(query, nil)
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) schedule(id primitive.ObjectID) (fn func()) {
return func() {
// schedule
s, err := svc.modelSvc.GetById(id)
if err != nil {
trace.PrintError(err)
return
}
// spider
spider, err := service.NewModelServiceV2[models.SpiderV2]().GetById(s.SpiderId)
if err != nil {
trace.PrintError(err)
return
}
// options
opts := &interfaces.SpiderRunOptions{
Mode: s.Mode,
NodeIds: s.NodeIds,
Cmd: s.Cmd,
Param: s.Param,
Priority: s.Priority,
ScheduleId: s.Id,
UserId: s.GetCreatedBy(),
}
// normalize options
if opts.Mode == "" {
opts.Mode = spider.Mode
}
if len(opts.NodeIds) == 0 {
opts.NodeIds = spider.NodeIds
}
if opts.Cmd == "" {
opts.Cmd = spider.Cmd
}
if opts.Param == "" {
opts.Param = spider.Param
}
if opts.Priority == 0 {
if spider.Priority > 0 {
opts.Priority = spider.Priority
} else {
opts.Priority = 5
}
}
// schedule or assign a task in the task queue
if _, err := svc.adminSvc.Schedule(s.SpiderId, opts); err != nil {
trace.PrintError(err)
}
}
}
func NewScheduleServiceV2() (svc2 *ServiceV2, err error) {
// service
svc := &ServiceV2{
WithConfigPath: config.NewConfigPathService(),
loc: time.Local,
// TODO: implement delay and skip
delay: false,
skip: false,
updateInterval: 1 * time.Minute,
}
svc.adminSvc, err = admin.GetSpiderAdminServiceV2()
if err != nil {
return nil, err
}
svc.modelSvc = service.NewModelServiceV2[models.ScheduleV2]()
// logger
svc.logger = NewLogger()
// cron
svc.cron = cron.New(
cron.WithLogger(svc.logger),
cron.WithLocation(svc.loc),
cron.WithChain(cron.Recover(svc.logger)),
)
// initialize
if err := svc.Init(); err != nil {
return nil, err
}
return svc, nil
}
var svcV2 *ServiceV2
func GetScheduleServiceV2() (res *ServiceV2, err error) {
if svcV2 != nil {
return svcV2, nil
}
svcV2, err = NewScheduleServiceV2()
if err != nil {
return nil, err
}
return svcV2, nil
}
|
2302_79757062/crawlab
|
core/schedule/service_v2.go
|
Go
|
bsd-3-clause
| 5,601
|
package test
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/schedule"
"go.uber.org/dig"
"testing"
)
func init() {
var err error
T, err = NewTest()
if err != nil {
panic(err)
}
}
var T *Test
type Test struct {
// dependencies
modelSvc service.ModelService
scheduleSvc interfaces.ScheduleService
// test data
TestSchedule interfaces.Schedule
TestSpider interfaces.Spider
ScriptName string
Script string
}
func (t *Test) Setup(t2 *testing.T) {
t.scheduleSvc.Start()
t2.Cleanup(t.Cleanup)
}
func (t *Test) Cleanup() {
t.scheduleSvc.Stop()
_ = t.modelSvc.GetBaseService(interfaces.ModelIdTask).Delete(nil)
}
func NewTest() (t *Test, err error) {
// test
t = &Test{
TestSpider: &models.Spider{
Name: "test_spider",
Cmd: "go run main.go",
},
ScriptName: "main.go",
Script: `package main
import "fmt"
func main() {
fmt.Println("it works")
}`,
}
// dependency injection
c := dig.New()
if err := c.Provide(service.GetService); err != nil {
return nil, err
}
if err := c.Provide(schedule.NewScheduleService); err != nil {
return nil, err
}
if err := c.Invoke(func(modelSvc service.ModelService, scheduleSvc interfaces.ScheduleService) {
t.modelSvc = modelSvc
t.scheduleSvc = scheduleSvc
}); err != nil {
return nil, err
}
// add spider to db
if err := delegate.NewModelDelegate(t.TestSpider).Add(); err != nil {
return nil, err
}
// test schedule
t.TestSchedule = &models.Schedule{
Name: "test_schedule",
SpiderId: t.TestSpider.GetId(),
Cron: "* * * * *",
}
if err := delegate.NewModelDelegate(t.TestSchedule).Add(); err != nil {
return nil, err
}
return t, nil
}
|
2302_79757062/crawlab
|
core/schedule/test/base.go
|
Go
|
bsd-3-clause
| 1,881
|
package admin
import "github.com/crawlab-team/crawlab/core/interfaces"
type Option func(svc interfaces.SpiderAdminService)
func WithConfigPath(path string) Option {
return func(svc interfaces.SpiderAdminService) {
svc.SetConfigPath(path)
}
}
|
2302_79757062/crawlab
|
core/spider/admin/options.go
|
Go
|
bsd-3-clause
| 249
|
package admin
import (
"context"
"github.com/apex/log"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/crawlab-team/crawlab/vcs"
"github.com/google/uuid"
"github.com/robfig/cron/v3"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"os"
"path"
"path/filepath"
"sync"
"time"
)
type Service struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
modelSvc service.ModelService
schedulerSvc interfaces.TaskSchedulerService
cron *cron.Cron
syncLock bool
// settings
cfgPath string
}
func (svc *Service) GetConfigPath() (path string) {
return svc.cfgPath
}
func (svc *Service) SetConfigPath(path string) {
svc.cfgPath = path
}
func (svc *Service) Start() (err error) {
return svc.SyncGit()
}
func (svc *Service) Schedule(id primitive.ObjectID, opts *interfaces.SpiderRunOptions) (taskIds []primitive.ObjectID, err error) {
// spider
s, err := svc.modelSvc.GetSpiderById(id)
if err != nil {
return nil, err
}
// assign tasks
return svc.scheduleTasks(s, opts)
}
func (svc *Service) Clone(id primitive.ObjectID, opts *interfaces.SpiderCloneOptions) (err error) {
// TODO: implement
return nil
}
func (svc *Service) Delete(id primitive.ObjectID) (err error) {
panic("implement me")
}
func (svc *Service) SyncGit() (err error) {
if _, err = svc.cron.AddFunc("* * * * *", svc.syncGit); err != nil {
return trace.TraceError(err)
}
svc.cron.Start()
return nil
}
func (svc *Service) SyncGitOne(g interfaces.Git) (err error) {
svc.syncGitOne(g)
return nil
}
func (svc *Service) Export(id primitive.ObjectID) (filePath string, err error) {
// spider fs
workspacePath := viper.GetString("workspace")
spiderFolderPath := filepath.Join(workspacePath, id.Hex())
// zip files in workspace
dirPath := spiderFolderPath
zipFilePath := path.Join(os.TempDir(), uuid.New().String()+".zip")
if err := utils.ZipDirectory(dirPath, zipFilePath); err != nil {
return "", trace.TraceError(err)
}
return zipFilePath, nil
}
func (svc *Service) scheduleTasks(s *models.Spider, opts *interfaces.SpiderRunOptions) (taskIds []primitive.ObjectID, err error) {
// main task
mainTask := &models.Task{
SpiderId: s.Id,
Mode: opts.Mode,
NodeIds: opts.NodeIds,
Cmd: opts.Cmd,
Param: opts.Param,
ScheduleId: opts.ScheduleId,
Priority: opts.Priority,
UserId: opts.UserId,
CreateTs: time.Now(),
}
// normalize
if mainTask.Mode == "" {
mainTask.Mode = s.Mode
}
if mainTask.NodeIds == nil {
mainTask.NodeIds = s.NodeIds
}
if mainTask.Cmd == "" {
mainTask.Cmd = s.Cmd
}
if mainTask.Param == "" {
mainTask.Param = s.Param
}
if mainTask.Priority == 0 {
mainTask.Priority = s.Priority
}
if svc.isMultiTask(opts) {
// multi tasks
nodeIds, err := svc.getNodeIds(opts)
if err != nil {
return nil, err
}
for _, nodeId := range nodeIds {
t := &models.Task{
SpiderId: s.Id,
Mode: opts.Mode,
Cmd: opts.Cmd,
Param: opts.Param,
NodeId: nodeId,
ScheduleId: opts.ScheduleId,
Priority: opts.Priority,
UserId: opts.UserId,
CreateTs: time.Now(),
}
t2, err := svc.schedulerSvc.Enqueue(t)
if err != nil {
return nil, err
}
taskIds = append(taskIds, t2.GetId())
}
} else {
// single task
nodeIds, err := svc.getNodeIds(opts)
if err != nil {
return nil, err
}
if len(nodeIds) > 0 {
mainTask.NodeId = nodeIds[0]
}
t2, err := svc.schedulerSvc.Enqueue(mainTask)
if err != nil {
return nil, err
}
taskIds = append(taskIds, t2.GetId())
}
return taskIds, nil
}
func (svc *Service) getNodeIds(opts *interfaces.SpiderRunOptions) (nodeIds []primitive.ObjectID, err error) {
if opts.Mode == constants.RunTypeAllNodes {
query := bson.M{
"active": true,
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := svc.modelSvc.GetNodeList(query, nil)
if err != nil {
return nil, err
}
for _, node := range nodes {
nodeIds = append(nodeIds, node.GetId())
}
} else if opts.Mode == constants.RunTypeSelectedNodes {
nodeIds = opts.NodeIds
}
return nodeIds, nil
}
func (svc *Service) isMultiTask(opts *interfaces.SpiderRunOptions) (res bool) {
if opts.Mode == constants.RunTypeAllNodes {
query := bson.M{
"active": true,
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := svc.modelSvc.GetNodeList(query, nil)
if err != nil {
trace.PrintError(err)
return false
}
return len(nodes) > 1
} else if opts.Mode == constants.RunTypeRandom {
return false
} else if opts.Mode == constants.RunTypeSelectedNodes {
return len(opts.NodeIds) > 1
} else {
return false
}
}
func (svc *Service) syncGit() {
if svc.syncLock {
log.Infof("[SpiderAdminService] sync git is locked, skip")
return
}
log.Infof("[SpiderAdminService] start to sync git")
svc.syncLock = true
defer func() {
svc.syncLock = false
}()
// spiders
spiders, err := svc.modelSvc.GetSpiderList(nil, nil)
if err != nil {
trace.PrintError(err)
return
}
// spider ids
var spiderIds []primitive.ObjectID
for _, s := range spiders {
spiderIds = append(spiderIds, s.Id)
}
if len(spiderIds) > 0 {
// gits
gits, err := svc.modelSvc.GetGitList(bson.M{
"_id": bson.M{
"$in": spiderIds,
},
"auto_pull": true,
}, nil)
if err != nil {
trace.PrintError(err)
return
}
wg := sync.WaitGroup{}
wg.Add(len(gits))
for _, g := range gits {
go func(g models.Git) {
svc.syncGitOne(&g)
wg.Done()
}(g)
}
wg.Wait()
}
log.Infof("[SpiderAdminService] finished sync git")
}
func (svc *Service) syncGitOne(g interfaces.Git) {
log.Infof("[SpiderAdminService] sync git %s", g.GetId())
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
// git client
workspacePath := viper.GetString("workspace")
gitClient, err := vcs.NewGitClient(vcs.WithPath(filepath.Join(workspacePath, g.GetId().Hex())))
if err != nil {
return
}
// set auth
utils.InitGitClientAuth(g, gitClient)
// check if remote has changes
ok, err := gitClient.IsRemoteChanged()
if err != nil {
trace.PrintError(err)
return
}
if !ok {
// no change
return
}
// pull and sync to workspace
if err := gitClient.Reset(); err != nil {
trace.PrintError(err)
return
}
if err := gitClient.Pull(); err != nil {
trace.PrintError(err)
return
}
// wait for context to end
<-ctx.Done()
}
func NewSpiderAdminService(opts ...Option) (svc2 interfaces.SpiderAdminService, err error) {
svc := &Service{
cfgPath: config2.GetConfigPath(),
}
// apply options
for _, opt := range opts {
opt(svc)
}
// dependency injection
if err := container.GetContainer().Invoke(func(nodeCfgSvc interfaces.NodeConfigService, modelSvc service.ModelService, schedulerSvc interfaces.TaskSchedulerService) {
svc.nodeCfgSvc = nodeCfgSvc
svc.modelSvc = modelSvc
svc.schedulerSvc = schedulerSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// cron
svc.cron = cron.New()
// validate node type
if !svc.nodeCfgSvc.IsMaster() {
return nil, trace.TraceError(errors.ErrorSpiderForbidden)
}
return svc, nil
}
var _service interfaces.SpiderAdminService
func GetSpiderAdminService() (svc2 interfaces.SpiderAdminService, err error) {
if _service != nil {
return _service, nil
}
_service, err = NewSpiderAdminService()
if err != nil {
return nil, err
}
return _service, nil
}
|
2302_79757062/crawlab
|
core/spider/admin/service.go
|
Go
|
bsd-3-clause
| 7,923
|
package admin
import (
"context"
"github.com/apex/log"
config2 "github.com/crawlab-team/crawlab/core/config"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/core/task/scheduler"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/crawlab-team/crawlab/vcs"
"github.com/google/uuid"
"github.com/robfig/cron/v3"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"os"
"path"
"path/filepath"
"sync"
"time"
)
type ServiceV2 struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
schedulerSvc *scheduler.ServiceV2
cron *cron.Cron
syncLock bool
// settings
cfgPath string
}
func (svc *ServiceV2) Start() (err error) {
return svc.SyncGit()
}
func (svc *ServiceV2) Schedule(id primitive.ObjectID, opts *interfaces.SpiderRunOptions) (taskIds []primitive.ObjectID, err error) {
// spider
s, err := service.NewModelServiceV2[models.SpiderV2]().GetById(id)
if err != nil {
return nil, err
}
// assign tasks
return svc.scheduleTasks(s, opts)
}
func (svc *ServiceV2) SyncGit() (err error) {
if _, err = svc.cron.AddFunc("* * * * *", svc.syncGit); err != nil {
return trace.TraceError(err)
}
svc.cron.Start()
return nil
}
func (svc *ServiceV2) SyncGitOne(g *models.GitV2) (err error) {
svc.syncGitOne(g)
return nil
}
func (svc *ServiceV2) Export(id primitive.ObjectID) (filePath string, err error) {
// spider fs
workspacePath := viper.GetString("workspace")
spiderFolderPath := filepath.Join(workspacePath, id.Hex())
// zip files in workspace
dirPath := spiderFolderPath
zipFilePath := path.Join(os.TempDir(), uuid.New().String()+".zip")
if err := utils.ZipDirectory(dirPath, zipFilePath); err != nil {
return "", trace.TraceError(err)
}
return zipFilePath, nil
}
func (svc *ServiceV2) scheduleTasks(s *models.SpiderV2, opts *interfaces.SpiderRunOptions) (taskIds []primitive.ObjectID, err error) {
// main task
mainTask := &models.TaskV2{
SpiderId: s.Id,
Mode: opts.Mode,
NodeIds: opts.NodeIds,
Cmd: opts.Cmd,
Param: opts.Param,
ScheduleId: opts.ScheduleId,
Priority: opts.Priority,
UserId: opts.UserId,
CreateTs: time.Now(),
}
mainTask.SetId(primitive.NewObjectID())
// normalize
if mainTask.Mode == "" {
mainTask.Mode = s.Mode
}
if mainTask.NodeIds == nil {
mainTask.NodeIds = s.NodeIds
}
if mainTask.Cmd == "" {
mainTask.Cmd = s.Cmd
}
if mainTask.Param == "" {
mainTask.Param = s.Param
}
if mainTask.Priority == 0 {
mainTask.Priority = s.Priority
}
if svc.isMultiTask(opts) {
// multi tasks
nodeIds, err := svc.getNodeIds(opts)
if err != nil {
return nil, err
}
for _, nodeId := range nodeIds {
t := &models.TaskV2{
SpiderId: s.Id,
Mode: opts.Mode,
Cmd: opts.Cmd,
Param: opts.Param,
NodeId: nodeId,
ScheduleId: opts.ScheduleId,
Priority: opts.Priority,
UserId: opts.UserId,
CreateTs: time.Now(),
}
t.SetId(primitive.NewObjectID())
t2, err := svc.schedulerSvc.Enqueue(t, opts.UserId)
if err != nil {
return nil, err
}
taskIds = append(taskIds, t2.Id)
}
} else {
// single task
nodeIds, err := svc.getNodeIds(opts)
if err != nil {
return nil, err
}
if len(nodeIds) > 0 {
mainTask.NodeId = nodeIds[0]
}
t2, err := svc.schedulerSvc.Enqueue(mainTask, opts.UserId)
if err != nil {
return nil, err
}
taskIds = append(taskIds, t2.Id)
}
return taskIds, nil
}
func (svc *ServiceV2) getNodeIds(opts *interfaces.SpiderRunOptions) (nodeIds []primitive.ObjectID, err error) {
if opts.Mode == constants.RunTypeAllNodes {
query := bson.M{
"active": true,
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := service.NewModelServiceV2[models.NodeV2]().GetMany(query, nil)
if err != nil {
return nil, err
}
for _, node := range nodes {
nodeIds = append(nodeIds, node.Id)
}
} else if opts.Mode == constants.RunTypeSelectedNodes {
nodeIds = opts.NodeIds
}
return nodeIds, nil
}
func (svc *ServiceV2) isMultiTask(opts *interfaces.SpiderRunOptions) (res bool) {
if opts.Mode == constants.RunTypeAllNodes {
query := bson.M{
"active": true,
"enabled": true,
"status": constants.NodeStatusOnline,
}
nodes, err := service.NewModelServiceV2[models.NodeV2]().GetMany(query, nil)
if err != nil {
trace.PrintError(err)
return false
}
return len(nodes) > 1
} else if opts.Mode == constants.RunTypeRandom {
return false
} else if opts.Mode == constants.RunTypeSelectedNodes {
return len(opts.NodeIds) > 1
} else {
return false
}
}
func (svc *ServiceV2) syncGit() {
if svc.syncLock {
log.Infof("[SpiderAdminService] sync git is locked, skip")
return
}
log.Infof("[SpiderAdminService] start to sync git")
svc.syncLock = true
defer func() {
svc.syncLock = false
}()
// spiders
spiders, err := service.NewModelServiceV2[models.SpiderV2]().GetMany(nil, nil)
if err != nil {
trace.PrintError(err)
return
}
// spider ids
var spiderIds []primitive.ObjectID
for _, s := range spiders {
spiderIds = append(spiderIds, s.Id)
}
if len(spiderIds) > 0 {
// gits
gits, err := service.NewModelServiceV2[models.GitV2]().GetMany(bson.M{
"_id": bson.M{
"$in": spiderIds,
},
"auto_pull": true,
}, nil)
if err != nil {
trace.PrintError(err)
return
}
wg := sync.WaitGroup{}
wg.Add(len(gits))
for _, g := range gits {
go func(g models.GitV2) {
svc.syncGitOne(&g)
wg.Done()
}(g)
}
wg.Wait()
}
log.Infof("[SpiderAdminService] finished sync git")
}
func (svc *ServiceV2) syncGitOne(g *models.GitV2) {
log.Infof("[SpiderAdminService] sync git %s", g.Id)
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
// git client
workspacePath := viper.GetString("workspace")
gitClient, err := vcs.NewGitClient(vcs.WithPath(filepath.Join(workspacePath, g.Id.Hex())))
if err != nil {
return
}
// set auth
utils.InitGitClientAuthV2(g, gitClient)
// check if remote has changes
ok, err := gitClient.IsRemoteChanged()
if err != nil {
trace.PrintError(err)
return
}
if !ok {
// no change
return
}
// pull and sync to workspace
if err := gitClient.Reset(); err != nil {
trace.PrintError(err)
return
}
if err := gitClient.Pull(); err != nil {
trace.PrintError(err)
return
}
// wait for context to end
<-ctx.Done()
}
func NewSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
svc := &ServiceV2{
nodeCfgSvc: config.GetNodeConfigService(),
cfgPath: config2.GetConfigPath(),
}
svc.schedulerSvc, err = scheduler.GetTaskSchedulerServiceV2()
if err != nil {
return nil, err
}
// cron
svc.cron = cron.New()
// validate node type
if !svc.nodeCfgSvc.IsMaster() {
return nil, trace.TraceError(errors.ErrorSpiderForbidden)
}
return svc, nil
}
var svcV2 *ServiceV2
func GetSpiderAdminServiceV2() (svc2 *ServiceV2, err error) {
if svcV2 != nil {
return svcV2, nil
}
svcV2, err = NewSpiderAdminServiceV2()
if err != nil {
return nil, err
}
return svcV2, nil
}
|
2302_79757062/crawlab
|
core/spider/admin/service_v2.go
|
Go
|
bsd-3-clause
| 7,469
|
package stats
import "github.com/crawlab-team/crawlab/core/interfaces"
type Option func(svc interfaces.StatsService)
|
2302_79757062/crawlab
|
core/stats/options.go
|
Go
|
bsd-3-clause
| 119
|
package stats
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
)
type Service struct {
}
func (svc *Service) GetOverviewStats(query bson.M) (data interface{}, err error) {
stats := bson.M{}
// nodes
stats["nodes"], err = mongo.GetMongoCol(interfaces.ModelColNameNode).Count(bson.M{"active": true})
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["nodes"] = 0
}
// projects
stats["projects"], err = mongo.GetMongoCol(interfaces.ModelColNameProject).Count(nil)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["projects"] = 0
}
// spiders
stats["spiders"], err = mongo.GetMongoCol(interfaces.ModelColNameSpider).Count(nil)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["spiders"] = 0
}
// schedules
stats["schedules"], err = mongo.GetMongoCol(interfaces.ModelColNameSchedule).Count(nil)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["schedules"] = 0
}
// tasks
stats["tasks"], err = mongo.GetMongoCol(interfaces.ModelColNameTask).Count(nil)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["tasks"] = 0
}
// error tasks
stats["error_tasks"], err = mongo.GetMongoCol(interfaces.ModelColNameTask).Count(bson.M{"status": constants.TaskStatusError})
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["error_tasks"] = 0
}
// results
stats["results"], err = svc.getOverviewResults(query)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["results"] = 0
}
// users
stats["users"], err = mongo.GetMongoCol(interfaces.ModelColNameUser).Count(nil)
if err != nil {
if err.Error() != mongo2.ErrNoDocuments.Error() {
return nil, err
}
stats["users"] = 0
}
return stats, nil
}
func (svc *Service) GetDailyStats(query bson.M) (data interface{}, err error) {
tasksStats, err := svc.getDailyTasksStats(query)
if err != nil {
return nil, err
}
return tasksStats, nil
}
func (svc *Service) GetTaskStats(query bson.M) (data interface{}, err error) {
stats := bson.M{}
// by status
stats["by_status"], err = svc.getTaskStatsByStatus(query)
if err != nil {
return nil, err
}
// by node
stats["by_node"], err = svc.getTaskStatsByNode(query)
if err != nil {
return nil, err
}
// by spider
stats["by_spider"], err = svc.getTaskStatsBySpider(query)
if err != nil {
return nil, err
}
return stats, nil
}
func (svc *Service) getDailyTasksStats(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{
"$match", query,
}},
{{
"$addFields",
bson.M{
"date": bson.M{
"$dateToString": bson.M{
"date": bson.M{"$toDate": "$_id"},
"format": "%Y-%m-%d",
"timezone": "Asia/Shanghai", // TODO: parameterization
},
},
},
}},
{{
"$group",
bson.M{
"_id": "$date",
"tasks": bson.M{"$sum": 1},
"results": bson.M{"$sum": "$result_count"},
},
}},
{{
"$sort",
bson.D{{"_id", 1}},
}},
}
var results []entity.StatsDailyItem
if err := mongo.GetMongoCol(interfaces.ModelColNameTaskStat).Aggregate(pipeline, nil).All(&results); err != nil {
return nil, err
}
return results, nil
}
func (svc *Service) getOverviewResults(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{"$match", query}},
{{
"$group",
bson.M{
"_id": nil,
"results": bson.M{"$sum": "$result_count"},
},
}},
}
var res bson.M
if err := mongo.GetMongoCol(interfaces.ModelColNameTaskStat).Aggregate(pipeline, nil).One(&res); err != nil {
return nil, err
}
return res["results"], nil
}
func (svc *Service) getTaskStatsByStatus(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{"$match", query}},
{{
"$group",
bson.M{
"_id": "$status",
"tasks": bson.M{"$sum": 1},
},
}},
{{
"$project",
bson.M{
"status": "$_id",
"tasks": "$tasks",
},
}},
}
var results []bson.M
if err := mongo.GetMongoCol(interfaces.ModelColNameTask).Aggregate(pipeline, nil).All(&results); err != nil {
return nil, err
}
return results, nil
}
func (svc *Service) getTaskStatsByNode(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{"$match", query}},
{{
"$group",
bson.M{
"_id": "$node_id",
"tasks": bson.M{"$sum": 1},
},
}},
{{
"$lookup",
bson.M{
"from": interfaces.ModelColNameNode,
"localField": "_id",
"foreignField": "_id",
"as": "_n",
},
}},
{{
"$project",
bson.M{
"node_id": "$node_id",
"node": bson.M{"$arrayElemAt": bson.A{"$_n", 0}},
"node_name": bson.M{"$arrayElemAt": bson.A{"$_n.name", 0}},
"tasks": "$tasks",
},
}},
}
var results []bson.M
if err := mongo.GetMongoCol(interfaces.ModelColNameTask).Aggregate(pipeline, nil).All(&results); err != nil {
return nil, err
}
return results, nil
}
func (svc *Service) getTaskStatsBySpider(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{"$match", query}},
{{
"$group",
bson.M{
"_id": "$spider_id",
"tasks": bson.M{"$sum": 1},
},
}},
{{
"$lookup",
bson.M{
"from": interfaces.ModelColNameSpider,
"localField": "_id",
"foreignField": "_id",
"as": "_s",
},
}},
{{
"$project",
bson.M{
"spider_id": "$spider_id",
"spider": bson.M{"$arrayElemAt": bson.A{"$_s", 0}},
"spider_name": bson.M{"$arrayElemAt": bson.A{"$_s.name", 0}},
"tasks": "$tasks",
},
}},
{{"$limit", 10}},
}
var results []bson.M
if err := mongo.GetMongoCol(interfaces.ModelColNameTask).Aggregate(pipeline, nil).All(&results); err != nil {
return nil, err
}
return results, nil
}
func (svc *Service) getTaskStatsHistogram(query bson.M) (data interface{}, err error) {
pipeline := mongo2.Pipeline{
{{"$match", query}},
{{
"$lookup",
bson.M{
"from": interfaces.ModelColNameTaskStat,
"localField": "_id",
"foreignField": "_id",
"as": "_ts",
},
}},
{{
"$facet",
bson.M{
"total_duration": bson.A{
bson.M{
"$bucketAuto": bson.M{
"groupBy": "$_ts.td",
"buckets": 10,
"granularity": "1-2-5",
},
},
},
},
}},
}
var res bson.M
if err := mongo.GetMongoCol(interfaces.ModelColNameTask).Aggregate(pipeline, nil).One(&res); err != nil {
return nil, err
}
return res, nil
}
var svc interfaces.StatsService
func GetStatsService() interfaces.StatsService {
if svc != nil {
return svc
}
// service
svc = &Service{}
return svc
}
|
2302_79757062/crawlab
|
core/stats/service.go
|
Go
|
bsd-3-clause
| 7,099
|
package sys_exec
import (
"bufio"
"github.com/crawlab-team/crawlab/trace"
"github.com/shirou/gopsutil/process"
"os/exec"
"time"
)
type KillProcessOptions struct {
Timeout time.Duration
Force bool
}
func KillProcess(cmd *exec.Cmd, opts *KillProcessOptions) error {
// process
p, err := process.NewProcess(int32(cmd.Process.Pid))
if err != nil {
return err
}
// kill function
killFunc := func(p *process.Process) error {
return killProcessRecursive(p, opts.Force)
}
if opts.Timeout != 0 {
// with timeout
return killProcessWithTimeout(p, opts.Timeout, killFunc)
} else {
// without timeout
return killFunc(p)
}
}
func killProcessWithTimeout(p *process.Process, timeout time.Duration, killFunc func(*process.Process) error) error {
go func() {
if err := killFunc(p); err != nil {
trace.PrintError(err)
}
}()
for i := 0; i < int(timeout.Seconds()); i++ {
ok, err := process.PidExists(p.Pid)
if err == nil && !ok {
return nil
}
time.Sleep(1 * time.Second)
}
return killProcess(p, true)
}
func killProcessRecursive(p *process.Process, force bool) (err error) {
// children processes
cps, err := p.Children()
if err != nil {
return killProcess(p, force)
}
// iterate children processes
for _, cp := range cps {
if err := killProcessRecursive(cp, force); err != nil {
return err
}
}
return nil
}
func killProcess(p *process.Process, force bool) (err error) {
if force {
err = p.Kill()
} else {
err = p.Terminate()
}
if err != nil {
return trace.TraceError(err)
}
return nil
}
func ConfigureCmdLogging(cmd *exec.Cmd, fn func(scanner *bufio.Scanner)) {
stdout, _ := (*cmd).StdoutPipe()
stderr, _ := (*cmd).StderrPipe()
scannerStdout := bufio.NewScanner(stdout)
scannerStderr := bufio.NewScanner(stderr)
go fn(scannerStdout)
go fn(scannerStderr)
}
|
2302_79757062/crawlab
|
core/sys_exec/sys_exec.go
|
Go
|
bsd-3-clause
| 1,837
|
//go:build darwin
// +build darwin
package sys_exec
import (
"os/exec"
"syscall"
)
func BuildCmd(cmdStr string) *exec.Cmd {
return exec.Command("sh", "-c", cmdStr)
}
func SetPgid(cmd *exec.Cmd) {
if cmd == nil {
return
}
if cmd.SysProcAttr == nil {
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
} else {
cmd.SysProcAttr.Setpgid = true
}
}
|
2302_79757062/crawlab
|
core/sys_exec/sys_exec_darwin.go
|
Go
|
bsd-3-clause
| 365
|
//go:build linux
// +build linux
package sys_exec
import (
"os/exec"
"syscall"
)
func BuildCmd(cmdStr string) *exec.Cmd {
return exec.Command("sh", "-c", cmdStr)
}
func SetPgid(cmd *exec.Cmd) {
if cmd == nil {
return
}
if cmd.SysProcAttr == nil {
cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
} else {
cmd.SysProcAttr.Setpgid = true
}
}
|
2302_79757062/crawlab
|
core/sys_exec/sys_exec_linux.go
|
Go
|
bsd-3-clause
| 363
|
//go:build windows
// +build windows
package sys_exec
import "os/exec"
func BuildCmd(cmdStr string) *exec.Cmd {
return exec.Command("cmd", "/C", cmdStr)
}
|
2302_79757062/crawlab
|
core/sys_exec/sys_exec_windows.go
|
Go
|
bsd-3-clause
| 159
|
package system
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
mongo2 "github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Service struct {
col *mongo2.Col
modelSvc service.ModelService
}
func (svc *Service) Init() (err error) {
// initialize data
if err := svc.initData(); err != nil {
return err
}
return nil
}
func (svc *Service) initData() (err error) {
total, err := svc.col.Count(bson.M{
"key": "site_title",
})
if err != nil {
return err
}
if total > 0 {
return nil
}
// data to initialize
settings := []models.Setting{
{
Id: primitive.NewObjectID(),
Key: "site_title",
Value: bson.M{
"customize_site_title": false,
"site_title": "",
},
},
}
var data []interface{}
for _, s := range settings {
data = append(data, s)
}
_, err = svc.col.InsertMany(data)
if err != nil {
return err
}
return nil
}
func NewService() *Service {
// service
svc := &Service{
col: mongo2.GetMongoCol(interfaces.ModelColNameSetting),
}
// model service
modelSvc, err := service.GetService()
if err != nil {
panic(err)
}
svc.modelSvc = modelSvc
if err := svc.Init(); err != nil {
panic(err)
}
return svc
}
var _service *Service
func GetService() *Service {
if _service == nil {
_service = NewService()
}
return _service
}
|
2302_79757062/crawlab
|
core/system/service.go
|
Go
|
bsd-3-clause
| 1,512
|
package task
import (
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
)
type BaseService struct {
// dependencies
interfaces.WithConfigPath
modelSvc service.ModelService
// internals
stopped bool
}
func (svc *BaseService) Init() error {
// implement me
return nil
}
func (svc *BaseService) Start() {
// implement me
}
func (svc *BaseService) Wait() {
utils.DefaultWait()
}
func (svc *BaseService) Stop() {
svc.stopped = true
}
// SaveTask deprecated
func (svc *BaseService) SaveTask(t interfaces.Task, status string) (err error) {
// normalize status
if status == "" {
status = constants.TaskStatusPending
}
// set task status
t.SetStatus(status)
// attempt to get task from database
_, err = svc.modelSvc.GetTaskById(t.GetId())
if err != nil {
// if task does not exist, add to database
if err == mongo.ErrNoDocuments {
if err := delegate.NewModelDelegate(t).Add(); err != nil {
return err
}
return nil
} else {
return err
}
} else {
// otherwise, update
if err := delegate.NewModelDelegate(t).Save(); err != nil {
return err
}
return nil
}
}
func (svc *BaseService) IsStopped() (res bool) {
return svc.stopped
}
func (svc *BaseService) GetQueue(nodeId primitive.ObjectID) (queue string) {
if nodeId.IsZero() {
return fmt.Sprintf("%s", constants.TaskListQueuePrefixPublic)
} else {
return fmt.Sprintf("%s:%s", constants.TaskListQueuePrefixNodes, nodeId.Hex())
}
}
func NewBaseService() (svc2 interfaces.TaskBaseService, err error) {
svc := &BaseService{}
// dependency injection
if err := container.GetContainer().Invoke(func(cfgPath interfaces.WithConfigPath, modelSvc service.ModelService) {
svc.WithConfigPath = cfgPath
svc.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
return svc, nil
}
|
2302_79757062/crawlab
|
core/task/base.go
|
Go
|
bsd-3-clause
| 2,202
|
package handler
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Option func(svc interfaces.TaskHandlerService)
func WithConfigPath(path string) Option {
return func(svc interfaces.TaskHandlerService) {
svc.SetConfigPath(path)
}
}
func WithExitWatchDuration(duration time.Duration) Option {
return func(svc interfaces.TaskHandlerService) {
svc.SetExitWatchDuration(duration)
}
}
func WithReportInterval(interval time.Duration) Option {
return func(svc interfaces.TaskHandlerService) {
svc.SetReportInterval(interval)
}
}
func WithCancelTimeout(timeout time.Duration) Option {
return func(svc interfaces.TaskHandlerService) {
svc.SetCancelTimeout(timeout)
}
}
type RunnerOption func(r interfaces.TaskRunner)
func WithSubscribeTimeout(timeout time.Duration) RunnerOption {
return func(r interfaces.TaskRunner) {
r.SetSubscribeTimeout(timeout)
}
}
|
2302_79757062/crawlab
|
core/task/handler/options.go
|
Go
|
bsd-3-clause
| 899
|
package handler
import (
"bufio"
"context"
"encoding/json"
"fmt"
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
fs2 "github.com/crawlab-team/crawlab/core/fs"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/client"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/sys_exec"
"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"
"github.com/shirou/gopsutil/process"
"github.com/sirupsen/logrus"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"time"
)
type Runner struct {
// dependencies
svc interfaces.TaskHandlerService // task handler service
fsSvc interfaces.FsServiceV2 // task fs service
hookSvc interfaces.TaskHookService // task hook service
// settings
subscribeTimeout time.Duration
bufferSize int
// internals
cmd *exec.Cmd // process command instance
pid int // process id
tid primitive.ObjectID // task id
t interfaces.Task // task model.Task
s interfaces.Spider // spider model.Spider
ch chan constants.TaskSignal // channel to communicate between Service and Runner
err error // standard process error
envs []models.Env // environment variables
cwd string // working directory
c interfaces.GrpcClient // grpc client
sub grpc.TaskService_SubscribeClient // grpc task service stream client
// log internals
scannerStdout *bufio.Reader
scannerStderr *bufio.Reader
logBatchSize int
}
func (r *Runner) Init() (err error) {
// update task
if err := r.updateTask("", nil); err != nil {
return err
}
// start grpc client
if !r.c.IsStarted() {
r.c.Start()
}
// working directory
workspacePath := viper.GetString("workspace")
r.cwd = filepath.Join(workspacePath, r.s.GetId().Hex())
// sync files from master
if !utils.IsMaster() {
if err := r.syncFiles(); err != nil {
return err
}
}
// grpc task service stream client
if err := r.initSub(); err != nil {
return err
}
// pre actions
if r.hookSvc != nil {
if err := r.hookSvc.PreActions(r.t, r.s, r.fsSvc, r.svc); err != nil {
return err
}
}
return nil
}
func (r *Runner) Run() (err error) {
// log task started
log.Infof("task[%s] started", r.tid.Hex())
// configure cmd
r.configureCmd()
// configure environment variables
r.configureEnv()
// configure logging
r.configureLogging()
// start process
if err := r.cmd.Start(); err != nil {
return r.updateTask(constants.TaskStatusError, err)
}
// start logging
go r.startLogging()
// process id
if r.cmd.Process == nil {
return r.updateTask(constants.TaskStatusError, constants.ErrNotExists)
}
r.pid = r.cmd.Process.Pid
r.t.SetPid(r.pid)
// update task status (processing)
if err := r.updateTask(constants.TaskStatusRunning, nil); err != nil {
return err
}
// wait for process to finish
go r.wait()
// start health check
go r.startHealthCheck()
// declare task status
status := ""
// wait for signal
signal := <-r.ch
switch signal {
case constants.TaskSignalFinish:
err = nil
status = constants.TaskStatusFinished
case constants.TaskSignalCancel:
err = constants.ErrTaskCancelled
status = constants.TaskStatusCancelled
case constants.TaskSignalError:
err = r.err
status = constants.TaskStatusError
case constants.TaskSignalLost:
err = constants.ErrTaskLost
status = constants.TaskStatusError
default:
err = constants.ErrInvalidSignal
status = constants.TaskStatusError
}
// update task status
if err := r.updateTask(status, err); err != nil {
return err
}
// post actions
if r.hookSvc != nil {
if err := r.hookSvc.PostActions(r.t, r.s, r.fsSvc, r.svc); err != nil {
return err
}
}
return err
}
func (r *Runner) Cancel() (err error) {
// kill process
opts := &sys_exec.KillProcessOptions{
Timeout: r.svc.GetCancelTimeout(),
Force: true,
}
if err := sys_exec.KillProcess(r.cmd, opts); err != nil {
return err
}
// make sure the process does not exist
op := func() error {
if exists, _ := process.PidExists(int32(r.pid)); exists {
return errors.ErrorTaskProcessStillExists
}
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), r.svc.GetExitWatchDuration())
defer cancel()
b := backoff.WithContext(backoff.NewConstantBackOff(1*time.Second), ctx)
if err := backoff.Retry(op, b); err != nil {
return trace.TraceError(errors.ErrorTaskUnableToCancel)
}
return nil
}
// CleanUp clean up task runner
func (r *Runner) CleanUp() (err error) {
return nil
}
func (r *Runner) SetSubscribeTimeout(timeout time.Duration) {
r.subscribeTimeout = timeout
}
func (r *Runner) GetTaskId() (id primitive.ObjectID) {
return r.tid
}
func (r *Runner) configureCmd() {
var cmdStr string
// customized spider
if r.t.GetCmd() == "" {
cmdStr = r.s.GetCmd()
} else {
cmdStr = r.t.GetCmd()
}
// parameters
if r.t.GetParam() != "" {
cmdStr += " " + r.t.GetParam()
} else if r.s.GetParam() != "" {
cmdStr += " " + r.s.GetParam()
}
// get cmd instance
r.cmd = sys_exec.BuildCmd(cmdStr)
// set working directory
r.cmd.Dir = r.cwd
// configure pgid to allow killing sub processes
//sys_exec.SetPgid(r.cmd)
}
func (r *Runner) configureLogging() {
// set stdout reader
stdout, _ := r.cmd.StdoutPipe()
r.scannerStdout = bufio.NewReaderSize(stdout, r.bufferSize)
// set stderr reader
stderr, _ := r.cmd.StderrPipe()
r.scannerStderr = bufio.NewReaderSize(stderr, r.bufferSize)
}
func (r *Runner) startLogging() {
// start reading stdout
go r.startLoggingReaderStdout()
// start reading stderr
go r.startLoggingReaderStderr()
}
func (r *Runner) startLoggingReaderStdout() {
for {
line, err := r.scannerStdout.ReadString(byte('\n'))
if err != nil {
break
}
line = strings.TrimSuffix(line, "\n")
r.writeLogLines([]string{line})
}
}
func (r *Runner) startLoggingReaderStderr() {
for {
line, err := r.scannerStderr.ReadString(byte('\n'))
if err != nil {
break
}
line = strings.TrimSuffix(line, "\n")
r.writeLogLines([]string{line})
}
}
func (r *Runner) startHealthCheck() {
if r.cmd.ProcessState == nil || r.cmd.ProcessState.Exited() {
return
}
for {
exists, _ := process.PidExists(int32(r.pid))
if !exists {
// process lost
r.ch <- constants.TaskSignalLost
return
}
time.Sleep(1 * time.Second)
}
}
func (r *Runner) configureEnv() {
// 默认把Node.js的全局node_modules加入环境变量
envPath := os.Getenv("PATH")
nodePath := "/usr/lib/node_modules"
if !strings.Contains(envPath, nodePath) {
_ = os.Setenv("PATH", nodePath+":"+envPath)
}
_ = os.Setenv("NODE_PATH", nodePath)
// default envs
r.cmd.Env = append(os.Environ(), "CRAWLAB_TASK_ID="+r.tid.Hex())
if viper.GetString("grpc.address") != "" {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_ADDRESS="+viper.GetString("grpc.address"))
}
if viper.GetString("grpc.authKey") != "" {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_AUTH_KEY="+viper.GetString("grpc.authKey"))
} else {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_AUTH_KEY="+constants.DefaultGrpcAuthKey)
}
// global environment variables
envs, err := r.svc.GetModelEnvironmentService().GetEnvironmentList(nil, nil)
if err != nil {
trace.PrintError(err)
return
}
for _, env := range envs {
r.cmd.Env = append(r.cmd.Env, env.GetKey()+"="+env.GetValue())
}
}
func (r *Runner) syncFiles() (err error) {
masterURL := fmt.Sprintf("%s/sync/%s", viper.GetString("api.endpoint"), r.s.GetId().Hex())
workspacePath := viper.GetString("workspace")
workerDir := filepath.Join(workspacePath, r.s.GetId().Hex())
// get file list from master
resp, err := http.Get(masterURL + "/scan")
if err != nil {
fmt.Println("Error getting file list from master:", err)
return trace.TraceError(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return trace.TraceError(err)
}
var masterFiles map[string]entity.FsFileInfo
err = json.Unmarshal(body, &masterFiles)
if err != nil {
fmt.Println("Error unmarshaling JSON:", err)
return trace.TraceError(err)
}
// create a map for master files
masterFilesMap := make(map[string]entity.FsFileInfo)
for _, file := range masterFiles {
masterFilesMap[file.Path] = file
}
// create worker directory if not exists
if _, err := os.Stat(workerDir); os.IsNotExist(err) {
if err := os.MkdirAll(workerDir, os.ModePerm); err != nil {
fmt.Println("Error creating worker directory:", err)
return trace.TraceError(err)
}
}
// get file list from worker
workerFiles, err := utils.ScanDirectory(workerDir)
if err != nil {
fmt.Println("Error scanning worker directory:", err)
return trace.TraceError(err)
}
// set up wait group and error channel
var wg sync.WaitGroup
errCh := make(chan error, 1)
// delete files that are deleted on master node
for path, workerFile := range workerFiles {
if _, exists := masterFilesMap[path]; !exists {
fmt.Println("Deleting file:", path)
err := os.Remove(workerFile.FullPath)
if err != nil {
fmt.Println("Error deleting file:", err)
}
}
}
// download files that are new or modified on master node
for path, masterFile := range masterFilesMap {
workerFile, exists := workerFiles[path]
if !exists || masterFile.Hash != workerFile.Hash {
wg.Add(1)
go func(path string, masterFile entity.FsFileInfo) {
defer wg.Done()
logrus.Infof("File needs to be synchronized: %s", path)
err := r.downloadFile(masterURL+"/download?path="+path, filepath.Join(workerDir, path))
if err != nil {
logrus.Errorf("Error downloading file: %v", err)
select {
case errCh <- err:
default:
}
}
}(path, masterFile)
}
}
wg.Wait()
close(errCh)
if err := <-errCh; err != nil {
return err
}
return nil
}
func (r *Runner) downloadFile(url string, filePath string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.Body.Close()
out, err := os.Create(filePath)
if err != nil {
return err
}
defer out.Close()
_, err = io.Copy(out, resp.Body)
return err
}
// wait for process to finish and send task signal (constants.TaskSignal)
// to task runner's channel (Runner.ch) according to exit code
func (r *Runner) wait() {
// wait for process to finish
if err := r.cmd.Wait(); err != nil {
exitError, ok := err.(*exec.ExitError)
if !ok {
r.ch <- constants.TaskSignalError
return
}
exitCode := exitError.ExitCode()
if exitCode == -1 {
// cancel error
r.ch <- constants.TaskSignalCancel
return
}
// standard error
r.err = err
r.ch <- constants.TaskSignalError
return
}
// success
r.ch <- constants.TaskSignalFinish
}
// updateTask update and get updated info of task (Runner.t)
func (r *Runner) updateTask(status string, e error) (err error) {
if r.t != nil && status != "" {
// update task status
r.t.SetStatus(status)
if e != nil {
r.t.SetError(e.Error())
}
if r.svc.GetNodeConfigService().IsMaster() {
if err := delegate.NewModelDelegate(r.t).Save(); err != nil {
return err
}
} else {
if err := client.NewModelDelegate(r.t, client.WithDelegateConfigPath(r.svc.GetConfigPath())).Save(); err != nil {
return err
}
}
// send notification
go r.sendNotification()
// update stats
go func() {
r._updateTaskStat(status)
r._updateSpiderStat(status)
}()
}
// get task
r.t, err = r.svc.GetTaskById(r.tid)
if err != nil {
return err
}
return nil
}
func (r *Runner) initSub() (err error) {
r.sub, err = r.c.GetTaskClient().Subscribe(context.Background())
if err != nil {
return trace.TraceError(err)
}
return nil
}
func (r *Runner) writeLogLines(lines []string) {
data, err := json.Marshal(&entity.StreamMessageTaskData{
TaskId: r.tid,
Logs: lines,
})
if err != nil {
trace.PrintError(err)
return
}
msg := &grpc.StreamMessage{
Code: grpc.StreamMessageCode_INSERT_LOGS,
Data: data,
}
if err := r.sub.Send(msg); err != nil {
trace.PrintError(err)
return
}
}
func (r *Runner) _updateTaskStat(status string) {
ts, err := r.svc.GetModelTaskStatService().GetTaskStatById(r.tid)
if err != nil {
trace.PrintError(err)
return
}
switch status {
case constants.TaskStatusPending:
// do nothing
case constants.TaskStatusRunning:
ts.SetStartTs(time.Now())
ts.SetWaitDuration(ts.GetStartTs().Sub(ts.GetCreateTs()).Milliseconds())
case constants.TaskStatusFinished, constants.TaskStatusError, constants.TaskStatusCancelled:
ts.SetEndTs(time.Now())
ts.SetRuntimeDuration(ts.GetEndTs().Sub(ts.GetStartTs()).Milliseconds())
ts.SetTotalDuration(ts.GetEndTs().Sub(ts.GetCreateTs()).Milliseconds())
}
if r.svc.GetNodeConfigService().IsMaster() {
if err := delegate.NewModelDelegate(ts).Save(); err != nil {
trace.PrintError(err)
return
}
} else {
if err := client.NewModelDelegate(ts, client.WithDelegateConfigPath(r.svc.GetConfigPath())).Save(); err != nil {
trace.PrintError(err)
return
}
}
}
func (r *Runner) sendNotification() {
data, err := json.Marshal(r.t)
if err != nil {
trace.PrintError(err)
return
}
req := &grpc.Request{
NodeKey: r.svc.GetNodeConfigService().GetNodeKey(),
Data: data,
}
_, err = r.c.GetTaskClient().SendNotification(context.Background(), req)
if err != nil {
trace.PrintError(err)
return
}
}
func (r *Runner) _updateSpiderStat(status string) {
// task stat
ts, err := r.svc.GetModelTaskStatService().GetTaskStatById(r.tid)
if err != nil {
trace.PrintError(err)
return
}
// update
var update bson.M
switch status {
case constants.TaskStatusPending, constants.TaskStatusRunning:
update = bson.M{
"$set": bson.M{
"last_task_id": r.tid, // last task id
},
"$inc": bson.M{
"tasks": 1, // task count
"wait_duration": ts.GetWaitDuration(), // wait duration
},
}
case constants.TaskStatusFinished, constants.TaskStatusError, constants.TaskStatusCancelled:
update = bson.M{
"$inc": bson.M{
"results": ts.GetResultCount(), // results
"runtime_duration": ts.GetRuntimeDuration() / 1000, // runtime duration
"total_duration": ts.GetTotalDuration() / 1000, // total duration
},
}
default:
trace.PrintError(errors.ErrorTaskInvalidType)
return
}
// perform update
if r.svc.GetNodeConfigService().IsMaster() {
if err := mongo.GetMongoCol(interfaces.ModelColNameSpiderStat).UpdateId(r.s.GetId(), update); err != nil {
trace.PrintError(err)
return
}
} else {
modelSvc, err := client.NewBaseServiceDelegate(
client.WithBaseServiceModelId(interfaces.ModelIdSpiderStat),
client.WithBaseServiceConfigPath(r.svc.GetConfigPath()),
)
if err != nil {
trace.PrintError(err)
return
}
if err := modelSvc.UpdateById(r.s.GetId(), update); err != nil {
trace.PrintError(err)
return
}
}
}
func NewTaskRunner(id primitive.ObjectID, svc interfaces.TaskHandlerService, opts ...RunnerOption) (r2 interfaces.TaskRunner, err error) {
// validate options
if id.IsZero() {
return nil, constants.ErrInvalidOptions
}
// runner
r := &Runner{
subscribeTimeout: 30 * time.Second,
bufferSize: 1024 * 1024,
svc: svc,
tid: id,
ch: make(chan constants.TaskSignal),
logBatchSize: 20,
}
// apply options
for _, opt := range opts {
opt(r)
}
// task
r.t, err = svc.GetTaskById(id)
if err != nil {
return nil, err
}
// spider
r.s, err = svc.GetSpiderById(r.t.GetSpiderId())
if err != nil {
return nil, err
}
// task fs service
r.fsSvc = fs2.NewFsServiceV2(filepath.Join(viper.GetString("workspace"), r.s.GetId().Hex()))
// dependency injection
if err := container.GetContainer().Invoke(func(
c interfaces.GrpcClient,
) {
r.c = c
}); err != nil {
return nil, trace.TraceError(err)
}
_ = container.GetContainer().Invoke(func(hookSvc interfaces.TaskHookService) {
r.hookSvc = hookSvc
})
// initialize task runner
if err := r.Init(); err != nil {
return r, err
}
return r, nil
}
|
2302_79757062/crawlab
|
core/task/handler/runner.go
|
Go
|
bsd-3-clause
| 16,765
|
package handler
import (
"bufio"
"context"
"encoding/json"
"fmt"
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
fs2 "github.com/crawlab-team/crawlab/core/fs"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/client"
"github.com/crawlab-team/crawlab/core/models/models"
service2 "github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/sys_exec"
"github.com/crawlab-team/crawlab/core/utils"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"github.com/shirou/gopsutil/process"
"github.com/sirupsen/logrus"
"github.com/spf13/viper"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"time"
)
type RunnerV2 struct {
// dependencies
svc *ServiceV2 // task handler service
fsSvc interfaces.FsServiceV2 // task fs service
// settings
subscribeTimeout time.Duration
bufferSize int
// internals
cmd *exec.Cmd // process command instance
pid int // process id
tid primitive.ObjectID // task id
t *models.TaskV2 // task model.Task
s *models.SpiderV2 // spider model.Spider
ch chan constants.TaskSignal // channel to communicate between Service and RunnerV2
err error // standard process error
envs []models.Env // environment variables
cwd string // working directory
c interfaces.GrpcClient // grpc client
sub grpc.TaskService_SubscribeClient // grpc task service stream client
// log internals
scannerStdout *bufio.Reader
scannerStderr *bufio.Reader
logBatchSize int
}
func (r *RunnerV2) Init() (err error) {
// update task
if err := r.updateTask("", nil); err != nil {
return err
}
// start grpc client
if !r.c.IsStarted() {
r.c.Start()
}
// working directory
workspacePath := viper.GetString("workspace")
r.cwd = filepath.Join(workspacePath, r.s.Id.Hex())
// sync files from master
if !utils.IsMaster() {
if err := r.syncFiles(); err != nil {
return err
}
}
// grpc task service stream client
if err := r.initSub(); err != nil {
return err
}
return nil
}
func (r *RunnerV2) Run() (err error) {
// log task started
log.Infof("task[%s] started", r.tid.Hex())
// configure cmd
r.configureCmd()
// configure environment variables
r.configureEnv()
// configure logging
r.configureLogging()
// start process
if err := r.cmd.Start(); err != nil {
return r.updateTask(constants.TaskStatusError, err)
}
// start logging
go r.startLogging()
// process id
if r.cmd.Process == nil {
return r.updateTask(constants.TaskStatusError, constants.ErrNotExists)
}
r.pid = r.cmd.Process.Pid
r.t.Pid = r.pid
// update task status (processing)
if err := r.updateTask(constants.TaskStatusRunning, nil); err != nil {
return err
}
// wait for process to finish
go r.wait()
// start health check
go r.startHealthCheck()
// declare task status
status := ""
// wait for signal
signal := <-r.ch
switch signal {
case constants.TaskSignalFinish:
err = nil
status = constants.TaskStatusFinished
case constants.TaskSignalCancel:
err = constants.ErrTaskCancelled
status = constants.TaskStatusCancelled
case constants.TaskSignalError:
err = r.err
status = constants.TaskStatusError
case constants.TaskSignalLost:
err = constants.ErrTaskLost
status = constants.TaskStatusError
default:
err = constants.ErrInvalidSignal
status = constants.TaskStatusError
}
// update task status
if err := r.updateTask(status, err); err != nil {
return err
}
return err
}
func (r *RunnerV2) Cancel() (err error) {
// kill process
opts := &sys_exec.KillProcessOptions{
Timeout: r.svc.GetCancelTimeout(),
Force: true,
}
if err := sys_exec.KillProcess(r.cmd, opts); err != nil {
return err
}
// make sure the process does not exist
op := func() error {
if exists, _ := process.PidExists(int32(r.pid)); exists {
return errors.ErrorTaskProcessStillExists
}
return nil
}
ctx, cancel := context.WithTimeout(context.Background(), r.svc.GetExitWatchDuration())
defer cancel()
b := backoff.WithContext(backoff.NewConstantBackOff(1*time.Second), ctx)
if err := backoff.Retry(op, b); err != nil {
return trace.TraceError(errors.ErrorTaskUnableToCancel)
}
return nil
}
// CleanUp clean up task runner
func (r *RunnerV2) CleanUp() (err error) {
return nil
}
func (r *RunnerV2) SetSubscribeTimeout(timeout time.Duration) {
r.subscribeTimeout = timeout
}
func (r *RunnerV2) GetTaskId() (id primitive.ObjectID) {
return r.tid
}
func (r *RunnerV2) configureCmd() {
var cmdStr string
// customized spider
if r.t.Cmd == "" {
cmdStr = r.s.Cmd
} else {
cmdStr = r.t.Cmd
}
// parameters
if r.t.Param != "" {
cmdStr += " " + r.t.Param
} else if r.s.Param != "" {
cmdStr += " " + r.s.Param
}
// get cmd instance
r.cmd = sys_exec.BuildCmd(cmdStr)
// set working directory
r.cmd.Dir = r.cwd
// configure pgid to allow killing sub processes
//sys_exec.SetPgid(r.cmd)
}
func (r *RunnerV2) configureLogging() {
// set stdout reader
stdout, _ := r.cmd.StdoutPipe()
r.scannerStdout = bufio.NewReaderSize(stdout, r.bufferSize)
// set stderr reader
stderr, _ := r.cmd.StderrPipe()
r.scannerStderr = bufio.NewReaderSize(stderr, r.bufferSize)
}
func (r *RunnerV2) startLogging() {
// start reading stdout
go r.startLoggingReaderStdout()
// start reading stderr
go r.startLoggingReaderStderr()
}
func (r *RunnerV2) startLoggingReaderStdout() {
for {
line, err := r.scannerStdout.ReadString(byte('\n'))
if err != nil {
break
}
line = strings.TrimSuffix(line, "\n")
r.writeLogLines([]string{line})
}
}
func (r *RunnerV2) startLoggingReaderStderr() {
for {
line, err := r.scannerStderr.ReadString(byte('\n'))
if err != nil {
break
}
line = strings.TrimSuffix(line, "\n")
r.writeLogLines([]string{line})
}
}
func (r *RunnerV2) startHealthCheck() {
if r.cmd.ProcessState == nil || r.cmd.ProcessState.Exited() {
return
}
for {
exists, _ := process.PidExists(int32(r.pid))
if !exists {
// process lost
r.ch <- constants.TaskSignalLost
return
}
time.Sleep(1 * time.Second)
}
}
func (r *RunnerV2) configureEnv() {
// 默认把Node.js的全局node_modules加入环境变量
envPath := os.Getenv("PATH")
nodePath := "/usr/lib/node_modules"
if !strings.Contains(envPath, nodePath) {
_ = os.Setenv("PATH", nodePath+":"+envPath)
}
_ = os.Setenv("NODE_PATH", nodePath)
// default envs
r.cmd.Env = append(os.Environ(), "CRAWLAB_TASK_ID="+r.tid.Hex())
if viper.GetString("grpc.address") != "" {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_ADDRESS="+viper.GetString("grpc.address"))
}
if viper.GetString("grpc.authKey") != "" {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_AUTH_KEY="+viper.GetString("grpc.authKey"))
} else {
r.cmd.Env = append(r.cmd.Env, "CRAWLAB_GRPC_AUTH_KEY="+constants.DefaultGrpcAuthKey)
}
// global environment variables
envs, err := client.NewModelServiceV2[models.EnvironmentV2]().GetMany(nil, nil)
if err != nil {
trace.PrintError(err)
return
}
for _, env := range envs {
r.cmd.Env = append(r.cmd.Env, env.Key+"="+env.Value)
}
}
func (r *RunnerV2) syncFiles() (err error) {
masterURL := fmt.Sprintf("%s/sync/%s", viper.GetString("api.endpoint"), r.s.Id.Hex())
workspacePath := viper.GetString("workspace")
workerDir := filepath.Join(workspacePath, r.s.Id.Hex())
// get file list from master
resp, err := http.Get(masterURL + "/scan")
if err != nil {
fmt.Println("Error getting file list from master:", err)
return trace.TraceError(err)
}
defer resp.Body.Close()
body, err := io.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response body:", err)
return trace.TraceError(err)
}
var masterFiles map[string]entity.FsFileInfo
err = json.Unmarshal(body, &masterFiles)
if err != nil {
fmt.Println("Error unmarshaling JSON:", err)
return trace.TraceError(err)
}
// create a map for master files
masterFilesMap := make(map[string]entity.FsFileInfo)
for _, file := range masterFiles {
masterFilesMap[file.Path] = file
}
// create worker directory if not exists
if _, err := os.Stat(workerDir); os.IsNotExist(err) {
if err := os.MkdirAll(workerDir, os.ModePerm); err != nil {
fmt.Println("Error creating worker directory:", err)
return trace.TraceError(err)
}
}
// get file list from worker
workerFiles, err := utils.ScanDirectory(workerDir)
if err != nil {
fmt.Println("Error scanning worker directory:", err)
return trace.TraceError(err)
}
// set up wait group and error channel
var wg sync.WaitGroup
errCh := make(chan error, 1)
// delete files that are deleted on master node
for path, workerFile := range workerFiles {
if _, exists := masterFilesMap[path]; !exists {
fmt.Println("Deleting file:", path)
err := os.Remove(workerFile.FullPath)
if err != nil {
fmt.Println("Error deleting file:", err)
}
}
}
// download files that are new or modified on master node
for path, masterFile := range masterFilesMap {
workerFile, exists := workerFiles[path]
if !exists || masterFile.Hash != workerFile.Hash {
wg.Add(1)
go func(path string, masterFile entity.FsFileInfo) {
defer wg.Done()
logrus.Infof("File needs to be synchronized: %s", path)
err := r.downloadFile(masterURL+"/download?path="+path, filepath.Join(workerDir, path))
if err != nil {
logrus.Errorf("Error downloading file: %v", err)
select {
case errCh <- err:
default:
}
}
}(path, masterFile)
}
}
wg.Wait()
close(errCh)
if err := <-errCh; err != nil {
return err
}
return nil
}
func (r *RunnerV2) downloadFile(url string, filePath string) error {
resp, err := http.Get(url)
if err != nil {
return err
}
defer resp.Body.Close()
out, err := os.Create(filePath)
if err != nil {
return err
}
defer out.Close()
_, err = io.Copy(out, resp.Body)
return err
}
// wait for process to finish and send task signal (constants.TaskSignal)
// to task runner's channel (RunnerV2.ch) according to exit code
func (r *RunnerV2) wait() {
// wait for process to finish
if err := r.cmd.Wait(); err != nil {
exitError, ok := err.(*exec.ExitError)
if !ok {
r.ch <- constants.TaskSignalError
return
}
exitCode := exitError.ExitCode()
if exitCode == -1 {
// cancel error
r.ch <- constants.TaskSignalCancel
return
}
// standard error
r.err = err
r.ch <- constants.TaskSignalError
return
}
// success
r.ch <- constants.TaskSignalFinish
}
// updateTask update and get updated info of task (RunnerV2.t)
func (r *RunnerV2) updateTask(status string, e error) (err error) {
if r.t != nil && status != "" {
// update task status
r.t.Status = status
if e != nil {
r.t.Error = e.Error()
}
if r.svc.GetNodeConfigService().IsMaster() {
err = service2.NewModelServiceV2[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
if err != nil {
return err
}
} else {
err = client.NewModelServiceV2[models.TaskV2]().ReplaceById(r.t.Id, *r.t)
if err != nil {
return err
}
}
// send notification
go r.sendNotification()
// update stats
go func() {
r._updateTaskStat(status)
r._updateSpiderStat(status)
}()
}
// get task
r.t, err = r.svc.GetTaskById(r.tid)
if err != nil {
return err
}
return nil
}
func (r *RunnerV2) initSub() (err error) {
r.sub, err = r.c.GetTaskClient().Subscribe(context.Background())
if err != nil {
return trace.TraceError(err)
}
return nil
}
func (r *RunnerV2) writeLogLines(lines []string) {
data, err := json.Marshal(&entity.StreamMessageTaskData{
TaskId: r.tid,
Logs: lines,
})
if err != nil {
trace.PrintError(err)
return
}
msg := &grpc.StreamMessage{
Code: grpc.StreamMessageCode_INSERT_LOGS,
Data: data,
}
if err := r.sub.Send(msg); err != nil {
trace.PrintError(err)
return
}
}
func (r *RunnerV2) _updateTaskStat(status string) {
ts, err := client.NewModelServiceV2[models.TaskStatV2]().GetById(r.tid)
if err != nil {
trace.PrintError(err)
return
}
switch status {
case constants.TaskStatusPending:
// do nothing
case constants.TaskStatusRunning:
ts.StartTs = time.Now()
ts.WaitDuration = ts.StartTs.Sub(ts.CreateTs).Milliseconds()
case constants.TaskStatusFinished, constants.TaskStatusError, constants.TaskStatusCancelled:
if ts.StartTs.IsZero() {
ts.StartTs = time.Now()
ts.WaitDuration = ts.StartTs.Sub(ts.CreateTs).Milliseconds()
}
ts.EndTs = time.Now()
ts.RuntimeDuration = ts.EndTs.Sub(ts.StartTs).Milliseconds()
ts.TotalDuration = ts.EndTs.Sub(ts.CreateTs).Milliseconds()
}
if r.svc.GetNodeConfigService().IsMaster() {
err = service2.NewModelServiceV2[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
if err != nil {
trace.PrintError(err)
return
}
} else {
err = client.NewModelServiceV2[models.TaskStatV2]().ReplaceById(ts.Id, *ts)
if err != nil {
trace.PrintError(err)
return
}
}
}
func (r *RunnerV2) sendNotification() {
data, err := json.Marshal(r.t)
if err != nil {
trace.PrintError(err)
return
}
req := &grpc.Request{
NodeKey: r.svc.GetNodeConfigService().GetNodeKey(),
Data: data,
}
_, err = r.c.GetTaskClient().SendNotification(context.Background(), req)
if err != nil {
trace.PrintError(err)
return
}
}
func (r *RunnerV2) _updateSpiderStat(status string) {
// task stat
ts, err := client.NewModelServiceV2[models.TaskStatV2]().GetById(r.tid)
if err != nil {
trace.PrintError(err)
return
}
// update
var update bson.M
switch status {
case constants.TaskStatusPending, constants.TaskStatusRunning:
update = bson.M{
"$set": bson.M{
"last_task_id": r.tid, // last task id
},
"$inc": bson.M{
"tasks": 1, // task count
"wait_duration": ts.WaitDuration, // wait duration
},
}
case constants.TaskStatusFinished, constants.TaskStatusError, constants.TaskStatusCancelled:
update = bson.M{
"$set": bson.M{
"last_task_id": r.tid, // last task id
},
"$inc": bson.M{
"results": ts.ResultCount, // results
"runtime_duration": ts.RuntimeDuration / 1000, // runtime duration
"total_duration": ts.TotalDuration / 1000, // total duration
},
}
default:
trace.PrintError(errors.ErrorTaskInvalidType)
return
}
// perform update
if r.svc.GetNodeConfigService().IsMaster() {
err = service2.NewModelServiceV2[models.SpiderStatV2]().UpdateById(r.s.Id, update)
if err != nil {
trace.PrintError(err)
return
}
} else {
err = client.NewModelServiceV2[models.SpiderStatV2]().UpdateById(r.s.Id, update)
if err != nil {
trace.PrintError(err)
return
}
}
}
func NewTaskRunnerV2(id primitive.ObjectID, svc *ServiceV2) (r2 *RunnerV2, err error) {
// validate options
if id.IsZero() {
return nil, constants.ErrInvalidOptions
}
// runner
r := &RunnerV2{
subscribeTimeout: 30 * time.Second,
bufferSize: 1024 * 1024,
svc: svc,
tid: id,
ch: make(chan constants.TaskSignal),
logBatchSize: 20,
}
// task
r.t, err = svc.GetTaskById(id)
if err != nil {
return nil, err
}
// spider
r.s, err = svc.GetSpiderById(r.t.SpiderId)
if err != nil {
return nil, err
}
// task fs service
r.fsSvc = fs2.NewFsServiceV2(filepath.Join(viper.GetString("workspace"), r.s.Id.Hex()))
// dependency injection
if err := container.GetContainer().Invoke(func(
c interfaces.GrpcClient,
) {
r.c = c
}); err != nil {
return nil, trace.TraceError(err)
}
// initialize task runner
if err := r.Init(); err != nil {
return r, err
}
return r, nil
}
|
2302_79757062/crawlab
|
core/task/handler/runner_v2.go
|
Go
|
bsd-3-clause
| 16,103
|
package handler
import (
"context"
"encoding/json"
"errors"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
errors2 "github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/client"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/task"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"sync"
"time"
)
type Service struct {
// dependencies
interfaces.TaskBaseService
cfgSvc interfaces.NodeConfigService
modelSvc service.ModelService
clientModelSvc interfaces.GrpcClientModelService
clientModelNodeSvc interfaces.GrpcClientModelNodeService
clientModelSpiderSvc interfaces.GrpcClientModelSpiderService
clientModelTaskSvc interfaces.GrpcClientModelTaskService
clientModelTaskStatSvc interfaces.GrpcClientModelTaskStatService
clientModelEnvironmentSvc interfaces.GrpcClientModelEnvironmentService
c interfaces.GrpcClient // grpc client
// settings
//maxRunners int
exitWatchDuration time.Duration
reportInterval time.Duration
fetchInterval time.Duration
fetchTimeout time.Duration
cancelTimeout time.Duration
// internals variables
stopped bool
mu sync.Mutex
runners sync.Map // pool of task runners started
syncLocks sync.Map // files sync locks map of task runners
}
func (svc *Service) Start() {
// Initialize gRPC if not started
if !svc.c.IsStarted() {
svc.c.Start()
}
go svc.ReportStatus()
go svc.Fetch()
}
func (svc *Service) Run(taskId primitive.ObjectID) (err error) {
return svc.run(taskId)
}
func (svc *Service) Reset() {
svc.mu.Lock()
defer svc.mu.Unlock()
}
func (svc *Service) Cancel(taskId primitive.ObjectID) (err error) {
r, err := svc.getRunner(taskId)
if err != nil {
return err
}
if err := r.Cancel(); err != nil {
return err
}
return nil
}
func (svc *Service) Fetch() {
for {
// wait
time.Sleep(svc.fetchInterval)
// current node
n, err := svc.GetCurrentNode()
if err != nil {
continue
}
// skip if node is not active or enabled
if !n.GetActive() || !n.GetEnabled() {
continue
}
// validate if there are available runners
if svc.getRunnerCount() >= n.GetMaxRunners() {
continue
}
// stop
if svc.stopped {
return
}
// fetch task
tid, err := svc.fetch()
if err != nil {
trace.PrintError(err)
continue
}
// skip if no task id
if tid.IsZero() {
continue
}
// run task
if err := svc.run(tid); err != nil {
trace.PrintError(err)
t, err := svc.GetTaskById(tid)
if err == nil && t.GetStatus() != constants.TaskStatusCancelled {
t.SetError(err.Error())
_ = svc.SaveTask(t, constants.TaskStatusError)
continue
}
continue
}
}
}
func (svc *Service) ReportStatus() {
for {
if svc.stopped {
return
}
// report handler status
if err := svc.reportStatus(); err != nil {
trace.PrintError(err)
}
// wait
time.Sleep(svc.reportInterval)
}
}
func (svc *Service) IsSyncLocked(path string) (ok bool) {
_, ok = svc.syncLocks.Load(path)
return ok
}
func (svc *Service) LockSync(path string) {
svc.syncLocks.Store(path, true)
}
func (svc *Service) UnlockSync(path string) {
svc.syncLocks.Delete(path)
}
//func (svc *Service) GetMaxRunners() (maxRunners int) {
// return svc.maxRunners
//}
//
//func (svc *Service) SetMaxRunners(maxRunners int) {
// svc.maxRunners = maxRunners
//}
func (svc *Service) GetExitWatchDuration() (duration time.Duration) {
return svc.exitWatchDuration
}
func (svc *Service) SetExitWatchDuration(duration time.Duration) {
svc.exitWatchDuration = duration
}
func (svc *Service) GetFetchInterval() (interval time.Duration) {
return svc.fetchInterval
}
func (svc *Service) SetFetchInterval(interval time.Duration) {
svc.fetchInterval = interval
}
func (svc *Service) GetReportInterval() (interval time.Duration) {
return svc.reportInterval
}
func (svc *Service) SetReportInterval(interval time.Duration) {
svc.reportInterval = interval
}
func (svc *Service) GetCancelTimeout() (timeout time.Duration) {
return svc.cancelTimeout
}
func (svc *Service) SetCancelTimeout(timeout time.Duration) {
svc.cancelTimeout = timeout
}
func (svc *Service) GetModelService() (modelSvc interfaces.GrpcClientModelService) {
return svc.clientModelSvc
}
func (svc *Service) GetModelSpiderService() (modelSpiderSvc interfaces.GrpcClientModelSpiderService) {
return svc.clientModelSpiderSvc
}
func (svc *Service) GetModelTaskService() (modelTaskSvc interfaces.GrpcClientModelTaskService) {
return svc.clientModelTaskSvc
}
func (svc *Service) GetModelTaskStatService() (modelTaskSvc interfaces.GrpcClientModelTaskStatService) {
return svc.clientModelTaskStatSvc
}
func (svc *Service) GetModelEnvironmentService() (modelTaskSvc interfaces.GrpcClientModelEnvironmentService) {
return svc.clientModelEnvironmentSvc
}
func (svc *Service) GetNodeConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *Service) GetCurrentNode() (n interfaces.Node, err error) {
// node key
nodeKey := svc.cfgSvc.GetNodeKey()
// current node
if svc.cfgSvc.IsMaster() {
n, err = svc.modelSvc.GetNodeByKey(nodeKey, nil)
} else {
n, err = svc.clientModelNodeSvc.GetNodeByKey(nodeKey)
}
if err != nil {
return nil, err
}
return n, nil
}
func (svc *Service) GetTaskById(id primitive.ObjectID) (t interfaces.Task, err error) {
if svc.cfgSvc.IsMaster() {
t, err = svc.modelSvc.GetTaskById(id)
} else {
t, err = svc.clientModelTaskSvc.GetTaskById(id)
}
if err != nil {
return nil, err
}
return t, nil
}
func (svc *Service) GetSpiderById(id primitive.ObjectID) (s interfaces.Spider, err error) {
if svc.cfgSvc.IsMaster() {
s, err = svc.modelSvc.GetSpiderById(id)
} else {
s, err = svc.clientModelSpiderSvc.GetSpiderById(id)
}
if err != nil {
return nil, err
}
return s, nil
}
func (svc *Service) getRunners() (runners []*Runner) {
svc.mu.Lock()
defer svc.mu.Unlock()
svc.runners.Range(func(key, value interface{}) bool {
r := value.(Runner)
runners = append(runners, &r)
return true
})
return runners
}
func (svc *Service) getRunnerCount() (count int) {
n, err := svc.GetCurrentNode()
if err != nil {
trace.PrintError(err)
return
}
query := bson.M{
"node_id": n.GetId(),
"status": constants.TaskStatusRunning,
}
if svc.cfgSvc.IsMaster() {
count, err = svc.modelSvc.GetBaseService(interfaces.ModelIdTask).Count(query)
if err != nil {
trace.PrintError(err)
return
}
} else {
count, err = svc.clientModelTaskSvc.Count(query)
if err != nil {
trace.PrintError(err)
return
}
}
return count
}
func (svc *Service) getRunner(taskId primitive.ObjectID) (r interfaces.TaskRunner, err error) {
log.Debugf("[TaskHandlerService] getRunner: taskId[%v]", taskId)
v, ok := svc.runners.Load(taskId)
if !ok {
return nil, trace.TraceError(errors2.ErrorTaskNotExists)
}
switch v.(type) {
case interfaces.TaskRunner:
r = v.(interfaces.TaskRunner)
default:
return nil, trace.TraceError(errors2.ErrorModelInvalidType)
}
return r, nil
}
func (svc *Service) addRunner(taskId primitive.ObjectID, r interfaces.TaskRunner) {
log.Debugf("[TaskHandlerService] addRunner: taskId[%v]", taskId)
svc.runners.Store(taskId, r)
}
func (svc *Service) deleteRunner(taskId primitive.ObjectID) {
log.Debugf("[TaskHandlerService] deleteRunner: taskId[%v]", taskId)
svc.runners.Delete(taskId)
}
func (svc *Service) saveTask(t interfaces.Task, status string) (err error) {
// normalize status
if status == "" {
status = constants.TaskStatusPending
}
// set task status
t.SetStatus(status)
// attempt to get task from database
_, err = svc.clientModelTaskSvc.GetTaskById(t.GetId())
if err != nil {
// if task does not exist, add to database
if err == mongo.ErrNoDocuments {
if err := client.NewModelDelegate(t, client.WithDelegateConfigPath(svc.GetConfigPath())).Add(); err != nil {
return err
}
return nil
} else {
return err
}
} else {
// otherwise, update
if err := client.NewModelDelegate(t, client.WithDelegateConfigPath(svc.GetConfigPath())).Save(); err != nil {
return err
}
return nil
}
}
func (svc *Service) reportStatus() (err error) {
// current node
n, err := svc.GetCurrentNode()
if err != nil {
return err
}
// available runners of handler
ar := n.GetMaxRunners() - svc.getRunnerCount()
// set available runners
n.SetAvailableRunners(ar)
// save node
if svc.cfgSvc.IsMaster() {
err = delegate.NewModelDelegate(n).Save()
} else {
err = client.NewModelDelegate(n, client.WithDelegateConfigPath(svc.GetConfigPath())).Save()
}
if err != nil {
return err
}
return nil
}
func (svc *Service) fetch() (tid primitive.ObjectID, err error) {
ctx, cancel := context.WithTimeout(context.Background(), svc.fetchTimeout)
defer cancel()
res, err := svc.c.GetTaskClient().Fetch(ctx, svc.c.NewRequest(nil))
if err != nil {
return tid, trace.TraceError(err)
}
if err := json.Unmarshal(res.Data, &tid); err != nil {
return tid, trace.TraceError(err)
}
return tid, nil
}
func (svc *Service) run(taskId primitive.ObjectID) (err error) {
// attempt to get runner from pool
_, ok := svc.runners.Load(taskId)
if ok {
return trace.TraceError(errors2.ErrorTaskAlreadyExists)
}
// create a new task runner
r, err := NewTaskRunner(taskId, svc)
if err != nil {
return trace.TraceError(err)
}
// add runner to pool
svc.addRunner(taskId, r)
// create a goroutine to run task
go func() {
// delete runner from pool
defer svc.deleteRunner(r.GetTaskId())
defer func(r interfaces.TaskRunner) {
err := r.CleanUp()
if err != nil {
log.Errorf("task[%s] clean up error: %v", r.GetTaskId().Hex(), err)
}
}(r)
// run task process (blocking)
// error or finish after task runner ends
if err := r.Run(); err != nil {
switch {
case errors.Is(err, constants.ErrTaskError):
log.Errorf("task[%s] finished with error: %v", r.GetTaskId().Hex(), err)
case errors.Is(err, constants.ErrTaskCancelled):
log.Errorf("task[%s] cancelled", r.GetTaskId().Hex())
default:
log.Errorf("task[%s] finished with unknown error: %v", r.GetTaskId().Hex(), err)
}
}
log.Infof("task[%s] finished", r.GetTaskId().Hex())
}()
return nil
}
func NewTaskHandlerService() (svc2 interfaces.TaskHandlerService, err error) {
// base service
baseSvc, err := task.NewBaseService()
if err != nil {
return nil, trace.TraceError(err)
}
// service
svc := &Service{
TaskBaseService: baseSvc,
exitWatchDuration: 60 * time.Second,
fetchInterval: 1 * time.Second,
fetchTimeout: 15 * time.Second,
reportInterval: 5 * time.Second,
cancelTimeout: 5 * time.Second,
mu: sync.Mutex{},
runners: sync.Map{},
syncLocks: sync.Map{},
}
// dependency injection
if err := container.GetContainer().Invoke(func(
cfgSvc interfaces.NodeConfigService,
modelSvc service.ModelService,
clientModelSvc interfaces.GrpcClientModelService,
clientModelNodeSvc interfaces.GrpcClientModelNodeService,
clientModelSpiderSvc interfaces.GrpcClientModelSpiderService,
clientModelTaskSvc interfaces.GrpcClientModelTaskService,
clientModelTaskStatSvc interfaces.GrpcClientModelTaskStatService,
clientModelEnvironmentSvc interfaces.GrpcClientModelEnvironmentService,
c interfaces.GrpcClient,
) {
svc.cfgSvc = cfgSvc
svc.modelSvc = modelSvc
svc.clientModelSvc = clientModelSvc
svc.clientModelNodeSvc = clientModelNodeSvc
svc.clientModelSpiderSvc = clientModelSpiderSvc
svc.clientModelTaskSvc = clientModelTaskSvc
svc.clientModelTaskStatSvc = clientModelTaskStatSvc
svc.clientModelEnvironmentSvc = clientModelEnvironmentSvc
svc.c = c
}); err != nil {
return nil, trace.TraceError(err)
}
log.Debugf("[NewTaskHandlerService] svc[cfgPath: %s]", svc.cfgSvc.GetConfigPath())
return svc, nil
}
var _service interfaces.TaskHandlerService
func GetTaskHandlerService() (svr interfaces.TaskHandlerService, err error) {
if _service != nil {
return _service, nil
}
_service, err = NewTaskHandlerService()
if err != nil {
return nil, err
}
return _service, nil
}
|
2302_79757062/crawlab
|
core/task/handler/service.go
|
Go
|
bsd-3-clause
| 12,542
|
package handler
import (
"context"
"encoding/json"
"errors"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
errors2 "github.com/crawlab-team/crawlab/core/errors"
grpcclient "github.com/crawlab-team/crawlab/core/grpc/client"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/client"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
"time"
)
type ServiceV2 struct {
// dependencies
cfgSvc interfaces.NodeConfigService
c *grpcclient.GrpcClientV2 // grpc client
// settings
//maxRunners int
exitWatchDuration time.Duration
reportInterval time.Duration
fetchInterval time.Duration
fetchTimeout time.Duration
cancelTimeout time.Duration
// internals variables
stopped bool
mu sync.Mutex
runners sync.Map // pool of task runners started
syncLocks sync.Map // files sync locks map of task runners
}
func (svc *ServiceV2) Start() {
// Initialize gRPC if not started
if !svc.c.IsStarted() {
svc.c.Start()
}
go svc.ReportStatus()
go svc.Fetch()
}
func (svc *ServiceV2) Run(taskId primitive.ObjectID) (err error) {
return svc.run(taskId)
}
func (svc *ServiceV2) Reset() {
svc.mu.Lock()
defer svc.mu.Unlock()
}
func (svc *ServiceV2) Cancel(taskId primitive.ObjectID) (err error) {
r, err := svc.getRunner(taskId)
if err != nil {
return err
}
if err := r.Cancel(); err != nil {
return err
}
return nil
}
func (svc *ServiceV2) Fetch() {
for {
// wait
time.Sleep(svc.fetchInterval)
// current node
n, err := svc.GetCurrentNode()
if err != nil {
continue
}
// skip if node is not active or enabled
if !n.Active || !n.Enabled {
continue
}
// validate if there are available runners
if svc.getRunnerCount() >= n.MaxRunners {
continue
}
// stop
if svc.stopped {
return
}
// fetch task
tid, err := svc.fetch()
if err != nil {
trace.PrintError(err)
continue
}
// skip if no task id
if tid.IsZero() {
continue
}
// run task
if err := svc.run(tid); err != nil {
trace.PrintError(err)
t, err := svc.GetTaskById(tid)
if err == nil && t.Status != constants.TaskStatusCancelled {
t.Error = err.Error()
t.Status = constants.TaskStatusError
t.SetUpdated(t.CreatedBy)
continue
}
continue
}
}
}
func (svc *ServiceV2) ReportStatus() {
for {
if svc.stopped {
return
}
// report handler status
if err := svc.reportStatus(); err != nil {
trace.PrintError(err)
}
// wait
time.Sleep(svc.reportInterval)
}
}
func (svc *ServiceV2) IsSyncLocked(path string) (ok bool) {
_, ok = svc.syncLocks.Load(path)
return ok
}
func (svc *ServiceV2) LockSync(path string) {
svc.syncLocks.Store(path, true)
}
func (svc *ServiceV2) UnlockSync(path string) {
svc.syncLocks.Delete(path)
}
//func (svc *ServiceV2) GetMaxRunners() (maxRunners int) {
// return svc.maxRunners
//}
//
//func (svc *ServiceV2) SetMaxRunners(maxRunners int) {
// svc.maxRunners = maxRunners
//}
func (svc *ServiceV2) GetExitWatchDuration() (duration time.Duration) {
return svc.exitWatchDuration
}
func (svc *ServiceV2) SetExitWatchDuration(duration time.Duration) {
svc.exitWatchDuration = duration
}
func (svc *ServiceV2) GetFetchInterval() (interval time.Duration) {
return svc.fetchInterval
}
func (svc *ServiceV2) SetFetchInterval(interval time.Duration) {
svc.fetchInterval = interval
}
func (svc *ServiceV2) GetReportInterval() (interval time.Duration) {
return svc.reportInterval
}
func (svc *ServiceV2) SetReportInterval(interval time.Duration) {
svc.reportInterval = interval
}
func (svc *ServiceV2) GetCancelTimeout() (timeout time.Duration) {
return svc.cancelTimeout
}
func (svc *ServiceV2) SetCancelTimeout(timeout time.Duration) {
svc.cancelTimeout = timeout
}
func (svc *ServiceV2) GetNodeConfigService() (cfgSvc interfaces.NodeConfigService) {
return svc.cfgSvc
}
func (svc *ServiceV2) GetCurrentNode() (n *models.NodeV2, err error) {
// node key
nodeKey := svc.cfgSvc.GetNodeKey()
// current node
if svc.cfgSvc.IsMaster() {
n, err = service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
} else {
n, err = client.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
}
if err != nil {
return nil, err
}
return n, nil
}
func (svc *ServiceV2) GetTaskById(id primitive.ObjectID) (t *models.TaskV2, err error) {
if svc.cfgSvc.IsMaster() {
t, err = service.NewModelServiceV2[models.TaskV2]().GetById(id)
} else {
t, err = client.NewModelServiceV2[models.TaskV2]().GetById(id)
}
if err != nil {
return nil, err
}
return t, nil
}
func (svc *ServiceV2) GetSpiderById(id primitive.ObjectID) (s *models.SpiderV2, err error) {
if svc.cfgSvc.IsMaster() {
s, err = service.NewModelServiceV2[models.SpiderV2]().GetById(id)
} else {
s, err = client.NewModelServiceV2[models.SpiderV2]().GetById(id)
}
if err != nil {
return nil, err
}
return s, nil
}
func (svc *ServiceV2) getRunners() (runners []*Runner) {
svc.mu.Lock()
defer svc.mu.Unlock()
svc.runners.Range(func(key, value interface{}) bool {
r := value.(Runner)
runners = append(runners, &r)
return true
})
return runners
}
func (svc *ServiceV2) getRunnerCount() (count int) {
n, err := svc.GetCurrentNode()
if err != nil {
trace.PrintError(err)
return
}
query := bson.M{
"node_id": n.Id,
"status": constants.TaskStatusRunning,
}
if svc.cfgSvc.IsMaster() {
count, err = service.NewModelServiceV2[models.TaskV2]().Count(query)
if err != nil {
trace.PrintError(err)
return
}
} else {
count, err = client.NewModelServiceV2[models.TaskV2]().Count(query)
if err != nil {
trace.PrintError(err)
return
}
}
return count
}
func (svc *ServiceV2) getRunner(taskId primitive.ObjectID) (r interfaces.TaskRunner, err error) {
log.Debugf("[TaskHandlerService] getRunner: taskId[%v]", taskId)
v, ok := svc.runners.Load(taskId)
if !ok {
return nil, trace.TraceError(errors2.ErrorTaskNotExists)
}
switch v.(type) {
case interfaces.TaskRunner:
r = v.(interfaces.TaskRunner)
default:
return nil, trace.TraceError(errors2.ErrorModelInvalidType)
}
return r, nil
}
func (svc *ServiceV2) addRunner(taskId primitive.ObjectID, r interfaces.TaskRunner) {
log.Debugf("[TaskHandlerService] addRunner: taskId[%v]", taskId)
svc.runners.Store(taskId, r)
}
func (svc *ServiceV2) deleteRunner(taskId primitive.ObjectID) {
log.Debugf("[TaskHandlerService] deleteRunner: taskId[%v]", taskId)
svc.runners.Delete(taskId)
}
func (svc *ServiceV2) reportStatus() (err error) {
// current node
n, err := svc.GetCurrentNode()
if err != nil {
return err
}
// available runners of handler
ar := n.MaxRunners - svc.getRunnerCount()
// set available runners
n.AvailableRunners = ar
// save node
n.SetUpdated(n.CreatedBy)
if svc.cfgSvc.IsMaster() {
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(n.Id, *n)
} else {
err = client.NewModelServiceV2[models.NodeV2]().ReplaceById(n.Id, *n)
}
if err != nil {
return err
}
return nil
}
func (svc *ServiceV2) fetch() (tid primitive.ObjectID, err error) {
ctx, cancel := context.WithTimeout(context.Background(), svc.fetchTimeout)
defer cancel()
res, err := svc.c.TaskClient.Fetch(ctx, svc.c.NewRequest(nil))
if err != nil {
return tid, trace.TraceError(err)
}
if err := json.Unmarshal(res.Data, &tid); err != nil {
return tid, trace.TraceError(err)
}
return tid, nil
}
func (svc *ServiceV2) run(taskId primitive.ObjectID) (err error) {
// attempt to get runner from pool
_, ok := svc.runners.Load(taskId)
if ok {
return trace.TraceError(errors2.ErrorTaskAlreadyExists)
}
// create a new task runner
r, err := NewTaskRunnerV2(taskId, svc)
if err != nil {
return trace.TraceError(err)
}
// add runner to pool
svc.addRunner(taskId, r)
// create a goroutine to run task
go func() {
// delete runner from pool
defer svc.deleteRunner(r.GetTaskId())
defer func(r interfaces.TaskRunner) {
err := r.CleanUp()
if err != nil {
log.Errorf("task[%s] clean up error: %v", r.GetTaskId().Hex(), err)
}
}(r)
// run task process (blocking)
// error or finish after task runner ends
if err := r.Run(); err != nil {
switch {
case errors.Is(err, constants.ErrTaskError):
log.Errorf("task[%s] finished with error: %v", r.GetTaskId().Hex(), err)
case errors.Is(err, constants.ErrTaskCancelled):
log.Errorf("task[%s] cancelled", r.GetTaskId().Hex())
default:
log.Errorf("task[%s] finished with unknown error: %v", r.GetTaskId().Hex(), err)
}
}
log.Infof("task[%s] finished", r.GetTaskId().Hex())
}()
return nil
}
func NewTaskHandlerServiceV2() (svc2 *ServiceV2, err error) {
// service
svc := &ServiceV2{
exitWatchDuration: 60 * time.Second,
fetchInterval: 1 * time.Second,
fetchTimeout: 15 * time.Second,
reportInterval: 5 * time.Second,
cancelTimeout: 5 * time.Second,
mu: sync.Mutex{},
runners: sync.Map{},
syncLocks: sync.Map{},
}
// dependency injection
svc.cfgSvc = nodeconfig.GetNodeConfigService()
// grpc client
svc.c, err = grpcclient.NewGrpcClientV2()
if err != nil {
return nil, err
}
log.Debugf("[NewTaskHandlerService] svc[cfgPath: %s]", svc.cfgSvc.GetConfigPath())
return svc, nil
}
var _serviceV2 *ServiceV2
func GetTaskHandlerServiceV2() (svr *ServiceV2, err error) {
if _serviceV2 != nil {
return _serviceV2, nil
}
_serviceV2, err = NewTaskHandlerServiceV2()
if err != nil {
return nil, err
}
return _serviceV2, nil
}
|
2302_79757062/crawlab
|
core/task/handler/service_v2.go
|
Go
|
bsd-3-clause
| 9,856
|
package log
const (
MetadataName = "metadata.json"
)
const (
DriverTypeFile = "file" // raw file
DriverTypeFs = "fs" // file system (SeaweedFS)
DriverTypeMongo = "mongo" // mongodb
DriverTypeEs = "es" // elastic search
)
|
2302_79757062/crawlab
|
core/task/log/constants.go
|
Go
|
bsd-3-clause
| 242
|
package log
import "time"
var DefaultLogTtl = 30 * 24 * time.Hour
|
2302_79757062/crawlab
|
core/task/log/default.go
|
Go
|
bsd-3-clause
| 68
|
package log
func GetLogDriver(logDriverType string) (driver Driver, err error) {
switch logDriverType {
case DriverTypeFile:
driver, err = GetFileLogDriver()
if err != nil {
return driver, err
}
case DriverTypeMongo:
return driver, ErrNotImplemented
case DriverTypeEs:
return driver, ErrNotImplemented
default:
return driver, ErrInvalidType
}
return driver, nil
}
|
2302_79757062/crawlab
|
core/task/log/driver.go
|
Go
|
bsd-3-clause
| 387
|
package log
import "time"
type Message struct {
Id int64 `json:"id" bson:"id"`
Msg string `json:"msg" bson:"msg"`
Ts time.Time `json:"ts" bson:"ts"`
}
type Metadata struct {
Size int64 `json:"size,omitempty" bson:"size"`
TotalLines int64 `json:"total_lines,omitempty" bson:"total_lines"`
TotalBytes int64 `json:"total_bytes,omitempty" bson:"total_bytes"`
Md5 string `json:"md5,omitempty" bson:"md5"`
}
|
2302_79757062/crawlab
|
core/task/log/entity.go
|
Go
|
bsd-3-clause
| 437
|
package log
import "errors"
var (
ErrInvalidType = errors.New("invalid type")
ErrNotImplemented = errors.New("not implemented")
)
|
2302_79757062/crawlab
|
core/task/log/errors.go
|
Go
|
bsd-3-clause
| 137
|
package log
import (
"bufio"
"bytes"
"errors"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
"io"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"time"
)
type FileLogDriver struct {
// settings
logFileName string
rootPath string
// internals
mu sync.Mutex
}
func (d *FileLogDriver) Init() (err error) {
go d.cleanup()
return nil
}
func (d *FileLogDriver) Close() (err error) {
return nil
}
func (d *FileLogDriver) WriteLine(id string, line string) (err error) {
d.initDir(id)
d.mu.Lock()
defer d.mu.Unlock()
filePath := d.getLogFilePath(id, d.logFileName)
f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_APPEND|os.O_CREATE, os.FileMode(0760))
if err != nil {
return trace.TraceError(err)
}
defer func(f *os.File) {
err := f.Close()
if err != nil {
log.Errorf("close file error: %s", err.Error())
}
}(f)
_, err = f.WriteString(line + "\n")
if err != nil {
return trace.TraceError(err)
}
return nil
}
func (d *FileLogDriver) WriteLines(id string, lines []string) (err error) {
linesString := strings.Join(lines, "\n")
if err := d.WriteLine(id, linesString); err != nil {
return err
}
return nil
}
func (d *FileLogDriver) Find(id string, pattern string, skip int, limit int) (lines []string, err error) {
if pattern != "" {
return lines, errors.New("not implemented")
}
if !utils.Exists(d.getLogFilePath(id, d.logFileName)) {
return nil, nil
}
f, err := os.Open(d.getLogFilePath(id, d.logFileName))
if err != nil {
return nil, trace.TraceError(err)
}
defer f.Close()
sc := bufio.NewReaderSize(f, 1024*1024*10)
i := -1
for {
line, err := sc.ReadString(byte('\n'))
if err != nil {
break
}
line = strings.TrimSuffix(line, "\n")
i++
if i < skip {
continue
}
if i >= skip+limit {
break
}
lines = append(lines, line)
}
return lines, nil
}
func (d *FileLogDriver) Count(id string, pattern string) (n int, err error) {
if pattern != "" {
return n, errors.New("not implemented")
}
if !utils.Exists(d.getLogFilePath(id, d.logFileName)) {
return 0, nil
}
f, err := os.Open(d.getLogFilePath(id, d.logFileName))
if err != nil {
return n, trace.TraceError(err)
}
return d.lineCounter(f)
}
func (d *FileLogDriver) Flush() (err error) {
return nil
}
func (d *FileLogDriver) getLogPath() (logPath string) {
return viper.GetString("log.path")
}
func (d *FileLogDriver) getBasePath(id string) (filePath string) {
return filepath.Join(d.getLogPath(), id)
}
func (d *FileLogDriver) getMetadataPath(id string) (filePath string) {
return filepath.Join(d.getBasePath(id), MetadataName)
}
func (d *FileLogDriver) getLogFilePath(id, fileName string) (filePath string) {
return filepath.Join(d.getBasePath(id), fileName)
}
func (d *FileLogDriver) getLogFiles(id string) (files []os.FileInfo) {
// 增加了对返回异常的捕获
files, err := utils.ListDir(d.getBasePath(id))
if err != nil {
trace.PrintError(err)
return nil
}
return
}
func (d *FileLogDriver) initDir(id string) {
if !utils.Exists(d.getBasePath(id)) {
if err := os.MkdirAll(d.getBasePath(id), os.FileMode(0770)); err != nil {
trace.PrintError(err)
}
}
}
func (d *FileLogDriver) lineCounter(r io.Reader) (n int, err error) {
buf := make([]byte, 32*1024)
count := 0
lineSep := []byte{'\n'}
for {
c, err := r.Read(buf)
count += bytes.Count(buf[:c], lineSep)
switch {
case err == io.EOF:
return count, nil
case err != nil:
return count, err
}
}
}
func (d *FileLogDriver) getTtl() time.Duration {
ttl := viper.GetString("log.ttl")
if ttl == "" {
return DefaultLogTtl
}
if strings.HasSuffix(ttl, "s") {
ttl = strings.TrimSuffix(ttl, "s")
n, err := strconv.Atoi(ttl)
if err != nil {
return DefaultLogTtl
}
return time.Duration(n) * time.Second
} else if strings.HasSuffix(ttl, "m") {
ttl = strings.TrimSuffix(ttl, "m")
n, err := strconv.Atoi(ttl)
if err != nil {
return DefaultLogTtl
}
return time.Duration(n) * time.Minute
} else if strings.HasSuffix(ttl, "h") {
ttl = strings.TrimSuffix(ttl, "h")
n, err := strconv.Atoi(ttl)
if err != nil {
return DefaultLogTtl
}
return time.Duration(n) * time.Hour
} else if strings.HasSuffix(ttl, "d") {
ttl = strings.TrimSuffix(ttl, "d")
n, err := strconv.Atoi(ttl)
if err != nil {
return DefaultLogTtl
}
return time.Duration(n) * 24 * time.Hour
} else {
return DefaultLogTtl
}
}
func (d *FileLogDriver) cleanup() {
if d.getLogPath() == "" {
return
}
if !utils.Exists(d.getLogPath()) {
if err := os.MkdirAll(d.getLogPath(), os.FileMode(0770)); err != nil {
log.Errorf("failed to create log directory: %s", d.getLogPath())
trace.PrintError(err)
return
}
}
for {
// 增加对目录不存在的判断
dirs, err := utils.ListDir(d.getLogPath())
if err != nil {
trace.PrintError(err)
time.Sleep(10 * time.Minute)
continue
}
for _, dir := range dirs {
if time.Now().After(dir.ModTime().Add(d.getTtl())) {
if err := os.RemoveAll(d.getBasePath(dir.Name())); err != nil {
trace.PrintError(err)
continue
}
log.Infof("removed outdated log directory: %s", d.getBasePath(dir.Name()))
}
}
time.Sleep(10 * time.Minute)
}
}
var logDriver Driver
func newFileLogDriver() (driver Driver, err error) {
// driver
driver = &FileLogDriver{
logFileName: "log.txt",
mu: sync.Mutex{},
}
// init
if err := driver.Init(); err != nil {
return nil, err
}
return driver, nil
}
func GetFileLogDriver() (driver Driver, err error) {
if logDriver != nil {
return logDriver, nil
}
logDriver, err = newFileLogDriver()
if err != nil {
return nil, err
}
return logDriver, nil
}
|
2302_79757062/crawlab
|
core/task/log/file_driver.go
|
Go
|
bsd-3-clause
| 5,775
|
package log
type Driver interface {
Init() (err error)
Close() (err error)
WriteLine(id string, line string) (err error)
WriteLines(id string, lines []string) (err error)
Find(id string, pattern string, skip int, limit int) (lines []string, err error)
Count(id string, pattern string) (n int, err error)
}
|
2302_79757062/crawlab
|
core/task/log/interface.go
|
Go
|
bsd-3-clause
| 313
|
package scheduler
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Option func(svc interfaces.TaskSchedulerService)
func WithConfigPath(path string) Option {
return func(svc interfaces.TaskSchedulerService) {
svc.SetConfigPath(path)
}
}
func WithInterval(interval time.Duration) Option {
return func(svc interfaces.TaskSchedulerService) {
svc.SetInterval(interval)
}
}
|
2302_79757062/crawlab
|
core/task/scheduler/options.go
|
Go
|
bsd-3-clause
| 407
|
package scheduler
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/task"
"github.com/crawlab-team/crawlab/db/mongo"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
type Service struct {
// dependencies
interfaces.TaskBaseService
nodeCfgSvc interfaces.NodeConfigService
modelSvc service.ModelService
svr interfaces.GrpcServer
handlerSvc interfaces.TaskHandlerService
// settings
interval time.Duration
}
func (svc *Service) Start() {
go svc.initTaskStatus()
go svc.cleanupTasks()
svc.Wait()
svc.Stop()
}
func (svc *Service) Enqueue(t interfaces.Task) (t2 interfaces.Task, err error) {
// set task status
t.SetStatus(constants.TaskStatusPending)
// user
var u *models.User
if !t.GetUserId().IsZero() {
u, _ = svc.modelSvc.GetUserById(t.GetUserId())
}
// add task
if err = delegate.NewModelDelegate(t, u).Add(); err != nil {
return nil, err
}
// task queue item
tq := &models.TaskQueueItem{
Id: t.GetId(),
Priority: t.GetPriority(),
NodeId: t.GetNodeId(),
}
// task stat
ts := &models.TaskStat{
Id: t.GetId(),
CreateTs: time.Now(),
}
// enqueue task
_, err = mongo.GetMongoCol(interfaces.ModelColNameTaskQueue).Insert(tq)
if err != nil {
return nil, trace.TraceError(err)
}
// add task stat
_, err = mongo.GetMongoCol(interfaces.ModelColNameTaskStat).Insert(ts)
if err != nil {
return nil, trace.TraceError(err)
}
// success
return t, nil
}
func (svc *Service) Cancel(id primitive.ObjectID, args ...interface{}) (err error) {
// task
t, err := svc.modelSvc.GetTaskById(id)
if err != nil {
return trace.TraceError(err)
}
// initial status
initialStatus := t.Status
// set task status as "cancelled"
_ = svc.SaveTask(t, constants.TaskStatusCancelled)
// set status of pending tasks as "cancelled" and remove from task item queue
if initialStatus == constants.TaskStatusPending {
// remove from task item queue
if err := mongo.GetMongoCol(interfaces.ModelColNameTaskQueue).DeleteId(t.GetId()); err != nil {
return trace.TraceError(err)
}
return nil
}
// whether task is running on master node
isMasterTask, err := svc.isMasterNode(t)
if err != nil {
// when error, force status being set as "cancelled"
return svc.SaveTask(t, constants.TaskStatusCancelled)
}
// node
n, err := svc.modelSvc.GetNodeById(t.GetNodeId())
if err != nil {
return trace.TraceError(err)
}
if isMasterTask {
// cancel task on master
if err := svc.handlerSvc.Cancel(id); err != nil {
return trace.TraceError(err)
}
// cancel success
return nil
} else {
// send to cancel task on worker nodes
if err := svc.svr.SendStreamMessageWithData("node:"+n.GetKey(), grpc.StreamMessageCode_CANCEL_TASK, t); err != nil {
return trace.TraceError(err)
}
// cancel success
return nil
}
}
func (svc *Service) SetInterval(interval time.Duration) {
svc.interval = interval
}
// initTaskStatus initialize task status of existing tasks
func (svc *Service) initTaskStatus() {
// set status of running tasks as TaskStatusAbnormal
runningTasks, err := svc.modelSvc.GetTaskList(bson.M{
"status": bson.M{
"$in": []string{
constants.TaskStatusPending,
constants.TaskStatusRunning,
},
},
}, nil)
if err != nil {
if err == mongo2.ErrNoDocuments {
return
}
trace.PrintError(err)
}
for _, t := range runningTasks {
go func(t *models.Task) {
if err := svc.SaveTask(t, constants.TaskStatusAbnormal); err != nil {
trace.PrintError(err)
}
}(&t)
}
if err := svc.modelSvc.GetBaseService(interfaces.ModelIdTaskQueue).DeleteList(nil); err != nil {
return
}
}
func (svc *Service) isMasterNode(t *models.Task) (ok bool, err error) {
if t.GetNodeId().IsZero() {
return false, trace.TraceError(errors.ErrorTaskNoNodeId)
}
n, err := svc.modelSvc.GetNodeById(t.GetNodeId())
if err != nil {
if err == mongo2.ErrNoDocuments {
return false, trace.TraceError(errors.ErrorTaskNodeNotFound)
}
return false, trace.TraceError(err)
}
return n.IsMaster, nil
}
func (svc *Service) cleanupTasks() {
for {
// task stats over 30 days ago
taskStats, err := svc.modelSvc.GetTaskStatList(bson.M{
"create_ts": bson.M{
"$lt": time.Now().Add(-30 * 24 * time.Hour),
},
}, nil)
if err != nil {
time.Sleep(30 * time.Minute)
continue
}
// task ids
var ids []primitive.ObjectID
for _, ts := range taskStats {
ids = append(ids, ts.Id)
}
if len(ids) > 0 {
// remove tasks
if err := svc.modelSvc.GetBaseService(interfaces.ModelIdTask).DeleteList(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)
}
// remove task stats
if err := svc.modelSvc.GetBaseService(interfaces.ModelIdTaskStat).DeleteList(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)
}
}
time.Sleep(30 * time.Minute)
}
}
func NewTaskSchedulerService() (svc2 interfaces.TaskSchedulerService, err error) {
// base service
baseSvc, err := task.NewBaseService()
if err != nil {
return nil, trace.TraceError(err)
}
// service
svc := &Service{
TaskBaseService: baseSvc,
interval: 5 * time.Second,
}
// dependency injection
if err := container.GetContainer().Invoke(func(
nodeCfgSvc interfaces.NodeConfigService,
modelSvc service.ModelService,
svr interfaces.GrpcServer,
handlerSvc interfaces.TaskHandlerService,
) {
svc.nodeCfgSvc = nodeCfgSvc
svc.modelSvc = modelSvc
svc.svr = svr
svc.handlerSvc = handlerSvc
}); err != nil {
return nil, err
}
return svc, nil
}
var svc interfaces.TaskSchedulerService
func GetTaskSchedulerService() (svr interfaces.TaskSchedulerService, err error) {
if svc != nil {
return svc, nil
}
svc, err = NewTaskSchedulerService()
if err != nil {
return nil, err
}
return svc, nil
}
|
2302_79757062/crawlab
|
core/task/scheduler/service.go
|
Go
|
bsd-3-clause
| 6,331
|
package scheduler
import (
errors2 "errors"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
type ServiceV2 struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
svr interfaces.GrpcServer
handlerSvc interfaces.TaskHandlerService
// settings
interval time.Duration
}
func (svc *ServiceV2) Start() {
go svc.initTaskStatus()
go svc.cleanupTasks()
utils.DefaultWait()
}
func (svc *ServiceV2) Enqueue(t *models.TaskV2, by primitive.ObjectID) (t2 *models.TaskV2, err error) {
// set task status
t.Status = constants.TaskStatusPending
t.SetCreatedBy(by)
t.SetUpdated(by)
// add task
taskModelSvc := service.NewModelServiceV2[models.TaskV2]()
_, err = taskModelSvc.InsertOne(*t)
if err != nil {
return nil, err
}
// task queue item
tq := models.TaskQueueItemV2{
Priority: t.Priority,
NodeId: t.NodeId,
}
tq.SetId(t.Id)
// task stat
ts := models.TaskStatV2{
CreateTs: time.Now(),
}
ts.SetId(t.Id)
// enqueue task
_, err = service.NewModelServiceV2[models.TaskQueueItemV2]().InsertOne(tq)
if err != nil {
return nil, trace.TraceError(err)
}
// add task stat
_, err = service.NewModelServiceV2[models.TaskStatV2]().InsertOne(ts)
if err != nil {
return nil, trace.TraceError(err)
}
// success
return t, nil
}
func (svc *ServiceV2) Cancel(id primitive.ObjectID, by primitive.ObjectID) (err error) {
// task
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(id)
if err != nil {
return trace.TraceError(err)
}
// initial status
initialStatus := t.Status
// set task status as "cancelled"
t.Status = constants.TaskStatusCancelled
_ = svc.SaveTask(t, by)
// set status of pending tasks as "cancelled" and remove from task item queue
if initialStatus == constants.TaskStatusPending {
// remove from task item queue
if err := service.NewModelServiceV2[models.TaskQueueItemV2]().DeleteById(t.Id); err != nil {
return trace.TraceError(err)
}
return nil
}
// whether task is running on master node
isMasterTask, err := svc.isMasterNode(t)
if err != nil {
// when error, force status being set as "cancelled"
t.Status = constants.TaskStatusCancelled
return svc.SaveTask(t, by)
}
// node
n, err := service.NewModelServiceV2[models.NodeV2]().GetById(t.NodeId)
if err != nil {
return trace.TraceError(err)
}
if isMasterTask {
// cancel task on master
if err := svc.handlerSvc.Cancel(id); err != nil {
return trace.TraceError(err)
}
// cancel success
return nil
} else {
// send to cancel task on worker nodes
if err := svc.svr.SendStreamMessageWithData("node:"+n.Key, grpc.StreamMessageCode_CANCEL_TASK, t); err != nil {
return trace.TraceError(err)
}
// cancel success
return nil
}
}
func (svc *ServiceV2) SetInterval(interval time.Duration) {
svc.interval = interval
}
func (svc *ServiceV2) SaveTask(t *models.TaskV2, by primitive.ObjectID) (err error) {
if t.Id.IsZero() {
t.SetCreated(by)
t.SetUpdated(by)
_, err = service.NewModelServiceV2[models.TaskV2]().InsertOne(*t)
return err
} else {
t.SetUpdated(by)
return service.NewModelServiceV2[models.TaskV2]().ReplaceById(t.Id, *t)
}
}
// initTaskStatus initialize task status of existing tasks
func (svc *ServiceV2) initTaskStatus() {
// set status of running tasks as TaskStatusAbnormal
runningTasks, err := service.NewModelServiceV2[models.TaskV2]().GetMany(bson.M{
"status": bson.M{
"$in": []string{
constants.TaskStatusPending,
constants.TaskStatusRunning,
},
},
}, nil)
if err != nil {
if errors2.Is(err, mongo2.ErrNoDocuments) {
return
}
trace.PrintError(err)
}
for _, t := range runningTasks {
go func(t *models.TaskV2) {
t.Status = constants.TaskStatusAbnormal
if err := svc.SaveTask(t, primitive.NilObjectID); err != nil {
trace.PrintError(err)
}
}(&t)
}
if err := service.NewModelServiceV2[models.TaskQueueItemV2]().DeleteMany(nil); err != nil {
return
}
}
func (svc *ServiceV2) isMasterNode(t *models.TaskV2) (ok bool, err error) {
if t.NodeId.IsZero() {
return false, trace.TraceError(errors.ErrorTaskNoNodeId)
}
n, err := service.NewModelServiceV2[models.NodeV2]().GetById(t.NodeId)
if err != nil {
if errors2.Is(err, mongo2.ErrNoDocuments) {
return false, trace.TraceError(errors.ErrorTaskNodeNotFound)
}
return false, trace.TraceError(err)
}
return n.IsMaster, nil
}
func (svc *ServiceV2) cleanupTasks() {
for {
// task stats over 30 days ago
taskStats, err := service.NewModelServiceV2[models.TaskStatV2]().GetMany(bson.M{
"create_ts": bson.M{
"$lt": time.Now().Add(-30 * 24 * time.Hour),
},
}, nil)
if err != nil {
time.Sleep(30 * time.Minute)
continue
}
// task ids
var ids []primitive.ObjectID
for _, ts := range taskStats {
ids = append(ids, ts.Id)
}
if len(ids) > 0 {
// remove tasks
if err := service.NewModelServiceV2[models.TaskV2]().DeleteMany(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)
}
// remove task stats
if err := service.NewModelServiceV2[models.TaskStatV2]().DeleteMany(bson.M{
"_id": bson.M{"$in": ids},
}); err != nil {
trace.PrintError(err)
}
}
time.Sleep(30 * time.Minute)
}
}
func NewTaskSchedulerServiceV2() (svc2 *ServiceV2, err error) {
// service
svc := &ServiceV2{
interval: 5 * time.Second,
}
// dependency injection
if err := container.GetContainer().Invoke(func(
nodeCfgSvc interfaces.NodeConfigService,
svr interfaces.GrpcServer,
handlerSvc interfaces.TaskHandlerService,
) {
svc.nodeCfgSvc = nodeCfgSvc
svc.svr = svr
svc.handlerSvc = handlerSvc
}); err != nil {
return nil, err
}
return svc, nil
}
var svcV2 *ServiceV2
func GetTaskSchedulerServiceV2() (svr *ServiceV2, err error) {
if svcV2 != nil {
return svcV2, nil
}
svcV2, err = NewTaskSchedulerServiceV2()
if err != nil {
return nil, err
}
return svcV2, nil
}
|
2302_79757062/crawlab
|
core/task/scheduler/service_v2.go
|
Go
|
bsd-3-clause
| 6,438
|
package stats
import "github.com/crawlab-team/crawlab/core/interfaces"
type Option func(service interfaces.TaskStatsService)
func WithConfigPath(path string) Option {
return func(svc interfaces.TaskStatsService) {
svc.SetConfigPath(path)
}
}
|
2302_79757062/crawlab
|
core/task/stats/options.go
|
Go
|
bsd-3-clause
| 249
|
package stats
import (
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/task"
"github.com/crawlab-team/crawlab/core/task/log"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
"time"
)
type Service struct {
// dependencies
interfaces.TaskBaseService
nodeCfgSvc interfaces.NodeConfigService
modelSvc service.ModelService
// internals
mu sync.Mutex
resultServices sync.Map
rsTtl time.Duration
logDriver log.Driver
}
func (svc *Service) Init() (err error) {
go svc.cleanup()
return nil
}
func (svc *Service) InsertData(id primitive.ObjectID, records ...interface{}) (err error) {
resultSvc, err := svc.getResultService(id)
if err != nil {
return err
}
if err := resultSvc.Insert(records...); err != nil {
return err
}
go svc.updateTaskStats(id, len(records))
return nil
}
func (svc *Service) InsertLogs(id primitive.ObjectID, logs ...string) (err error) {
return svc.logDriver.WriteLines(id.Hex(), logs)
}
func (svc *Service) getResultService(id primitive.ObjectID) (resultSvc interfaces.ResultService, err error) {
// atomic operation
svc.mu.Lock()
defer svc.mu.Unlock()
// attempt to get from cache
res, _ := svc.resultServices.Load(id.Hex())
if res != nil {
// hit in cache
resultSvc, ok := res.(interfaces.ResultService)
resultSvc.SetTime(time.Now())
if ok {
return resultSvc, nil
}
}
// task
t, err := svc.modelSvc.GetTaskById(id)
if err != nil {
return nil, err
}
// result service
resultSvc, err = result.GetResultService(t.SpiderId)
if err != nil {
return nil, err
}
// store in cache
svc.resultServices.Store(id.Hex(), resultSvc)
return resultSvc, nil
}
func (svc *Service) updateTaskStats(id primitive.ObjectID, resultCount int) {
_ = mongo.GetMongoCol(interfaces.ModelColNameTaskStat).UpdateId(id, bson.M{
"$inc": bson.M{
"result_count": resultCount,
},
})
}
func (svc *Service) cleanup() {
for {
// atomic operation
svc.mu.Lock()
svc.resultServices.Range(func(key, value interface{}) bool {
rs := value.(interfaces.ResultService)
if time.Now().After(rs.GetTime().Add(svc.rsTtl)) {
svc.resultServices.Delete(key)
}
return true
})
svc.mu.Unlock()
time.Sleep(10 * time.Minute)
}
}
func NewTaskStatsService() (svc2 interfaces.TaskStatsService, err error) {
// base service
baseSvc, err := task.NewBaseService()
if err != nil {
return nil, trace.TraceError(err)
}
// service
svc := &Service{
mu: sync.Mutex{},
TaskBaseService: baseSvc,
resultServices: sync.Map{},
}
// dependency injection
if err := container.GetContainer().Invoke(func(nodeCfgSvc interfaces.NodeConfigService, modelSvc service.ModelService) {
svc.nodeCfgSvc = nodeCfgSvc
svc.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// log driver
svc.logDriver, err = log.GetLogDriver(log.DriverTypeFile)
if err != nil {
return nil, err
}
return svc, nil
}
var _service interfaces.TaskStatsService
func GetTaskStatsService() (svr interfaces.TaskStatsService, err error) {
if _service != nil {
return _service, nil
}
_service, err = NewTaskStatsService()
if err != nil {
return nil, err
}
return _service, nil
}
|
2302_79757062/crawlab
|
core/task/stats/service.go
|
Go
|
bsd-3-clause
| 3,523
|
package stats
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/task/log"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"sync"
"time"
)
type ServiceV2 struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
modelSvc service.ModelService
// internals
mu sync.Mutex
resultServices sync.Map
rsTtl time.Duration
logDriver log.Driver
}
func (svc *ServiceV2) Init() (err error) {
go svc.cleanup()
return nil
}
func (svc *ServiceV2) InsertData(id primitive.ObjectID, records ...interface{}) (err error) {
resultSvc, err := svc.getResultService(id)
if err != nil {
return err
}
if err := resultSvc.Insert(records...); err != nil {
return err
}
go svc.updateTaskStats(id, len(records))
return nil
}
func (svc *ServiceV2) InsertLogs(id primitive.ObjectID, logs ...string) (err error) {
return svc.logDriver.WriteLines(id.Hex(), logs)
}
func (svc *ServiceV2) getResultService(id primitive.ObjectID) (resultSvc interfaces.ResultService, err error) {
// atomic operation
svc.mu.Lock()
defer svc.mu.Unlock()
// attempt to get from cache
res, _ := svc.resultServices.Load(id.Hex())
if res != nil {
// hit in cache
resultSvc, ok := res.(interfaces.ResultService)
resultSvc.SetTime(time.Now())
if ok {
return resultSvc, nil
}
}
// task
t, err := svc.modelSvc.GetTaskById(id)
if err != nil {
return nil, err
}
// result service
resultSvc, err = result.GetResultService(t.SpiderId)
if err != nil {
return nil, err
}
// store in cache
svc.resultServices.Store(id.Hex(), resultSvc)
return resultSvc, nil
}
func (svc *ServiceV2) updateTaskStats(id primitive.ObjectID, resultCount int) {
err := service.NewModelServiceV2[models.TaskStatV2]().UpdateById(id, bson.M{
"$inc": bson.M{
"result_count": resultCount,
},
})
if err != nil {
trace.PrintError(err)
}
}
func (svc *ServiceV2) cleanup() {
for {
// atomic operation
svc.mu.Lock()
svc.resultServices.Range(func(key, value interface{}) bool {
rs := value.(interfaces.ResultService)
if time.Now().After(rs.GetTime().Add(svc.rsTtl)) {
svc.resultServices.Delete(key)
}
return true
})
svc.mu.Unlock()
time.Sleep(10 * time.Minute)
}
}
func NewTaskStatsServiceV2() (svc2 *ServiceV2, err error) {
// service
svc := &ServiceV2{
mu: sync.Mutex{},
resultServices: sync.Map{},
}
svc.nodeCfgSvc = nodeconfig.GetNodeConfigService()
// log driver
svc.logDriver, err = log.GetLogDriver(log.DriverTypeFile)
if err != nil {
return nil, err
}
return svc, nil
}
var _serviceV2 *ServiceV2
func GetTaskStatsServiceV2() (svr *ServiceV2, err error) {
if _serviceV2 != nil {
return _serviceV2, nil
}
_serviceV2, err = NewTaskStatsServiceV2()
if err != nil {
return nil, err
}
return _serviceV2, nil
}
|
2302_79757062/crawlab
|
core/task/stats/service_v2.go
|
Go
|
bsd-3-clause
| 3,148
|
package user
import "github.com/crawlab-team/crawlab/core/interfaces"
type Option func(svc interfaces.UserService)
func WithJwtSecret(secret string) Option {
return func(svc interfaces.UserService) {
svc.SetJwtSecret(secret)
}
}
|
2302_79757062/crawlab
|
core/user/options.go
|
Go
|
bsd-3-clause
| 236
|
package user
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
mongo2 "github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"time"
)
type Service struct {
// settings variables
jwtSecret string
jwtSigningMethod jwt.SigningMethod
// dependencies
modelSvc service.ModelService
}
func (svc *Service) Init() (err error) {
_, err = svc.modelSvc.GetUserByUsername(constants.DefaultAdminUsername, nil)
if err == nil {
return nil
}
if err.Error() != mongo.ErrNoDocuments.Error() {
return err
}
return svc.Create(&interfaces.UserCreateOptions{
Username: constants.DefaultAdminUsername,
Password: constants.DefaultAdminPassword,
Role: constants.RoleAdmin,
})
}
func (svc *Service) SetJwtSecret(secret string) {
svc.jwtSecret = secret
}
func (svc *Service) SetJwtSigningMethod(method jwt.SigningMethod) {
svc.jwtSigningMethod = method
}
func (svc *Service) Create(opts *interfaces.UserCreateOptions, args ...interface{}) (err error) {
actor := utils.GetUserFromArgs(args...)
// validate options
if opts.Username == "" || opts.Password == "" {
return trace.TraceError(errors.ErrorUserMissingRequiredFields)
}
if len(opts.Password) < 5 {
return trace.TraceError(errors.ErrorUserInvalidPassword)
}
// normalize options
if opts.Role == "" {
opts.Role = constants.RoleNormal
}
// check if user exists
if u, err := svc.modelSvc.GetUserByUsername(opts.Username, nil); err == nil && u != nil && !u.Id.IsZero() {
return trace.TraceError(errors.ErrorUserAlreadyExists)
}
// transaction
return mongo2.RunTransaction(func(ctx mongo.SessionContext) error {
// add user
u := &models.User{
Username: opts.Username,
Role: opts.Role,
Email: opts.Email,
}
if err := delegate.NewModelDelegate(u, actor).Add(); err != nil {
return err
}
// add password
p := &models.Password{
Id: u.Id,
Password: utils.EncryptMd5(opts.Password),
}
if err := delegate.NewModelDelegate(p, actor).Add(); err != nil {
return err
}
return nil
})
}
func (svc *Service) Login(opts *interfaces.UserLoginOptions) (token string, u interfaces.User, err error) {
u, err = svc.modelSvc.GetUserByUsername(opts.Username, nil)
if err != nil {
return "", nil, err
}
p, err := svc.modelSvc.GetPasswordById(u.GetId())
if err != nil {
return "", nil, err
}
if p.Password != utils.EncryptMd5(opts.Password) {
return "", nil, errors.ErrorUserMismatch
}
token, err = svc.makeToken(u)
if err != nil {
return "", nil, err
}
return token, u, nil
}
func (svc *Service) CheckToken(tokenStr string) (u interfaces.User, err error) {
return svc.checkToken(tokenStr)
}
func (svc *Service) ChangePassword(id primitive.ObjectID, password string, args ...interface{}) (err error) {
actor := utils.GetUserFromArgs(args...)
p, err := svc.modelSvc.GetPasswordById(id)
if err != nil {
return err
}
p.Password = utils.EncryptMd5(password)
if err := delegate.NewModelDelegate(p, actor).Save(); err != nil {
return err
}
return nil
}
func (svc *Service) MakeToken(user interfaces.User) (tokenStr string, err error) {
return svc.makeToken(user)
}
func (svc *Service) GetCurrentUser(c *gin.Context) (user interfaces.User, err error) {
// token string
tokenStr := c.GetHeader("Authorization")
// user
u, err := userSvc.CheckToken(tokenStr)
if err != nil {
return nil, err
}
return u, nil
}
func (svc *Service) makeToken(user interfaces.User) (tokenStr string, err error) {
token := jwt.NewWithClaims(svc.jwtSigningMethod, jwt.MapClaims{
"id": user.GetId(),
"username": user.GetUsername(),
"nbf": time.Now().Unix(),
})
return token.SignedString([]byte(svc.jwtSecret))
}
func (svc *Service) checkToken(tokenStr string) (user interfaces.User, err error) {
token, err := jwt.Parse(tokenStr, svc.getSecretFunc())
if err != nil {
return
}
claim, ok := token.Claims.(jwt.MapClaims)
if !ok {
err = errors.ErrorUserInvalidType
return
}
if !token.Valid {
err = errors.ErrorUserInvalidToken
return
}
id, err := primitive.ObjectIDFromHex(claim["id"].(string))
if err != nil {
return user, err
}
username := claim["username"].(string)
user, err = svc.modelSvc.GetUserById(id)
if err != nil {
err = errors.ErrorUserNotExists
return
}
if username != user.GetUsername() {
err = errors.ErrorUserMismatch
return
}
return
}
func (svc *Service) getSecretFunc() jwt.Keyfunc {
return func(token *jwt.Token) (interface{}, error) {
return []byte(svc.jwtSecret), nil
}
}
func NewUserService() (svc2 interfaces.UserService, err error) {
// service
svc := &Service{
jwtSecret: "crawlab",
jwtSigningMethod: jwt.SigningMethodHS256,
}
// dependency injection
if err := container.GetContainer().Invoke(func(modelSvc service.ModelService) {
svc.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// initialize
if err := svc.Init(); err != nil {
return nil, trace.TraceError(err)
}
return svc, nil
}
var userSvc interfaces.UserService
func GetUserService() (svc interfaces.UserService, err error) {
if userSvc != nil {
return userSvc, nil
}
svc, err = NewUserService()
if err != nil {
return nil, err
}
userSvc = svc
return svc, nil
}
|
2302_79757062/crawlab
|
core/user/service.go
|
Go
|
bsd-3-clause
| 5,767
|
package user
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/utils"
mongo2 "github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"github.com/golang-jwt/jwt/v5"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"time"
)
type ServiceV2 struct {
jwtSecret string
jwtSigningMethod jwt.SigningMethod
modelSvc *service.ModelServiceV2[models.UserV2]
}
func (svc *ServiceV2) Init() (err error) {
_, err = svc.modelSvc.GetOne(bson.M{"username": constants.DefaultAdminUsername}, nil)
if err == nil {
return nil
}
if err.Error() != mongo.ErrNoDocuments.Error() {
return err
}
return svc.Create(
constants.DefaultAdminUsername,
constants.DefaultAdminPassword,
constants.RoleAdmin,
"",
primitive.NilObjectID,
)
}
func (svc *ServiceV2) SetJwtSecret(secret string) {
svc.jwtSecret = secret
}
func (svc *ServiceV2) SetJwtSigningMethod(method jwt.SigningMethod) {
svc.jwtSigningMethod = method
}
func (svc *ServiceV2) Create(username, password, role, email string, by primitive.ObjectID) (err error) {
// validate options
if username == "" || password == "" {
return trace.TraceError(errors.ErrorUserMissingRequiredFields)
}
if len(password) < 5 {
return trace.TraceError(errors.ErrorUserInvalidPassword)
}
// normalize options
if role == "" {
role = constants.RoleNormal
}
// check if user exists
if u, err := svc.modelSvc.GetOne(bson.M{"username": username}, nil); err == nil && u != nil && !u.Id.IsZero() {
return trace.TraceError(errors.ErrorUserAlreadyExists)
}
// transaction
return mongo2.RunTransaction(func(ctx mongo.SessionContext) error {
// add user
u := models.UserV2{
Username: username,
Role: role,
Password: utils.EncryptMd5(password),
Email: email,
}
u.SetCreated(by)
u.SetUpdated(by)
_, err = svc.modelSvc.InsertOne(u)
return err
})
}
func (svc *ServiceV2) Login(username, password string) (token string, u *models.UserV2, err error) {
u, err = svc.modelSvc.GetOne(bson.M{"username": username}, nil)
if err != nil {
return "", nil, err
}
if u.Password != utils.EncryptMd5(password) {
return "", nil, errors.ErrorUserMismatch
}
token, err = svc.makeToken(u)
if err != nil {
return "", nil, err
}
return token, u, nil
}
func (svc *ServiceV2) CheckToken(tokenStr string) (u *models.UserV2, err error) {
return svc.checkToken(tokenStr)
}
func (svc *ServiceV2) ChangePassword(id primitive.ObjectID, password string, by primitive.ObjectID) (err error) {
u, err := svc.modelSvc.GetById(id)
if err != nil {
return err
}
u.Password = utils.EncryptMd5(password)
u.SetCreatedBy(by)
return svc.modelSvc.ReplaceById(id, *u)
}
func (svc *ServiceV2) MakeToken(user *models.UserV2) (tokenStr string, err error) {
return svc.makeToken(user)
}
func (svc *ServiceV2) GetCurrentUser(c *gin.Context) (user interfaces.User, err error) {
// token string
tokenStr := c.GetHeader("Authorization")
// user
u, err := userSvc.CheckToken(tokenStr)
if err != nil {
return nil, err
}
return u, nil
}
func (svc *ServiceV2) makeToken(user *models.UserV2) (tokenStr string, err error) {
token := jwt.NewWithClaims(svc.jwtSigningMethod, jwt.MapClaims{
"id": user.Id,
"username": user.Username,
"nbf": time.Now().Unix(),
})
return token.SignedString([]byte(svc.jwtSecret))
}
func (svc *ServiceV2) checkToken(tokenStr string) (user *models.UserV2, err error) {
token, err := jwt.Parse(tokenStr, svc.getSecretFunc())
if err != nil {
return
}
claim, ok := token.Claims.(jwt.MapClaims)
if !ok {
err = errors.ErrorUserInvalidType
return
}
if !token.Valid {
err = errors.ErrorUserInvalidToken
return
}
id, err := primitive.ObjectIDFromHex(claim["id"].(string))
if err != nil {
return user, err
}
username := claim["username"].(string)
user, err = svc.modelSvc.GetById(id)
if err != nil {
err = errors.ErrorUserNotExists
return
}
if username != user.Username {
err = errors.ErrorUserMismatch
return
}
return
}
func (svc *ServiceV2) getSecretFunc() jwt.Keyfunc {
return func(token *jwt.Token) (interface{}, error) {
return []byte(svc.jwtSecret), nil
}
}
func NewUserServiceV2() (svc *ServiceV2, err error) {
// service
svc = &ServiceV2{
modelSvc: service.NewModelServiceV2[models.UserV2](),
jwtSecret: "crawlab",
jwtSigningMethod: jwt.SigningMethodHS256,
}
// initialize
if err := svc.Init(); err != nil {
return nil, trace.TraceError(err)
}
return svc, nil
}
var userSvcV2 *ServiceV2
func GetUserServiceV2() (svc *ServiceV2, err error) {
if userSvcV2 != nil {
return userSvcV2, nil
}
svc, err = NewUserServiceV2()
if err != nil {
return nil, err
}
userSvcV2 = svc
return svc, nil
}
|
2302_79757062/crawlab
|
core/user/service_v2.go
|
Go
|
bsd-3-clause
| 5,090
|
package test
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/user"
"go.uber.org/dig"
"testing"
)
func init() {
var err error
T, err = NewTest()
if err != nil {
panic(err)
}
}
var T *Test
type Test struct {
// dependencies
modelSvc service.ModelService
userSvc interfaces.UserService
// test data
TestUsername string
TestPassword string
TestNewPassword string
}
func (t *Test) Setup(t2 *testing.T) {
var err error
t.userSvc, err = user.NewUserService()
if err != nil {
panic(err)
}
t2.Cleanup(t.Cleanup)
}
func (t *Test) Cleanup() {
_ = t.modelSvc.GetBaseService(interfaces.ModelIdUser).DeleteList(nil)
}
func NewTest() (t *Test, err error) {
// test
t = &Test{
TestUsername: "test_username",
TestPassword: "test_password",
TestNewPassword: "test_new_password",
}
// dependency injection
c := dig.New()
if err := c.Provide(service.GetService); err != nil {
return nil, err
}
if err := c.Invoke(func(modelSvc service.ModelService) {
t.modelSvc = modelSvc
}); err != nil {
return nil, err
}
return t, nil
}
|
2302_79757062/crawlab
|
core/user/test/base.go
|
Go
|
bsd-3-clause
| 1,179
|
package utils
import "github.com/crawlab-team/crawlab/core/interfaces"
func GetUserFromArgs(args ...interface{}) (u interfaces.User) {
for _, arg := range args {
switch arg.(type) {
case interfaces.User:
var ok bool
u, ok = arg.(interfaces.User)
if ok {
return u
}
}
}
return nil
}
|
2302_79757062/crawlab
|
core/utils/args.go
|
Go
|
bsd-3-clause
| 309
|
package utils
import (
"errors"
"math/rand"
"reflect"
"time"
)
func StringArrayContains(arr []string, str string) bool {
for _, s := range arr {
if s == str {
return true
}
}
return false
}
func GetArrayItems(array interface{}) (res []interface{}, err error) {
switch reflect.TypeOf(array).Kind() {
case reflect.Slice, reflect.Array:
s := reflect.ValueOf(array)
for i := 0; i < s.Len(); i++ {
obj, ok := s.Index(i).Interface().(interface{})
if !ok {
return nil, errors.New("invalid type")
}
res = append(res, obj)
}
default:
return nil, errors.New("invalid type")
}
return res, nil
}
func ShuffleArray(slice []interface{}) (err error) {
r := rand.New(rand.NewSource(time.Now().Unix()))
for len(slice) > 0 {
n := len(slice)
randIndex := r.Intn(n)
slice[n-1], slice[randIndex] = slice[randIndex], slice[n-1]
slice = slice[:n-1]
}
return nil
}
|
2302_79757062/crawlab
|
core/utils/array.go
|
Go
|
bsd-3-clause
| 901
|
package utils
import (
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/trace"
"time"
)
func BackoffErrorNotify(prefix string) backoff.Notify {
return func(err error, duration time.Duration) {
log.Errorf("%s error: %v. reattempt in %.1f seconds...", prefix, err, duration.Seconds())
trace.PrintError(err)
}
}
|
2302_79757062/crawlab
|
core/utils/backoff.go
|
Go
|
bsd-3-clause
| 360
|
package binders
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
)
func NewColNameBinder(id interfaces.ModelId) (b *ColNameBinder) {
return &ColNameBinder{id: id}
}
type ColNameBinder struct {
id interfaces.ModelId
}
func (b *ColNameBinder) Bind() (res interface{}, err error) {
switch b.id {
// system models
case interfaces.ModelIdArtifact:
return interfaces.ModelColNameArtifact, nil
case interfaces.ModelIdTag:
return interfaces.ModelColNameTag, nil
// operation models
case interfaces.ModelIdNode:
return interfaces.ModelColNameNode, nil
case interfaces.ModelIdProject:
return interfaces.ModelColNameProject, nil
case interfaces.ModelIdSpider:
return interfaces.ModelColNameSpider, nil
case interfaces.ModelIdTask:
return interfaces.ModelColNameTask, nil
case interfaces.ModelIdJob:
return interfaces.ModelColNameJob, nil
case interfaces.ModelIdSchedule:
return interfaces.ModelColNameSchedule, nil
case interfaces.ModelIdUser:
return interfaces.ModelColNameUser, nil
case interfaces.ModelIdSetting:
return interfaces.ModelColNameSetting, nil
case interfaces.ModelIdToken:
return interfaces.ModelColNameToken, nil
case interfaces.ModelIdVariable:
return interfaces.ModelColNameVariable, nil
case interfaces.ModelIdTaskQueue:
return interfaces.ModelColNameTaskQueue, nil
case interfaces.ModelIdTaskStat:
return interfaces.ModelColNameTaskStat, nil
case interfaces.ModelIdSpiderStat:
return interfaces.ModelColNameSpiderStat, nil
case interfaces.ModelIdDataSource:
return interfaces.ModelColNameDataSource, nil
case interfaces.ModelIdDataCollection:
return interfaces.ModelColNameDataCollection, nil
case interfaces.ModelIdPassword:
return interfaces.ModelColNamePasswords, nil
case interfaces.ModelIdExtraValue:
return interfaces.ModelColNameExtraValues, nil
case interfaces.ModelIdGit:
return interfaces.ModelColNameGit, nil
case interfaces.ModelIdRole:
return interfaces.ModelColNameRole, nil
case interfaces.ModelIdUserRole:
return interfaces.ModelColNameUserRole, nil
case interfaces.ModelIdPermission:
return interfaces.ModelColNamePermission, nil
case interfaces.ModelIdRolePermission:
return interfaces.ModelColNameRolePermission, nil
case interfaces.ModelIdEnvironment:
return interfaces.ModelColNameEnvironment, nil
case interfaces.ModelIdDependencySetting:
return interfaces.ModelColNameDependencySetting, nil
// invalid
default:
return res, errors.ErrorModelNotImplemented
}
}
func (b *ColNameBinder) MustBind() (res interface{}) {
res, err := b.Bind()
if err != nil {
panic(err)
}
return res
}
func (b *ColNameBinder) BindString() (res string, err error) {
res_, err := b.Bind()
if err != nil {
return "", err
}
res = res_.(string)
return res, nil
}
func (b *ColNameBinder) MustBindString() (res string) {
return b.MustBind().(string)
}
|
2302_79757062/crawlab
|
core/utils/binders/binder_col_name.go
|
Go
|
bsd-3-clause
| 2,922
|
package utils
import "github.com/spf13/viper"
func EnvIsTrue(key string, defaultOk bool) bool {
isTrueBool := viper.GetBool(key)
isTrueString := viper.GetString(key)
if isTrueString == "" {
return defaultOk
}
return isTrueBool || isTrueString == "Y"
}
|
2302_79757062/crawlab
|
core/utils/bool.go
|
Go
|
bsd-3-clause
| 261
|
package utils
import (
"github.com/emirpasic/gods/sets/hashset"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"reflect"
)
func BsonMEqual(v1, v2 bson.M) (ok bool) {
//ok = reflect.DeepEqual(v1, v2)
ok = bsonMEqual(v1, v2)
return ok
}
func bsonMEqual(v1, v2 bson.M) (ok bool) {
// all keys
allKeys := hashset.New()
for key := range v1 {
allKeys.Add(key)
}
for key := range v2 {
allKeys.Add(key)
}
for _, keyRes := range allKeys.Values() {
key := keyRes.(string)
v1Value, ok := v1[key]
if !ok {
return false
}
v2Value, ok := v2[key]
if !ok {
return false
}
mode := 0
var v1ValueBsonM bson.M
var v1ValueBsonA bson.A
switch v1Value.(type) {
case bson.M:
mode = 1
v1ValueBsonM = v1Value.(bson.M)
case bson.A:
mode = 2
v1ValueBsonA = v1Value.(bson.A)
}
var v2ValueBsonM bson.M
var v2ValueBsonA bson.A
switch v2Value.(type) {
case bson.M:
if mode != 1 {
return false
}
v2ValueBsonM = v2Value.(bson.M)
case bson.A:
if mode != 2 {
return false
}
v2ValueBsonA = v2Value.(bson.A)
}
switch mode {
case 0:
if v1Value != v2Value {
return false
}
case 1:
if !bsonMEqual(v1ValueBsonM, v2ValueBsonM) {
return false
}
case 2:
if !reflect.DeepEqual(v1ValueBsonA, v2ValueBsonA) {
return false
}
default:
// not reachable
return false
}
}
return true
}
func NormalizeBsonMObjectId(m bson.M) (res bson.M) {
for k, v := range m {
switch v.(type) {
case string:
oid, err := primitive.ObjectIDFromHex(v.(string))
if err == nil {
m[k] = oid
}
case bson.M:
m[k] = NormalizeBsonMObjectId(v.(bson.M))
}
}
return m
}
func DenormalizeBsonMObjectId(m bson.M) (res bson.M) {
for k, v := range m {
switch v.(type) {
case primitive.ObjectID:
m[k] = v.(primitive.ObjectID).Hex()
case bson.M:
m[k] = NormalizeBsonMObjectId(v.(bson.M))
}
}
return m
}
func NormalizeObjectId(v interface{}) (res interface{}) {
switch v.(type) {
case string:
oid, err := primitive.ObjectIDFromHex(v.(string))
if err != nil {
return v
}
return oid
default:
return v
}
}
|
2302_79757062/crawlab
|
core/utils/bson.go
|
Go
|
bsd-3-clause
| 2,171
|
package utils
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
func GetFromDbCache(key string, getFn func() (string, error)) (res string, err error) {
col := mongo.GetMongoCol(constants.CacheColName)
var d bson.M
if err := col.Find(bson.M{
constants.CacheColKey: key,
}, nil).One(&d); err != nil {
if err != mongo2.ErrNoDocuments {
return "", err
}
// get cache value
res, err = getFn()
if err != nil {
return "", err
}
// save cache
d = bson.M{
constants.CacheColKey: key,
constants.CacheColValue: res,
constants.CacheColTime: time.Now(),
}
if _, err := col.Insert(d); err != nil {
return "", err
}
return res, nil
}
// type conversion
r, ok := d[constants.CacheColValue]
if !ok {
if err := col.Delete(bson.M{constants.CacheColKey: key}); err != nil {
return "", err
}
return GetFromDbCache(key, getFn)
}
res, ok = r.(string)
if !ok {
if err := col.Delete(bson.M{constants.CacheColKey: key}); err != nil {
return "", err
}
return GetFromDbCache(key, getFn)
}
return res, nil
}
|
2302_79757062/crawlab
|
core/utils/cache.go
|
Go
|
bsd-3-clause
| 1,207
|
package utils
import (
"sync"
)
var TaskExecChanMap = NewChanMap()
type ChanMap struct {
m sync.Map
}
func NewChanMap() *ChanMap {
return &ChanMap{m: sync.Map{}}
}
func (cm *ChanMap) Chan(key string) chan string {
if ch, ok := cm.m.Load(key); ok {
return ch.(interface{}).(chan string)
}
ch := make(chan string, 10)
cm.m.Store(key, ch)
return ch
}
func (cm *ChanMap) ChanBlocked(key string) chan string {
if ch, ok := cm.m.Load(key); ok {
return ch.(interface{}).(chan string)
}
ch := make(chan string)
cm.m.Store(key, ch)
return ch
}
func (cm *ChanMap) HasChanKey(key string) bool {
if _, ok := cm.m.Load(key); ok {
return true
}
return false
}
|
2302_79757062/crawlab
|
core/utils/chan.go
|
Go
|
bsd-3-clause
| 675
|
package utils
import (
"context"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/upper/db/v4"
"github.com/upper/db/v4/adapter/mssql"
"time"
)
func GetCockroachdbSession(ds *models.DataSource) (s db.Session, err error) {
return getCockroachdbSession(context.Background(), ds)
}
func GetCockroachdbSessionWithTimeout(ds *models.DataSource, timeout time.Duration) (s db.Session, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getCockroachdbSession(ctx, ds)
}
func getCockroachdbSession(ctx context.Context, ds *models.DataSource) (s db.Session, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultCockroachdbPort
}
// connect settings
settings := mssql.ConnectionURL{
User: ds.Username,
Password: ds.Password,
Database: ds.Database,
Host: fmt.Sprintf("%s:%s", host, port),
Options: nil,
}
// session
done := make(chan struct{})
go func() {
s, err = mssql.Open(settings)
close(done)
}()
// wait for done
select {
case <-ctx.Done():
if ctx.Err() != nil {
err = ctx.Err()
}
case <-done:
}
return s, err
}
|
2302_79757062/crawlab
|
core/utils/cockroachdb.go
|
Go
|
bsd-3-clause
| 1,306
|
package utils
import (
"fmt"
"math"
"strconv"
"strings"
)
// cronBounds provides a range of acceptable values (plus a map of name to value).
type cronBounds struct {
min, max uint
names map[string]uint
}
type cronUtils struct {
// The cronBounds for each field.
seconds cronBounds
minutes cronBounds
hours cronBounds
dom cronBounds
months cronBounds
dow cronBounds
// Set the top bit if a star was included in the expression.
starBit uint64
}
// getRange returns the bits indicated by the given expression:
// number | number "-" number [ "/" number ]
// or error parsing range.
func (u *cronUtils) getRange(expr string, r cronBounds) (uint64, error) {
var (
start, end, step uint
rangeAndStep = strings.Split(expr, "/")
lowAndHigh = strings.Split(rangeAndStep[0], "-")
singleDigit = len(lowAndHigh) == 1
err error
)
var extra uint64
if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" {
start = r.min
end = r.max
extra = CronUtils.starBit
} else {
start, err = u.parseIntOrName(lowAndHigh[0], r.names)
if err != nil {
return 0, err
}
switch len(lowAndHigh) {
case 1:
end = start
case 2:
end, err = u.parseIntOrName(lowAndHigh[1], r.names)
if err != nil {
return 0, err
}
default:
return 0, fmt.Errorf("too many hyphens: %s", expr)
}
}
switch len(rangeAndStep) {
case 1:
step = 1
case 2:
step, err = u.mustParseInt(rangeAndStep[1])
if err != nil {
return 0, err
}
// Special handling: "N/step" means "N-max/step".
if singleDigit {
end = r.max
}
if step > 1 {
extra = 0
}
default:
return 0, fmt.Errorf("too many slashes: %s", expr)
}
if start < r.min {
return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
}
if end > r.max {
return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr)
}
if start > end {
return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
}
if step == 0 {
return 0, fmt.Errorf("step of range should be a positive number: %s", expr)
}
return u.getBits(start, end, step) | extra, nil
}
// parseIntOrName returns the (possibly-named) integer contained in expr.
func (u *cronUtils) parseIntOrName(expr string, names map[string]uint) (uint, error) {
if names != nil {
if namedInt, ok := names[strings.ToLower(expr)]; ok {
return namedInt, nil
}
}
return u.mustParseInt(expr)
}
// mustParseInt parses the given expression as an int or returns an error.
func (u *cronUtils) mustParseInt(expr string) (uint, error) {
num, err := strconv.Atoi(expr)
if err != nil {
return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err)
}
if num < 0 {
return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr)
}
return uint(num), nil
}
// getBits sets all bits in the range [min, max], modulo the given step size.
func (u *cronUtils) getBits(min, max, step uint) uint64 {
var bits uint64
// If step is 1, use shifts.
if step == 1 {
return ^(math.MaxUint64 << (max + 1)) & (math.MaxUint64 << min)
}
// Else, use a simple loop.
for i := min; i <= max; i += step {
bits |= 1 << i
}
return bits
}
// all returns all bits within the given cronBounds. (plus the star bit)
func (u *cronUtils) all(r cronBounds) uint64 {
return u.getBits(r.min, r.max, 1) | CronUtils.starBit
}
var CronUtils = cronUtils{
// The cronBounds for each field.
seconds: cronBounds{0, 59, nil},
minutes: cronBounds{0, 59, nil},
hours: cronBounds{0, 23, nil},
dom: cronBounds{1, 31, nil},
months: cronBounds{1, 12, map[string]uint{
"jan": 1,
"feb": 2,
"mar": 3,
"apr": 4,
"may": 5,
"jun": 6,
"jul": 7,
"aug": 8,
"sep": 9,
"oct": 10,
"nov": 11,
"dec": 12,
}},
dow: cronBounds{0, 6, map[string]uint{
"sun": 0,
"mon": 1,
"tue": 2,
"wed": 3,
"thu": 4,
"fri": 5,
"sat": 6,
}},
// Set the top bit if a star was included in the expression.
starBit: 1 << 63,
}
|
2302_79757062/crawlab
|
core/utils/cron.go
|
Go
|
bsd-3-clause
| 4,014
|
package utils
import (
"fmt"
"github.com/spf13/viper"
"time"
)
func IsDebug() bool {
return viper.GetBool("debug")
}
func LogDebug(msg string) {
if !IsDebug() {
return
}
fmt.Println(fmt.Sprintf("[DEBUG] %s: %s", time.Now().Format("2006-01-02 15:04:05"), msg))
}
|
2302_79757062/crawlab
|
core/utils/debug.go
|
Go
|
bsd-3-clause
| 274
|
package utils
import (
"fmt"
"github.com/crawlab-team/crawlab/core/sys_exec"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
)
func GetApiAddress() (res string) {
apiAddress := viper.GetString("api.address")
if apiAddress == "" {
return "http://localhost:8000"
}
return apiAddress
}
func IsDemo() (ok bool) {
return EnvIsTrue("demo", true)
}
func InitializedDemo() (ok bool) {
col := mongo.GetMongoCol("users")
n, err := col.Count(nil)
if err != nil {
return true
}
return n > 0
}
func ImportDemo() (err error) {
cmdStr := fmt.Sprintf("crawlab-cli login -a %s && crawlab-demo import", GetApiAddress())
cmd := sys_exec.BuildCmd(cmdStr)
if err := cmd.Run(); err != nil {
trace.PrintError(err)
}
return nil
}
func ReimportDemo() (err error) {
cmdStr := fmt.Sprintf("crawlab-cli login -a %s && crawlab-demo reimport", GetApiAddress())
cmd := sys_exec.BuildCmd(cmdStr)
if err := cmd.Run(); err != nil {
trace.PrintError(err)
}
return nil
}
func CleanupDemo() (err error) {
cmdStr := fmt.Sprintf("crawlab-cli login -a %s && crawlab-demo reimport", GetApiAddress())
cmd := sys_exec.BuildCmd(cmdStr)
if err := cmd.Run(); err != nil {
trace.PrintError(err)
}
return nil
}
|
2302_79757062/crawlab
|
core/utils/demo.go
|
Go
|
bsd-3-clause
| 1,270
|
package utils
import (
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
"go.uber.org/dig"
"os"
)
func VisualizeContainer(c *dig.Container) (err error) {
if !viper.GetBool("debug.di.visualize") {
return nil
}
if err := dig.Visualize(c, os.Stdout); err != nil {
return trace.TraceError(err)
}
return nil
}
|
2302_79757062/crawlab
|
core/utils/di.go
|
Go
|
bsd-3-clause
| 335
|
package utils
func IsDocker() (ok bool) {
return EnvIsTrue("docker", false)
}
|
2302_79757062/crawlab
|
core/utils/docker.go
|
Go
|
bsd-3-clause
| 80
|
package utils
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"crypto/hmac"
"crypto/md5"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"io"
)
func GetSecretKey() string {
return constants.DefaultEncryptServerKey
}
func GetSecretKeyBytes() []byte {
return []byte(GetSecretKey())
}
func ComputeHmacSha256(message string, secret string) string {
key := []byte(secret)
h := hmac.New(sha256.New, key)
h.Write([]byte(message))
sha := hex.EncodeToString(h.Sum(nil))
return base64.StdEncoding.EncodeToString([]byte(sha))
}
func EncryptMd5(str string) string {
w := md5.New()
_, _ = io.WriteString(w, str)
md5str := fmt.Sprintf("%x", w.Sum(nil))
return md5str
}
func padding(src []byte, blockSize int) []byte {
padNum := blockSize - len(src)%blockSize
pad := bytes.Repeat([]byte{byte(padNum)}, padNum)
return append(src, pad...)
}
func unPadding(src []byte) []byte {
n := len(src)
unPadNum := int(src[n-1])
return src[:n-unPadNum]
}
func EncryptAES(src string) (res string, err error) {
srcBytes := []byte(src)
key := GetSecretKeyBytes()
block, err := aes.NewCipher(key)
if err != nil {
return res, err
}
srcBytes = padding(srcBytes, block.BlockSize())
blockMode := cipher.NewCBCEncrypter(block, key)
blockMode.CryptBlocks(srcBytes, srcBytes)
res = hex.EncodeToString(srcBytes)
return res, nil
}
func DecryptAES(src string) (res string, err error) {
srcBytes, err := hex.DecodeString(src)
if err != nil {
return res, err
}
key := GetSecretKeyBytes()
block, err := aes.NewCipher(key)
if err != nil {
return res, err
}
blockMode := cipher.NewCBCDecrypter(block, key)
blockMode.CryptBlocks(srcBytes, srcBytes)
res = string(unPadding(srcBytes))
return res, nil
}
|
2302_79757062/crawlab
|
core/utils/encrypt.go
|
Go
|
bsd-3-clause
| 1,770
|
package utils
import (
"bytes"
"context"
"encoding/json"
"fmt"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/trace"
"github.com/elastic/go-elasticsearch/v8"
"github.com/elastic/go-elasticsearch/v8/esapi"
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
func GetElasticsearchClient(ds *models.DataSource) (c *elasticsearch.Client, err error) {
return getElasticsearchClient(context.Background(), ds)
}
func GetElasticsearchClientWithTimeout(ds *models.DataSource, timeout time.Duration) (c *elasticsearch.Client, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getElasticsearchClient(ctx, ds)
}
func getElasticsearchClient(ctx context.Context, ds *models.DataSource) (c *elasticsearch.Client, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultElasticsearchPort
}
// es hosts
addresses := []string{
fmt.Sprintf("http://%s:%s", host, port),
}
// retry backoff
rb := backoff.NewExponentialBackOff()
// es client options
cfg := elasticsearch.Config{
Addresses: addresses,
Username: ds.Username,
Password: ds.Password,
//CloudID: "",
//APIKey: "",
//ServiceToken: "",
//CertificateFingerprint: "",
//Header: nil,
//CACert: nil,
//RetryOnStatus: nil,
//DisableRetry: false,
//EnableRetryOnTimeout: false,
//MaxRetries: 0,
//CompressRequestBody: false,
//DiscoverNodesOnStart: false,
//DiscoverNodesInterval: 0,
//EnableMetrics: false,
//EnableDebugLogger: false,
//EnableCompatibilityMode: false,
//DisableMetaHeader: false,
//UseResponseCheckOnly: false,
RetryBackoff: func(i int) time.Duration {
if i == 1 {
rb.Reset()
}
return rb.NextBackOff()
},
//Transport: nil,
//Logger: nil,
//Selector: nil,
//ConnectionPoolFunc: nil,
}
// es client
done := make(chan struct{})
go func() {
c, err = elasticsearch.NewClient(cfg)
if err != nil {
return
}
var res *esapi.Response
res, err = c.Info()
fmt.Println(res)
close(done)
}()
// wait for done
select {
case <-ctx.Done():
if ctx.Err() != nil {
err = ctx.Err()
}
case <-done:
}
return c, err
}
func GetElasticsearchQuery(query generic.ListQuery) (buf *bytes.Buffer) {
q := map[string]interface{}{}
if len(query) > 0 {
match := getElasticsearchQueryMatch(query)
q["query"] = map[string]interface{}{
"match": match,
}
}
buf = &bytes.Buffer{}
if err := json.NewEncoder(buf).Encode(q); err != nil {
trace.PrintError(err)
}
return buf
}
func GetElasticsearchQueryWithOptions(query generic.ListQuery, opts *generic.ListOptions) (buf *bytes.Buffer) {
q := map[string]interface{}{
"size": opts.Limit,
"from": opts.Skip,
// TODO: sort
}
if len(query) > 0 {
match := getElasticsearchQueryMatch(query)
q["query"] = map[string]interface{}{
"match": match,
}
}
buf = &bytes.Buffer{}
if err := json.NewEncoder(buf).Encode(q); err != nil {
trace.PrintError(err)
}
return buf
}
func getElasticsearchQueryMatch(query generic.ListQuery) (match map[string]interface{}) {
match = map[string]interface{}{}
for _, c := range query {
switch c.Value.(type) {
case primitive.ObjectID:
c.Value = c.Value.(primitive.ObjectID).Hex()
}
switch c.Op {
case generic.OpEqual:
match[c.Key] = c.Value
default:
match[c.Key] = map[string]interface{}{
c.Op: c.Value,
}
}
}
return match
}
|
2302_79757062/crawlab
|
core/utils/es.go
|
Go
|
bsd-3-clause
| 3,854
|
package utils
import (
"archive/zip"
"crypto/md5"
"encoding/hex"
"fmt"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"io"
"io/fs"
"os"
"path"
"path/filepath"
"runtime/debug"
)
func OpenFile(fileName string) *os.File {
file, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR, os.ModePerm)
if err != nil {
log.Errorf("create file error: %s, file_name: %s", err.Error(), fileName)
debug.PrintStack()
return nil
}
return file
}
func Exists(path string) bool {
_, err := os.Stat(path) //os.Stat获取文件信息
if err != nil {
return os.IsExist(err)
}
return true
}
func IsDir(path string) bool {
s, err := os.Stat(path)
if err != nil {
return false
}
return s.IsDir()
}
// ListDir Add: 增加error类型作为第二返回值
// 在其他函数如 /task/log/file_driver.go中的 *FileLogDriver.cleanup()函数调用时
// 可以通过判断err是否为nil来判断是否有错误发生
func ListDir(path string) ([]fs.FileInfo, error) {
list, err := os.ReadDir(path)
if err != nil {
log.Errorf(err.Error())
debug.PrintStack()
return nil, err
}
var res []fs.FileInfo
for _, item := range list {
info, err := item.Info()
if err != nil {
log.Errorf(err.Error())
debug.PrintStack()
return nil, err
}
res = append(res, info)
}
return res, nil
}
func DeCompress(srcFile *os.File, dstPath string) error {
// 如果保存路径不存在，创建一个
if !Exists(dstPath) {
if err := os.MkdirAll(dstPath, os.ModePerm); err != nil {
debug.PrintStack()
return err
}
}
// 读取zip文件
zipFile, err := zip.OpenReader(srcFile.Name())
if err != nil {
log.Errorf("Unzip File Error：" + err.Error())
debug.PrintStack()
return err
}
defer Close(zipFile)
// 遍历zip内所有文件和目录
for _, innerFile := range zipFile.File {
// 获取该文件数据
info := innerFile.FileInfo()
// 如果是目录，则创建一个
if info.IsDir() {
err = os.MkdirAll(filepath.Join(dstPath, innerFile.Name), os.ModeDir|os.ModePerm)
if err != nil {
log.Errorf("Unzip File Error : " + err.Error())
debug.PrintStack()
return err
}
continue
}
// 如果文件目录不存在，则创建一个
dirPath := filepath.Join(dstPath, filepath.Dir(innerFile.Name))
if !Exists(dirPath) {
if err = os.MkdirAll(dirPath, os.ModeDir|os.ModePerm); err != nil {
log.Errorf("Unzip File Error : " + err.Error())
debug.PrintStack()
return err
}
}
// 打开该文件
srcFile, err := innerFile.Open()
if err != nil {
log.Errorf("Unzip File Error : " + err.Error())
debug.PrintStack()
continue
}
// 创建新文件
newFilePath := filepath.Join(dstPath, innerFile.Name)
newFile, err := os.OpenFile(newFilePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, info.Mode())
if err != nil {
log.Errorf("Unzip File Error : " + err.Error())
debug.PrintStack()
continue
}
// 拷贝该文件到新文件中
if _, err := io.Copy(newFile, srcFile); err != nil {
debug.PrintStack()
return err
}
// 关闭该文件
if err := srcFile.Close(); err != nil {
debug.PrintStack()
return err
}
// 关闭新文件
if err := newFile.Close(); err != nil {
debug.PrintStack()
return err
}
}
return nil
}
// Compress 压缩文件
// files 文件数组，可以是不同dir下的文件或者文件夹
// dest 压缩文件存放地址
func Compress(files []*os.File, dest string) error {
d, _ := os.Create(dest)
defer Close(d)
w := zip.NewWriter(d)
defer Close(w)
for _, file := range files {
if err := _Compress(file, "", w); err != nil {
return err
}
}
return nil
}
func _Compress(file *os.File, prefix string, zw *zip.Writer) error {
info, err := file.Stat()
if err != nil {
debug.PrintStack()
return err
}
if info.IsDir() {
prefix = prefix + "/" + info.Name()
fileInfos, err := file.Readdir(-1)
if err != nil {
debug.PrintStack()
return err
}
for _, fi := range fileInfos {
f, err := os.Open(file.Name() + "/" + fi.Name())
if err != nil {
debug.PrintStack()
return err
}
err = _Compress(f, prefix, zw)
if err != nil {
debug.PrintStack()
return err
}
}
} else {
header, err := zip.FileInfoHeader(info)
if err != nil {
debug.PrintStack()
return err
}
header.Name = prefix + "/" + header.Name
writer, err := zw.CreateHeader(header)
if err != nil {
debug.PrintStack()
return err
}
_, err = io.Copy(writer, file)
Close(file)
if err != nil {
debug.PrintStack()
return err
}
}
return nil
}
func TrimFileData(data []byte) (res []byte) {
if string(data) == constants.EmptyFileData {
return res
}
return data
}
func ZipDirectory(dir, zipfile string) error {
zipFile, err := os.Create(zipfile)
if err != nil {
return err
}
defer zipFile.Close()
zipWriter := zip.NewWriter(zipFile)
defer zipWriter.Close()
baseDir := filepath.Dir(dir)
err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
relPath, err := filepath.Rel(baseDir, path)
if err != nil {
return err
}
zipFile, err := zipWriter.Create(relPath)
if err != nil {
return err
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
_, err = io.Copy(zipFile, file)
if err != nil {
return err
}
return nil
})
return err
}
// CopyFile File copies a single file from src to dst
func CopyFile(src, dst string) error {
var err error
var srcFd *os.File
var dstFd *os.File
var srcInfo os.FileInfo
if srcFd, err = os.Open(src); err != nil {
return err
}
defer srcFd.Close()
if dstFd, err = os.Create(dst); err != nil {
return err
}
defer dstFd.Close()
if _, err = io.Copy(dstFd, srcFd); err != nil {
return err
}
if srcInfo, err = os.Stat(src); err != nil {
return err
}
return os.Chmod(dst, srcInfo.Mode())
}
// CopyDir Dir copies a whole directory recursively
func CopyDir(src string, dst string) error {
var err error
var fds []os.DirEntry
var srcInfo os.FileInfo
if srcInfo, err = os.Stat(src); err != nil {
return err
}
if err = os.MkdirAll(dst, srcInfo.Mode()); err != nil {
return err
}
if fds, err = os.ReadDir(src); err != nil {
return err
}
for _, fd := range fds {
srcfp := path.Join(src, fd.Name())
dstfp := path.Join(dst, fd.Name())
if fd.IsDir() {
if err = CopyDir(srcfp, dstfp); err != nil {
fmt.Println(err)
}
} else {
if err = CopyFile(srcfp, dstfp); err != nil {
fmt.Println(err)
}
}
}
return nil
}
func GetFileHash(filePath string) (res string, err error) {
file, err := os.Open(filePath)
if err != nil {
return "", err
}
defer file.Close()
hash := md5.New()
if _, err := io.Copy(hash, file); err != nil {
return "", err
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
func ScanDirectory(dir string) (res map[string]entity.FsFileInfo, err error) {
files := make(map[string]entity.FsFileInfo)
err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
hash, err := GetFileHash(path)
if err != nil {
return err
}
relPath, err := filepath.Rel(dir, path)
if err != nil {
return err
}
files[relPath] = entity.FsFileInfo{
Name: info.Name(),
Path: relPath,
FullPath: path,
Extension: filepath.Ext(path),
FileSize: info.Size(),
ModTime: info.ModTime(),
Mode: info.Mode(),
Hash: hash,
}
return nil
})
if err != nil {
return nil, err
}
return files, nil
}
|
2302_79757062/crawlab
|
core/utils/file.go
|
Go
|
bsd-3-clause
| 7,712
|
package utils
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"go.mongodb.org/mongo-driver/bson"
)
// FilterToQuery Translate entity.Filter to bson.M
func FilterToQuery(f interfaces.Filter) (q bson.M, err error) {
if f == nil || f.IsNil() {
return nil, nil
}
q = bson.M{}
for _, cond := range f.GetConditions() {
key := cond.GetKey()
op := cond.GetOp()
value := cond.GetValue()
switch op {
case constants.FilterOpNotSet:
// do nothing
case constants.FilterOpEqual:
q[key] = cond.GetValue()
case constants.FilterOpNotEqual:
q[key] = bson.M{"$ne": value}
case constants.FilterOpContains, constants.FilterOpRegex, constants.FilterOpSearch:
q[key] = bson.M{"$regex": value, "$options": "i"}
case constants.FilterOpNotContains:
q[key] = bson.M{"$not": bson.M{"$regex": value}}
case constants.FilterOpIn:
q[key] = bson.M{"$in": value}
case constants.FilterOpNotIn:
q[key] = bson.M{"$nin": value}
case constants.FilterOpGreaterThan:
q[key] = bson.M{"$gt": value}
case constants.FilterOpGreaterThanEqual:
q[key] = bson.M{"$gte": value}
case constants.FilterOpLessThan:
q[key] = bson.M{"$lt": value}
case constants.FilterOpLessThanEqual:
q[key] = bson.M{"$lte": value}
default:
return nil, errors.ErrorFilterInvalidOperation
}
}
return q, nil
}
|
2302_79757062/crawlab
|
core/utils/filter.go
|
Go
|
bsd-3-clause
| 1,427
|
package utils
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
vcs "github.com/crawlab-team/crawlab/vcs"
)
func InitGitClientAuth(g interfaces.Git, gitClient *vcs.GitClient) {
// set auth
switch g.GetAuthType() {
case constants.GitAuthTypeHttp:
gitClient.SetAuthType(vcs.GitAuthTypeHTTP)
gitClient.SetUsername(g.GetUsername())
gitClient.SetPassword(g.GetPassword())
case constants.GitAuthTypeSsh:
gitClient.SetAuthType(vcs.GitAuthTypeSSH)
gitClient.SetUsername(g.GetUsername())
gitClient.SetPrivateKey(g.GetPassword())
}
}
func InitGitClientAuthV2(g *models.GitV2, gitClient *vcs.GitClient) {
// set auth
switch g.AuthType {
case constants.GitAuthTypeHttp:
gitClient.SetAuthType(vcs.GitAuthTypeHTTP)
gitClient.SetUsername(g.Username)
gitClient.SetPassword(g.Password)
case constants.GitAuthTypeSsh:
gitClient.SetAuthType(vcs.GitAuthTypeSSH)
gitClient.SetUsername(g.Username)
gitClient.SetPrivateKey(g.Password)
}
}
|
2302_79757062/crawlab
|
core/utils/git.go
|
Go
|
bsd-3-clause
| 1,068
|
package utils
import (
"github.com/crawlab-team/crawlab/trace"
"io"
"reflect"
"unsafe"
)
func BytesToString(b []byte) string {
return *(*string)(unsafe.Pointer(&b))
}
func Close(c io.Closer) {
err := c.Close()
if err != nil {
trace.PrintError(err)
}
}
func Contains(array interface{}, val interface{}) (fla bool) {
fla = false
switch reflect.TypeOf(array).Kind() {
case reflect.Slice:
{
s := reflect.ValueOf(array)
for i := 0; i < s.Len(); i++ {
if reflect.DeepEqual(val, s.Index(i).Interface()) {
fla = true
return
}
}
}
}
return
}
|
2302_79757062/crawlab
|
core/utils/helpers.go
|
Go
|
bsd-3-clause
| 583
|
package utils
import (
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/trace"
"github.com/gin-gonic/gin"
"net/http"
)
func handleError(statusCode int, c *gin.Context, err error, print bool) {
if print {
trace.PrintError(err)
}
c.AbortWithStatusJSON(statusCode, entity.Response{
Status: constants.HttpResponseStatusOk,
Message: constants.HttpResponseMessageError,
Error: err.Error(),
})
}
func HandleError(statusCode int, c *gin.Context, err error) {
handleError(statusCode, c, err, true)
}
func HandleErrorUnauthorized(c *gin.Context, err error) {
HandleError(http.StatusUnauthorized, c, err)
}
func HandleErrorInternalServerError(c *gin.Context, err error) {
HandleError(http.StatusInternalServerError, c, err)
}
|
2302_79757062/crawlab
|
core/utils/http.go
|
Go
|
bsd-3-clause
| 822
|
package utils
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"sync"
)
var moduleInitializedMap = sync.Map{}
func InitModule(id interfaces.ModuleId, fn func() error) (err error) {
res, ok := moduleInitializedMap.Load(id)
if ok {
initialized, _ := res.(bool)
if initialized {
return nil
}
}
if err := fn(); err != nil {
return err
}
moduleInitializedMap.Store(id, true)
return nil
}
func ForceInitModule(fn func() error) (err error) {
return fn()
}
|
2302_79757062/crawlab
|
core/utils/init.go
|
Go
|
bsd-3-clause
| 487
|
package utils
import "encoding/json"
func JsonToBytes(d interface{}) (bytes []byte, err error) {
switch d.(type) {
case []byte:
return d.([]byte), nil
default:
return json.Marshal(d)
}
}
|
2302_79757062/crawlab
|
core/utils/json.go
|
Go
|
bsd-3-clause
| 197
|
package utils
import (
"context"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/segmentio/kafka-go"
"time"
)
func GetKafkaConnection(ds *models.DataSource) (c *kafka.Conn, err error) {
return getKafkaConnection(context.Background(), ds)
}
func GetKafkaConnectionWithTimeout(ds *models.DataSource, timeout time.Duration) (c *kafka.Conn, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getKafkaConnection(ctx, ds)
}
func getKafkaConnection(ctx context.Context, ds *models.DataSource) (c *kafka.Conn, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultKafkaPort
}
// kafka connection address
network := "tcp"
address := fmt.Sprintf("%s:%s", host, port)
topic := ds.Database
partition := 0 // TODO: parameterize
// kafka connection
return kafka.DialLeader(ctx, network, address, topic, partition)
}
|
2302_79757062/crawlab
|
core/utils/kafka.go
|
Go
|
bsd-3-clause
| 1,064
|
package utils
import (
"context"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
func GetMongoQuery(query generic.ListQuery) (res bson.M) {
res = bson.M{}
for _, c := range query {
switch c.Op {
case generic.OpEqual:
res[c.Key] = c.Value
default:
res[c.Key] = bson.M{
c.Op: c.Value,
}
}
}
return res
}
func GetMongoOpts(opts *generic.ListOptions) (res *mongo.FindOptions) {
var sort bson.D
for _, s := range opts.Sort {
direction := 1
if s.Direction == generic.SortDirectionAsc {
direction = 1
} else if s.Direction == generic.SortDirectionDesc {
direction = -1
}
sort = append(sort, bson.E{Key: s.Key, Value: direction})
}
return &mongo.FindOptions{
Skip: opts.Skip,
Limit: opts.Limit,
Sort: sort,
}
}
func GetMongoClient(ds *models.DataSource) (c *mongo2.Client, err error) {
return getMongoClient(context.Background(), ds)
}
func GetMongoClientWithTimeout(ds *models.DataSource, timeout time.Duration) (c *mongo2.Client, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getMongoClient(ctx, ds)
}
func getMongoClient(ctx context.Context, ds *models.DataSource) (c *mongo2.Client, err error) {
// normalize settings
if ds.Host == "" {
ds.Host = constants.DefaultHost
}
if ds.Port == "" {
ds.Port = constants.DefaultMongoPort
}
// options
var opts []mongo.ClientOption
opts = append(opts, mongo.WithContext(ctx))
opts = append(opts, mongo.WithUri(ds.Url))
opts = append(opts, mongo.WithHost(ds.Host))
opts = append(opts, mongo.WithPort(ds.Port))
opts = append(opts, mongo.WithDb(ds.Database))
opts = append(opts, mongo.WithUsername(ds.Username))
opts = append(opts, mongo.WithPassword(ds.Password))
opts = append(opts, mongo.WithHosts(ds.Hosts))
// extra
if ds.Extra != nil {
// auth source
authSource, ok := ds.Extra["auth_source"]
if ok {
opts = append(opts, mongo.WithAuthSource(authSource))
}
// auth mechanism
authMechanism, ok := ds.Extra["auth_mechanism"]
if ok {
opts = append(opts, mongo.WithAuthMechanism(authMechanism))
}
}
// client
return mongo.GetMongoClient(opts...)
}
|
2302_79757062/crawlab
|
core/utils/mongo.go
|
Go
|
bsd-3-clause
| 2,387
|
package utils
import (
"context"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/upper/db/v4"
"github.com/upper/db/v4/adapter/mssql"
"time"
)
func GetMssqlSession(ds *models.DataSource) (s db.Session, err error) {
return getMssqlSession(context.Background(), ds)
}
func GetMssqlSessionWithTimeout(ds *models.DataSource, timeout time.Duration) (s db.Session, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getMssqlSession(ctx, ds)
}
func getMssqlSession(ctx context.Context, ds *models.DataSource) (s db.Session, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultMssqlPort
}
// connect settings
settings := mssql.ConnectionURL{
User: ds.Username,
Password: ds.Password,
Database: ds.Database,
Host: fmt.Sprintf("%s:%s", host, port),
Options: nil,
}
// session
done := make(chan struct{})
go func() {
s, err = mssql.Open(settings)
close(done)
}()
// wait for done
select {
case <-ctx.Done():
if ctx.Err() != nil {
err = ctx.Err()
}
case <-done:
}
return s, err
}
|
2302_79757062/crawlab
|
core/utils/mssql.go
|
Go
|
bsd-3-clause
| 1,270
|
package utils
import (
"context"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/upper/db/v4"
"github.com/upper/db/v4/adapter/mysql"
"time"
)
func GetMysqlSession(ds *models.DataSource) (s db.Session, err error) {
return getMysqlSession(context.Background(), ds)
}
func GetMysqlSessionWithTimeout(ds *models.DataSource, timeout time.Duration) (s db.Session, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getMysqlSession(ctx, ds)
}
func getMysqlSession(ctx context.Context, ds *models.DataSource) (s db.Session, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultMysqlPort
}
// connect settings
settings := mysql.ConnectionURL{
User: ds.Username,
Password: ds.Password,
Database: ds.Database,
Host: fmt.Sprintf("%s:%s", host, port),
Options: nil,
}
// session
done := make(chan struct{})
go func() {
s, err = mysql.Open(settings)
close(done)
}()
// wait for done
select {
case <-ctx.Done():
if ctx.Err() != nil {
err = ctx.Err()
}
case <-done:
}
return s, err
}
|
2302_79757062/crawlab
|
core/utils/mysql.go
|
Go
|
bsd-3-clause
| 1,270
|
package utils
func IsMaster() bool {
return EnvIsTrue("node.master", false)
}
func GetNodeType() string {
if IsMaster() {
return "master"
} else {
return "worker"
}
}
|
2302_79757062/crawlab
|
core/utils/node.go
|
Go
|
bsd-3-clause
| 177
|
package utils
import (
"os"
"os/signal"
"syscall"
)
func DefaultWait() {
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
}
|
2302_79757062/crawlab
|
core/utils/os.go
|
Go
|
bsd-3-clause
| 175
|
package utils
import (
"context"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/upper/db/v4"
"github.com/upper/db/v4/adapter/postgresql"
"time"
)
func GetPostgresqlSession(ds *models.DataSource) (s db.Session, err error) {
return getPostgresqlSession(context.Background(), ds)
}
func GetPostgresqlSessionWithTimeout(ds *models.DataSource, timeout time.Duration) (s db.Session, err error) {
ctx, cancel := context.WithTimeout(context.Background(), timeout)
defer cancel()
return getPostgresqlSession(ctx, ds)
}
func getPostgresqlSession(ctx context.Context, ds *models.DataSource) (s db.Session, err error) {
// normalize settings
host := ds.Host
port := ds.Port
if ds.Host == "" {
host = constants.DefaultHost
}
if ds.Port == "" {
port = constants.DefaultPostgresqlPort
}
// connect settings
settings := postgresql.ConnectionURL{
User: ds.Username,
Password: ds.Password,
Database: ds.Database,
Host: fmt.Sprintf("%s:%s", host, port),
Options: nil,
}
// session
done := make(chan struct{})
go func() {
s, err = postgresql.Open(settings)
close(done)
}()
// wait for done
select {
case <-ctx.Done():
if ctx.Err() != nil {
err = ctx.Err()
}
case <-done:
}
return s, err
}
|
2302_79757062/crawlab
|
core/utils/postgresql.go
|
Go
|
bsd-3-clause
| 1,315
|