Junction driver WIP

robocom-zero.cabal

@@ -27,6 +27,8 @@ library
                      , ATrade.Quotes.QTIS
                      , ATrade.Driver.Real
                      , ATrade.Driver.Backtest
+                     , ATrade.Driver.Junction
+                     , ATrade.Driver.Junction.Types
                      , ATrade.BarAggregator
                      , ATrade.RoboCom
   other-modules:       Paths_robocom_zero

src/ATrade/Driver/Junction.hs

@@ -0,0 +1,58 @@
+
+module ATrade.Driver.Junction
+  (
+    junctionMain
+  ) where
+
+import           ATrade.Driver.Junction.Types (StrategyDescriptor (..),
+                                               StrategyInstance (..),
+                                               StrategyInstanceDescriptor (..))
+import           Data.Aeson                   (decode)
+import qualified Data.ByteString              as B
+import qualified Data.ByteString.Lazy         as BL
+import           Data.IORef
+import qualified Data.Map.Strict              as M
+import qualified Data.Text                    as T
+
+load :: T.Text -> IO B.ByteString
+load = undefined
+
+junctionMain :: M.Map T.Text StrategyDescriptor -> IO ()
+junctionMain descriptors = do
+  parseOptions
+  instanceDescriptors <- undefined
+  strategies <- mkStrategies instanceDescriptors
+
+  start strategies
+
+  where
+    parseOptions = undefined
+
+    mkStrategies :: [StrategyInstanceDescriptor] -> IO [StrategyInstance]
+    mkStrategies = mapM mkStrategy
+
+    mkStrategy :: StrategyInstanceDescriptor -> IO StrategyInstance
+    mkStrategy desc = do
+      sState <- load (stateKey desc)
+      sCfg <- load (configKey desc)
+      case M.lookup (strategyId desc) descriptors of
+        Just (StrategyDescriptor _sName sCallback _sDefState) ->
+          case (decode $ BL.fromStrict sCfg, decode $ BL.fromStrict sState) of
+            (Just pCfg, Just pState) -> do
+              cfgRef <- newIORef pCfg
+              stateRef <- newIORef pState
+              return $ StrategyInstance
+                {
+                  strategyInstanceId = strategyName desc,
+                  strategyEventCallback  = sCallback,
+                  strategyState = stateRef,
+                  strategyConfig = cfgRef
+                }
+            _ -> undefined
+        _ -> undefined
+
+    start = undefined
+
+
+
+

src/ATrade/Driver/Junction/Types.hs

@@ -0,0 +1,54 @@
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE RankNTypes                #-}
+
+module ATrade.Driver.Junction.Types
+  (
+    StrategyDescriptor(..),
+    TickerConfig(..),
+    StrategyInstanceDescriptor(..),
+    StrategyInstance(..)
+  ) where
+
+import           ATrade.RoboCom.Monad (EventCallback)
+import           ATrade.Types         (BarTimeframe, TickerId)
+import           Data.Aeson           (FromJSON (..), ToJSON (..))
+import qualified Data.ByteString      as B
+import           Data.IORef
+import qualified Data.Text            as T
+
+data StrategyDescriptor =
+  forall c s. (FromJSON s, ToJSON s, FromJSON c) =>
+    StrategyDescriptor
+    {
+      baseStrategyName :: T.Text,
+      eventCallback    :: EventCallback c s,
+      defaultState     :: s
+    }
+
+data TickerConfig =
+  TickerConfig
+  {
+    tickerId  :: TickerId,
+    timeframe :: BarTimeframe
+  }
+
+data StrategyInstanceDescriptor =
+  StrategyInstanceDescriptor
+  {
+    strategyId   :: T.Text,
+    strategyName :: T.Text,
+    configKey    :: T.Text,
+    stateKey     :: T.Text,
+    logPath      :: T.Text,
+    tickers      :: [TickerConfig]
+  }
+
+data StrategyInstance =
+  forall c s. (FromJSON s, ToJSON s, FromJSON c) =>
+    StrategyInstance
+    {
+      strategyInstanceId    :: T.Text,
+      strategyEventCallback :: EventCallback c s,
+      strategyState         :: IORef s,
+      strategyConfig        :: IORef c
+    }