github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/infura/stream.go (about)

     1  package infura
     2  
     3  import (
     4  	"fmt"
     5  
     6  	"github.com/spf13/viper"
     7  
     8  	"github.com/fibonacci-chain/fbc/libs/tendermint/libs/log"
     9  	"github.com/fibonacci-chain/fbc/x/infura/distrlock"
    10  	"github.com/fibonacci-chain/fbc/x/infura/types"
    11  	"github.com/google/uuid"
    12  )
    13  
    14  const (
    15  	latestTaskKey         = "infura_latest_task"
    16  	distributeLock        = "infura_lock"
    17  	distributeLockTimeout = 300000
    18  	taskTimeout           = distributeLockTimeout * 0.98
    19  
    20  	FlagEnable         = "infura.enable"
    21  	FlagRedisUrl       = "infura.redis-url"
    22  	FlagRedisAuth      = "infura.redis-auth"
    23  	FlagRedisDB        = "infura.redis-db"
    24  	FlagMysqlUrl       = "infura.mysql-url"
    25  	FlagMysqlUser      = "infura.mysql-user"
    26  	FlagMysqlPass      = "infura.mysql-pass"
    27  	FlagMysqlDB        = "infura.mysql-db"
    28  	FlagCacheQueueSize = "infura.cache-queue-size"
    29  )
    30  
    31  // Stream maintains the infura engine
    32  type Stream struct {
    33  	enable     bool
    34  	logger     log.Logger
    35  	cfg        *types.Config
    36  	cache      *Cache
    37  	engine     types.IStreamEngine
    38  	scheduler  types.IDistributeStateService
    39  	cacheQueue *CacheQueue
    40  }
    41  
    42  func NewStream(logger log.Logger) *Stream {
    43  	logger.Info("entering NewStream")
    44  	se := &Stream{
    45  		enable: viper.GetBool(FlagEnable),
    46  		logger: logger,
    47  	}
    48  	if !se.enable {
    49  		return se
    50  	}
    51  	// initialize
    52  	se.cache = NewCache()
    53  	se.cfg = initConfig()
    54  	engine, err := newStreamEngine(se.cfg, logger)
    55  	if err != nil {
    56  		panic(fmt.Sprintf("ParseStreamEngineConfig failed: %+v", err))
    57  	}
    58  	se.engine = engine
    59  
    60  	scheduler, err := newRedisLockService(se.cfg.RedisUrl, se.cfg.RedisAuth, se.cfg.RedisDB, logger)
    61  	if err != nil {
    62  		errStr := fmt.Sprintf("parse redis scheduler failed error: %s, redis url: %s", err.Error(), se.cfg.RedisUrl)
    63  		logger.Error(errStr)
    64  		panic(errStr)
    65  	}
    66  	se.scheduler = scheduler
    67  
    68  	// start cache queue
    69  	if se.cfg.CacheQueueSize > 0 {
    70  		se.cacheQueue = newCacheQueue(se.cfg.CacheQueueSize)
    71  		go se.cacheQueue.Start()
    72  	}
    73  
    74  	se.logger.Info("NewStream success.")
    75  	return se
    76  }
    77  
    78  func initConfig() *types.Config {
    79  	return &types.Config{
    80  		RedisUrl:       viper.GetString(FlagRedisUrl),
    81  		RedisAuth:      viper.GetString(FlagRedisAuth),
    82  		RedisDB:        viper.GetInt(FlagRedisDB),
    83  		MysqlUrl:       viper.GetString(FlagMysqlUrl),
    84  		MysqlUser:      viper.GetString(FlagMysqlUser),
    85  		MysqlPass:      viper.GetString(FlagMysqlPass),
    86  		MysqlDB:        viper.GetString(FlagMysqlDB),
    87  		CacheQueueSize: viper.GetInt(FlagCacheQueueSize),
    88  	}
    89  }
    90  
    91  func newRedisLockService(redisURL string, redisPass string, db int, logger log.Logger) (types.IDistributeStateService, error) {
    92  	if redisURL == "" {
    93  		return nil, fmt.Errorf("no valid redisUrl found, no IDistributeStateService is created, redisUrl: %s", redisURL)
    94  	}
    95  	workerID := uuid.New().String()
    96  
    97  	scheduler, err := distrlock.NewRedisDistributeStateService(redisURL, redisPass, db, logger, workerID)
    98  	return scheduler, err
    99  }