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
|
|---|---|---|---|---|---|
<!doctype html> <!-- Important: must specify -->
<html>
<head>
<meta charset="utf-8"> <!-- Important: rapi-doc uses utf8 characters -->
<script type="module" src="https://unpkg.com/rapidoc/dist/rapidoc-min.js"></script>
</head>
<body>
<rapi-doc spec-url="./openapi.yaml"></rapi-doc>
</body>
</html>
|
2302_79757062/crawlab
|
core/docs/api/index.html
|
HTML
|
bsd-3-clause
| 301
|
const path = require('path')
const qiniu = require('qiniu')
const walkSync = require('walk-sync')
const chalk = require('chalk')
// target directory
const targetDir = './api'
// access key
const accessKey = process.env.QINIU_ACCESS_KEY
// secret key
const secretKey = process.env.QINIU_SECRET_KEY
// bucket
const bucket = process.env.QINIU_BUCKET
// config
const config = new qiniu.conf.Config()
// zone
config.zone = qiniu.zone[process.env.QINIU_ZONE]
function uploadFile(localFile, key) {
// options
const options = {
scope: `${bucket}:${key}`,
}
// mac
const mac = new qiniu.auth.digest.Mac(accessKey, secretKey)
// put policy
const putPolicy = new qiniu.rs.PutPolicy(options)
// upload token
const uploadToken = putPolicy.uploadToken(mac)
return new Promise((resolve, reject) => {
const formUploader = new qiniu.form_up.FormUploader(config)
const putExtra = new qiniu.form_up.PutExtra()
formUploader.putFile(uploadToken, key, localFile, putExtra, function (respErr, respBody, respInfo) {
if (respErr) {
throw respErr
}
if (respInfo.statusCode === 200) {
console.log(`${chalk.green('uploaded')} ${localFile} => ${key}`)
resolve()
} else if (respInfo.statusCode === 614) {
console.log(`${chalk.yellow('exists')} ${localFile} => ${key}`)
resolve()
} else {
const errMsg = `${chalk.red('error[' + respInfo.statusCode + ']')} ${localFile} => ${key}`
console.error(errMsg)
reject(new Error(respBody))
}
})
})
}
async function main() {
// paths
const paths = walkSync(targetDir, {
includeBasePath: true, directories: false,
})
// iterate paths
for (const filePath of paths) {
const localFile = path.resolve(filePath)
const key = filePath.replace(targetDir + '/', '')
try {
await uploadFile(localFile, key)
} finally {
// do nothing
}
}
}
(async () => {
await main()
})()
|
2302_79757062/crawlab
|
core/docs/scripts/publish.js
|
JavaScript
|
bsd-3-clause
| 1,878
|
package ds
import (
"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/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type CockroachdbService struct {
SqlService
}
func NewDataSourceCockroachdbService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &CockroachdbService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, trace.TraceError(err)
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, trace.TraceError(err)
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultCockroachdbPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, trace.TraceError(err)
}
// session
svc.s, err = utils.GetCockroachdbSession(svc.ds)
if err != nil {
return nil, trace.TraceError(err)
}
// collection
svc.col = svc.s.Collection(svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/cockroachdb.go
|
Go
|
bsd-3-clause
| 1,601
|
package ds
|
2302_79757062/crawlab
|
core/ds/default.go
|
Go
|
bsd-3-clause
| 11
|
package ds
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/crawlab-team/crawlab/core/constants"
constants2 "github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
entity2 "github.com/crawlab-team/crawlab/core/entity"
"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/trace"
"github.com/elastic/go-elasticsearch/v8"
"github.com/elastic/go-elasticsearch/v8/esapi"
"github.com/google/uuid"
"go.mongodb.org/mongo-driver/bson/primitive"
"strings"
"sync"
"time"
)
type ElasticsearchService struct {
// dependencies
modelSvc service.ModelService
// internals
dc *models.DataCollection // models.DataCollection
ds *models.DataSource // models.DataSource
c *elasticsearch.Client // elasticsearch.Client
t time.Time
}
func (svc *ElasticsearchService) Insert(records ...interface{}) (err error) {
// wait group
var wg sync.WaitGroup
wg.Add(len(records))
// iterate records
for _, r := range records {
// async operation
go func(r interface{}) {
switch r.(type) {
case entity.Result:
// convert type to entity.Result
d := r.(entity.Result)
// get document id
id := d.GetValue("id")
var docId string
switch id.(type) {
case string:
docId = id.(string)
}
if docId == "" {
docId = uuid.New().String() // generate new uuid if id is empty
}
// collection
d[constants2.DataCollectionKey] = svc.dc.Name
// index request
req := esapi.IndexRequest{
Index: svc.getIndexName(),
DocumentID: docId,
Body: strings.NewReader(d.String()),
}
// perform request
res, err := req.Do(context.Background(), svc.c)
if err != nil {
trace.PrintError(err)
wg.Done()
return
}
defer res.Body.Close()
if res.IsError() {
trace.PrintError(errors.New(fmt.Sprintf("[ElasticsearchService] [%s] error inserting record: %v", res.Status(), r)))
}
// release
wg.Done()
default:
wg.Done()
return
}
}(r)
}
// wait
wg.Wait()
return nil
}
func (svc *ElasticsearchService) List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error) {
data, err := svc.getListResponse(query, opts, false)
if err != nil {
return nil, err
}
for _, hit := range data.Hits.Hits {
results = append(results, hit.Source)
}
return results, nil
}
func (svc *ElasticsearchService) Count(query generic.ListQuery) (n int, err error) {
data, err := svc.getListResponse(query, nil, true)
if err != nil {
return n, err
}
return int(data.Hits.Total.Value), nil
}
func (svc *ElasticsearchService) getListResponse(query generic.ListQuery, opts *generic.ListOptions, trackTotalHits bool) (data *entity2.ElasticsearchResponseData, err error) {
if opts == nil {
opts = &generic.ListOptions{}
}
query = append(query, generic.ListQueryCondition{
Key: constants2.DataCollectionKey,
Op: constants2.FilterOpEqual,
Value: svc.dc.Name,
})
res, err := svc.c.Search(
svc.c.Search.WithContext(context.Background()),
svc.c.Search.WithIndex(svc.getIndexName()),
svc.c.Search.WithBody(utils.GetElasticsearchQueryWithOptions(query, opts)),
svc.c.Search.WithTrackTotalHits(trackTotalHits),
)
if err != nil {
return nil, trace.TraceError(err)
}
defer res.Body.Close()
if res.IsError() {
err = errors.New(fmt.Sprintf("[ElasticsearchService] [%s] error listing records: response=%s, query=%v opts=%v", res.Status(), res.String(), query, opts))
trace.PrintError(err)
return nil, err
}
data = &entity2.ElasticsearchResponseData{}
if err := json.NewDecoder(res.Body).Decode(data); err != nil {
return nil, trace.TraceError(err)
}
return data, nil
}
func (svc *ElasticsearchService) getIndexName() (index string) {
if svc.ds.Database == "" {
return svc.dc.Name
} else {
return svc.ds.Name
}
}
func NewDataSourceElasticsearchService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &ElasticsearchService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, err
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultElasticsearchPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, err
}
// client
svc.c, err = utils.GetElasticsearchClient(svc.ds)
if err != nil {
return nil, err
}
return svc, nil
}
func (svc *ElasticsearchService) Index(fields []string) {
// TODO: implement me
}
func (svc *ElasticsearchService) SetTime(t time.Time) {
svc.t = t
}
func (svc *ElasticsearchService) GetTime() (t time.Time) {
return svc.t
}
|
2302_79757062/crawlab
|
core/ds/es.go
|
Go
|
bsd-3-clause
| 5,394
|
package ds
import (
"github.com/cenkalti/backoff/v4"
"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/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/trace"
"github.com/segmentio/kafka-go"
"go.mongodb.org/mongo-driver/bson/primitive"
"time"
)
type KafkaService struct {
// dependencies
modelSvc service.ModelService
// internals
dc *models.DataCollection // models.DataCollection
ds *models.DataSource // models.DataSource
c *kafka.Conn // kafka.Conn
rb backoff.BackOff
t time.Time
}
func (svc *KafkaService) Insert(records ...interface{}) (err error) {
var messages []kafka.Message
for _, r := range records {
switch r.(type) {
case entity.Result:
d := r.(entity.Result)
messages = append(messages, kafka.Message{
Topic: svc.ds.Database,
Key: []byte(d.GetTaskId().Hex()),
Value: d.Bytes(),
})
}
}
_, err = svc.c.WriteMessages(messages...)
if err != nil {
return trace.TraceError(err)
}
return nil
}
func (svc *KafkaService) List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error) {
// N/A
return nil, nil
}
func (svc *KafkaService) Count(query generic.ListQuery) (n int, err error) {
// N/A
return 0, nil
}
func NewDataSourceKafkaService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &KafkaService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, err
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultKafkaPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, err
}
return svc, nil
}
func (svc *KafkaService) Index(fields []string) {
// TODO: implement me
}
func (svc *KafkaService) SetTime(t time.Time) {
svc.t = t
}
func (svc *KafkaService) GetTime() (t time.Time) {
return svc.t
}
|
2302_79757062/crawlab
|
core/ds/kafka.go
|
Go
|
bsd-3-clause
| 2,652
|
package ds
import (
"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"
utils2 "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/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"time"
)
type MongoService struct {
// dependencies
modelSvc service.ModelService
// internals
dc *models.DataCollection // models.DataCollection
ds *models.DataSource // models.DataSource
c *mongo2.Client
db *mongo2.Database
col *mongo.Col
t time.Time
}
func (svc *MongoService) Insert(records ...interface{}) (err error) {
_, err = svc.col.InsertMany(records)
return err
}
func (svc *MongoService) List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error) {
var docs []models.Result
if err := svc.col.Find(utils.GetMongoQuery(query), utils.GetMongoOpts(opts)).All(&docs); err != nil {
return nil, err
}
for i := range docs {
results = append(results, &docs[i])
}
return results, nil
}
func (svc *MongoService) Count(query generic.ListQuery) (n int, err error) {
return svc.col.Count(utils.GetMongoQuery(query))
}
func NewDataSourceMongoService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &MongoService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, err
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultMongoPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, err
}
// mongo client
svc.c, err = utils2.GetMongoClient(svc.ds)
if err != nil {
return nil, err
}
// mongo database
svc.db = mongo.GetMongoDb(svc.ds.Database, mongo.WithDbClient(svc.c))
// mongo col
svc.col = mongo.GetMongoColWithDb(svc.dc.Name, svc.db)
return svc, nil
}
func (svc *MongoService) Index(fields []string) {
// TODO: implement me
}
func (svc *MongoService) SetTime(t time.Time) {
svc.t = t
}
func (svc *MongoService) GetTime() (t time.Time) {
return svc.t
}
|
2302_79757062/crawlab
|
core/ds/mongo.go
|
Go
|
bsd-3-clause
| 2,805
|
package ds
import (
"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"
utils2 "github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type MssqlService struct {
SqlService
}
func NewDataSourceMssqlService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &MssqlService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, trace.TraceError(err)
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, trace.TraceError(err)
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultMssqlPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, trace.TraceError(err)
}
// session
svc.s, err = utils2.GetMssqlSession(svc.ds)
if err != nil {
return nil, trace.TraceError(err)
}
// collection
svc.col = svc.s.Collection(svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/mssql.go
|
Go
|
bsd-3-clause
| 1,625
|
package ds
import (
"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"
utils2 "github.com/crawlab-team/crawlab/core/utils"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type MysqlService struct {
SqlService
}
func NewDataSourceMysqlService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &MysqlService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, err
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultMysqlPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, err
}
// session
svc.s, err = utils2.GetMysqlSession(svc.ds)
if err != nil {
return nil, err
}
// collection
svc.col = svc.s.Collection(svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/mysql.go
|
Go
|
bsd-3-clause
| 1,511
|
package ds
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type DataSourceServiceOption func(svc interfaces.DataSourceService)
func WithMonitorInterval(duration time.Duration) DataSourceServiceOption {
return func(svc interfaces.DataSourceService) {
svc.SetMonitorInterval(duration)
}
}
|
2302_79757062/crawlab
|
core/ds/options.go
|
Go
|
bsd-3-clause
| 316
|
package ds
import (
"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"
utils2 "github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type PostgresqlService struct {
SqlService
}
func NewDataSourcePostgresqlService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &PostgresqlService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, trace.TraceError(err)
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, trace.TraceError(err)
}
}
// data source defaults
if svc.ds.Host == "" {
svc.ds.Host = constants.DefaultHost
}
if svc.ds.Port == "" {
svc.ds.Port = constants.DefaultPostgresqlPort
}
// data source password
pwd, err := svc.modelSvc.GetPasswordById(svc.ds.Id)
if err == nil {
svc.ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return nil, err
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, trace.TraceError(err)
}
// session
svc.s, err = utils2.GetPostgresqlSession(svc.ds)
if err != nil {
return nil, trace.TraceError(err)
}
// collection
svc.col = svc.s.Collection(svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/postgresql.go
|
Go
|
bsd-3-clause
| 1,650
|
package ds
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
constants2 "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/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/core/result"
"github.com/crawlab-team/crawlab/core/utils"
utils2 "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"
"sync"
"time"
)
type Service struct {
// dependencies
modelSvc service.ModelService
// internals
timeout time.Duration
monitorInterval time.Duration
stopped bool
}
func (svc *Service) Init() {
// result service registry
reg := result.GetResultServiceRegistry()
// register result services
reg.Register(constants.DataSourceTypeMongo, NewDataSourceMongoService)
reg.Register(constants.DataSourceTypeMysql, NewDataSourceMysqlService)
reg.Register(constants.DataSourceTypePostgresql, NewDataSourcePostgresqlService)
reg.Register(constants.DataSourceTypeMssql, NewDataSourceMssqlService)
reg.Register(constants.DataSourceTypeSqlite, NewDataSourceSqliteService)
reg.Register(constants.DataSourceTypeCockroachdb, NewDataSourceCockroachdbService)
reg.Register(constants.DataSourceTypeElasticSearch, NewDataSourceElasticsearchService)
reg.Register(constants.DataSourceTypeKafka, NewDataSourceKafkaService)
}
func (svc *Service) Start() {
// start monitoring
go svc.Monitor()
}
func (svc *Service) Wait() {
utils.DefaultWait()
}
func (svc *Service) Stop() {
svc.stopped = true
}
func (svc *Service) ChangePassword(id primitive.ObjectID, password string) (err error) {
p, err := svc.modelSvc.GetPasswordById(id)
if err == nil {
// exists, save
encryptedPassword, err := utils.EncryptAES(password)
if err != nil {
return err
}
p.Password = encryptedPassword
if err := delegate.NewModelDelegate(p).Save(); err != nil {
return err
}
return nil
} else if err.Error() == mongo.ErrNoDocuments.Error() {
// not exists, add
encryptedPassword, err := utils.EncryptAES(password)
if err != nil {
return err
}
p = &models.Password{
Id: id,
Password: encryptedPassword,
}
if err := delegate.NewModelDelegate(p).Add(); err != nil {
return err
}
return nil
} else {
// error
return err
}
}
func (svc *Service) Monitor() {
for {
// return if stopped
if svc.stopped {
return
}
// monitor
if err := svc.monitor(); err != nil {
trace.PrintError(err)
}
// wait
time.Sleep(svc.monitorInterval)
}
}
func (svc *Service) CheckStatus(id primitive.ObjectID) (err error) {
ds, err := svc.modelSvc.GetDataSourceById(id)
if err != nil {
return err
}
return svc.checkStatus(ds, true)
}
func (svc *Service) SetTimeout(duration time.Duration) {
svc.timeout = duration
}
func (svc *Service) SetMonitorInterval(duration time.Duration) {
svc.monitorInterval = duration
}
func (svc *Service) monitor() (err error) {
// start
tic := time.Now()
log.Debugf("[DataSourceService] start monitoring")
// data source list
dsList, err := svc.modelSvc.GetDataSourceList(nil, nil)
if err != nil {
return err
}
// waiting group
wg := sync.WaitGroup{}
wg.Add(len(dsList))
// iterate data source list
for _, ds := range dsList {
// async operation
go func(ds models.DataSource) {
// check status and save
_ = svc.checkStatus(&ds, true)
// release
wg.Done()
}(ds)
}
// wait
wg.Wait()
// finish
toc := time.Now()
log.Debugf("[DataSourceService] finished monitoring. elapsed: %d ms", (toc.Sub(tic)).Milliseconds())
return nil
}
func (svc *Service) checkStatus(ds *models.DataSource, save bool) (err error) {
// password
if ds.Password == "" {
pwd, err := svc.modelSvc.GetPasswordById(ds.Id)
if err == nil {
ds.Password, err = utils.DecryptAES(pwd.Password)
if err != nil {
return err
}
} else if err.Error() != mongo.ErrNoDocuments.Error() {
return trace.TraceError(err)
}
}
// check status
if err := svc._checkStatus(ds); err != nil {
ds.Status = constants2.DataSourceStatusOffline
ds.Error = err.Error()
} else {
ds.Status = constants2.DataSourceStatusOnline
ds.Error = ""
}
// save
if save {
return svc._save(ds)
}
return nil
}
func (svc *Service) _save(ds *models.DataSource) (err error) {
log.Debugf("[DataSourceService] saving data source: name=%s, type=%s, status=%s, error=%s", ds.Name, ds.Type, ds.Status, ds.Error)
return delegate.NewModelDelegate(ds).Save()
}
func (svc *Service) _checkStatus(ds *models.DataSource) (err error) {
switch ds.Type {
case constants.DataSourceTypeMongo:
_, err := utils2.GetMongoClientWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
case constants.DataSourceTypeMysql:
s, err := utils2.GetMysqlSessionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if s != nil {
s.Close()
}
case constants.DataSourceTypePostgresql:
s, err := utils2.GetPostgresqlSessionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if s != nil {
s.Close()
}
case constants.DataSourceTypeMssql:
s, err := utils2.GetMssqlSessionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if s != nil {
s.Close()
}
case constants.DataSourceTypeSqlite:
s, err := utils2.GetSqliteSessionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if s != nil {
s.Close()
}
case constants.DataSourceTypeCockroachdb:
s, err := utils2.GetCockroachdbSessionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if s != nil {
s.Close()
}
case constants.DataSourceTypeElasticSearch:
_, err := utils2.GetElasticsearchClientWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
case constants.DataSourceTypeKafka:
c, err := utils2.GetKafkaConnectionWithTimeout(ds, svc.timeout)
if err != nil {
return err
}
if c != nil {
c.Close()
}
default:
log.Warnf("[DataSourceService] invalid data source type: %s", ds.Type)
}
return nil
}
func NewDataSourceService(opts ...DataSourceServiceOption) (svc2 interfaces.DataSourceService, err error) {
// service
svc := &Service{
monitorInterval: 15 * time.Second,
timeout: 10 * time.Second,
}
// apply options
for _, opt := range opts {
opt(svc)
}
// dependency injection
if err := container.GetContainer().Invoke(func(modelSvc service.ModelService) {
svc.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
// initialize
svc.Init()
// start
svc.Start()
return svc, nil
}
var _dsSvc interfaces.DataSourceService
func GetDataSourceService() (svc interfaces.DataSourceService, err error) {
if _dsSvc != nil {
return _dsSvc, nil
}
svc, err = NewDataSourceService()
if err != nil {
return nil, err
}
_dsSvc = svc
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/service.go
|
Go
|
bsd-3-clause
| 7,072
|
package ds
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
utils2 "github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/db/generic"
"github.com/crawlab-team/crawlab/trace"
"github.com/upper/db/v4"
"time"
)
type SqlService struct {
// dependencies
modelSvc service.ModelService
// internals
ds *models.DataSource
dc *models.DataCollection
s db.Session
col db.Collection
t time.Time
}
func (svc *SqlService) Insert(records ...interface{}) (err error) {
for _, d := range records {
var r entity.Result
switch d.(type) {
case entity.Result:
r = d.(entity.Result)
default:
continue
}
_r := r.Flatten()
if _, err = svc.col.Insert(_r); err != nil {
trace.PrintError(err)
continue
}
}
return nil
}
func (svc *SqlService) List(query generic.ListQuery, opts *generic.ListOptions) (results []interface{}, err error) {
var docs []entity.Result
if err := svc.col.Find(utils2.GetSqlQuery(query)).
Offset(opts.Skip).
Limit(opts.Limit).All(&docs); err != nil {
return nil, trace.TraceError(err)
}
for i := range docs {
d := docs[i].ToJSON()
results = append(results, &d)
}
return results, nil
}
func (svc *SqlService) Count(query generic.ListQuery) (n int, err error) {
nInt64, err := svc.col.Find(utils2.GetSqlQuery(query)).Count()
if err != nil {
return n, err
}
return int(nInt64), nil
}
func (svc *SqlService) Index(fields []string) {
// TODO: implement me
}
func (svc *SqlService) SetTime(t time.Time) {
svc.t = t
}
func (svc *SqlService) GetTime() (t time.Time) {
return svc.t
}
|
2302_79757062/crawlab
|
core/ds/sql.go
|
Go
|
bsd-3-clause
| 1,694
|
package ds
type SqlOptions struct {
DefaultHost string
DefaultPort string
}
|
2302_79757062/crawlab
|
core/ds/sql_options.go
|
Go
|
bsd-3-clause
| 79
|
package ds
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
utils2 "github.com/crawlab-team/crawlab/core/utils"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type SqliteService struct {
SqlService
}
func NewDataSourceSqliteService(colId primitive.ObjectID, dsId primitive.ObjectID) (svc2 interfaces.ResultService, err error) {
// service
svc := &SqliteService{}
// dependency injection
svc.modelSvc, err = service.GetService()
if err != nil {
return nil, trace.TraceError(err)
}
// data source
if dsId.IsZero() {
svc.ds = &models.DataSource{}
} else {
svc.ds, err = svc.modelSvc.GetDataSourceById(dsId)
if err != nil {
return nil, trace.TraceError(err)
}
}
// data collection
svc.dc, err = svc.modelSvc.GetDataCollectionById(colId)
if err != nil {
return nil, trace.TraceError(err)
}
// session
svc.s, err = utils2.GetSqliteSession(svc.ds)
if err != nil {
return nil, trace.TraceError(err)
}
// collection
svc.col = svc.s.Collection(svc.dc.Name)
return svc, nil
}
|
2302_79757062/crawlab
|
core/ds/sqlite.go
|
Go
|
bsd-3-clause
| 1,176
|
package entity
import (
"errors"
"fmt"
"strings"
)
type Address struct {
Host string
Port string
}
func (a *Address) String() (res string) {
return fmt.Sprintf("%s:%s", a.Host, a.Port)
}
func (a *Address) IsEmpty() (res bool) {
return a.Host == "" || a.Port == ""
}
func (a *Address) Value() (res interface{}) {
return a
}
type AddressOptions struct {
Host string
Port string
}
func NewAddress(opts *AddressOptions) (res *Address) {
if opts == nil {
opts = &AddressOptions{}
}
//if opts.Host == "" {
// opts.Host = "localhost"
//}
if opts.Port == "" {
opts.Port = "9666"
}
return &Address{
Host: opts.Host,
Port: opts.Port,
}
}
func NewAddressFromString(address string) (res *Address, err error) {
parts := strings.Split(address, ":")
if len(parts) == 1 {
return NewAddress(&AddressOptions{Host: parts[0]}), nil
} else if len(parts) == 2 {
return NewAddress(&AddressOptions{Host: parts[0], Port: parts[1]}), nil
} else {
return nil, errors.New(fmt.Sprintf("parsing address error: %v", err))
}
}
|
2302_79757062/crawlab
|
core/entity/address.go
|
Go
|
bsd-3-clause
| 1,041
|
package entity
type Color struct {
Name string `json:"name"`
Hex string `json:"hex"`
}
func (c *Color) GetHex() string {
return c.Hex
}
func (c *Color) GetName() string {
return c.Name
}
func (c *Color) Value() interface{} {
return c
}
|
2302_79757062/crawlab
|
core/entity/color.go
|
Go
|
bsd-3-clause
| 246
|
package entity
import "strconv"
type Page struct {
Skip int
Limit int
PageNum int
PageSize int
}
func (p *Page) GetPage(pageNum string, pageSize string) {
p.PageNum, _ = strconv.Atoi(pageNum)
p.PageSize, _ = strconv.Atoi(pageSize)
p.Skip = p.PageSize * (p.PageNum - 1)
p.Limit = p.PageSize
}
|
2302_79757062/crawlab
|
core/entity/common.go
|
Go
|
bsd-3-clause
| 311
|
package entity
type ConfigSpiderData struct {
// 通用
Name string `yaml:"name" json:"name"`
DisplayName string `yaml:"display_name" json:"display_name"`
Col string `yaml:"col" json:"col"`
Remark string `yaml:"remark" json:"remark"`
Type string `yaml:"type" bson:"type"`
// 可配置爬虫
Engine string `yaml:"engine" json:"engine"`
StartUrl string `yaml:"start_url" json:"start_url"`
StartStage string `yaml:"start_stage" json:"start_stage"`
Stages []Stage `yaml:"stages" json:"stages"`
Settings map[string]string `yaml:"settings" json:"settings"`
// 自定义爬虫
Cmd string `yaml:"cmd" json:"cmd"`
}
type Stage struct {
Name string `yaml:"name" json:"name"`
IsList bool `yaml:"is_list" json:"is_list"`
ListCss string `yaml:"list_css" json:"list_css"`
ListXpath string `yaml:"list_xpath" json:"list_xpath"`
PageCss string `yaml:"page_css" json:"page_css"`
PageXpath string `yaml:"page_xpath" json:"page_xpath"`
PageAttr string `yaml:"page_attr" json:"page_attr"`
Fields []Field `yaml:"fields" json:"fields"`
}
type Field struct {
Name string `yaml:"name" json:"name"`
Css string `yaml:"css" json:"css"`
Xpath string `yaml:"xpath" json:"xpath"`
Attr string `yaml:"attr" json:"attr"`
NextStage string `yaml:"next_stage" json:"next_stage"`
Remark string `yaml:"remark" json:"remark"`
}
|
2302_79757062/crawlab
|
core/entity/config_spider.go
|
Go
|
bsd-3-clause
| 1,452
|
package entity
type DataField struct {
Key string `json:"key" bson:"key"`
Type string `json:"type" bson:"type"`
}
|
2302_79757062/crawlab
|
core/entity/data_field.go
|
Go
|
bsd-3-clause
| 118
|
package entity
type DocItem struct {
Title string `json:"title"`
Url string `json:"url"`
Path string `json:"path"`
Children []DocItem `json:"children"`
}
|
2302_79757062/crawlab
|
core/entity/doc.go
|
Go
|
bsd-3-clause
| 180
|
package entity
/* ElasticsearchResponseData JSON format
{
"took" : 6,
"timed_out" : false,
"_shards" : {
"total" : 1,
"successful" : 1,
"skipped" : 0,
"failed" : 0
},
"hits" : {
"total" : {
"value" : 60,
"relation" : "eq"
},
"max_score" : 1.0,
"hits" : [
{
"_index" : "test_table",
"_id" : "c39ad9a2-9a37-49fb-b7ea-f1b55913e0af",
"_score" : 1.0,
"_source" : {
"_tid" : "62524ac7f5f99e7ef594de64",
"author" : "James Baldwin",
"tags" : [
"love"
],
"text" : "“Love does not begin and end the way we seem to think it does. Love is a battle, love is a war; love is a growing up.”"
}
}
]
}
}
*/
type ElasticsearchResponseData struct {
Took int64 `json:"took"`
Timeout bool `json:"timeout"`
Hits struct {
Total struct {
Value int64 `json:"value"`
Relation string `json:"relation"`
} `json:"total"`
MaxScore float64 `json:"max_score"`
Hits []struct {
Index string `json:"_index"`
Id string `json:"_id"`
Score float64 `json:"_score"`
Source interface{} `json:"_source"`
} `json:"hits"`
} `json:"hits"`
}
|
2302_79757062/crawlab
|
core/entity/es.go
|
Go
|
bsd-3-clause
| 1,242
|
package entity
type EventData struct {
Event string
Data interface{}
}
func (d *EventData) GetEvent() string {
return d.Event
}
func (d *EventData) GetData() interface{} {
return d.Data
}
|
2302_79757062/crawlab
|
core/entity/event.go
|
Go
|
bsd-3-clause
| 196
|
package entity
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Export struct {
Id string `json:"id"`
Type string `json:"type"`
Target string `json:"target"`
Filter interfaces.Filter `json:"filter"`
Status string `json:"status"`
StartTs time.Time `json:"start_ts"`
EndTs time.Time `json:"end_ts"`
FileName string `json:"file_name"`
DownloadPath string `json:"-"`
Limit int `json:"-"`
}
func (e *Export) GetId() string {
return e.Id
}
func (e *Export) GetType() string {
return e.Type
}
func (e *Export) GetTarget() string {
return e.Target
}
func (e *Export) GetFilter() interfaces.Filter {
return e.Filter
}
func (e *Export) GetStatus() string {
return e.Status
}
func (e *Export) GetStartTs() time.Time {
return e.StartTs
}
func (e *Export) GetEndTs() time.Time {
return e.EndTs
}
func (e *Export) GetDownloadPath() string {
return e.DownloadPath
}
|
2302_79757062/crawlab
|
core/entity/export.go
|
Go
|
bsd-3-clause
| 1,060
|
package entity
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"reflect"
)
type Condition struct {
Key string `json:"key"`
Op string `json:"op"`
Value interface{} `json:"value"`
}
func (c *Condition) GetKey() (key string) {
return c.Key
}
func (c *Condition) SetKey(key string) {
c.Key = key
}
func (c *Condition) GetOp() (op string) {
return c.Op
}
func (c *Condition) SetOp(op string) {
c.Op = op
}
func (c *Condition) GetValue() (value interface{}) {
return c.Value
}
func (c *Condition) SetValue(value interface{}) {
c.Value = value
}
type Filter struct {
IsOr bool `form:"is_or" url:"is_or"`
Conditions []*Condition `json:"conditions"`
}
func (f *Filter) GetIsOr() (isOr bool) {
return f.IsOr
}
func (f *Filter) SetIsOr(isOr bool) {
f.IsOr = isOr
}
func (f *Filter) GetConditions() (conditions []interfaces.FilterCondition) {
for _, c := range f.Conditions {
conditions = append(conditions, c)
}
return conditions
}
func (f *Filter) SetConditions(conditions []interfaces.FilterCondition) {
f.Conditions = make([]*Condition, len(conditions))
for _, c := range conditions {
f.Conditions = append(f.Conditions, c.(*Condition))
}
}
func (f *Filter) IsNil() (ok bool) {
val := reflect.ValueOf(f)
return val.IsNil()
}
|
2302_79757062/crawlab
|
core/entity/filter.go
|
Go
|
bsd-3-clause
| 1,298
|
package entity
type FilterSelectOption struct {
Value interface{} `json:"value" bson:"value"`
Label string `json:"label" bson:"label"`
}
|
2302_79757062/crawlab
|
core/entity/filter_select_option.go
|
Go
|
bsd-3-clause
| 145
|
package entity
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"os"
"time"
)
type FsFileInfo struct {
Name string `json:"name"` // file name
Path string `json:"path"` // file path
FullPath string `json:"full_path"` // file full path
Extension string `json:"extension"` // file extension
IsDir bool `json:"is_dir"` // whether it is directory
FileSize int64 `json:"file_size"` // file size (bytes)
Children []interfaces.FsFileInfo `json:"children"` // children for sub-directory
ModTime time.Time `json:"mod_time"` // modification time
Mode os.FileMode `json:"mode"` // file mode
Hash string `json:"hash"` // file hash
}
func (f *FsFileInfo) GetName() string {
return f.Name
}
func (f *FsFileInfo) GetPath() string {
return f.Path
}
func (f *FsFileInfo) GetFullPath() string {
return f.FullPath
}
func (f *FsFileInfo) GetExtension() string {
return f.Extension
}
func (f *FsFileInfo) GetIsDir() bool {
return f.IsDir
}
func (f *FsFileInfo) GetFileSize() int64 {
return f.FileSize
}
func (f *FsFileInfo) GetModTime() time.Time {
return f.ModTime
}
func (f *FsFileInfo) GetMode() os.FileMode {
return f.Mode
}
func (f *FsFileInfo) GetHash() string {
return f.Hash
}
func (f *FsFileInfo) GetChildren() []interfaces.FsFileInfo {
return f.Children
}
|
2302_79757062/crawlab
|
core/entity/fs_file_info.go
|
Go
|
bsd-3-clause
| 1,491
|
package entity
type GitPayload struct {
Paths []string `json:"paths"`
CommitMessage string `json:"commit_message"`
Branch string `json:"branch"`
Tag string `json:"tag"`
}
type GitConfig struct {
Url string `json:"url" bson:"url"`
}
|
2302_79757062/crawlab
|
core/entity/git.go
|
Go
|
bsd-3-clause
| 270
|
package entity
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/trace"
)
type GrpcBaseServiceMessage struct {
ModelId interfaces.ModelId `json:"id"`
Data []byte `json:"d"`
}
func (msg *GrpcBaseServiceMessage) GetModelId() interfaces.ModelId {
return msg.ModelId
}
func (msg *GrpcBaseServiceMessage) GetData() []byte {
return msg.Data
}
func (msg *GrpcBaseServiceMessage) ToBytes() (data []byte) {
data, err := json.Marshal(*msg)
if err != nil {
_ = trace.TraceError(err)
return data
}
return data
}
|
2302_79757062/crawlab
|
core/entity/grpc_base_service_message.go
|
Go
|
bsd-3-clause
| 593
|
package entity
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type GrpcBaseServiceParams struct {
Query bson.M `json:"q"`
Id primitive.ObjectID `json:"id"`
Update bson.M `json:"u"`
Doc interfaces.Model `json:"d"`
Fields []string `json:"f"`
FindOptions *mongo.FindOptions `json:"o"`
Docs []interface{} `json:"dl"`
User interfaces.User `json:"U"`
}
func (params *GrpcBaseServiceParams) Value() interface{} {
return params
}
|
2302_79757062/crawlab
|
core/entity/grpc_base_service_params.go
|
Go
|
bsd-3-clause
| 666
|
package entity
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/trace"
)
type GrpcDelegateMessage struct {
ModelId interfaces.ModelId `json:"id"`
Method interfaces.ModelDelegateMethod `json:"m"`
Data []byte `json:"d"`
}
func (msg *GrpcDelegateMessage) GetModelId() interfaces.ModelId {
return msg.ModelId
}
func (msg *GrpcDelegateMessage) GetMethod() interfaces.ModelDelegateMethod {
return msg.Method
}
func (msg *GrpcDelegateMessage) GetData() []byte {
return msg.Data
}
func (msg *GrpcDelegateMessage) ToBytes() (data []byte) {
data, err := json.Marshal(*msg)
if err != nil {
_ = trace.TraceError(err)
return data
}
return data
}
|
2302_79757062/crawlab
|
core/entity/grpc_delegate_message.go
|
Go
|
bsd-3-clause
| 755
|
package entity
type GrpcEventServiceMessage struct {
Type string `json:"type"`
Events []string `json:"events"`
Key string `json:"key"`
Data []byte `json:"data"`
}
|
2302_79757062/crawlab
|
core/entity/grpc_event_service_message.go
|
Go
|
bsd-3-clause
| 181
|
package entity
import (
"github.com/crawlab-team/crawlab/core/interfaces"
)
type GrpcSubscribe struct {
Stream interfaces.GrpcStream
Finished chan bool
}
func (sub *GrpcSubscribe) GetStream() interfaces.GrpcStream {
return sub.Stream
}
func (sub *GrpcSubscribe) GetStreamBidirectional() interfaces.GrpcStreamBidirectional {
stream, ok := sub.Stream.(interfaces.GrpcStreamBidirectional)
if !ok {
return nil
}
return stream
}
func (sub *GrpcSubscribe) GetFinished() chan bool {
return sub.Finished
}
|
2302_79757062/crawlab
|
core/entity/grpc_subscribe.go
|
Go
|
bsd-3-clause
| 516
|
package entity
import "go.mongodb.org/mongo-driver/bson/primitive"
type Response struct {
Status string `json:"status"`
Message string `json:"message"`
Data interface{} `json:"data"`
Error string `json:"error"`
}
type ListResponse struct {
Status string `json:"status"`
Message string `json:"message"`
Total int `json:"total"`
Data interface{} `json:"data"`
Error string `json:"error"`
}
type ListRequestData struct {
PageNum int `form:"page_num" json:"page_num"`
PageSize int `form:"page_size" json:"page_size"`
SortKey string `form:"sort_key" json:"sort_key"`
Status string `form:"status" json:"status"`
Keyword string `form:"keyword" json:"keyword"`
}
type BatchRequestPayload struct {
Ids []primitive.ObjectID `form:"ids" json:"ids"`
}
type BatchRequestPayloadWithStringData struct {
Ids []primitive.ObjectID `form:"ids" json:"ids"`
Data string `form:"data" json:"data"`
Fields []string `form:"fields" json:"fields"`
}
type FileRequestPayload struct {
Path string `json:"path" form:"path"`
NewPath string `json:"new_path" form:"new_path"`
Data string `json:"data" form:"data"`
}
|
2302_79757062/crawlab
|
core/entity/http.go
|
Go
|
bsd-3-clause
| 1,211
|
package entity
import "github.com/crawlab-team/crawlab/core/interfaces"
type ModelDelegate struct {
Id interfaces.ModelId `json:"id"`
ColName string `json:"col_name"`
Doc interfaces.Model `json:"doc"`
Artifact interfaces.ModelArtifact `json:"a"`
User interfaces.User `json:"u"`
}
|
2302_79757062/crawlab
|
core/entity/model_delegate.go
|
Go
|
bsd-3-clause
| 344
|
package entity
import "github.com/crawlab-team/crawlab/core/interfaces"
type ModelInfo struct {
Id interfaces.ModelId
ColName string
}
|
2302_79757062/crawlab
|
core/entity/model_info.go
|
Go
|
bsd-3-clause
| 144
|
package entity
type NodeInfo struct {
Key string `json:"key"`
IsMaster bool `json:"is_master"`
Name string `json:"name"`
Ip string `json:"ip"`
Mac string `json:"mac"`
Hostname string `json:"hostname"`
Description string `json:"description"`
AuthKey string `json:"auth_key"`
MaxRunners int `json:"max_runners"`
}
func (n NodeInfo) Value() interface{} {
return n
}
|
2302_79757062/crawlab
|
core/entity/node.go
|
Go
|
bsd-3-clause
| 423
|
package entity
import "github.com/crawlab-team/crawlab/core/constants"
type Pagination struct {
Page int `form:"page" url:"page"`
Size int `form:"size" url:"size"`
}
func (p *Pagination) IsZero() (ok bool) {
return p.Page == 0 &&
p.Size == 0
}
func (p *Pagination) IsDefault() (ok bool) {
return p.Page == constants.PaginationDefaultPage &&
p.Size == constants.PaginationDefaultSize
}
|
2302_79757062/crawlab
|
core/entity/pagination.go
|
Go
|
bsd-3-clause
| 397
|
package entity
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/trace"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type Result map[string]interface{}
func (r Result) Value() map[string]interface{} {
return r
}
func (r Result) SetValue(key string, value interface{}) {
r[key] = value
}
func (r Result) GetValue(key string) (value interface{}) {
value, _ = r[key]
return value
}
func (r Result) GetTaskId() (id primitive.ObjectID) {
_tid, ok := r[constants.TaskKey]
if !ok {
return id
}
switch _tid.(type) {
case string:
oid, err := primitive.ObjectIDFromHex(_tid.(string))
if err != nil {
return id
}
return oid
default:
return id
}
}
func (r Result) SetTaskId(id primitive.ObjectID) {
r[constants.TaskKey] = id
}
func (r Result) DenormalizeObjectId() (res Result) {
for k, v := range r {
switch v.(type) {
case primitive.ObjectID:
r[k] = v.(primitive.ObjectID).Hex()
case Result:
r[k] = v.(Result).DenormalizeObjectId()
}
}
return r
}
func (r Result) ToJSON() (res Result) {
r = r.DenormalizeObjectId()
for k, v := range r {
switch v.(type) {
case []byte:
r[k] = string(v.([]byte))
}
}
return r
}
func (r Result) Flatten() (res Result) {
r = r.ToJSON()
for k, v := range r {
switch v.(type) {
case string,
bool,
uint, uint8, uint16, uint32, uint64,
int, int8, int16, int32, int64,
float32, float64:
default:
bytes, err := json.Marshal(v)
if err != nil {
trace.PrintError(err)
return nil
}
r[k] = string(bytes)
}
}
return r
}
func (r Result) String() (s string) {
return string(r.Bytes())
}
func (r Result) Bytes() (bytes []byte) {
bytes, err := json.Marshal(r.ToJSON())
if err != nil {
return bytes
}
return bytes
}
|
2302_79757062/crawlab
|
core/entity/result.go
|
Go
|
bsd-3-clause
| 1,801
|
package entity
type RpcMessage struct {
Id string `json:"id"` // 消息ID
Method string `json:"method"` // 消息方法
NodeId string `json:"node_id"` // 节点ID
Params map[string]string `json:"params"` // 参数
Timeout int `json:"timeout"` // 超时
Result string `json:"result"` // 结果
Error string `json:"error"` // 错误
}
|
2302_79757062/crawlab
|
core/entity/rpc.go
|
Go
|
bsd-3-clause
| 431
|
package entity
type Sort struct {
Key string `json:"key"`
Direction string `json:"d"`
}
|
2302_79757062/crawlab
|
core/entity/sort.go
|
Go
|
bsd-3-clause
| 97
|
package entity
type SpiderType struct {
Type string `json:"type" bson:"_id"`
Count int `json:"count" bson:"count"`
}
type ScrapySettingParam struct {
Key string `json:"key"`
Value interface{} `json:"value"`
Type string `json:"type"`
}
type ScrapyItem struct {
Name string `json:"name"`
Fields []string `json:"fields"`
}
|
2302_79757062/crawlab
|
core/entity/spider.go
|
Go
|
bsd-3-clause
| 351
|
package entity
type StatsDailyItem struct {
Date string `json:"date" bson:"_id"`
Tasks int64 `json:"tasks" bson:"tasks"`
Results int64 `json:"results" bson:"results"`
}
type StatsTasksByStatusItem struct {
Status string `json:"status" bson:"_id"`
Tasks int64 `json:"tasks" bson:"tasks"`
}
|
2302_79757062/crawlab
|
core/entity/stats.go
|
Go
|
bsd-3-clause
| 305
|
package entity
type SystemInfo struct {
Edition string `json:"edition"` // edition. e.g. community / pro
Version string `json:"version"` // version. e.g. v0.6.0
}
|
2302_79757062/crawlab
|
core/entity/system_info.go
|
Go
|
bsd-3-clause
| 166
|
package entity
import (
"encoding/json"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type TaskMessage struct {
Id primitive.ObjectID `json:"id"`
Key string `json:"key"`
Cmd string `json:"cmd"`
Param string `json:"param"`
}
func (m *TaskMessage) ToString() (string, error) {
data, err := json.Marshal(&m)
if err != nil {
return "", err
}
return string(data), err
}
type TaskRunOptions struct {
}
type StreamMessageTaskData struct {
TaskId primitive.ObjectID `json:"task_id"`
Records []Result `json:"data"`
Logs []string `json:"logs"`
}
|
2302_79757062/crawlab
|
core/entity/task.go
|
Go
|
bsd-3-clause
| 624
|
package entity
type Translation struct {
Lang string `json:"lang"`
Key string `json:"key"`
Value string `json:"value"`
}
func (t Translation) GetLang() (l string) {
return t.Lang
}
|
2302_79757062/crawlab
|
core/entity/translation.go
|
Go
|
bsd-3-clause
| 190
|
package entity
import (
"sync"
"time"
)
type TTLMap struct {
TTL time.Duration
data sync.Map
}
type expireEntry struct {
ExpiresAt time.Time
Value interface{}
}
func (t *TTLMap) Store(key string, val interface{}) {
t.data.Store(key, expireEntry{
ExpiresAt: time.Now().Add(t.TTL),
Value: val,
})
}
func (t *TTLMap) Load(key string) (val interface{}) {
entry, ok := t.data.Load(key)
if !ok {
return nil
}
expireEntry := entry.(expireEntry)
if expireEntry.ExpiresAt.After(time.Now()) {
return nil
}
return expireEntry.Value
}
func NewTTLMap(ttl time.Duration) (m *TTLMap) {
m = &TTLMap{
TTL: ttl,
}
go func() {
for now := range time.Tick(time.Second) {
m.data.Range(func(k, v interface{}) bool {
expiresAt := v.(expireEntry).ExpiresAt
if expiresAt.Before(now) {
m.data.Delete(k)
}
return true
})
}
}()
return
}
|
2302_79757062/crawlab
|
core/entity/ttl_map.go
|
Go
|
bsd-3-clause
| 888
|
package entity
type Release struct {
Name string `json:"name"`
Draft bool `json:"draft"`
PreRelease bool `json:"pre_release"`
PublishedAt string `json:"published_at"`
Body string `json:"body"`
}
type ReleaseSlices []Release
func (r ReleaseSlices) Len() int {
return len(r)
}
func (r ReleaseSlices) Less(i, j int) bool {
return r[i].PublishedAt < r[j].PublishedAt
}
func (r ReleaseSlices) Swap(i, j int) {
r[i], r[j] = r[j], r[i]
}
|
2302_79757062/crawlab
|
core/entity/version.go
|
Go
|
bsd-3-clause
| 469
|
package errors
import (
"errors"
"fmt"
)
const (
ErrorPrefixController = "controller"
ErrorPrefixModel = "model"
ErrorPrefixFilter = "filter"
ErrorPrefixHttp = "http"
ErrorPrefixGrpc = "grpc"
ErrorPrefixNode = "node"
ErrorPrefixInject = "inject"
ErrorPrefixSpider = "spider"
ErrorPrefixFs = "fs"
ErrorPrefixTask = "task"
ErrorPrefixSchedule = "schedule"
ErrorPrefixUser = "user"
ErrorPrefixStats = "stats"
ErrorPrefixEvent = "event"
ErrorPrefixProcess = "process"
ErrorPrefixGit = "git"
ErrorPrefixResult = "result"
ErrorPrefixDataSource = "data_source"
)
type ErrorPrefix string
func NewError(prefix ErrorPrefix, msg string) (err error) {
return errors.New(fmt.Sprintf("%s error: %s", prefix, msg))
}
|
2302_79757062/crawlab
|
core/errors/base.go
|
Go
|
bsd-3-clause
| 808
|
package errors
func NewControllerError(msg string) (err error) {
return NewError(ErrorPrefixController, msg)
}
var ErrorControllerInvalidControllerId = NewControllerError("invalid controller id")
var ErrorControllerInvalidType = NewControllerError("invalid type")
var ErrorControllerAddError = NewControllerError("add error")
var ErrorControllerUpdateError = NewControllerError("update error")
var ErrorControllerDeleteError = NewControllerError("delete error")
var ErrorControllerNotImplemented = NewControllerError("not implemented")
var ErrorControllerNoModelService = NewControllerError("no model service")
var ErrorControllerRequestPayloadInvalid = NewControllerError("request payload invalid")
var ErrorControllerMissingInCache = NewControllerError("missing in cache")
var ErrorControllerNotCancellable = NewControllerError("not cancellable")
var ErrorControllerMissingRequestFields = NewControllerError("missing request fields")
var ErrorControllerEmptyResponse = NewControllerError("empty response")
var ErrorControllerFilerNotFound = NewControllerError("filer not found")
|
2302_79757062/crawlab
|
core/errors/controller.go
|
Go
|
bsd-3-clause
| 1,084
|
package errors
func NewDataSourceError(msg string) (err error) {
return NewError(ErrorPrefixDataSource, msg)
}
var (
ErrorDataSourceInvalidType = NewDataSourceError("invalid type")
ErrorDataSourceNotExists = NewDataSourceError("not exists")
ErrorDataSourceNotExistsInContext = NewDataSourceError("not exists in context")
ErrorDataSourceAlreadyExists = NewDataSourceError("already exists")
ErrorDataSourceMismatch = NewDataSourceError("mismatch")
ErrorDataSourceMissingRequiredFields = NewDataSourceError("missing required fields")
ErrorDataSourceUnauthorized = NewDataSourceError("unauthorized")
)
|
2302_79757062/crawlab
|
core/errors/ds.go
|
Go
|
bsd-3-clause
| 663
|
package errors
func NewEventError(msg string) (err error) {
return NewError(ErrorPrefixEvent, msg)
}
var ErrorEventNotFound = NewEventError("not found")
var ErrorEventInvalidType = NewEventError("invalid type")
var ErrorEventAlreadyExists = NewEventError("already exists")
var ErrorEventUnknownAction = NewEventError("unknown action")
|
2302_79757062/crawlab
|
core/errors/event.go
|
Go
|
bsd-3-clause
| 338
|
package errors
func NewFilterError(msg string) (err error) {
return NewError(ErrorPrefixFilter, msg)
}
var ErrorFilterInvalidOperation = NewFilterError("invalid operation")
var ErrorFilterUnableToParseQuery = NewFilterError("unable to parse query")
|
2302_79757062/crawlab
|
core/errors/filter.go
|
Go
|
bsd-3-clause
| 252
|
package errors
func NewFsError(msg string) (err error) {
return NewError(ErrorPrefixFs, msg)
}
var ErrorFsForbidden = NewFsError("forbidden")
var ErrorFsEmptyWorkspacePath = NewFsError("empty workspace path")
var ErrorFsInvalidType = NewFsError("invalid type")
var ErrorFsAlreadyExists = NewFsError("already exists")
var ErrorFsInvalidContent = NewFsError("invalid content")
|
2302_79757062/crawlab
|
core/errors/fs.go
|
Go
|
bsd-3-clause
| 378
|
package errors
func NewGitError(msg string) (err error) {
return NewError(ErrorPrefixGit, msg)
}
var (
ErrorGitInvalidAuthType = NewGitError("invalid auth type")
ErrorGitNoMainBranch = NewGitError("no main branch")
)
|
2302_79757062/crawlab
|
core/errors/git.go
|
Go
|
bsd-3-clause
| 225
|
package errors
func NewGrpcError(msg string) (err error) {
return NewError(ErrorPrefixGrpc, msg)
}
var (
ErrorGrpcClientFailedToStart = NewGrpcError("client failed to start")
ErrorGrpcServerFailedToListen = NewGrpcError("server failed to listen")
ErrorGrpcServerFailedToServe = NewGrpcError("server failed to serve")
ErrorGrpcClientNotExists = NewGrpcError("client not exists")
ErrorGrpcClientAlreadyExists = NewGrpcError("client already exists")
ErrorGrpcInvalidType = NewGrpcError("invalid type")
ErrorGrpcNotAllowed = NewGrpcError("not allowed")
ErrorGrpcSubscribeNotExists = NewGrpcError("subscribe not exists")
ErrorGrpcStreamNotFound = NewGrpcError("stream not found")
ErrorGrpcInvalidCode = NewGrpcError("invalid code")
ErrorGrpcUnauthorized = NewGrpcError("unauthorized")
ErrorGrpcInvalidNodeKey = NewGrpcError("invalid node key")
)
|
2302_79757062/crawlab
|
core/errors/grpc.go
|
Go
|
bsd-3-clause
| 914
|
package errors
func NewHttpError(msg string) (err error) {
return NewError(ErrorPrefixHttp, msg)
}
var ErrorHttpBadRequest = NewHttpError("bad request")
var ErrorHttpUnauthorized = NewHttpError("unauthorized")
var ErrorHttpNotFound = NewHttpError("not found")
|
2302_79757062/crawlab
|
core/errors/http.go
|
Go
|
bsd-3-clause
| 263
|
package errors
import "errors"
func NewModelError(msg string) (err error) {
return NewError(ErrorPrefixModel, msg)
}
var ErrorModelInvalidType = NewModelError("invalid type")
var ErrorModelInvalidModelId = NewModelError("invalid model id")
var ErrorModelNotImplemented = NewModelError("not implemented")
var ErrorModelNotFound = NewModelError("not found")
var ErrorModelAlreadyExists = NewModelError("already exists")
var ErrorModelNotExists = NewModelError("not exists")
var ErrorModelMissingRequiredData = NewModelError("missing required data")
var ErrorModelMissingId = errors.New("missing _id")
var ErrorModelNotAllowed = NewModelError("not allowed")
var ErrorModelDeleteListError = NewModelError("delete list error")
var ErrorModelNilPointer = NewModelError("nil pointer")
|
2302_79757062/crawlab
|
core/errors/model.go
|
Go
|
bsd-3-clause
| 782
|
package errors
func NewNodeError(msg string) (err error) {
return NewError(ErrorPrefixNode, msg)
}
var ErrorNodeUnregistered = NewNodeError("unregistered")
var ErrorNodeServiceNotExists = NewNodeError("service not exists")
var ErrorNodeInvalidType = NewNodeError("invalid type")
var ErrorNodeInvalidStatus = NewNodeError("invalid status")
var ErrorNodeInvalidCode = NewNodeError("invalid code")
var ErrorNodeInvalidNodeKey = NewNodeError("invalid node key")
var ErrorNodeMonitorError = NewNodeError("monitor error")
var ErrorNodeNotExists = NewNodeError("not exists")
|
2302_79757062/crawlab
|
core/errors/node.go
|
Go
|
bsd-3-clause
| 571
|
package errors
func NewProcessError(msg string) (err error) {
return NewError(ErrorPrefixProcess, msg)
}
var (
ErrorProcessReachedMaxErrors = NewProcessError("reached max errors")
ErrorProcessDaemonProcessExited = NewProcessError("daemon process exited")
)
|
2302_79757062/crawlab
|
core/errors/process.go
|
Go
|
bsd-3-clause
| 265
|
package errors
func NewResultError(msg string) (err error) {
return NewError(ErrorPrefixResult, msg)
}
|
2302_79757062/crawlab
|
core/errors/result.go
|
Go
|
bsd-3-clause
| 105
|
package errors
func NewScheduleError(msg string) (err error) {
return NewError(ErrorPrefixSchedule, msg)
}
//var ErrorSchedule = NewScheduleError("unregistered")
|
2302_79757062/crawlab
|
core/errors/schedule.go
|
Go
|
bsd-3-clause
| 165
|
package errors
func NewSpiderError(msg string) (err error) {
return NewError(ErrorPrefixSpider, msg)
}
var (
ErrorSpiderMissingRequiredOption = NewSpiderError("missing required option")
ErrorSpiderForbidden = NewSpiderError("forbidden")
)
|
2302_79757062/crawlab
|
core/errors/spider.go
|
Go
|
bsd-3-clause
| 256
|
package errors
func NewStatsError(msg string) (err error) {
return NewError(ErrorPrefixStats, msg)
}
var ErrorStatsInvalidType = NewStatsError("invalid type")
|
2302_79757062/crawlab
|
core/errors/stats.go
|
Go
|
bsd-3-clause
| 162
|
package errors
func NewInjectError(msg string) (err error) {
return NewError(ErrorPrefixInject, msg)
}
var ErrorInjectEmptyValue = NewInjectError("empty value")
var ErrorInjectNotExists = NewInjectError("not exists")
var ErrorInjectInvalidType = NewInjectError("invalid type")
|
2302_79757062/crawlab
|
core/errors/store.go
|
Go
|
bsd-3-clause
| 280
|
package errors
func NewTaskError(msg string) (err error) {
return NewError(ErrorPrefixTask, msg)
}
var (
ErrorTaskNotExists = NewTaskError("not exists")
ErrorTaskAlreadyExists = NewTaskError("already exists")
ErrorTaskInvalidType = NewTaskError("invalid type")
ErrorTaskProcessStillExists = NewTaskError("process still exists")
ErrorTaskUnableToCancel = NewTaskError("unable to cancel")
ErrorTaskForbidden = NewTaskError("forbidden")
ErrorTaskNoAvailableRunners = NewTaskError("no available runner")
ErrorTaskEmptySpiderId = NewTaskError("empty spider id")
ErrorTaskNoNodeId = NewTaskError("no node id")
ErrorTaskNodeNotFound = NewTaskError("node not found")
ErrorTaskMissingRequiredOption = NewSpiderError("missing required option")
)
|
2302_79757062/crawlab
|
core/errors/task.go
|
Go
|
bsd-3-clause
| 835
|
package errors
func NewUserError(msg string) (err error) {
return NewError(ErrorPrefixUser, msg)
}
var (
ErrorUserInvalidType = NewUserError("invalid type")
ErrorUserInvalidToken = NewUserError("invalid token")
ErrorUserNotExists = NewUserError("not exists")
ErrorUserNotExistsInContext = NewUserError("not exists in context")
ErrorUserAlreadyExists = NewUserError("already exists")
ErrorUserMismatch = NewUserError("mismatch")
ErrorUserMissingRequiredFields = NewUserError("missing required fields")
ErrorUserUnauthorized = NewUserError("unauthorized")
ErrorUserInvalidPassword = NewUserError("invalid password (length must be no less than 5)")
)
|
2302_79757062/crawlab
|
core/errors/user.go
|
Go
|
bsd-3-clause
| 730
|
package event
func SendEvent(eventName string, data ...interface{}) {
svc := NewEventService()
svc.SendEvent(eventName, data...)
}
|
2302_79757062/crawlab
|
core/event/func.go
|
Go
|
bsd-3-clause
| 134
|
package event
|
2302_79757062/crawlab
|
core/event/options.go
|
Go
|
bsd-3-clause
| 14
|
package event
import (
"fmt"
"github.com/apex/log"
"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"
"github.com/thoas/go-funk"
"regexp"
)
var S interfaces.EventService
type Service struct {
keys []string
includes []string
excludes []string
chs []*chan interfaces.EventData
}
func (svc *Service) Register(key, include, exclude string, ch *chan interfaces.EventData) {
svc.keys = append(svc.keys, key)
svc.includes = append(svc.includes, include)
svc.excludes = append(svc.excludes, exclude)
svc.chs = append(svc.chs, ch)
}
func (svc *Service) Unregister(key string) {
idx := funk.IndexOfString(svc.keys, key)
if idx != -1 {
svc.keys = append(svc.keys[:idx], svc.keys[(idx+1):]...)
svc.includes = append(svc.includes[:idx], svc.includes[(idx+1):]...)
svc.excludes = append(svc.excludes[:idx], svc.excludes[(idx+1):]...)
svc.chs = append(svc.chs[:idx], svc.chs[(idx+1):]...)
log.Infof("[EventService] unregistered %s", key)
}
}
func (svc *Service) SendEvent(eventName string, data ...interface{}) {
for i, key := range svc.keys {
// include
include := svc.includes[i]
matchedInclude, err := regexp.MatchString(include, eventName)
if err != nil {
trace.PrintError(err)
continue
}
if !matchedInclude {
continue
}
// exclude
exclude := svc.excludes[i]
matchedExclude, err := regexp.MatchString(exclude, eventName)
if err != nil {
trace.PrintError(err)
continue
}
if matchedExclude {
continue
}
// send event
utils.LogDebug(fmt.Sprintf("key %s matches event %s", key, eventName))
ch := svc.chs[i]
go func(ch *chan interfaces.EventData) {
for _, d := range data {
*ch <- &entity.EventData{
Event: eventName,
Data: d,
}
}
}(ch)
}
}
func NewEventService() (svc interfaces.EventService) {
if S != nil {
return S
}
svc = &Service{
chs: []*chan interfaces.EventData{},
keys: []string{},
}
S = svc
return svc
}
|
2302_79757062/crawlab
|
core/event/service.go
|
Go
|
bsd-3-clause
| 2,075
|
package export
import (
"context"
"encoding/csv"
"errors"
"fmt"
"github.com/ReneKroon/ttlcache"
"github.com/apex/log"
"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/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/hashicorp/go-uuid"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"os"
"path"
"sort"
"strconv"
"time"
)
type CsvService struct {
cache *ttlcache.Cache
}
func (svc *CsvService) GenerateId() (exportId string, err error) {
exportId, err = uuid.GenerateUUID()
if err != nil {
return "", trace.TraceError(err)
}
return exportId, nil
}
func (svc *CsvService) Export(exportType, target string, filter interfaces.Filter) (exportId string, err error) {
// generate export id
exportId, err = svc.GenerateId()
if err != nil {
return "", err
}
// export
export := &entity.Export{
Id: exportId,
Type: exportType,
Target: target,
Filter: filter,
Status: constants.TaskStatusRunning,
StartTs: time.Now(),
FileName: svc.getFileName(exportId),
DownloadPath: svc.getDownloadPath(exportId),
Limit: 100,
}
// save to cache
svc.cache.Set(exportId, export)
// execute export
go svc.export(export)
return exportId, nil
}
func (svc *CsvService) GetExport(exportId string) (export interfaces.Export, err error) {
// get export from cache
res, ok := svc.cache.Get(exportId)
if !ok {
return nil, trace.TraceError(errors.New("export not found"))
}
export = res.(interfaces.Export)
return export, nil
}
func (svc *CsvService) export(export *entity.Export) {
// check empty
if export.Target == "" {
err := errors.New("empty target")
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// mongo collection
col := mongo.GetMongoCol(export.Target)
// mongo query
query, err := utils.FilterToQuery(export.Filter)
if err != nil {
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// mongo cursor
cur := col.Find(query, nil).GetCursor()
// csv writer
csvWriter, csvFile, err := svc.getCsvWriter(export)
defer func() {
csvWriter.Flush()
_ = csvFile.Close()
}()
if err != nil {
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// write bom
bom := []byte{0xEF, 0xBB, 0xBF}
_, err = csvFile.Write(bom)
if err != nil {
trace.PrintError(err)
return
}
// write csv header row
columns, err := svc.getColumns(query, export)
err = csvWriter.Write(columns)
if err != nil {
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
csvWriter.Flush()
// iterate cursor
i := 0
for {
// increment counter
i++
// check error
err := cur.Err()
if err != nil {
if err != mongo2.ErrNoDocuments {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
} else {
// no more data
export.Status = constants.TaskStatusFinished
export.EndTs = time.Now()
log.Infof("export finished (id: %s)", export.Id)
}
svc.cache.Set(export.Id, export)
return
}
// has data
if !cur.Next(context.Background()) {
// no more data
export.Status = constants.TaskStatusFinished
export.EndTs = time.Now()
log.Infof("export finished (id: %s)", export.Id)
svc.cache.Set(export.Id, export)
return
}
// convert raw data to entity
var data bson.M
err = cur.Decode(&data)
if err != nil {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// write csv row cells
cells := svc.getRowCells(columns, data)
err = csvWriter.Write(cells)
if err != nil {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// flush if limit reached
if i >= export.Limit {
csvWriter.Flush()
i = 0
}
}
}
func (svc *CsvService) getExportDir() (dir string, err error) {
tempDir := os.TempDir()
exportDir := path.Join(tempDir, "export", "csv")
if !utils.Exists(exportDir) {
err := os.MkdirAll(exportDir, 0755)
if err != nil {
return "", err
}
}
return exportDir, nil
}
func (svc *CsvService) getFileName(exportId string) (fileName string) {
return exportId + "_" + time.Now().Format("20060102150405") + ".csv"
}
// getDownloadPath returns the download path for the export
// format: <tempDir>/export/<exportId>/<exportId>_<timestamp>.csv
func (svc *CsvService) getDownloadPath(exportId string) (downloadPath string) {
exportDir, err := svc.getExportDir()
if err != nil {
return ""
}
downloadPath = path.Join(exportDir, svc.getFileName(exportId))
return downloadPath
}
func (svc *CsvService) getCsvWriter(export *entity.Export) (csvWriter *csv.Writer, csvFile *os.File, err error) {
// open file
csvFile, err = os.Create(export.DownloadPath)
if err != nil {
return nil, nil, trace.TraceError(err)
}
// create csv writer
csvWriter = csv.NewWriter(csvFile)
return csvWriter, csvFile, nil
}
func (svc *CsvService) getColumns(query bson.M, export interfaces.Export) (columns []string, err error) {
// get mongo collection
col := mongo.GetMongoCol(export.GetTarget())
// get 10 records
var data []bson.M
if err := col.Find(query, &mongo.FindOptions{Limit: 10}).All(&data); err != nil {
return nil, trace.TraceError(err)
}
// columns set
columnsSet := make(map[string]bool)
for _, d := range data {
for k := range d {
columnsSet[k] = true
}
}
// columns
columns = make([]string, 0, len(columnsSet))
for k := range columnsSet {
// skip task key
if k == constants.TaskKey {
continue
}
// skip _id
if k == "_id" {
continue
}
// append to columns
columns = append(columns, k)
}
// order columns
sort.Strings(columns)
return columns, nil
}
func (svc *CsvService) getRowCells(columns []string, data bson.M) (cells []string) {
for _, c := range columns {
v, ok := data[c]
if !ok {
cells = append(cells, "")
continue
}
switch v.(type) {
case string:
cells = append(cells, v.(string))
case time.Time:
cells = append(cells, v.(time.Time).Format("2006-01-02 15:04:05"))
case int:
cells = append(cells, strconv.Itoa(v.(int)))
case int32:
cells = append(cells, strconv.Itoa(int(v.(int32))))
case int64:
cells = append(cells, strconv.FormatInt(v.(int64), 10))
case float32:
cells = append(cells, strconv.FormatFloat(float64(v.(float32)), 'f', -1, 32))
case float64:
cells = append(cells, strconv.FormatFloat(v.(float64), 'f', -1, 64))
case bool:
cells = append(cells, strconv.FormatBool(v.(bool)))
case primitive.ObjectID:
cells = append(cells, v.(primitive.ObjectID).Hex())
case primitive.DateTime:
cells = append(cells, v.(primitive.DateTime).Time().Format("2006-01-02 15:04:05"))
default:
cells = append(cells, fmt.Sprintf("%v", v))
}
}
return cells
}
func NewCsvService() (svc2 interfaces.ExportService) {
cache := ttlcache.NewCache()
cache.SetTTL(time.Minute * 5)
svc := &CsvService{
cache: cache,
}
return svc
}
var _csvService interfaces.ExportService
func GetCsvService() (svc interfaces.ExportService) {
if _csvService == nil {
_csvService = NewCsvService()
}
return _csvService
}
|
2302_79757062/crawlab
|
core/export/csv_service.go
|
Go
|
bsd-3-clause
| 8,238
|
package export
import (
"context"
"encoding/json"
"errors"
"github.com/ReneKroon/ttlcache"
"github.com/apex/log"
"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/core/utils"
"github.com/crawlab-team/crawlab/db/mongo"
"github.com/crawlab-team/crawlab/trace"
"github.com/hashicorp/go-uuid"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"os"
"path"
"time"
)
type JsonService struct {
cache *ttlcache.Cache
}
func (svc *JsonService) GenerateId() (exportId string, err error) {
exportId, err = uuid.GenerateUUID()
if err != nil {
return "", trace.TraceError(err)
}
return exportId, nil
}
func (svc *JsonService) Export(exportType, target string, filter interfaces.Filter) (exportId string, err error) {
// generate export id
exportId, err = svc.GenerateId()
if err != nil {
return "", err
}
// export
export := &entity.Export{
Id: exportId,
Type: exportType,
Target: target,
Filter: filter,
Status: constants.TaskStatusRunning,
StartTs: time.Now(),
FileName: svc.getFileName(exportId),
DownloadPath: svc.getDownloadPath(exportId),
Limit: 100,
}
// save to cache
svc.cache.Set(exportId, export)
// execute export
go svc.export(export)
return exportId, nil
}
func (svc *JsonService) GetExport(exportId string) (export interfaces.Export, err error) {
// get export from cache
res, ok := svc.cache.Get(exportId)
if !ok {
return nil, trace.TraceError(errors.New("export not found"))
}
export = res.(interfaces.Export)
return export, nil
}
func (svc *JsonService) export(export *entity.Export) {
// check empty
if export.Target == "" {
err := errors.New("empty target")
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// mongo collection
col := mongo.GetMongoCol(export.Target)
// mongo query
query, err := utils.FilterToQuery(export.Filter)
if err != nil {
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
// mongo cursor
cur := col.Find(query, nil).GetCursor()
// data
var jsonData []interface{}
// iterate cursor
i := 0
for {
// increment counter
i++
// check error
err := cur.Err()
if err != nil {
if err != mongo2.ErrNoDocuments {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
} else {
// no more data
export.Status = constants.TaskStatusFinished
export.EndTs = time.Now()
log.Infof("export finished (id: %s)", export.Id)
}
svc.cache.Set(export.Id, export)
return
}
// has data
if !cur.Next(context.Background()) {
// no more data
export.Status = constants.TaskStatusFinished
export.EndTs = time.Now()
log.Infof("export finished (id: %s)", export.Id)
svc.cache.Set(export.Id, export)
break
}
// convert raw data to entity
var data map[string]interface{}
err = cur.Decode(&data)
if err != nil {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
jsonData = append(jsonData, data)
}
jsonBytes, err := json.Marshal(jsonData)
if err != nil {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
jsonString := string(jsonBytes)
f := utils.OpenFile(export.DownloadPath)
_, err = f.WriteString(jsonString)
if err != nil {
// error
export.Status = constants.TaskStatusError
export.EndTs = time.Now()
log.Errorf("export error (id: %s): %v", export.Id, err)
trace.PrintError(err)
svc.cache.Set(export.Id, export)
return
}
}
func (svc *JsonService) getExportDir() (dir string, err error) {
tempDir := os.TempDir()
exportDir := path.Join(tempDir, "export", "json")
if !utils.Exists(exportDir) {
err := os.MkdirAll(exportDir, 0755)
if err != nil {
return "", err
}
}
return exportDir, nil
}
func (svc *JsonService) getFileName(exportId string) (fileName string) {
return exportId + "_" + time.Now().Format("20060102150405") + ".json"
}
// getDownloadPath returns the download path for the export
// format: <tempDir>/export/<exportId>/<exportId>_<timestamp>.csv
func (svc *JsonService) getDownloadPath(exportId string) (downloadPath string) {
exportDir, err := svc.getExportDir()
if err != nil {
return ""
}
downloadPath = path.Join(exportDir, svc.getFileName(exportId))
return downloadPath
}
func NewJsonService() (svc2 interfaces.ExportService) {
cache := ttlcache.NewCache()
cache.SetTTL(time.Minute * 5)
svc := &JsonService{
cache: cache,
}
return svc
}
var _jsonService interfaces.ExportService
func GetJsonService() (svc interfaces.ExportService) {
if _jsonService == nil {
_jsonService = NewJsonService()
}
return _jsonService
}
|
2302_79757062/crawlab
|
core/export/json_service.go
|
Go
|
bsd-3-clause
| 5,395
|
package fs
import (
"github.com/apex/log"
"github.com/mitchellh/go-homedir"
"github.com/spf13/viper"
"path/filepath"
)
func init() {
rootDir, err := homedir.Dir()
if err != nil {
log.Warnf("cannot find home directory: %v", err)
return
}
DefaultWorkspacePath = filepath.Join(rootDir, "crawlab_workspace")
workspacePath := viper.GetString("workspace")
if workspacePath == "" {
viper.Set("workspace", DefaultWorkspacePath)
}
}
var DefaultWorkspacePath string
|
2302_79757062/crawlab
|
core/fs/default.go
|
Go
|
bsd-3-clause
| 477
|
package fs
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/utils"
"io"
"os"
"path/filepath"
)
type ServiceV2 struct {
// settings
rootPath string
skipNames []string
}
func (svc *ServiceV2) List(path string) (files []interfaces.FsFileInfo, err error) {
// Normalize the provided path
normPath := filepath.Clean(path)
if normPath == "." {
normPath = ""
}
fullPath := filepath.Join(svc.rootPath, normPath)
// Temporary map to hold directory information and their children
dirMap := make(map[string]*entity.FsFileInfo)
// Use filepath.Walk to recursively traverse directories
err = filepath.Walk(fullPath, func(p string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, err := filepath.Rel(svc.rootPath, p)
if err != nil {
return err
}
fi := &entity.FsFileInfo{
Name: info.Name(),
Path: filepath.ToSlash(relPath),
FullPath: p,
Extension: filepath.Ext(p),
IsDir: info.IsDir(),
FileSize: info.Size(),
ModTime: info.ModTime(),
Mode: info.Mode(),
Children: nil,
}
// Skip files/folders matching the pattern
for _, name := range svc.skipNames {
if fi.Name == name {
return nil
}
}
if info.IsDir() {
dirMap[p] = fi
}
if parentDir := filepath.Dir(p); parentDir != p && dirMap[parentDir] != nil {
dirMap[parentDir].Children = append(dirMap[parentDir].Children, fi)
}
return nil
})
if rootInfo, ok := dirMap[fullPath]; ok {
for _, info := range rootInfo.GetChildren() {
files = append(files, info)
}
}
return files, err
}
func (svc *ServiceV2) GetFile(path string) (data []byte, err error) {
return os.ReadFile(filepath.Join(svc.rootPath, path))
}
func (svc *ServiceV2) GetFileInfo(path string) (file interfaces.FsFileInfo, err error) {
f, err := os.Stat(filepath.Join(svc.rootPath, path))
if err != nil {
return nil, err
}
return &entity.FsFileInfo{
Name: f.Name(),
Path: path,
FullPath: filepath.Join(svc.rootPath, path),
Extension: filepath.Ext(path),
IsDir: f.IsDir(),
FileSize: f.Size(),
ModTime: f.ModTime(),
Mode: f.Mode(),
Children: nil,
}, nil
}
func (svc *ServiceV2) Save(path string, data []byte) (err error) {
// Create directories if not exist
dir := filepath.Dir(filepath.Join(svc.rootPath, path))
if _, err := os.Stat(dir); os.IsNotExist(err) {
if err := os.MkdirAll(dir, 0755); err != nil {
return err
}
}
// Write file
return os.WriteFile(filepath.Join(svc.rootPath, path), data, 0644)
}
func (svc *ServiceV2) CreateDir(path string) (err error) {
return os.MkdirAll(filepath.Join(svc.rootPath, path), 0755)
}
func (svc *ServiceV2) Rename(path, newPath string) (err error) {
oldPath := filepath.Join(svc.rootPath, path)
newFullPath := filepath.Join(svc.rootPath, newPath)
return os.Rename(oldPath, newFullPath)
}
func (svc *ServiceV2) Delete(path string) (err error) {
fullPath := filepath.Join(svc.rootPath, path)
return os.RemoveAll(fullPath)
}
func (svc *ServiceV2) Copy(path, newPath string) (err error) {
srcPath := filepath.Join(svc.rootPath, path)
destPath := filepath.Join(svc.rootPath, newPath)
// Get source info
srcInfo, err := os.Stat(srcPath)
if err != nil {
return err
}
// If source is file, copy it
if !srcInfo.IsDir() {
srcFile, err := os.Open(srcPath)
if err != nil {
return err
}
defer srcFile.Close()
destFile, err := os.Create(destPath)
if err != nil {
return err
}
defer destFile.Close()
_, err = io.Copy(destFile, srcFile)
return err
} else {
// If source is directory, copy it recursively
return utils.CopyDir(srcPath, destPath)
}
}
func NewFsServiceV2(path string) (svc interfaces.FsServiceV2) {
return &ServiceV2{
rootPath: path,
skipNames: []string{".git"},
}
}
|
2302_79757062/crawlab
|
core/fs/service_v2.go
|
Go
|
bsd-3-clause
| 3,893
|
package client
import (
"context"
"encoding/json"
"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"
"github.com/crawlab-team/crawlab/core/grpc/middlewares"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/utils"
grpc2 "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
"google.golang.org/grpc"
"google.golang.org/grpc/connectivity"
"io"
"time"
)
type Client struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
// settings
cfgPath string
address interfaces.Address
timeout time.Duration
subscribeType string
handleMessage bool
// internals
conn *grpc.ClientConn
stream grpc2.NodeService_SubscribeClient
msgCh chan *grpc2.StreamMessage
err error
// grpc clients
ModelDelegateClient grpc2.ModelDelegateClient
ModelBaseServiceClient grpc2.ModelBaseServiceClient
NodeClient grpc2.NodeServiceClient
TaskClient grpc2.TaskServiceClient
MessageClient grpc2.MessageServiceClient
}
func (c *Client) Init() (err error) {
// do nothing
return nil
}
func (c *Client) Start() (err error) {
// connect
if err := c.connect(); err != nil {
return err
}
// register rpc services
if err := c.Register(); err != nil {
return err
}
// subscribe
if err := c.subscribe(); err != nil {
return err
}
// handle stream message
if c.handleMessage {
go c.handleStreamMessage()
}
return nil
}
func (c *Client) Stop() (err error) {
// skip if connection is nil
if c.conn == nil {
return nil
}
// grpc server address
address := c.address.String()
// unsubscribe
if err := c.unsubscribe(); err != nil {
return err
}
log.Infof("grpc client unsubscribed from %s", address)
// close connection
if err := c.conn.Close(); err != nil {
return err
}
log.Infof("grpc client disconnected from %s", address)
return nil
}
func (c *Client) Register() (err error) {
// model delegate
c.ModelDelegateClient = grpc2.NewModelDelegateClient(c.conn)
// model base service
c.ModelBaseServiceClient = grpc2.NewModelBaseServiceClient(c.conn)
// node
c.NodeClient = grpc2.NewNodeServiceClient(c.conn)
// task
c.TaskClient = grpc2.NewTaskServiceClient(c.conn)
// message
c.MessageClient = grpc2.NewMessageServiceClient(c.conn)
// log
log.Infof("[GrpcClient] grpc client registered client services")
log.Debugf("[GrpcClient] ModelDelegateClient: %v", c.ModelDelegateClient)
log.Debugf("[GrpcClient] ModelBaseServiceClient: %v", c.ModelBaseServiceClient)
log.Debugf("[GrpcClient] NodeClient: %v", c.NodeClient)
log.Debugf("[GrpcClient] TaskClient: %v", c.TaskClient)
log.Debugf("[GrpcClient] MessageClient: %v", c.MessageClient)
return nil
}
func (c *Client) GetModelDelegateClient() (res grpc2.ModelDelegateClient) {
return c.ModelDelegateClient
}
func (c *Client) GetModelBaseServiceClient() (res grpc2.ModelBaseServiceClient) {
return c.ModelBaseServiceClient
}
func (c *Client) GetNodeClient() grpc2.NodeServiceClient {
return c.NodeClient
}
func (c *Client) GetTaskClient() grpc2.TaskServiceClient {
return c.TaskClient
}
func (c *Client) GetMessageClient() grpc2.MessageServiceClient {
return c.MessageClient
}
func (c *Client) SetAddress(address interfaces.Address) {
c.address = address
}
func (c *Client) SetTimeout(timeout time.Duration) {
c.timeout = timeout
}
func (c *Client) SetSubscribeType(value string) {
c.subscribeType = value
}
func (c *Client) SetHandleMessage(handleMessage bool) {
c.handleMessage = handleMessage
}
func (c *Client) Context() (ctx context.Context, cancel context.CancelFunc) {
return context.WithTimeout(context.Background(), c.timeout)
}
func (c *Client) NewRequest(d interface{}) (req *grpc2.Request) {
return &grpc2.Request{
NodeKey: c.nodeCfgSvc.GetNodeKey(),
Data: c.getRequestData(d),
}
}
func (c *Client) GetConfigPath() (path string) {
return c.cfgPath
}
func (c *Client) SetConfigPath(path string) {
c.cfgPath = path
}
func (c *Client) NewModelBaseServiceRequest(id interfaces.ModelId, params interfaces.GrpcBaseServiceParams) (req *grpc2.Request, err error) {
data, err := json.Marshal(params)
if err != nil {
return nil, trace.TraceError(err)
}
msg := &entity.GrpcBaseServiceMessage{
ModelId: id,
Data: data,
}
return c.NewRequest(msg), nil
}
func (c *Client) GetMessageChannel() (msgCh chan *grpc2.StreamMessage) {
return c.msgCh
}
func (c *Client) Restart() (err error) {
if c.needRestart() {
return c.Start()
}
return nil
}
func (c *Client) IsStarted() (res bool) {
return c.conn != nil
}
func (c *Client) IsClosed() (res bool) {
if c.conn != nil {
return c.conn.GetState() == connectivity.Shutdown
}
return false
}
func (c *Client) Err() (err error) {
return c.err
}
func (c *Client) GetStream() (stream grpc2.NodeService_SubscribeClient) {
return c.stream
}
func (c *Client) connect() (err error) {
return backoff.RetryNotify(c._connect, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client connect"))
}
func (c *Client) _connect() (err error) {
// grpc server address
address := c.address.String()
// timeout context
ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
defer cancel()
// connection
// TODO: configure dial options
var opts []grpc.DialOption
opts = append(opts, grpc.WithInsecure())
opts = append(opts, grpc.WithBlock())
opts = append(opts, grpc.WithChainUnaryInterceptor(middlewares.GetAuthTokenUnaryChainInterceptor(c.nodeCfgSvc)))
opts = append(opts, grpc.WithChainStreamInterceptor(middlewares.GetAuthTokenStreamChainInterceptor(c.nodeCfgSvc)))
c.conn, err = grpc.DialContext(ctx, address, opts...)
if err != nil {
_ = trace.TraceError(err)
return errors.ErrorGrpcClientFailedToStart
}
log.Infof("[GrpcClient] grpc client connected to %s", address)
return nil
}
func (c *Client) subscribe() (err error) {
var op func() error
switch c.subscribeType {
case constants.GrpcSubscribeTypeNode:
op = c._subscribeNode
default:
return errors.ErrorGrpcInvalidType
}
return backoff.RetryNotify(op, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client subscribe"))
}
func (c *Client) _subscribeNode() (err error) {
req := c.NewRequest(&entity.NodeInfo{
Key: c.nodeCfgSvc.GetNodeKey(),
IsMaster: false,
})
c.stream, err = c.GetNodeClient().Subscribe(context.Background(), req)
if err != nil {
return trace.TraceError(err)
}
// log
log.Infof("[GrpcClient] grpc client subscribed to remote server")
return nil
}
func (c *Client) unsubscribe() (err error) {
req := c.NewRequest(&entity.NodeInfo{
Key: c.nodeCfgSvc.GetNodeKey(),
IsMaster: false,
})
if _, err = c.GetNodeClient().Unsubscribe(context.Background(), req); err != nil {
return trace.TraceError(err)
}
return nil
}
func (c *Client) handleStreamMessage() {
log.Infof("[GrpcClient] start handling stream message...")
for {
// resubscribe if stream is set to nil
if c.stream == nil {
if err := backoff.RetryNotify(c.subscribe, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client subscribe")); err != nil {
log.Errorf("subscribe")
return
}
}
// receive stream message
msg, err := c.stream.Recv()
log.Debugf("[GrpcClient] received message: %v", msg)
if err != nil {
// set error
c.err = err
// end
if err == io.EOF {
log.Infof("[GrpcClient] received EOF signal, disconnecting")
return
}
// connection closed
if c.IsClosed() {
return
}
// error
trace.PrintError(err)
c.stream = nil
time.Sleep(1 * time.Second)
continue
}
// send stream message to channel
c.msgCh <- msg
// reset error
c.err = nil
}
}
func (c *Client) needRestart() bool {
switch c.conn.GetState() {
case connectivity.Shutdown, connectivity.TransientFailure:
return true
case connectivity.Idle, connectivity.Connecting, connectivity.Ready:
return false
default:
return false
}
}
func (c *Client) getRequestData(d interface{}) (data []byte) {
if d == nil {
return data
}
switch d.(type) {
case []byte:
data = d.([]byte)
default:
var err error
data, err = json.Marshal(d)
if err != nil {
panic(err)
}
}
return data
}
func NewClient() (res interfaces.GrpcClient, err error) {
// client
client := &Client{
address: entity.NewAddress(&entity.AddressOptions{
Host: constants.DefaultGrpcClientRemoteHost,
Port: constants.DefaultGrpcClientRemotePort,
}),
timeout: 10 * time.Second,
msgCh: make(chan *grpc2.StreamMessage),
subscribeType: constants.GrpcSubscribeTypeNode,
handleMessage: true,
}
if viper.GetString("grpc.address") != "" {
client.address, err = entity.NewAddressFromString(viper.GetString("grpc.address"))
if err != nil {
return nil, trace.TraceError(err)
}
}
// dependency injection
if err := container.GetContainer().Invoke(func(nodeCfgSvc interfaces.NodeConfigService) {
client.nodeCfgSvc = nodeCfgSvc
}); err != nil {
return nil, err
}
// init
if err := client.Init(); err != nil {
return nil, err
}
return client, nil
}
var _client interfaces.GrpcClient
func GetClient() (c interfaces.GrpcClient, err error) {
if _client != nil {
return _client, nil
}
_client, err = createClient()
if err != nil {
return nil, err
}
return _client, nil
}
func createClient() (client2 interfaces.GrpcClient, err error) {
if err := container.GetContainer().Invoke(func(client interfaces.GrpcClient) {
client2 = client
}); err != nil {
return nil, trace.TraceError(err)
}
return client2, nil
}
|
2302_79757062/crawlab
|
core/grpc/client/client.go
|
Go
|
bsd-3-clause
| 9,823
|
package client
import (
"context"
"encoding/json"
"github.com/apex/log"
"github.com/cenkalti/backoff/v4"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/grpc/middlewares"
"github.com/crawlab-team/crawlab/core/interfaces"
nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/core/utils"
grpc2 "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"github.com/spf13/viper"
"google.golang.org/grpc"
"google.golang.org/grpc/connectivity"
"google.golang.org/grpc/credentials/insecure"
"io"
"time"
)
type GrpcClientV2 struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
// settings
address interfaces.Address
timeout time.Duration
// internals
conn *grpc.ClientConn
stream grpc2.NodeService_SubscribeClient
msgCh chan *grpc2.StreamMessage
err error
// clients
NodeClient grpc2.NodeServiceClient
TaskClient grpc2.TaskServiceClient
ModelBaseServiceV2Client grpc2.ModelBaseServiceV2Client
DependenciesClient grpc2.DependencyServiceV2Client
}
func (c *GrpcClientV2) Init() (err error) {
return nil
}
func (c *GrpcClientV2) Start() (err error) {
// connect
if err := c.connect(); err != nil {
return err
}
// register rpc services
c.Register()
// subscribe
if err := c.subscribe(); err != nil {
return err
}
// handle stream message
go c.handleStreamMessage()
return nil
}
func (c *GrpcClientV2) Stop() (err error) {
// skip if connection is nil
if c.conn == nil {
return nil
}
// grpc server address
address := c.address.String()
// unsubscribe
if err := c.unsubscribe(); err != nil {
return err
}
log.Infof("grpc client unsubscribed from %s", address)
// close connection
if err := c.conn.Close(); err != nil {
return err
}
log.Infof("grpc client disconnected from %s", address)
return nil
}
func (c *GrpcClientV2) Register() {
c.NodeClient = grpc2.NewNodeServiceClient(c.conn)
c.ModelBaseServiceV2Client = grpc2.NewModelBaseServiceV2Client(c.conn)
c.TaskClient = grpc2.NewTaskServiceClient(c.conn)
c.DependenciesClient = grpc2.NewDependencyServiceV2Client(c.conn)
// log
log.Infof("[GrpcClient] grpc client registered client services")
log.Debugf("[GrpcClient] NodeClient: %v", c.NodeClient)
log.Debugf("[GrpcClient] ModelBaseServiceV2Client: %v", c.ModelBaseServiceV2Client)
}
func (c *GrpcClientV2) Context() (ctx context.Context, cancel context.CancelFunc) {
return context.WithTimeout(context.Background(), c.timeout)
}
func (c *GrpcClientV2) NewRequest(d interface{}) (req *grpc2.Request) {
return &grpc2.Request{
NodeKey: c.nodeCfgSvc.GetNodeKey(),
Data: c.getRequestData(d),
}
}
func (c *GrpcClientV2) IsStarted() (res bool) {
return c.conn != nil
}
func (c *GrpcClientV2) IsClosed() (res bool) {
if c.conn != nil {
return c.conn.GetState() == connectivity.Shutdown
}
return false
}
func (c *GrpcClientV2) GetMessageChannel() (msgCh chan *grpc2.StreamMessage) {
return c.msgCh
}
func (c *GrpcClientV2) getRequestData(d interface{}) (data []byte) {
if d == nil {
return data
}
switch d.(type) {
case []byte:
data = d.([]byte)
default:
var err error
data, err = json.Marshal(d)
if err != nil {
panic(err)
}
}
return data
}
func (c *GrpcClientV2) unsubscribe() (err error) {
req := c.NewRequest(&entity.NodeInfo{
Key: c.nodeCfgSvc.GetNodeKey(),
IsMaster: false,
})
if _, err = c.NodeClient.Unsubscribe(context.Background(), req); err != nil {
return trace.TraceError(err)
}
return nil
}
func (c *GrpcClientV2) connect() (err error) {
op := func() error {
// grpc server address
address := c.address.String()
// timeout context
ctx, cancel := context.WithTimeout(context.Background(), c.timeout)
defer cancel()
// connection
// TODO: configure dial options
var opts []grpc.DialOption
opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
opts = append(opts, grpc.WithBlock())
opts = append(opts, grpc.WithChainUnaryInterceptor(middlewares.GetAuthTokenUnaryChainInterceptor(c.nodeCfgSvc)))
opts = append(opts, grpc.WithChainStreamInterceptor(middlewares.GetAuthTokenStreamChainInterceptor(c.nodeCfgSvc)))
c.conn, err = grpc.DialContext(ctx, address, opts...)
if err != nil {
_ = trace.TraceError(err)
return errors.ErrorGrpcClientFailedToStart
}
log.Infof("[GrpcClient] grpc client connected to %s", address)
return nil
}
return backoff.RetryNotify(op, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client connect"))
}
func (c *GrpcClientV2) subscribe() (err error) {
op := func() error {
req := c.NewRequest(&entity.NodeInfo{
Key: c.nodeCfgSvc.GetNodeKey(),
IsMaster: false,
})
c.stream, err = c.NodeClient.Subscribe(context.Background(), req)
if err != nil {
return trace.TraceError(err)
}
// log
log.Infof("[GrpcClient] grpc client subscribed to remote server")
return nil
}
return backoff.RetryNotify(op, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client subscribe"))
}
func (c *GrpcClientV2) handleStreamMessage() {
log.Infof("[GrpcClient] start handling stream message...")
for {
// resubscribe if stream is set to nil
if c.stream == nil {
if err := backoff.RetryNotify(c.subscribe, backoff.NewExponentialBackOff(), utils.BackoffErrorNotify("grpc client subscribe")); err != nil {
log.Errorf("subscribe")
return
}
}
// receive stream message
msg, err := c.stream.Recv()
log.Debugf("[GrpcClient] received message: %v", msg)
if err != nil {
// set error
c.err = err
// end
if err == io.EOF {
log.Infof("[GrpcClient] received EOF signal, disconnecting")
return
}
// connection closed
if c.IsClosed() {
return
}
// error
trace.PrintError(err)
c.stream = nil
time.Sleep(1 * time.Second)
continue
}
// send stream message to channel
c.msgCh <- msg
// reset error
c.err = nil
}
}
func NewGrpcClientV2() (c *GrpcClientV2, err error) {
client := &GrpcClientV2{
address: entity.NewAddress(&entity.AddressOptions{
Host: constants.DefaultGrpcClientRemoteHost,
Port: constants.DefaultGrpcClientRemotePort,
}),
timeout: 10 * time.Second,
msgCh: make(chan *grpc2.StreamMessage),
}
client.nodeCfgSvc = nodeconfig.GetNodeConfigService()
if viper.GetString("grpc.address") != "" {
client.address, err = entity.NewAddressFromString(viper.GetString("grpc.address"))
if err != nil {
return nil, trace.TraceError(err)
}
}
if err := client.Init(); err != nil {
return nil, err
}
return client, nil
}
var _clientV2 *GrpcClientV2
func GetGrpcClientV2() (client *GrpcClientV2, err error) {
if _clientV2 != nil {
return _clientV2, nil
}
_clientV2, err = NewGrpcClientV2()
if err != nil {
return nil, err
}
return _clientV2, nil
}
|
2302_79757062/crawlab
|
core/grpc/client/client_v2.go
|
Go
|
bsd-3-clause
| 7,008
|
package client
import (
"github.com/crawlab-team/crawlab/core/interfaces"
"time"
)
type Option func(client interfaces.GrpcClient)
func WithConfigPath(path string) Option {
return func(c interfaces.GrpcClient) {
c.SetConfigPath(path)
}
}
func WithAddress(address interfaces.Address) Option {
return func(c interfaces.GrpcClient) {
c.SetAddress(address)
}
}
func WithTimeout(timeout time.Duration) Option {
return func(c interfaces.GrpcClient) {
}
}
func WithSubscribeType(subscribeType string) Option {
return func(c interfaces.GrpcClient) {
c.SetSubscribeType(subscribeType)
}
}
func WithHandleMessage(handleMessage bool) Option {
return func(c interfaces.GrpcClient) {
c.SetHandleMessage(handleMessage)
}
}
type PoolOption func(p interfaces.GrpcClientPool)
func WithPoolConfigPath(path string) PoolOption {
return func(c interfaces.GrpcClientPool) {
c.SetConfigPath(path)
}
}
func WithPoolSize(size int) PoolOption {
return func(c interfaces.GrpcClientPool) {
c.SetSize(size)
}
}
|
2302_79757062/crawlab
|
core/grpc/client/options.go
|
Go
|
bsd-3-clause
| 1,019
|
package client
import (
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/trace"
"github.com/emirpasic/gods/lists/arraylist"
"math/rand"
)
type Pool struct {
// settings
size int
cfgPath string
// internals
clients *arraylist.List
}
func (p *Pool) GetConfigPath() (path string) {
return p.cfgPath
}
func (p *Pool) SetConfigPath(path string) {
p.cfgPath = path
}
func (p *Pool) Init() (err error) {
for i := 0; i < p.size; i++ {
if err := p.NewClient(); err != nil {
return err
}
}
return nil
}
func (p *Pool) NewClient() (err error) {
c, err := NewClient()
if err != nil {
return trace.TraceError(err)
}
if err := c.Start(); err != nil {
return err
}
p.clients.Add(c)
return nil
}
func (p *Pool) GetClient() (c interfaces.GrpcClient, err error) {
idx := p.getRandomIndex()
res, ok := p.clients.Get(idx)
if !ok {
return nil, trace.TraceError(errors.ErrorGrpcClientNotExists)
}
c, ok = res.(interfaces.GrpcClient)
if !ok {
return nil, trace.TraceError(errors.ErrorGrpcInvalidType)
}
return c, nil
}
func (p *Pool) SetSize(size int) {
p.size = size
}
func (p *Pool) getRandomIndex() (idx int) {
return rand.Intn(p.clients.Size())
}
func NewPool(opts ...PoolOption) (p interfaces.GrpcClientPool, err error) {
// pool
p = &Pool{
size: 1,
clients: arraylist.New(),
}
// apply options
for _, opt := range opts {
opt(p)
}
// initialize
if err := p.Init(); err != nil {
return nil, err
}
return p, nil
}
|
2302_79757062/crawlab
|
core/grpc/client/pool.go
|
Go
|
bsd-3-clause
| 1,559
|
package client
import grpc2 "github.com/crawlab-team/crawlab/grpc"
var EmptyRequest = &grpc2.Request{}
|
2302_79757062/crawlab
|
core/grpc/client/utils_proto.go
|
Go
|
bsd-3-clause
| 105
|
package middlewares
import (
"context"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/grpc-ecosystem/go-grpc-middleware/auth"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
)
func GetAuthTokenFunc(nodeCfgSvc interfaces.NodeConfigService) grpc_auth.AuthFunc {
return func(ctx context.Context) (ctx2 context.Context, err error) {
// authentication (token verification)
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return nil, errors.ErrorGrpcUnauthorized
}
// auth key from incoming context
res, ok := md[constants.GrpcHeaderAuthorization]
if !ok {
return ctx, errors.ErrorGrpcUnauthorized
}
if len(res) != 1 {
return ctx, errors.ErrorGrpcUnauthorized
}
authKey := res[0]
// validate
svrAuthKey := nodeCfgSvc.GetAuthKey()
if authKey != svrAuthKey {
return ctx, errors.ErrorGrpcUnauthorized
}
return ctx, nil
}
}
func GetAuthTokenUnaryChainInterceptor(nodeCfgSvc interfaces.NodeConfigService) grpc.UnaryClientInterceptor {
// set auth key
md := metadata.Pairs(constants.GrpcHeaderAuthorization, nodeCfgSvc.GetAuthKey())
//header := metadata.MD{}
//header[constants.GrpcHeaderAuthorization] = []string{nodeCfgSvc.GetAuthKey()}
return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
ctx = metadata.NewOutgoingContext(context.Background(), md)
//opts = append(opts, grpc.Header(&header))
return invoker(ctx, method, req, reply, cc, opts...)
}
}
func GetAuthTokenStreamChainInterceptor(nodeCfgSvc interfaces.NodeConfigService) grpc.StreamClientInterceptor {
// set auth key
md := metadata.Pairs(constants.GrpcHeaderAuthorization, nodeCfgSvc.GetAuthKey())
//header := metadata.MD{}
//header[constants.GrpcHeaderAuthorization] = []string{nodeCfgSvc.GetAuthKey()}
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (grpc.ClientStream, error) {
ctx = metadata.NewOutgoingContext(context.Background(), md)
//opts = append(opts, grpc.Header(&header))
s, err := streamer(ctx, desc, cc, method, opts...)
if err != nil {
return nil, err
}
return s, nil
}
}
|
2302_79757062/crawlab
|
core/grpc/middlewares/auth_token.go
|
Go
|
bsd-3-clause
| 2,352
|
package payload
import (
"github.com/crawlab-team/crawlab/db/mongo"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
)
type ModelServiceV2Payload struct {
Type string `json:"type,omitempty"`
Id primitive.ObjectID `json:"_id,omitempty"`
Query bson.M `json:"query,omitempty"`
FindOptions *mongo.FindOptions `json:"find_options,omitempty"`
Model any `json:"model,omitempty"`
Update bson.M `json:"update,omitempty"`
Models []any `json:"models,omitempty"`
}
|
2302_79757062/crawlab
|
core/grpc/payload/model_service_v2_payload.go
|
Go
|
bsd-3-clause
| 598
|
package server
import (
"context"
grpc "github.com/crawlab-team/crawlab/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
)
type DependenciesServerV2 struct {
grpc.UnimplementedDependencyServiceV2Server
}
func (svr DependenciesServerV2) Connect(stream grpc.DependencyServiceV2_ConnectServer) (err error) {
return status.Errorf(codes.Unimplemented, "method Connect not implemented")
}
func (svr DependenciesServerV2) Sync(ctx context.Context, request *grpc.DependenciesServiceV2SyncRequest) (response *grpc.Response, err error) {
return nil, status.Errorf(codes.Unimplemented, "method Sync not implemented")
}
func (svr DependenciesServerV2) Install(stream grpc.DependencyServiceV2_InstallServer) (err error) {
return status.Errorf(codes.Unimplemented, "method Install not implemented")
}
func (svr DependenciesServerV2) UninstallDependencies(stream grpc.DependencyServiceV2_UninstallDependenciesServer) (err error) {
return status.Errorf(codes.Unimplemented, "method UninstallDependencies not implemented")
}
func NewDependenciesServerV2() *DependenciesServerV2 {
return &DependenciesServerV2{}
}
|
2302_79757062/crawlab
|
core/grpc/server/dependencies_server_v2.go
|
Go
|
bsd-3-clause
| 1,133
|
package server
import (
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/service"
grpc "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"io"
)
type MessageServer struct {
grpc.UnimplementedMessageServiceServer
// dependencies
modelSvc service.ModelService
cfgSvc interfaces.NodeConfigService
// internals
server interfaces.GrpcServer
}
func (svr MessageServer) Connect(stream grpc.MessageService_ConnectServer) (err error) {
finished := make(chan bool)
for {
msg, err := stream.Recv()
nodeKey := "unknown node key"
if msg != nil {
nodeKey = msg.NodeKey
}
if err == io.EOF {
log.Infof("[MessageServer] received signal EOF from node[%s], now quit", nodeKey)
return nil
}
if err != nil {
log.Errorf("[MessageServer] receiving message error from node[%s]: %v", nodeKey, err)
return err
}
switch msg.Code {
case grpc.StreamMessageCode_CONNECT:
log.Infof("[MessageServer] received connect request from node[%s], key: %s", nodeKey, msg.Key)
svr.server.SetSubscribe(msg.Key, &entity.GrpcSubscribe{
Stream: stream,
Finished: finished,
})
case grpc.StreamMessageCode_DISCONNECT:
log.Infof("[MessageServer] received disconnect request from node[%s], key: %s", nodeKey, msg.Key)
svr.server.DeleteSubscribe(msg.Key)
return nil
case grpc.StreamMessageCode_SEND:
log.Debugf("[MessageServer] received send request from node[%s] to %s", nodeKey, msg.To)
sub, err := svr.server.GetSubscribe(msg.To)
if err != nil {
return err
}
svr.redirectMessage(sub, msg)
}
}
}
func (svr MessageServer) redirectMessage(sub interfaces.GrpcSubscribe, msg *grpc.StreamMessage) {
stream := sub.GetStream()
if stream == nil {
trace.PrintError(errors.ErrorGrpcStreamNotFound)
return
}
log.Debugf("[MessageServer] redirect message: %v", msg)
if err := stream.Send(msg); err != nil {
trace.PrintError(err)
return
}
}
func NewMessageServer() (res *MessageServer, err error) {
// message server
svr := &MessageServer{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
cfgSvc interfaces.NodeConfigService,
) {
svr.modelSvc = modelSvc
svr.cfgSvc = cfgSvc
}); err != nil {
return nil, err
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/message_server.go
|
Go
|
bsd-3-clause
| 2,506
|
package server
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
)
func NewModelBaseServiceBinder(req *grpc.Request) (b *ModelBaseServiceBinder) {
return &ModelBaseServiceBinder{
req: req,
msg: &entity.GrpcBaseServiceMessage{},
}
}
type ModelBaseServiceBinder struct {
req *grpc.Request
msg interfaces.GrpcModelBaseServiceMessage
}
func (b *ModelBaseServiceBinder) Bind() (res *entity.GrpcBaseServiceParams, err error) {
if err := b.bindBaseServiceMessage(); err != nil {
return nil, err
}
params := &entity.GrpcBaseServiceParams{}
return b.process(params)
}
func (b *ModelBaseServiceBinder) MustBind() (res interface{}) {
res, err := b.Bind()
if err != nil {
panic(err)
}
return res
}
func (b *ModelBaseServiceBinder) BindWithBaseServiceMessage() (params *entity.GrpcBaseServiceParams, msg interfaces.GrpcModelBaseServiceMessage, err error) {
if err := json.Unmarshal(b.req.Data, b.msg); err != nil {
return nil, nil, err
}
params, err = b.Bind()
if err != nil {
return nil, nil, err
}
return params, b.msg, nil
}
func (b *ModelBaseServiceBinder) process(params *entity.GrpcBaseServiceParams) (res *entity.GrpcBaseServiceParams, err error) {
if err := json.Unmarshal(b.msg.GetData(), params); err != nil {
return nil, trace.TraceError(err)
}
return params, nil
}
func (b *ModelBaseServiceBinder) bindBaseServiceMessage() (err error) {
return json.Unmarshal(b.req.Data, b.msg)
}
|
2302_79757062/crawlab
|
core/grpc/server/model_base_service_binder.go
|
Go
|
bsd-3-clause
| 1,578
|
package server
import (
"context"
"encoding/json"
"github.com/crawlab-team/crawlab/core/container"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/interfaces"
"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"
)
type ModelBaseServiceServer struct {
grpc.UnimplementedModelBaseServiceServer
// dependencies
modelSvc interfaces.ModelService
}
func (svr ModelBaseServiceServer) GetById(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
return svc.GetById(params.Id)
})
}
func (svr ModelBaseServiceServer) Get(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
return svc.Get(utils.NormalizeBsonMObjectId(params.Query), params.FindOptions)
})
}
func (svr ModelBaseServiceServer) GetList(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
list, err := svc.GetList(utils.NormalizeBsonMObjectId(params.Query), params.FindOptions)
if err != nil {
return nil, err
}
data, err := json.Marshal(list)
if err != nil {
return nil, err
}
return data, nil
})
}
func (svr ModelBaseServiceServer) DeleteById(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.DeleteById(params.Id, params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) Delete(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.Delete(utils.NormalizeBsonMObjectId(params.Query), params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) DeleteList(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.DeleteList(utils.NormalizeBsonMObjectId(params.Query), params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) ForceDeleteList(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.ForceDeleteList(utils.NormalizeBsonMObjectId(params.Query), params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) UpdateById(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.UpdateById(params.Id, params.Update)
return nil, err
})
}
func (svr ModelBaseServiceServer) Update(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.Update(utils.NormalizeBsonMObjectId(params.Query), params.Update, params.Fields, params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) UpdateDoc(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.UpdateDoc(utils.NormalizeBsonMObjectId(params.Query), params.Doc, params.Fields, params.User)
return nil, err
})
}
func (svr ModelBaseServiceServer) Insert(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
err := svc.Insert(params.User, params.Docs...)
return nil, err
})
}
func (svr ModelBaseServiceServer) Count(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return svr.handleRequest(req, func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error) {
return svc.Count(utils.NormalizeBsonMObjectId(params.Query))
})
}
func (svr ModelBaseServiceServer) handleRequest(req *grpc.Request, handle handleBaseServiceRequest) (res *grpc.Response, err error) {
params, msg, err := NewModelBaseServiceBinder(req).BindWithBaseServiceMessage()
if err != nil {
return HandleError(err)
}
svc := svr.modelSvc.GetBaseService(msg.GetModelId())
d, err := handle(params, svc)
if err != nil {
return HandleError(err)
}
if d == nil {
return HandleSuccess()
}
return HandleSuccessWithData(d)
}
type handleBaseServiceRequest func(params *entity.GrpcBaseServiceParams, svc interfaces.ModelBaseService) (interface{}, error)
func NewModelBaseServiceServer() (svr2 *ModelBaseServiceServer, err error) {
svr := &ModelBaseServiceServer{}
// dependency injection
if err := container.GetContainer().Invoke(func(modelSvc service.ModelService) {
svr.modelSvc = modelSvc
}); err != nil {
return nil, trace.TraceError(err)
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/model_base_service_server.go
|
Go
|
bsd-3-clause
| 5,642
|
package server
import (
"context"
"encoding/json"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/db/mongo"
grpc "github.com/crawlab-team/crawlab/grpc"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"reflect"
)
var (
typeNameColNameMap = make(map[string]string)
typeOneNameModelMap = make(map[string]any)
typeOneInstances = []any{
*new(models.TestModel),
*new(models.DataCollectionV2),
*new(models.DataSourceV2),
*new(models.DependencySettingV2),
*new(models.EnvironmentV2),
*new(models.GitV2),
*new(models.NodeV2),
*new(models.PermissionV2),
*new(models.ProjectV2),
*new(models.RolePermissionV2),
*new(models.RoleV2),
*new(models.ScheduleV2),
*new(models.SettingV2),
*new(models.SpiderV2),
*new(models.TaskQueueItemV2),
*new(models.TaskStatV2),
*new(models.TaskV2),
*new(models.TokenV2),
*new(models.UserRoleV2),
*new(models.UserV2),
}
)
func init() {
for _, v := range typeOneInstances {
t := reflect.TypeOf(v)
typeName := t.Name()
colName := service.GetCollectionNameByInstance(v)
typeNameColNameMap[typeName] = colName
typeOneNameModelMap[typeName] = v
}
}
func GetOneInstanceModel(typeName string) any {
return typeOneNameModelMap[typeName]
}
type ModelBaseServiceServerV2 struct {
grpc.UnimplementedModelBaseServiceV2Server
}
func (svr ModelBaseServiceServerV2) GetById(ctx context.Context, req *grpc.ModelServiceV2GetByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetById(id)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) GetOne(ctx context.Context, req *grpc.ModelServiceV2GetOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
var options mongo.FindOptions
err = json.Unmarshal(req.FindOptions, &options)
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetOne(query, &options)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) GetMany(ctx context.Context, req *grpc.ModelServiceV2GetManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
var options mongo.FindOptions
err = json.Unmarshal(req.FindOptions, &options)
if err != nil {
return HandleError(err)
}
modelSvc := service.NewModelServiceV2WithColName[bson.M](typeNameColNameMap[req.ModelType])
data, err := modelSvc.GetMany(query, &options)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(data)
}
func (svr ModelBaseServiceServerV2) DeleteById(ctx context.Context, req *grpc.ModelServiceV2DeleteByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.DeleteById(id)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) DeleteOne(ctx context.Context, req *grpc.ModelServiceV2DeleteOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.DeleteOne(query)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) DeleteMany(ctx context.Context, req *grpc.ModelServiceV2DeleteManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.DeleteMany(query)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateById(ctx context.Context, req *grpc.ModelServiceV2UpdateByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
}
var update bson.M
err = json.Unmarshal(req.Update, &update)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.UpdateById(id, update)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateOne(ctx context.Context, req *grpc.ModelServiceV2UpdateOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
var update bson.M
err = json.Unmarshal(req.Update, &update)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.UpdateOne(query, update)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) UpdateMany(ctx context.Context, req *grpc.ModelServiceV2UpdateManyRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
var update bson.M
err = json.Unmarshal(req.Update, &update)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.UpdateMany(query, update)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) ReplaceById(ctx context.Context, req *grpc.ModelServiceV2ReplaceByIdRequest) (res *grpc.Response, err error) {
id, err := primitive.ObjectIDFromHex(req.Id)
if err != nil {
return HandleError(err)
}
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelValuePtr := reflect.New(modelType).Interface()
err = json.Unmarshal(req.Model, modelValuePtr)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.GetCol().ReplaceId(id, modelValuePtr)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) ReplaceOne(ctx context.Context, req *grpc.ModelServiceV2ReplaceOneRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelValuePtr := reflect.New(modelType).Interface()
err = json.Unmarshal(req.Model, &modelValuePtr)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
err = modelSvc.GetCol().Replace(query, modelValuePtr)
if err != nil {
return HandleError(err)
}
return HandleSuccess()
}
func (svr ModelBaseServiceServerV2) InsertOne(ctx context.Context, req *grpc.ModelServiceV2InsertOneRequest) (res *grpc.Response, err error) {
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelValuePtr := reflect.New(modelType).Interface()
err = json.Unmarshal(req.Model, modelValuePtr)
if err != nil {
return HandleError(err)
}
modelSvc := GetModelService[bson.M](req.ModelType)
r, err := modelSvc.GetCol().GetCollection().InsertOne(modelSvc.GetCol().GetContext(), modelValuePtr)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(r.InsertedID)
}
func (svr ModelBaseServiceServerV2) InsertMany(ctx context.Context, req *grpc.ModelServiceV2InsertManyRequest) (res *grpc.Response, err error) {
model := GetOneInstanceModel(req.ModelType)
modelType := reflect.TypeOf(model)
modelsSliceType := reflect.SliceOf(modelType)
modelsSlicePtr := reflect.New(modelsSliceType).Interface()
err = json.Unmarshal(req.Models, modelsSlicePtr)
if err != nil {
return HandleError(err)
}
modelsSlice := reflect.ValueOf(modelsSlicePtr).Elem()
modelsInterface := make([]any, modelsSlice.Len())
for i := 0; i < modelsSlice.Len(); i++ {
modelsInterface[i] = modelsSlice.Index(i).Interface()
}
modelSvc := GetModelService[bson.M](req.ModelType)
r, err := modelSvc.GetCol().GetCollection().InsertMany(modelSvc.GetCol().GetContext(), modelsInterface)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(r.InsertedIDs)
}
func (svr ModelBaseServiceServerV2) Count(ctx context.Context, req *grpc.ModelServiceV2CountRequest) (res *grpc.Response, err error) {
var query bson.M
err = json.Unmarshal(req.Query, &query)
if err != nil {
return HandleError(err)
}
count, err := GetModelService[bson.M](req.ModelType).Count(query)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(count)
}
func GetModelService[T any](typeName string) *service.ModelServiceV2[T] {
return service.NewModelServiceV2WithColName[T](typeNameColNameMap[typeName])
}
func NewModelBaseServiceV2Server() *ModelBaseServiceServerV2 {
return &ModelBaseServiceServerV2{}
}
|
2302_79757062/crawlab
|
core/grpc/server/model_base_service_v2_server.go
|
Go
|
bsd-3-clause
| 9,290
|
package server
import (
"encoding/json"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/grpc"
)
func NewModelDelegateBinder(req *grpc.Request) (b *ModelDelegateBinder) {
return &ModelDelegateBinder{
req: req,
msg: &entity.GrpcDelegateMessage{},
}
}
type ModelDelegateBinder struct {
req *grpc.Request
msg interfaces.GrpcModelDelegateMessage
}
func (b *ModelDelegateBinder) Bind() (res interface{}, err error) {
if err := b.bindDelegateMessage(); err != nil {
return nil, err
}
m := models.NewModelMap()
switch b.msg.GetModelId() {
case interfaces.ModelIdArtifact:
return b.process(&m.Artifact, interfaces.ModelIdTag)
case interfaces.ModelIdTag:
return b.process(&m.Tag, interfaces.ModelIdTag)
case interfaces.ModelIdNode:
return b.process(&m.Node, interfaces.ModelIdTag)
case interfaces.ModelIdProject:
return b.process(&m.Project, interfaces.ModelIdTag)
case interfaces.ModelIdSpider:
return b.process(&m.Spider, interfaces.ModelIdTag)
case interfaces.ModelIdTask:
return b.process(&m.Task)
case interfaces.ModelIdJob:
return b.process(&m.Job)
case interfaces.ModelIdSchedule:
return b.process(&m.Schedule)
case interfaces.ModelIdUser:
return b.process(&m.User)
case interfaces.ModelIdSetting:
return b.process(&m.Setting)
case interfaces.ModelIdToken:
return b.process(&m.Token)
case interfaces.ModelIdVariable:
return b.process(&m.Variable)
case interfaces.ModelIdTaskQueue:
return b.process(&m.TaskQueueItem)
case interfaces.ModelIdTaskStat:
return b.process(&m.TaskStat)
case interfaces.ModelIdSpiderStat:
return b.process(&m.SpiderStat)
case interfaces.ModelIdDataSource:
return b.process(&m.DataSource)
case interfaces.ModelIdDataCollection:
return b.process(&m.DataCollection)
case interfaces.ModelIdResult:
return b.process(&m.Result)
case interfaces.ModelIdPassword:
return b.process(&m.Password)
case interfaces.ModelIdExtraValue:
return b.process(&m.ExtraValue)
case interfaces.ModelIdGit:
return b.process(&m.Git)
case interfaces.ModelIdRole:
return b.process(&m.Role)
case interfaces.ModelIdUserRole:
return b.process(&m.UserRole)
case interfaces.ModelIdPermission:
return b.process(&m.Permission)
case interfaces.ModelIdRolePermission:
return b.process(&m.RolePermission)
case interfaces.ModelIdEnvironment:
return b.process(&m.Environment)
case interfaces.ModelIdDependencySetting:
return b.process(&m.DependencySetting)
default:
return nil, errors.ErrorModelInvalidModelId
}
}
func (b *ModelDelegateBinder) MustBind() (res interface{}) {
res, err := b.Bind()
if err != nil {
panic(err)
}
return res
}
func (b *ModelDelegateBinder) BindWithDelegateMessage() (res interface{}, msg interfaces.GrpcModelDelegateMessage, err error) {
if err := json.Unmarshal(b.req.Data, b.msg); err != nil {
return nil, nil, err
}
res, err = b.Bind()
if err != nil {
return nil, nil, err
}
return res, b.msg, nil
}
func (b *ModelDelegateBinder) process(d interface{}, fieldIds ...interfaces.ModelId) (res interface{}, err error) {
if err := json.Unmarshal(b.msg.GetData(), d); err != nil {
return nil, err
}
//return models.AssignFields(d, fieldIds...) // TODO: do we need to assign fields?
return d, nil
}
func (b *ModelDelegateBinder) bindDelegateMessage() (err error) {
return json.Unmarshal(b.req.Data, b.msg)
}
|
2302_79757062/crawlab
|
core/grpc/server/model_delegate_binder.go
|
Go
|
bsd-3-clause
| 3,530
|
package server
import (
"context"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
grpc "github.com/crawlab-team/crawlab/grpc"
)
type ModelDelegateServer struct {
grpc.UnimplementedModelDelegateServer
}
// Do and perform an RPC action of constants.Delegate
func (svr ModelDelegateServer) Do(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
// bind message
obj, msg, err := NewModelDelegateBinder(req).BindWithDelegateMessage()
if err != nil {
return HandleError(err)
}
// convert to model
doc, ok := obj.(interfaces.Model)
if !ok {
return HandleError(errors.ErrorModelInvalidType)
}
// model delegate
d := delegate.NewModelDelegate(doc)
// apply method
switch msg.GetMethod() {
case interfaces.ModelDelegateMethodAdd:
err = d.Add()
case interfaces.ModelDelegateMethodSave:
err = d.Save()
case interfaces.ModelDelegateMethodDelete:
err = d.Delete()
case interfaces.ModelDelegateMethodGetArtifact, interfaces.ModelDelegateMethodRefresh:
err = d.Refresh()
}
if err != nil {
return HandleError(err)
}
// model
m := d.GetModel()
if msg.GetMethod() == interfaces.ModelDelegateMethodGetArtifact {
m, err = d.GetArtifact()
if err != nil {
return nil, err
}
}
// json bytes
data, err := d.ToBytes(m)
if err != nil {
return nil, err
}
return HandleSuccessWithData(data)
}
func NewModelDelegateServer() (svr *ModelDelegateServer) {
return &ModelDelegateServer{}
}
|
2302_79757062/crawlab
|
core/grpc/server/model_delegate_server.go
|
Go
|
bsd-3-clause
| 1,550
|
package server
import (
"context"
"encoding/json"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/delegate"
"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/grpc"
"go.mongodb.org/mongo-driver/mongo"
)
type NodeServer struct {
grpc.UnimplementedNodeServiceServer
// dependencies
modelSvc service.ModelService
cfgSvc interfaces.NodeConfigService
// internals
server interfaces.GrpcServer
}
// Register from handler/worker to master
func (svr NodeServer) Register(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
// unmarshall data
var nodeInfo entity.NodeInfo
if req.Data != nil {
if err := json.Unmarshal(req.Data, &nodeInfo); err != nil {
return HandleError(err)
}
if nodeInfo.IsMaster {
// error: cannot register master node
return HandleError(errors.ErrorGrpcNotAllowed)
}
}
// node key
var nodeKey string
if req.NodeKey != "" {
nodeKey = req.NodeKey
} else {
nodeKey = nodeInfo.Key
}
if nodeKey == "" {
return HandleError(errors.ErrorModelMissingRequiredData)
}
// find in db
node, err := svr.modelSvc.GetNodeByKey(nodeKey, nil)
if err == nil {
if node.IsMaster {
// error: cannot register master node
return HandleError(errors.ErrorGrpcNotAllowed)
} else {
// register existing
node.Status = constants.NodeStatusRegistered
node.Active = true
nodeD := delegate.NewModelNodeDelegate(node)
if err := nodeD.Save(); err != nil {
return HandleError(err)
}
var ok bool
node, ok = nodeD.GetModel().(*models.Node)
if !ok {
return HandleError(errors.ErrorGrpcInvalidType)
}
log.Infof("[NodeServer] updated worker[%s] in db. id: %s", nodeKey, nodeD.GetModel().GetId().Hex())
}
} else if err == mongo.ErrNoDocuments {
// register new
node = &models.Node{
Key: nodeKey,
Name: nodeInfo.Name,
Ip: nodeInfo.Ip,
Hostname: nodeInfo.Hostname,
Description: nodeInfo.Description,
MaxRunners: nodeInfo.MaxRunners,
Status: constants.NodeStatusRegistered,
Active: true,
Enabled: true,
}
if node.Name == "" {
node.Name = nodeKey
}
nodeD := delegate.NewModelDelegate(node)
if err := nodeD.Add(); err != nil {
return HandleError(err)
}
var ok bool
node, ok = nodeD.GetModel().(*models.Node)
if !ok {
return HandleError(errors.ErrorGrpcInvalidType)
}
log.Infof("[NodeServer] added worker[%s] in db. id: %s", nodeKey, nodeD.GetModel().GetId().Hex())
} else {
// error
return HandleError(err)
}
log.Infof("[NodeServer] master registered worker[%s]", req.GetNodeKey())
return HandleSuccessWithData(node)
}
// SendHeartbeat from worker to master
func (svr NodeServer) SendHeartbeat(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
// find in db
node, err := svr.modelSvc.GetNodeByKey(req.NodeKey, nil)
if err != nil {
if err == mongo.ErrNoDocuments {
return HandleError(errors.ErrorNodeNotExists)
}
return HandleError(err)
}
// validate status
if node.Status == constants.NodeStatusUnregistered {
return HandleError(errors.ErrorNodeUnregistered)
}
// update status
nodeD := delegate.NewModelNodeDelegate(node)
if err := nodeD.UpdateStatusOnline(); err != nil {
return HandleError(err)
}
return HandleSuccessWithData(node)
}
// Ping from worker to master
func (svr NodeServer) Ping(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return HandleSuccess()
}
func (svr NodeServer) Subscribe(request *grpc.Request, stream grpc.NodeService_SubscribeServer) (err error) {
log.Infof("[NodeServer] master received subscribe request from node[%s]", request.NodeKey)
// finished channel
finished := make(chan bool)
// set subscribe
svr.server.SetSubscribe("node:"+request.NodeKey, &entity.GrpcSubscribe{
Stream: stream,
Finished: finished,
})
ctx := stream.Context()
log.Infof("[NodeServer] master subscribed node[%s]", request.NodeKey)
// Keep this scope alive because once this scope exits - the stream is closed
for {
select {
case <-finished:
log.Infof("[NodeServer] closing stream for node[%s]", request.NodeKey)
return nil
case <-ctx.Done():
log.Infof("[NodeServer] node[%s] has disconnected", request.NodeKey)
return nil
}
}
}
func (svr NodeServer) Unsubscribe(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
sub, err := svr.server.GetSubscribe("node:" + req.NodeKey)
if err != nil {
return nil, errors.ErrorGrpcSubscribeNotExists
}
select {
case sub.GetFinished() <- true:
log.Infof("unsubscribed node[%s]", req.NodeKey)
default:
// Default case is to avoid blocking in case client has already unsubscribed
}
svr.server.DeleteSubscribe(req.NodeKey)
return &grpc.Response{
Code: grpc.ResponseCode_OK,
Message: "unsubscribed successfully",
}, nil
}
func NewNodeServer() (res *NodeServer, err error) {
// node server
svr := &NodeServer{}
svr.modelSvc, err = service.GetService()
if err != nil {
return nil, err
}
svr.cfgSvc, err = nodeconfig.NewNodeConfigService()
if err != nil {
return nil, err
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/node_server.go
|
Go
|
bsd-3-clause
| 5,493
|
package server
import (
"context"
"encoding/json"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/models/models"
"github.com/crawlab-team/crawlab/core/models/service"
nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
"github.com/crawlab-team/crawlab/grpc"
errors2 "github.com/pkg/errors"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"go.mongodb.org/mongo-driver/mongo"
"time"
)
type NodeServerV2 struct {
grpc.UnimplementedNodeServiceServer
// dependencies
cfgSvc interfaces.NodeConfigService
// internals
server *GrpcServerV2
}
// Register from handler/worker to master
func (svr NodeServerV2) Register(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
// unmarshall data
var node models.NodeV2
if req.Data != nil {
if err := json.Unmarshal(req.Data, &node); err != nil {
return HandleError(err)
}
if node.IsMaster {
// error: cannot register master node
return HandleError(errors.ErrorGrpcNotAllowed)
}
}
// node key
var nodeKey string
if req.NodeKey != "" {
nodeKey = req.NodeKey
} else {
nodeKey = node.Key
}
if nodeKey == "" {
return HandleError(errors.ErrorModelMissingRequiredData)
}
// find in db
nodeDb, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err == nil {
if node.IsMaster {
// error: cannot register master node
return HandleError(errors.ErrorGrpcNotAllowed)
} else {
// register existing
nodeDb.Status = constants.NodeStatusRegistered
nodeDb.Active = true
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(nodeDb.Id, *nodeDb)
if err != nil {
return HandleError(err)
}
log.Infof("[NodeServerV2] updated worker[%s] in db. id: %s", nodeKey, node.Id.Hex())
}
} else if errors2.Is(err, mongo.ErrNoDocuments) {
// register new
node.Key = nodeKey
node.Status = constants.NodeStatusRegistered
node.Active = true
node.ActiveAt = time.Now()
node.Enabled = true
if node.Name == "" {
node.Name = nodeKey
}
node.SetCreated(primitive.NilObjectID)
node.SetUpdated(primitive.NilObjectID)
_, err = service.NewModelServiceV2[models.NodeV2]().InsertOne(*nodeDb)
if err != nil {
return HandleError(err)
}
log.Infof("[NodeServerV2] added worker[%s] in db. id: %s", nodeKey, node.Id.Hex())
} else {
// error
return HandleError(err)
}
log.Infof("[NodeServerV2] master registered worker[%s]", req.GetNodeKey())
return HandleSuccessWithData(node)
}
// SendHeartbeat from worker to master
func (svr NodeServerV2) SendHeartbeat(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
// find in db
node, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": req.NodeKey}, nil)
if err != nil {
if errors2.Is(err, mongo.ErrNoDocuments) {
return HandleError(errors.ErrorNodeNotExists)
}
return HandleError(err)
}
// validate status
if node.Status == constants.NodeStatusUnregistered {
return HandleError(errors.ErrorNodeUnregistered)
}
// update status
node.Status = constants.NodeStatusOnline
node.Active = true
node.ActiveAt = time.Now()
err = service.NewModelServiceV2[models.NodeV2]().ReplaceById(node.Id, *node)
if err != nil {
return HandleError(err)
}
return HandleSuccessWithData(node)
}
// Ping from worker to master
func (svr NodeServerV2) Ping(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
return HandleSuccess()
}
func (svr NodeServerV2) Subscribe(request *grpc.Request, stream grpc.NodeService_SubscribeServer) (err error) {
log.Infof("[NodeServerV2] master received subscribe request from node[%s]", request.NodeKey)
// finished channel
finished := make(chan bool)
// set subscribe
svr.server.SetSubscribe("node:"+request.NodeKey, &entity.GrpcSubscribe{
Stream: stream,
Finished: finished,
})
ctx := stream.Context()
log.Infof("[NodeServerV2] master subscribed node[%s]", request.NodeKey)
// Keep this scope alive because once this scope exits - the stream is closed
for {
select {
case <-finished:
log.Infof("[NodeServerV2] closing stream for node[%s]", request.NodeKey)
return nil
case <-ctx.Done():
log.Infof("[NodeServerV2] node[%s] has disconnected", request.NodeKey)
return nil
}
}
}
func (svr NodeServerV2) Unsubscribe(ctx context.Context, req *grpc.Request) (res *grpc.Response, err error) {
sub, err := svr.server.GetSubscribe("node:" + req.NodeKey)
if err != nil {
return nil, errors.ErrorGrpcSubscribeNotExists
}
select {
case sub.GetFinished() <- true:
log.Infof("unsubscribed node[%s]", req.NodeKey)
default:
// Default case is to avoid blocking in case client has already unsubscribed
}
svr.server.DeleteSubscribe(req.NodeKey)
return &grpc.Response{
Code: grpc.ResponseCode_OK,
Message: "unsubscribed successfully",
}, nil
}
func NewNodeServerV2() (res *NodeServerV2, err error) {
// node server
svr := &NodeServerV2{}
svr.cfgSvc, err = nodeconfig.NewNodeConfigService()
if err != nil {
return nil, err
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/node_server_v2.go
|
Go
|
bsd-3-clause
| 5,288
|
package server
import (
"github.com/crawlab-team/crawlab/core/interfaces"
)
type Option func(svr interfaces.GrpcServer)
func WithConfigPath(path string) Option {
return func(svr interfaces.GrpcServer) {
svr.SetConfigPath(path)
}
}
func WithAddress(address interfaces.Address) Option {
return func(svr interfaces.GrpcServer) {
svr.SetAddress(address)
}
}
type NodeServerOption func(svr *NodeServer)
func WithServerNodeServerService(server interfaces.GrpcServer) NodeServerOption {
return func(svr *NodeServer) {
svr.server = server
}
}
type TaskServerOption func(svr *TaskServer)
func WithServerTaskServerService(server interfaces.GrpcServer) TaskServerOption {
return func(svr *TaskServer) {
svr.server = server
}
}
type MessageServerOption func(svr *MessageServer)
func WithServerMessageServerService(server interfaces.GrpcServer) MessageServerOption {
return func(svr *MessageServer) {
svr.server = server
}
}
|
2302_79757062/crawlab
|
core/grpc/server/options.go
|
Go
|
bsd-3-clause
| 943
|
package server
import (
"encoding/json"
"fmt"
"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/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/grpc/middlewares"
"github.com/crawlab-team/crawlab/core/interfaces"
grpc2 "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
"github.com/grpc-ecosystem/go-grpc-middleware"
grpc_auth "github.com/grpc-ecosystem/go-grpc-middleware/auth"
"github.com/grpc-ecosystem/go-grpc-middleware/recovery"
"github.com/spf13/viper"
"go/types"
"google.golang.org/grpc"
"net"
"sync"
)
var subs = sync.Map{}
type Server struct {
// dependencies
nodeCfgSvc interfaces.NodeConfigService
nodeSvr *NodeServer
taskSvr *TaskServer
messageSvr *MessageServer
modelDelegateSvr *ModelDelegateServer
modelBaseServiceSvr *ModelBaseServiceServer
// settings
cfgPath string
address interfaces.Address
// internals
svr *grpc.Server
l net.Listener
stopped bool
}
func (svr *Server) Init() (err error) {
// register
if err := svr.Register(); err != nil {
return err
}
return nil
}
func (svr *Server) Start() (err error) {
// grpc server binding address
address := svr.address.String()
// listener
svr.l, err = net.Listen("tcp", address)
if err != nil {
_ = trace.TraceError(err)
return errors.ErrorGrpcServerFailedToListen
}
log.Infof("grpc server listens to %s", address)
// start grpc server
go func() {
if err := svr.svr.Serve(svr.l); err != nil {
if err == grpc.ErrServerStopped {
return
}
trace.PrintError(err)
log.Error(errors.ErrorGrpcServerFailedToServe.Error())
}
}()
return nil
}
func (svr *Server) Stop() (err error) {
// skip if listener is nil
if svr.l == nil {
return nil
}
// graceful stop
log.Infof("grpc server stopping...")
svr.svr.Stop()
// close listener
log.Infof("grpc server closing listener...")
_ = svr.l.Close()
// mark as stopped
svr.stopped = true
// log
log.Infof("grpc server stopped")
return nil
}
func (svr *Server) Register() (err error) {
grpc2.RegisterModelDelegateServer(svr.svr, *svr.modelDelegateSvr) // model delegate
grpc2.RegisterModelBaseServiceServer(svr.svr, *svr.modelBaseServiceSvr) // model base service
grpc2.RegisterNodeServiceServer(svr.svr, *svr.nodeSvr) // node service
grpc2.RegisterTaskServiceServer(svr.svr, *svr.taskSvr) // task service
grpc2.RegisterMessageServiceServer(svr.svr, *svr.messageSvr) // message service
return nil
}
func (svr *Server) SetAddress(address interfaces.Address) {
svr.address = address
}
func (svr *Server) GetConfigPath() (path string) {
return svr.cfgPath
}
func (svr *Server) SetConfigPath(path string) {
svr.cfgPath = path
}
func (svr *Server) GetSubscribe(key string) (sub interfaces.GrpcSubscribe, err error) {
res, ok := subs.Load(key)
if !ok {
return nil, trace.TraceError(errors.ErrorGrpcStreamNotFound)
}
sub, ok = res.(interfaces.GrpcSubscribe)
if !ok {
return nil, trace.TraceError(errors.ErrorGrpcInvalidType)
}
return sub, nil
}
func (svr *Server) SetSubscribe(key string, sub interfaces.GrpcSubscribe) {
subs.Store(key, sub)
}
func (svr *Server) DeleteSubscribe(key string) {
subs.Delete(key)
}
func (svr *Server) SendStreamMessage(key string, code grpc2.StreamMessageCode) (err error) {
return svr.SendStreamMessageWithData(key, code, nil)
}
func (svr *Server) SendStreamMessageWithData(key string, code grpc2.StreamMessageCode, d interface{}) (err error) {
var data []byte
switch d.(type) {
case types.Nil:
// do nothing
case []byte:
data = d.([]byte)
default:
var err error
data, err = json.Marshal(d)
if err != nil {
panic(err)
}
}
sub, err := svr.GetSubscribe(key)
if err != nil {
return err
}
msg := &grpc2.StreamMessage{
Code: code,
Key: svr.nodeCfgSvc.GetNodeKey(),
Data: data,
}
return sub.GetStream().Send(msg)
}
func (svr *Server) IsStopped() (res bool) {
return svr.stopped
}
func (svr *Server) recoveryHandlerFunc(p interface{}) (err error) {
err = errors.NewError(errors.ErrorPrefixGrpc, fmt.Sprintf("%v", p))
trace.PrintError(err)
return err
}
func NewServer() (svr2 interfaces.GrpcServer, err error) {
// server
svr := &Server{
cfgPath: config2.GetConfigPath(),
address: entity.NewAddress(&entity.AddressOptions{
Host: constants.DefaultGrpcServerHost,
Port: constants.DefaultGrpcServerPort,
}),
}
if viper.GetString("grpc.server.address") != "" {
svr.address, err = entity.NewAddressFromString(viper.GetString("grpc.server.address"))
if err != nil {
return nil, err
}
}
// dependency injection
if err := container.GetContainer().Invoke(func(
nodeCfgSvc interfaces.NodeConfigService,
modelDelegateSvr *ModelDelegateServer,
modelBaseServiceSvr *ModelBaseServiceServer,
nodeSvr *NodeServer,
taskSvr *TaskServer,
messageSvr *MessageServer,
) {
// dependencies
svr.nodeCfgSvc = nodeCfgSvc
svr.modelDelegateSvr = modelDelegateSvr
svr.modelBaseServiceSvr = modelBaseServiceSvr
svr.nodeSvr = nodeSvr
svr.taskSvr = taskSvr
svr.messageSvr = messageSvr
// server
svr.nodeSvr.server = svr
svr.taskSvr.server = svr
svr.messageSvr.server = svr
}); err != nil {
return nil, err
}
// recovery options
recoveryOpts := []grpc_recovery.Option{
grpc_recovery.WithRecoveryHandler(svr.recoveryHandlerFunc),
}
// grpc server
svr.svr = grpc.NewServer(
grpc_middleware.WithUnaryServerChain(
grpc_recovery.UnaryServerInterceptor(recoveryOpts...),
grpc_auth.UnaryServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
),
grpc_middleware.WithStreamServerChain(
grpc_recovery.StreamServerInterceptor(recoveryOpts...),
grpc_auth.StreamServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
),
)
// initialize
if err := svr.Init(); err != nil {
return nil, err
}
return svr, nil
}
var _server interfaces.GrpcServer
func GetServer() (svr interfaces.GrpcServer, err error) {
if _server != nil {
return _server, nil
}
_server, err = NewServer()
if err != nil {
return nil, err
}
return _server, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/server.go
|
Go
|
bsd-3-clause
| 6,351
|
package server
import (
"encoding/json"
"fmt"
"github.com/apex/log"
"github.com/crawlab-team/crawlab/core/constants"
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/errors"
"github.com/crawlab-team/crawlab/core/grpc/middlewares"
"github.com/crawlab-team/crawlab/core/interfaces"
nodeconfig "github.com/crawlab-team/crawlab/core/node/config"
grpc2 "github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
grpc_auth "github.com/grpc-ecosystem/go-grpc-middleware/auth"
grpc_recovery "github.com/grpc-ecosystem/go-grpc-middleware/recovery"
errors2 "github.com/pkg/errors"
"github.com/spf13/viper"
"go/types"
"google.golang.org/grpc"
"net"
"sync"
)
var (
subsV2 = map[string]interfaces.GrpcSubscribe{}
mutexSubsV2 = &sync.Mutex{}
)
type GrpcServerV2 struct {
// settings
cfgPath string
address interfaces.Address
// internals
svr *grpc.Server
l net.Listener
stopped bool
// dependencies
nodeCfgSvc interfaces.NodeConfigService
// servers
nodeSvr *NodeServerV2
taskSvr *TaskServerV2
modelBaseServiceSvr *ModelBaseServiceServerV2
dependenciesSvr *DependenciesServerV2
}
func (svr *GrpcServerV2) GetConfigPath() (path string) {
return svr.cfgPath
}
func (svr *GrpcServerV2) SetConfigPath(path string) {
svr.cfgPath = path
}
func (svr *GrpcServerV2) Init() (err error) {
// register
if err := svr.Register(); err != nil {
return err
}
return nil
}
func (svr *GrpcServerV2) Start() (err error) {
// grpc server binding address
address := svr.address.String()
// listener
svr.l, err = net.Listen("tcp", address)
if err != nil {
_ = trace.TraceError(err)
return errors.ErrorGrpcServerFailedToListen
}
log.Infof("grpc server listens to %s", address)
// start grpc server
go func() {
if err := svr.svr.Serve(svr.l); err != nil {
if errors2.Is(err, grpc.ErrServerStopped) {
return
}
trace.PrintError(err)
log.Error(errors.ErrorGrpcServerFailedToServe.Error())
}
}()
return nil
}
func (svr *GrpcServerV2) Stop() (err error) {
// skip if listener is nil
if svr.l == nil {
return nil
}
// graceful stop
log.Infof("grpc server stopping...")
svr.svr.Stop()
// close listener
log.Infof("grpc server closing listener...")
_ = svr.l.Close()
// mark as stopped
svr.stopped = true
// log
log.Infof("grpc server stopped")
return nil
}
func (svr *GrpcServerV2) Register() (err error) {
grpc2.RegisterNodeServiceServer(svr.svr, *svr.nodeSvr) // node service
grpc2.RegisterModelBaseServiceV2Server(svr.svr, *svr.modelBaseServiceSvr)
grpc2.RegisterTaskServiceServer(svr.svr, *svr.taskSvr)
return nil
}
func (svr *GrpcServerV2) recoveryHandlerFunc(p interface{}) (err error) {
err = errors.NewError(errors.ErrorPrefixGrpc, fmt.Sprintf("%v", p))
trace.PrintError(err)
return err
}
func (svr *GrpcServerV2) SetAddress(address interfaces.Address) {
}
func (svr *GrpcServerV2) GetSubscribe(key string) (sub interfaces.GrpcSubscribe, err error) {
mutexSubsV2.Lock()
defer mutexSubsV2.Unlock()
sub, ok := subsV2[key]
if !ok {
return nil, errors.ErrorGrpcSubscribeNotExists
}
return sub, nil
}
func (svr *GrpcServerV2) SetSubscribe(key string, sub interfaces.GrpcSubscribe) {
mutexSubsV2.Lock()
defer mutexSubsV2.Unlock()
subsV2[key] = sub
}
func (svr *GrpcServerV2) DeleteSubscribe(key string) {
mutexSubsV2.Lock()
defer mutexSubsV2.Unlock()
delete(subsV2, key)
}
func (svr *GrpcServerV2) SendStreamMessage(key string, code grpc2.StreamMessageCode) (err error) {
return svr.SendStreamMessageWithData(key, code, nil)
}
func (svr *GrpcServerV2) SendStreamMessageWithData(key string, code grpc2.StreamMessageCode, d interface{}) (err error) {
var data []byte
switch d.(type) {
case types.Nil:
// do nothing
case []byte:
data = d.([]byte)
default:
var err error
data, err = json.Marshal(d)
if err != nil {
return err
}
}
sub, err := svr.GetSubscribe(key)
if err != nil {
return err
}
msg := &grpc2.StreamMessage{
Code: code,
Key: svr.nodeCfgSvc.GetNodeKey(),
Data: data,
}
return sub.GetStream().Send(msg)
}
func (svr *GrpcServerV2) IsStopped() (res bool) {
return svr.stopped
}
func NewGrpcServerV2() (svr *GrpcServerV2, err error) {
// server
svr = &GrpcServerV2{
address: entity.NewAddress(&entity.AddressOptions{
Host: constants.DefaultGrpcServerHost,
Port: constants.DefaultGrpcServerPort,
}),
}
if viper.GetString("grpc.server.address") != "" {
svr.address, err = entity.NewAddressFromString(viper.GetString("grpc.server.address"))
if err != nil {
return nil, err
}
}
svr.nodeCfgSvc = nodeconfig.GetNodeConfigService()
svr.nodeSvr, err = NewNodeServerV2()
if err != nil {
return nil, err
}
svr.modelBaseServiceSvr = NewModelBaseServiceV2Server()
svr.taskSvr, err = NewTaskServerV2()
if err != nil {
return nil, err
}
svr.dependenciesSvr = NewDependenciesServerV2()
// recovery options
recoveryOpts := []grpc_recovery.Option{
grpc_recovery.WithRecoveryHandler(svr.recoveryHandlerFunc),
}
// grpc server
svr.svr = grpc.NewServer(
grpc_middleware.WithUnaryServerChain(
grpc_recovery.UnaryServerInterceptor(recoveryOpts...),
grpc_auth.UnaryServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
),
grpc_middleware.WithStreamServerChain(
grpc_recovery.StreamServerInterceptor(recoveryOpts...),
grpc_auth.StreamServerInterceptor(middlewares.GetAuthTokenFunc(svr.nodeCfgSvc)),
),
)
// initialize
if err := svr.Init(); err != nil {
return nil, err
}
return svr, nil
}
var _serverV2 *GrpcServerV2
func GetGrpcServerV2() (svr *GrpcServerV2, err error) {
if _serverV2 != nil {
return _serverV2, nil
}
_serverV2, err = NewGrpcServerV2()
if err != nil {
return nil, err
}
return _serverV2, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/server_v2.go
|
Go
|
bsd-3-clause
| 5,898
|
package server
import (
"context"
"encoding/json"
"github.com/apex/log"
"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"
"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/notification"
"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"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"io"
"strings"
)
type TaskServer struct {
grpc.UnimplementedTaskServiceServer
// dependencies
modelSvc service.ModelService
cfgSvc interfaces.NodeConfigService
statsSvc interfaces.TaskStatsService
// internals
server interfaces.GrpcServer
}
// Subscribe to task stream when a task runner in a node starts
func (svr TaskServer) Subscribe(stream grpc.TaskService_SubscribeServer) (err error) {
for {
msg, err := stream.Recv()
utils.LogDebug(msg.String())
if err == io.EOF {
return nil
}
if err != nil {
if strings.HasSuffix(err.Error(), "context canceled") {
return nil
}
trace.PrintError(err)
continue
}
switch msg.Code {
case grpc.StreamMessageCode_INSERT_DATA:
err = svr.handleInsertData(msg)
case grpc.StreamMessageCode_INSERT_LOGS:
err = svr.handleInsertLogs(msg)
default:
err = errors.ErrorGrpcInvalidCode
log.Errorf("invalid stream message code: %d", msg.Code)
continue
}
if err != nil {
log.Errorf("grpc error[%d]: %v", msg.Code, err)
}
}
}
// Fetch tasks to be executed by a task handler
func (svr TaskServer) Fetch(ctx context.Context, request *grpc.Request) (response *grpc.Response, err error) {
nodeKey := request.GetNodeKey()
if nodeKey == "" {
return nil, trace.TraceError(errors.ErrorGrpcInvalidNodeKey)
}
n, err := svr.modelSvc.GetNodeByKey(nodeKey, nil)
if err != nil {
return nil, trace.TraceError(err)
}
var tid primitive.ObjectID
opts := &mongo.FindOptions{
Sort: bson.D{
{"p", 1},
{"_id", 1},
},
Limit: 1,
}
if err := mongo.RunTransactionWithContext(ctx, func(sc mongo2.SessionContext) (err error) {
// get task queue item assigned to this node
tid, err = svr.getTaskQueueItemIdAndDequeue(bson.M{"nid": n.Id}, opts, n.Id)
if err != nil {
return err
}
if !tid.IsZero() {
return nil
}
// get task queue item assigned to any node (random mode)
tid, err = svr.getTaskQueueItemIdAndDequeue(bson.M{"nid": nil}, opts, n.Id)
if !tid.IsZero() {
return nil
}
if err != nil {
return err
}
return nil
}); err != nil {
return nil, err
}
return HandleSuccessWithData(tid)
}
func (svr TaskServer) SendNotification(ctx context.Context, request *grpc.Request) (response *grpc.Response, err error) {
svc := notification.GetService()
var t = new(models.Task)
if err := json.Unmarshal(request.Data, t); err != nil {
return nil, trace.TraceError(err)
}
t, err = svr.modelSvc.GetTaskById(t.Id)
if err != nil {
return nil, trace.TraceError(err)
}
td, err := json.Marshal(t)
if err != nil {
return nil, trace.TraceError(err)
}
var e bson.M
if err := json.Unmarshal(td, &e); err != nil {
return nil, trace.TraceError(err)
}
ts, err := svr.modelSvc.GetTaskStatById(t.Id)
if err != nil {
return nil, trace.TraceError(err)
}
settings, _, err := svc.GetSettingList(bson.M{
"enabled": true,
}, nil, nil)
if err != nil {
return nil, trace.TraceError(err)
}
for _, s := range settings {
switch s.TaskTrigger {
case constants.NotificationTriggerTaskFinish:
if t.Status != constants.TaskStatusPending && t.Status != constants.TaskStatusRunning {
_ = svc.Send(s, e)
}
case constants.NotificationTriggerTaskError:
if t.Status == constants.TaskStatusError || t.Status == constants.TaskStatusAbnormal {
_ = svc.Send(s, e)
}
case constants.NotificationTriggerTaskEmptyResults:
if t.Status != constants.TaskStatusPending && t.Status != constants.TaskStatusRunning {
if ts.ResultCount == 0 {
_ = svc.Send(s, e)
}
}
case constants.NotificationTriggerTaskNever:
}
}
return nil, nil
}
func (svr TaskServer) handleInsertData(msg *grpc.StreamMessage) (err error) {
data, err := svr.deserialize(msg)
if err != nil {
return err
}
var records []interface{}
for _, d := range data.Records {
res, ok := d[constants.TaskKey]
if ok {
switch res.(type) {
case string:
id, err := primitive.ObjectIDFromHex(res.(string))
if err == nil {
d[constants.TaskKey] = id
}
}
}
records = append(records, d)
}
return svr.statsSvc.InsertData(data.TaskId, records...)
}
func (svr TaskServer) handleInsertLogs(msg *grpc.StreamMessage) (err error) {
data, err := svr.deserialize(msg)
if err != nil {
return err
}
return svr.statsSvc.InsertLogs(data.TaskId, data.Logs...)
}
func (svr TaskServer) getTaskQueueItemIdAndDequeue(query bson.M, opts *mongo.FindOptions, nid primitive.ObjectID) (tid primitive.ObjectID, err error) {
var tq models.TaskQueueItem
if err := mongo.GetMongoCol(interfaces.ModelColNameTaskQueue).Find(query, opts).One(&tq); err != nil {
if err == mongo2.ErrNoDocuments {
return tid, nil
}
return tid, trace.TraceError(err)
}
t, err := svr.modelSvc.GetTaskById(tq.Id)
if err == nil {
t.NodeId = nid
_ = delegate.NewModelDelegate(t).Save()
}
_ = delegate.NewModelDelegate(&tq).Delete()
return tq.Id, nil
}
func (svr TaskServer) deserialize(msg *grpc.StreamMessage) (data entity.StreamMessageTaskData, err error) {
if err := json.Unmarshal(msg.Data, &data); err != nil {
return data, trace.TraceError(err)
}
if data.TaskId.IsZero() {
return data, trace.TraceError(errors.ErrorGrpcInvalidType)
}
return data, nil
}
func NewTaskServer() (res *TaskServer, err error) {
// task server
svr := &TaskServer{}
// dependency injection
if err := container.GetContainer().Invoke(func(
modelSvc service.ModelService,
statsSvc interfaces.TaskStatsService,
cfgSvc interfaces.NodeConfigService,
) {
svr.modelSvc = modelSvc
svr.statsSvc = statsSvc
svr.cfgSvc = cfgSvc
}); err != nil {
return nil, err
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/task_server.go
|
Go
|
bsd-3-clause
| 6,460
|
package server
import (
"context"
"encoding/json"
"errors"
"github.com/apex/log"
"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/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/notification"
"github.com/crawlab-team/crawlab/core/task/stats"
"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"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
mongo2 "go.mongodb.org/mongo-driver/mongo"
"io"
"strings"
)
type TaskServerV2 struct {
grpc.UnimplementedTaskServiceServer
// dependencies
cfgSvc interfaces.NodeConfigService
statsSvc *stats.ServiceV2
// internals
server interfaces.GrpcServer
}
// Subscribe to task stream when a task runner in a node starts
func (svr TaskServerV2) Subscribe(stream grpc.TaskService_SubscribeServer) (err error) {
for {
msg, err := stream.Recv()
utils.LogDebug(msg.String())
if err == io.EOF {
return nil
}
if err != nil {
if strings.HasSuffix(err.Error(), "context canceled") {
return nil
}
trace.PrintError(err)
continue
}
switch msg.Code {
case grpc.StreamMessageCode_INSERT_DATA:
err = svr.handleInsertData(msg)
case grpc.StreamMessageCode_INSERT_LOGS:
err = svr.handleInsertLogs(msg)
default:
err = errors.New("invalid stream message code")
log.Errorf("invalid stream message code: %d", msg.Code)
continue
}
if err != nil {
log.Errorf("grpc error[%d]: %v", msg.Code, err)
}
}
}
// Fetch tasks to be executed by a task handler
func (svr TaskServerV2) Fetch(ctx context.Context, request *grpc.Request) (response *grpc.Response, err error) {
nodeKey := request.GetNodeKey()
if nodeKey == "" {
return nil, errors.New("invalid node key")
}
n, err := service.NewModelServiceV2[models.NodeV2]().GetOne(bson.M{"key": nodeKey}, nil)
if err != nil {
return nil, trace.TraceError(err)
}
var tid primitive.ObjectID
opts := &mongo.FindOptions{
Sort: bson.D{
{"p", 1},
{"_id", 1},
},
Limit: 1,
}
if err := mongo.RunTransactionWithContext(ctx, func(sc mongo2.SessionContext) (err error) {
// get task queue item assigned to this node
tid, err = svr.getTaskQueueItemIdAndDequeue(bson.M{"nid": n.Id}, opts, n.Id)
if err != nil {
return err
}
if !tid.IsZero() {
return nil
}
// get task queue item assigned to any node (random mode)
tid, err = svr.getTaskQueueItemIdAndDequeue(bson.M{"nid": nil}, opts, n.Id)
if !tid.IsZero() {
return nil
}
if err != nil {
return err
}
return nil
}); err != nil {
return nil, err
}
return HandleSuccessWithData(tid)
}
func (svr TaskServerV2) SendNotification(ctx context.Context, request *grpc.Request) (response *grpc.Response, err error) {
svc := notification.GetServiceV2()
var t = new(models.TaskV2)
if err := json.Unmarshal(request.Data, t); err != nil {
return nil, trace.TraceError(err)
}
t, err = service.NewModelServiceV2[models.TaskV2]().GetById(t.Id)
if err != nil {
return nil, trace.TraceError(err)
}
td, err := json.Marshal(t)
if err != nil {
return nil, trace.TraceError(err)
}
var e bson.M
if err := json.Unmarshal(td, &e); err != nil {
return nil, trace.TraceError(err)
}
ts, err := service.NewModelServiceV2[models.TaskStatV2]().GetById(t.Id)
if err != nil {
return nil, trace.TraceError(err)
}
settings, _, err := svc.GetSettingList(bson.M{
"enabled": true,
}, nil, nil)
if err != nil {
return nil, trace.TraceError(err)
}
for _, s := range settings {
switch s.TaskTrigger {
case constants.NotificationTriggerTaskFinish:
if t.Status != constants.TaskStatusPending && t.Status != constants.TaskStatusRunning {
_ = svc.Send(&s, e)
}
case constants.NotificationTriggerTaskError:
if t.Status == constants.TaskStatusError || t.Status == constants.TaskStatusAbnormal {
_ = svc.Send(&s, e)
}
case constants.NotificationTriggerTaskEmptyResults:
if t.Status != constants.TaskStatusPending && t.Status != constants.TaskStatusRunning {
if ts.ResultCount == 0 {
_ = svc.Send(&s, e)
}
}
case constants.NotificationTriggerTaskNever:
}
}
return nil, nil
}
func (svr TaskServerV2) handleInsertData(msg *grpc.StreamMessage) (err error) {
data, err := svr.deserialize(msg)
if err != nil {
return err
}
var records []interface{}
for _, d := range data.Records {
res, ok := d[constants.TaskKey]
if ok {
switch res.(type) {
case string:
id, err := primitive.ObjectIDFromHex(res.(string))
if err == nil {
d[constants.TaskKey] = id
}
}
}
records = append(records, d)
}
return svr.statsSvc.InsertData(data.TaskId, records...)
}
func (svr TaskServerV2) handleInsertLogs(msg *grpc.StreamMessage) (err error) {
data, err := svr.deserialize(msg)
if err != nil {
return err
}
return svr.statsSvc.InsertLogs(data.TaskId, data.Logs...)
}
func (svr TaskServerV2) getTaskQueueItemIdAndDequeue(query bson.M, opts *mongo.FindOptions, nid primitive.ObjectID) (tid primitive.ObjectID, err error) {
tq, err := service.NewModelServiceV2[models.TaskQueueItemV2]().GetOne(query, opts)
if err != nil {
if errors.Is(err, mongo2.ErrNoDocuments) {
return tid, nil
}
return tid, trace.TraceError(err)
}
t, err := service.NewModelServiceV2[models.TaskV2]().GetById(tq.Id)
if err == nil {
t.NodeId = nid
err = service.NewModelServiceV2[models.TaskV2]().ReplaceById(t.Id, *t)
if err != nil {
return tid, trace.TraceError(err)
}
}
err = service.NewModelServiceV2[models.TaskQueueItemV2]().DeleteById(tq.Id)
if err != nil {
return tid, trace.TraceError(err)
}
return tq.Id, nil
}
func (svr TaskServerV2) deserialize(msg *grpc.StreamMessage) (data entity.StreamMessageTaskData, err error) {
if err := json.Unmarshal(msg.Data, &data); err != nil {
return data, trace.TraceError(err)
}
if data.TaskId.IsZero() {
return data, errors.New("invalid task id")
}
return data, nil
}
func NewTaskServerV2() (res *TaskServerV2, err error) {
// task server
svr := &TaskServerV2{}
svr.cfgSvc = nodeconfig.GetNodeConfigService()
svr.statsSvc, err = stats.GetTaskStatsServiceV2()
if err != nil {
return nil, err
}
return svr, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/task_server_v2.go
|
Go
|
bsd-3-clause
| 6,504
|
package server
import (
"encoding/json"
"github.com/crawlab-team/crawlab/grpc"
"github.com/crawlab-team/crawlab/trace"
)
func HandleError(err error) (res *grpc.Response, err2 error) {
trace.PrintError(err)
return &grpc.Response{
Code: grpc.ResponseCode_ERROR,
Error: err.Error(),
}, err
}
func HandleSuccess() (res *grpc.Response, err error) {
return &grpc.Response{
Code: grpc.ResponseCode_OK,
Message: "success",
}, nil
}
func HandleSuccessWithData(data interface{}) (res *grpc.Response, err error) {
var bytes []byte
switch data.(type) {
case []byte:
bytes = data.([]byte)
default:
bytes, err = json.Marshal(data)
if err != nil {
return HandleError(err)
}
}
return &grpc.Response{
Code: grpc.ResponseCode_OK,
Message: "success",
Data: bytes,
}, nil
}
func HandleSuccessWithListData(data interface{}, total int) (res *grpc.Response, err error) {
bytes, err := json.Marshal(data)
if err != nil {
return HandleError(err)
}
return &grpc.Response{
Code: grpc.ResponseCode_OK,
Message: "success",
Data: bytes,
Total: int64(total),
}, nil
}
|
2302_79757062/crawlab
|
core/grpc/server/utils_handle.go
|
Go
|
bsd-3-clause
| 1,115
|
package test
import (
"github.com/crawlab-team/crawlab/core/entity"
"github.com/crawlab-team/crawlab/core/grpc/client"
"github.com/crawlab-team/crawlab/core/grpc/server"
"github.com/crawlab-team/crawlab/core/interfaces"
"github.com/crawlab-team/crawlab/core/node/test"
"testing"
"time"
)
type Test struct {
Server interfaces.GrpcServer
Client interfaces.GrpcClient
MasterNodeInfo *entity.NodeInfo
WorkerNodeInfo *entity.NodeInfo
}
func (t *Test) Setup(t2 *testing.T) {
test.T.Cleanup()
t2.Cleanup(t.Cleanup)
if !T.Client.IsStarted() {
_ = T.Client.Start()
} else if T.Client.IsClosed() {
_ = T.Client.Restart()
}
}
func (t *Test) Cleanup() {
_ = t.Client.Stop()
_ = t.Server.Stop()
test.T.Cleanup()
// wait to avoid caching
time.Sleep(200 * time.Millisecond)
}
var T *Test
func NewTest() (res *Test, err error) {
// test
t := &Test{}
// server
t.Server, err = server.NewServer(
server.WithConfigPath(test.T.MasterSvc.GetConfigPath()),
server.WithAddress(test.T.MasterSvc.GetAddress()),
)
if err != nil {
return nil, err
}
if err := t.Server.Start(); err != nil {
return nil, err
}
// client
t.Client, err = client.GetClient(test.T.WorkerSvc.GetConfigPath())
if err != nil {
return nil, err
}
// master node info
t.MasterNodeInfo = &entity.NodeInfo{
Key: "master",
IsMaster: true,
}
// worker node info
t.WorkerNodeInfo = &entity.NodeInfo{
Key: "worker",
IsMaster: false,
}
return t, nil
}
|
2302_79757062/crawlab
|
core/grpc/test/base.go
|
Go
|
bsd-3-clause
| 1,475
|
package i18n
import "github.com/crawlab-team/crawlab/core/interfaces"
var translations []interfaces.Translation
var _svc interfaces.I18nService
type Service struct {
}
func (svc *Service) AddTranslations(t []interfaces.Translation) {
translations = append(translations, t...)
}
func (svc *Service) GetTranslations() (t []interfaces.Translation) {
return translations
}
func GetI18nService(cfgPath string) (svc2 interfaces.I18nService, err error) {
if _svc != nil {
return _svc, nil
}
_svc, err = NewI18nService()
if err != nil {
return nil, err
}
return _svc, nil
}
func ProvideGetI18nService(cfgPath string) func() (svc interfaces.I18nService, err error) {
return func() (svc interfaces.I18nService, err error) {
return GetI18nService(cfgPath)
}
}
func NewI18nService() (svc2 interfaces.I18nService, err error) {
svc := &Service{}
return svc, nil
}
|
2302_79757062/crawlab
|
core/i18n/service.go
|
Go
|
bsd-3-clause
| 880
|
package interfaces
type Address interface {
Entity
String() string
IsEmpty() bool
}
|
2302_79757062/crawlab
|
core/interfaces/address.go
|
Go
|
bsd-3-clause
| 88
|
package interfaces
type Color interface {
Entity
GetHex() string
GetName() string
}
|
2302_79757062/crawlab
|
core/interfaces/color.go
|
Go
|
bsd-3-clause
| 88
|