Skip to content

A peer-to-peer stack for code collaboration

19.5 KB
Raw Blame
-- | The radicle daemon; a long-running background process which
-- materialises the state of remote IPFS machines on the user's PC, and
-- writes to those IPFS machines the user is an owner of.
--
-- See
-- <https://github.com/oscoin/radicle/blob/master/rfcs/0003-radicle-daemon.rst
-- the RFC>.
module Daemon (main) where

import           Protolude hiding
                 ( async
                 , catch
                 , fromStrict
                 , option
                 , poll
                 , tryJust
                 , wait
                 , waitEitherCatchCancel
                 )

import           Control.Exception.Safe hiding (Handler)
import qualified Data.Map.Strict as Map
import qualified Data.Text as T
import qualified Data.Time.Clock.System as Time
import           Network.Wai.Handler.Warp (run)
import           Network.Wai.Middleware.Cors (CorsResourcePolicy(..))
import qualified Network.Wai.Middleware.Cors as Cors
import           Servant
import           System.IO (BufferMode(..), hSetBuffering)
import           UnliftIO.Async

import qualified Radicle.Daemon.Cli as Cli
import           Radicle.Daemon.Error
import qualified Radicle.Daemon.HttpApi as Api
import           Radicle.Daemon.Ipfs
import           Radicle.Daemon.Logging
import           Radicle.Daemon.MachineConfig
import           Radicle.Daemon.MachineStore
import           Radicle.Daemon.Monad

import qualified Radicle.Ipfs as Ipfs

import           Radicle hiding (DaemonError, Env)
import qualified Radicle.Internal.ConcurrentMap as CMap
import qualified Radicle.Lang.Internal.UUID as UUID


-- | Repeatedly tries to connect to the Radicle IPFS daemon API until
-- succesfull. Times out after five seconds and throws 'IpfsDaemonNotReachable'.
waitForIpfsDaemon :: Daemon ()
waitForIpfsDaemon = do
    isOnline <- checkIpfsIsOnline
    if isOnline
    then pure ()
    else do
        logInfo "Waiting for Radicle IPFS daemon" []
        go 5
  where
    go :: Int -> Daemon ()
    go 0 = throw IpfsDaemonNotReachable
    go n = do
        isOnline <- checkIpfsIsOnline
        if isOnline
        then pure ()
        else do
            liftIO $ threadDelay (1000 * 1000)
            go (n - 1)

    checkIpfsIsOnline :: Daemon Bool
    checkIpfsIsOnline = do
        result <- tryJust isIpfsExceptionNoDaemon Ipfs.version
        pure $ case result of
            Left _  -> False
            Right _ -> True

    isIpfsExceptionNoDaemon :: Ipfs.IpfsException -> Maybe ()
    isIpfsExceptionNoDaemon Ipfs.IpfsExceptionNoDaemon = Just ()
    isIpfsExceptionNoDaemon _                          = Nothing

-- We use 'Void' to enforce the use of 'exitFailure'
main :: IO Void
main = do
    hSetBuffering stdout LineBuffering
    Cli.Opts{..} <- Cli.parse
    machineConfigFileLock <- newMVar ()
    machines <- CachedMachines <$> CMap.empty
    envIpfsClient <- Ipfs.newClient
    let env = Env{ logLevel = if debug then LogDebug else LogInfo, ..}
    machineConfig <- readMachineConfigIO machineConfigFileLock machineConfigFile
    initRes <- runDaemon env $ do
        waitForIpfsDaemon
        init machineConfig
    case initRes of
      Left err -> do
        logDaemonError err
        exitFailure
      Right _ -> do
        polling <- async $ initPolling env
        let app = corsWithContentType $ serve Api.daemonApi (server env)
        runDaemon env $ logInfo "Start listening" [("port", show port)]
        serv <- async $ run port app
        exc <- waitEitherCatchCancel polling serv
        case exc of
          Left (Left err) -> do
            logError' "Polling failed with an exception" [("error", toS (displayException err))]
            exitFailure
          Left (Right void') -> absurd void'
          Right (Left err) -> do
            logError' "Server failed with an exception" [("error", toS (displayException err))]
            exitFailure
          Right (Right ()) -> do
            logError' "Server stopped (this should not happen)" []
            exitFailure
  where
    -- | Allow Content-Type header with values other then allowed by simpleCors.
    corsWithContentType = Cors.cors (const $ Just policy)
      where
        policy = Cors.simpleCorsResourcePolicy
                   { corsRequestHeaders = ["Content-Type"] }

server :: Env -> Server Api.DaemonApi
server env = hoistServer Api.daemonApi nt daemonServer
  where
    daemonServer :: ServerT Api.DaemonApi Daemon
    daemonServer = newMachine :<|> query :<|> send :<|> frontend :<|> pure Api.swagger

    nt :: Daemon a -> Handler a
    nt d = do
      x_ <- liftIO $ runDaemon env d
      case x_ of
        Left err -> do
            logDaemonError err
            throwError (toServantErr err)
        Right x  -> pure x

    toServantErr err = errCode { errBody = toS bod }
      where
        (msg, infos) = displayError err
        bod = msg <> ":" <> T.concat ["\n  " <> k <> ": " <> v | (k,v) <- infos]
        errCode = case err of
          MachineError _ e -> case e of
            InvalidInput _ -> err400
            AckTimeout     -> err504
            _              -> err500
          _ -> err500

-- | Initiate machines according to follow file.
init :: MachinesConfig -> Daemon ()
init follows = pooledForConcurrentlyN_ 5 (Map.toList follows) initMachine
  where
    initMachine (id, ConfigReader) = do
        result <- tryError $ initAsReader id
        case result of
            Right m -> insertMachine m
            Left err  -> do
                let (msg, infos) = displayError err
                logError' "Could not initiate reader-mode machine on startup" $ ("init-error", msg) : infos
                insertUninitializedReader id
    initMachine (id, ConfigWriter idx) = do
        machineIpfs id $ ipnsPublish id idx
        m <- loadMachine Writer id
        insertMachine m
        actAsWriter m

    tryError f = (Right <$> f) `catch` (pure . Left)

-- * Endpoints

-- | Create a new IPFS machine and initialise the daemon as as the
-- /writer/.
newMachine :: Daemon Api.NewResponse
newMachine = do
    id <- wrapException CouldNotCreateMachine createMachine
    sub <- initDaemonSubscription id
    logInfo "Created new IPFS machine" [("machine-id", getMachineId id)]
    m <- emptyMachine id Writer sub
    insertMachine m
    actAsWriter m
    writeMachineConfig
    pure (Api.NewResponse id)

-- | Evaluate an expression against a cached machine. The resulting
-- state is always discarded, and the expression is never sent to the
-- writer. Only used for local queries.
--
-- Hitting this endpoint will turn on high-frequency polling for a
-- fixed amount of time.
query :: MachineId -> Api.QueryRequest -> Daemon Api.QueryResponse
query id (Api.QueryRequest v) = do
  m <- ensureMachineLoaded id
  bumpPolling id
  case fst <$> runIdentity $ runLang (machineState m) $ eval v of
    Left err -> throw $ MachineError id (InvalidInput err)
    Right rv -> do
      logInfo "Handled query" [("machine-id", getMachineId id)]
      pure (Api.QueryResponse rv)

-- | Write a new expression to an IPFS machine.
--
-- - If the daemon is the writer for the machine, it will write the
--   new inputs to IPFS and then send out a notification on the
--   machine's pubsub topic.
--
-- - If the daemon is a reader for the machine, it will request the
--   machine's writer daemon to perform the write, and wait for an
--   ack.
send :: MachineId -> Api.SendRequest -> Daemon Api.SendResponse
send id (Api.SendRequest expressions) = do
    Machine{machineMode, machineSubscription} <- ensureMachineLoaded id
    case machineMode of
        Reader -> requestInput machineSubscription
        Writer -> do
            results <- writeInputs "http" id expressions Nothing
            pure Api.SendResponse{..}
  where
    matchMessage nonce = \case
        (New InputsApplied{results, nonce = Just nonce'}) | nonce' == nonce -> Just results
        _ -> Nothing
    requestInput sub = do
      nonce <- liftIO $ UUID.uuid
      asyncMsg <- liftIO $ async $ subscribeOne sub ackWaitTime (matchMessage nonce)
      machineIpfs id $ publish id (Submit SubmitInputs{..})
      logInfo "Sent input request to writer"
              [ ("machine-id", getMachineId id)
              , ("expressions", valuesForLog expressions)
              , ("nonce", nonce)
              ]
      msg_ <- machineIpfs id $ wait asyncMsg
      case msg_ of
        Just results -> do
          logInfo "Writer accepted input request"
                  [ ("machine-id", getMachineId id)
                  , ("results", valuesForLog results)
                  , ("nonce", nonce)
                  ]
          bumpPolling id
          pure Api.SendResponse{..}
        Nothing -> throw $ MachineError id AckTimeout


-- | Give the HTML specified by a machine (via defining `(get-html)`).
frontend :: MachineId -> [Text] -> Daemon Api.HtmlText
frontend id path = do
    m <- ensureMachineLoaded id
    bumpPolling id
    case runIdentity $ interpret "[frontend]" "(get-html)" (machineState m) of
        Left err -> do
            logError "Frontend load failed" [("machine-id", getMachineId id)]
            throw $ MachineError id
                  $ FrontendError
                  $ "(get-html) failed: " <> renderCompactPretty err
        Right (String v) -> do
            logInfo "Handled frontend request" [("machine-id", getMachineId id)]
            case Ipfs.cidFromText v of
                Left _ -> do
                    logError "Frontend returned invalid CID" [("machine-id", getMachineId id)]
                    throw $ MachineError id
                          $ FrontendError "get-html returned invalid CID"
                Right v' -> do
                    let ipfsPath = show v' <> "/" <> T.intercalate "/" path
                    logInfo "Query HTML" [ ("CID", show v')
                                         , ("machine-id", getMachineId id)
                                         , ("ipfs-path", ipfsPath)
                                         ]
                    val <- Ipfs.ipfsHttpGet' "cat" [("arg", ipfsPath)]
                    pure $ Api.HtmlText $ toS val
        Right _ -> do
            logError "Frontend load failed" [("machine-id", getMachineId id)]
            throw $ MachineError id $ FrontendError "(get-html) did not evaluate to a string"

-- | Given an 'MachineId', makes sure the machine is loaded and
-- fetch the latest inputs.
--
-- If the machine is not yet loaded into memory we fetch its inputs, load it
-- into memory and start following its changes.
ensureMachineLoaded :: MachineId -> Daemon Machine
ensureMachineLoaded id = do
    (m, shouldWriteConfig) <- modifyMachine' id $ \case
        Nothing -> do
            m <- initAsReader id
            pure (Just (Cached m), (m, True))
        Just (UninitialisedReader _) -> do
            m <- initAsReader id
            pure (Just (Cached m), (m, False))
        Just (Cached m) -> do
            m' <- pullInputs m
            pure (Just (Cached m'), (m', False))
    -- Note: writing of the config-file should not happen in the above
    -- 'modifyMachine'' transaction.
    when shouldWriteConfig writeMachineConfig
    pure m

-- | Creates a IPFS pusbsub subscription for the given machine. This
-- wraps 'initSubscription' and logs all message parsing errors.
initDaemonSubscription :: MachineId -> Daemon TopicSubscription
initDaemonSubscription id =
    machineIpfs id $ initSubscription id logNonDecodableMsg
  where
    logNonDecodableMsg bad =
        logError' "Non-decodable message on machine's pubsub topic"
            [("machine-id", getMachineId id), ("message", bad)]

-- | Load a machine by pulling all data from IPFS
loadMachine :: ReaderOrWriter -> MachineId -> Daemon Machine
loadMachine mode id = do
  (idx, is) <- machineIpfs id $ machineInputsFrom id Nothing
  sub <- initDaemonSubscription id
  m <- emptyMachine id mode sub
  addInputs is idx m

-- | Runs some inputs over the state of a cached machine. Returns the new state
-- that would result, and the outputs. Throws an error if the inputs are
-- invalid.
runInputs :: Machine -> [Value] -> Daemon (Bindings (PrimFns Identity), [Value])
runInputs m inputs = do
  let (result, newState) = runIdentity $ runLang (machineState m) $ traverse eval inputs
  case result of
    Left err      -> throw $ MachineError (machineId m) (InvalidInput err)
    Right outputs -> pure (newState, outputs)

-- | Modify the state and index of a cached machine.
updateState :: Bindings (PrimFns Identity) -> MachineEntryIndex -> Machine -> Daemon Machine
updateState newState index m = do
  t <- liftIO $ Time.getSystemTime
  let m' = m { machineState = newState
             , machineLastIndex = index
             , machineLastUpdated = t
             }
  pure m'

-- | Add inputs to a machine and update to a new index. Checks that the new
-- inputs are valid.
addInputs :: [Value] -> MachineEntryIndex -> Machine -> Daemon Machine
addInputs is idx m = do
  (newState, _) <- runInputs m is
  updateState newState idx m

machineIpfs :: MachineId -> Daemon a -> Daemon a
machineIpfs id io = wrapException (MachineError id . IpfsError) io

-- | Do some high-freq polling for a while.
bumpPolling :: MachineId -> Daemon ()
bumpPolling id = do
  modifyMachine id $ \m -> pure (m { machinePolling = highFreq }, () )
  logDebug "Reset to high-frequency polling" [("machine-id", getMachineId id)]

-- ** Reader

-- | Load a machine in /reader mode/ and return it.
--
-- Loads the machines input log from IPFS and listens for machine
-- updates on pubsub.
initAsReader :: MachineId -> Daemon Machine
initAsReader id = do
    m <- loadMachine Reader id
    installMachineMessageHandler m onMsg
    logInfo "Following as reader" [ ("machine-id", getMachineId id)
                                  , ("current-input-index", show (machineLastIndex m)) ]
    pure m
  where
    onMsg :: Message -> Daemon ()
    onMsg = \case
      New InputsApplied{..} -> do
        pullStoreInputs id
        -- TODO(james): decide if this should bump polling. If this is
        -- a very active chain this will mean the polling is always
        -- high-frequency.
        bumpPolling id
      _ -> pure ()

-- | Updates the machine in the store by calling 'pullInputs'.
pullStoreInputs :: MachineId -> Daemon ()
pullStoreInputs id = modifyMachine id $ \m -> do
    m' <- pullInputs m
    pure (m', ())

-- | Fetch latest inputs from the network and apply them. Returns the
-- updated machine.
--
-- This is a no-op for machines we own.
pullInputs :: Machine -> Daemon Machine
pullInputs m =
    case machineMode m of
        Writer -> pure m
        Reader -> do
            let currentIdx = machineLastIndex m
            (newIdx, is) <- machineIpfs (machineId m) $ machineInputsFrom (machineId m) (Just currentIdx)
            if currentIdx == newIdx
            then pure m
            else do
                m' <- addInputs is newIdx m
                logDebug "Updated reader" [mid, ("n", show (length is)), ("input-index", show newIdx)]
                pure m'

  where
    mid = ("machine-id", getMachineId (machineId m))

-- ** Writer

-- | Subscribes the daemon to the machine's pubsub topic to listen for
-- input requests.
actAsWriter :: Machine -> Daemon ()
actAsWriter m = do
    installMachineMessageHandler m onMsg
    logInfo "Acting as writer" [("machine-id", getMachineId id)]
  where
    id = machineId m
    onMsg = \case
      Submit SubmitInputs{..} -> do
        logDebug "Writer received write-request"
                 [ ("machine-id", getMachineId id)
                 , ("nonce", nonce)
                 , ("expressions", valuesForLog expressions)
                 ]
        writeInputs "pubsub" id expressions (Just nonce) >> pure ()
      _ -> pure ()

-- | Installs a handler for messages sent on the machine's IPFS pubsub channel.
--
-- If the handler produces an error it is logged.
installMachineMessageHandler :: Machine -> (Message -> Daemon ()) -> Daemon ()
installMachineMessageHandler m handleMessage = do
    env <- ask
    void $ liftIO $ addHandler (machineSubscription m) $ \msg -> do
        result <- runDaemon env (handleMessage msg)
        case result of
            Left err -> logDaemonError err
            Right () -> pure ()

-- | Write and evaluate inputs in a machine we control.
--
-- Returns the outputs generated by evaluating the inputs.
--
-- Sends out a 'InputsApplied' message over pubsub that includes the
-- outputs and the given nonce.
--
-- @source@ is the source of the inputs (either HTTP or pubsub) and is
-- only used for logging.
writeInputs :: Text -> MachineId -> [Value] -> Maybe Text -> Daemon [Value]
writeInputs source id inputs nonce = do
    (rs, idx) <- modifyMachine id $ \machine -> do
        -- We check that the new inputs are valid before writing them to IPFS.
        (newState, results) <- runInputs machine inputs
        newIndex <- machineIpfs id $ writeIpfs id inputs
        machine' <- updateState newState newIndex machine
        machineIpfs id $ publish id (New InputsApplied{results, nonce})
        pure (machine', (results, machineLastIndex machine'))
    writeMachineConfig
    logInfo "Updated machine"
        [ ("machine-id", getMachineId id)
        , ("new-input-index", show idx)
        , ("source", source)
        ]
    pure rs

valuesForLog :: [Value] -> Text
valuesForLog = T.intercalate "," . (renderCompactPretty <$>)

-- * Polling

-- | Fetch and apply new inputs for all machines in reader mode.
pollMachines :: Daemon ()
pollMachines = traverseMachines pollMachine
  where
    pollMachine :: MachineId -> CachedMachine -> Daemon ()
    pollMachine _ = \case
      Cached m@Machine{ machineMode = Reader, .. } -> do
        delta <- liftIO $ sinceLastUpdate m
        let (shouldPoll, newPoll) =
              case machinePolling of
                HighFreq more ->
                  let more' = more - delta
                  in if more' > 0
                     then (True, HighFreq more')
                     else (False, LowFreq)
                -- Low frequency polling is every 10 seconds.
                LowFreq -> (delta > lowFreqPollPeriod, LowFreq)
        when shouldPoll $ pullStoreInputs machineId
        modifyMachine machineId $ \m' -> pure (m' { machinePolling = newPoll }, ())
      -- Don't update owned and unavailable machines.
      _ -> pure ()

-- | Returns the amount of time since the last time the machine was
-- updated.
sinceLastUpdate :: Machine -> IO Milliseconds
sinceLastUpdate = timeSince . machineLastUpdated

timeSince :: Time.SystemTime -> IO Milliseconds
timeSince x = timeDelta x <$> Time.getSystemTime
  where
    timeDelta a b =
        case (trunc a, trunc b) of
          (Time.MkSystemTime s n, Time.MkSystemTime s' n') -> 1000 * (s' - s) + fromIntegral (n' - n) `div` 1000000
      where
        trunc = Time.truncateSystemTimeLeapSecond

-- | Polling loop that looks for changes on all loaded reader machines
-- and updates them.
initPolling :: Env -> IO Void
initPolling env = do
  threadDelay (millisToMicros highFreqPollPeriod)
  res <- runDaemon env pollMachines
  -- If polling encounters an error it should log it but continue.
  -- Later we might detect some errors as critical and halt the
  -- daemon.
  case res of
    Left err -> logDaemonError err
    Right _  -> pure ()
  initPolling env

-- * Timings

type Milliseconds = Int64

millisToMicros :: Milliseconds -> Int
millisToMicros n = 1000 * fromIntegral n

-- | High-frequency polling happens once every half-second.
highFreqPollPeriod :: Milliseconds
highFreqPollPeriod = 500

-- | Low-frequency polling happens once every 10 seconds.
lowFreqPollPeriod :: Milliseconds
lowFreqPollPeriod = 10 * 1000

-- | The amount of time a reader will wait for a response message from
-- a writer: 20 seconds.
ackWaitTime :: Milliseconds
ackWaitTime = 20 * 1000

logDaemonError :: MonadIO m => Error -> m ()
logDaemonError (displayError -> (m, xs)) = logError' m xs