Skip to content

A peer-to-peer stack for code collaboration

4.9 KB
Raw Blame
-- | Client for the daemons machine API.
--
-- Also provides primitive functions to bind the client into the Radicle
-- interpreter with @daemonClientPrimFns@.
module Radicle.Daemon.Client
    ( createDaemonClientPrimFns
    , newClient
    , newMachine
    , query
    , send
    , MachineId(..)
    , getMachineIndex
    ) where

import           Protolude hiding (TypeError)

import           Control.Monad.Except
import           GHC.Exts (fromList)
import qualified Network.HTTP.Client as HttpClient
import qualified Servant.Client as Servant
import           System.Environment

import           Radicle.Daemon.HttpApi
import qualified Radicle.Ipfs as Ipfs
import           Radicle.Lang.Core
import           Radicle.Lang.Identifier
import qualified Radicle.Lang.PrimFns as PrimFns
import           Radicle.Lang.Type

-- | Constraints for all client functions
type ClientM m = (MonadIO m, MonadError Servant.ServantError m)

data Client = Client
    { clientBaseUrl     :: Servant.BaseUrl
    , clientHttpManager :: HttpClient.Manager
    }

-- | Create a new client for the daemon API. Reads the base URL from the
-- @RAD_DAEMON_API_URL@ environment variable. If the variable is not set we use
-- @http://localhost:8909@
newClient :: IO Client
newClient = do
    baseUrlString <- fromMaybe "http://localhost:8909" <$> lookupEnv "RAD_DAEMON_API_URL"
    clientBaseUrl <- Servant.parseBaseUrl baseUrlString
    clientHttpManager <- Ipfs.newIpfsHttpClientManager
    pure Client {..}

-- | Send an input to a machine to be evaluated and applied. Returns the results
-- of evaluting the inputs.
send :: ClientM m => Client -> MachineId -> Seq Value -> m [Value]
send client machineId inputs = do
    SendResponse {..} <- runClient client $ Servant.client machineSendEndpoint machineId (SendRequest $ toList inputs)
    pure results

-- | Send an expression to a machine to be evaluated and return the result of
-- the evaluation. The state of the machine is not changed.
query :: (ClientM m) => Client -> MachineId -> Value -> m Value
query client machineId q = do
    QueryResponse {..} <- runClient client $ Servant.client machineQueryEndpoint machineId (QueryRequest q)
    pure result

-- | Create a new machine and return its ID.
newMachine :: (ClientM m) => Client -> m MachineId
newMachine client = do
    NewResponse {..} <- runClient client $ Servant.client newMachineEndpoint
    pure machineId


--- | Get the index page for a machine.
getMachineIndex :: (ClientM m) => Client -> MachineId -> m HtmlText
getMachineIndex client mid = runClient client $ Servant.client frontendEndpoint mid ["index.html"]

-- | Primitive function defitions for @daemon/send!@, @daemon/query!@, and
-- @daemon/new-machine!@.
createDaemonClientPrimFns ::(MonadIO m) => IO (PrimFns m)
createDaemonClientPrimFns = do
    client <- newClient
    pure $ fromList
        [ (unsafeToIdent sendName, Nothing, sendPrimFn client)
        , (unsafeToIdent queryName, Nothing, queryPrimFn client)
        , (unsafeToIdent newMachineName, Nothing, newMachinePrimFn client)
        ]
  where
    sendName = "daemon/send!"
    sendPrimFn httpManager =
        PrimFns.twoArg sendName $ \case
            (String id, Vec v) -> wrapServantError $ Vec . fromList <$> send httpManager (MachineId id) v
            (String _, v) -> throwErrorHere $ TypeError sendName 1 TVec v
            (v, _) -> throwErrorHere $ TypeError sendName 0 TString v

    queryName = "daemon/query!"
    queryPrimFn httpManager =
        PrimFns.twoArg queryName $ \case
            (String id, q) -> wrapServantError $ query httpManager (MachineId id) q
            (v, _)        -> throwErrorHere $ TypeError queryName 0 TString v

    newMachineName = "daemon/new-machine!"
    newMachinePrimFn httpManager =
        PrimFns.noArg newMachineName $ do
            MachineId id <- wrapServantError $ newMachine httpManager
            pure $ String id

-- * Internal

runClient :: forall a m. (ClientM m) => Client -> Servant.ClientM a -> m a
runClient Client {..} clientAction = do
    let clientEnv = Servant.mkClientEnv clientHttpManager clientBaseUrl
    result <- liftIO $ Servant.runClientM clientAction clientEnv
    liftEither result

-- | Rethrow Servant error as Radicle language error
--
-- If the Servant error is 'FailureResponse' we wrap the content of the reponse
-- body. Otherwise we use 'displayException'.
wrapServantError :: Monad m => ExceptT Servant.ServantError m a -> Lang m a
wrapServantError action = do
    result <- lift $ runExceptT action
    case result of
        Left (Servant.FailureResponse response) -> throwErrorHere $ DaemonError $ toS $ Servant.responseBody response
        Left e -> case e of
          Servant.ConnectionError ce -> throwErrorHere $ DaemonError $ startDaemonHint <> "\n\n" <> ce
          _ -> throwErrorHere $ DaemonError $ toS $ displayException e
        Right value -> pure value
  where
    startDaemonHint = "Could not connect to the Radicle daemon, most likely it is not running. Please see the documentation for how to start it."