Skip to content

A peer-to-peer stack for code collaboration

10.0 KB
Raw Blame
module Radicle.Daemon.Ipfs
  ( MachineId(..)
  , MonadMachineIpfs
  , Message(..)
  , InputsApplied(..)
  , SubmitInputs(..)
  , writeIpfs
  , publish
  , ipnsPublish
  , machineInputsFrom
  , createMachine
  , emptyMachineEntryIndex
  , MachineEntryIndex
  , TopicSubscription
  , initSubscription
  , subscribeOne
  , addHandler
  , valueToJson
  , jsonToValue
  ) where

import           Protolude hiding (async, bracket, catches)

import           Control.Exception.Safe
import           Control.Monad.Fail
import           Control.Monad.IO.Unlift
import           Data.Aeson (decodeStrict, (.:), (.=))
import qualified Data.Aeson as Aeson
import qualified Data.Aeson.Types as Aeson
import           Data.IPLD.CID
import qualified Data.Map.Strict as Map
import qualified Data.Unique as Unique
import           System.Timeout
import           UnliftIO.Async

import           Radicle.Daemon.Logging (MonadLog)
import qualified Radicle.Ipfs as Ipfs
import           Radicle.Lang.Core
import qualified Radicle.Lang.Internal.UUID as UUID
import           Radicle.Lang.Json
import           Radicle.Lang.Parse
import           Radicle.Lang.Pretty

-- * Types


class (MonadIO m, MonadThrow m, MonadUnliftIO m, MonadLog m, MonadMask m, Ipfs.MonadIpfs m) => MonadMachineIpfs m

newtype MachineId = MachineId { getMachineId :: Text }
    deriving (Show, Eq, Ord, Generic)

instance Aeson.ToJSONKey MachineId where
  toJSONKey = Aeson.toJSONKeyText getMachineId
instance Aeson.FromJSONKey MachineId where
  fromJSONKey = Aeson.FromJSONKeyText MachineId
instance Aeson.ToJSON MachineId where
  toJSON (MachineId id) = Aeson.String id
instance Aeson.FromJSON MachineId where
  parseJSON js = MachineId <$> Aeson.parseJSON js

-- | Messages sent on a machine's IPFS pubsub topic.
data Message = New InputsApplied | Submit SubmitInputs

instance Aeson.FromJSON Message where
  parseJSON = Aeson.withObject "Message" $ \o -> do
    typ :: Text <- o .: "type"
    case typ of
      "new_inputs" -> do
        nonce <- o .: "nonce"
        results <- traverse jsonToValue =<< o .: "results"
        pure $ New InputsApplied{..}
      "request_inputs" -> do
        nonce <- o .: "nonce"
        expressions <- traverse jsonToValue =<< o .: "expressions"
        pure $ Submit SubmitInputs{..}
      _ -> fail "Messages on a machine's pubsub topic must be of type 'new_inputs' or 'request_inputs'."

instance Aeson.ToJSON Message where
  toJSON = \case
    New InputsApplied{..} -> Aeson.object
      [ "type" .= ("new_inputs" :: Text)
      , "nonce" .= nonce
      , "results" .= (valueToJson <$> results)
      ]
    Submit SubmitInputs{..} -> Aeson.object
      [ "type" .= ("request_inputs" :: Text)
      , "nonce" .= nonce
      , "expressions" .= (valueToJson <$> expressions)
      ]

-- | Message sent to signal a new input has been added to the machine.
data InputsApplied = InputsApplied
  { nonce   :: Maybe Text
  , results :: [Value]
  }

-- | Message sent to request the writer add inputs to the machine.
data SubmitInputs = SubmitInputs
  { nonce       :: Text
  , expressions :: [Value]
  }


-- | A node in the linked list of inputs of a machine.
--
-- Stored as an IPLD document with the IPFS DAG API. The document has
-- the following shape
-- @
--      {
--        "expressions": [
--          "(def foo :hey)",
--          "(get-value)"
--        ],
--        "previous": { "/": "QmA..." }
--      }
-- @
data MachineEntry = MachineEntry
    { entryExpressions :: [Value]
    , entryPrevious    :: CID
    } deriving (Eq, Show, Read, Generic)

instance Aeson.FromJSON MachineEntry where
    parseJSON = Aeson.withObject "MachineEntry" $ \o -> do
        expressionCodes <- o .: "expressions"
        let src = "[ipfs]"
        entryExpressions :: [Value] <-
            case traverse (parse src) expressionCodes of
                Left err  -> fail $ "failed to parse Radicle expression: " <> show err
                Right v -> pure v
        entryPrevious <- Ipfs.parseIpldLink =<< o .: "previous"
        pure MachineEntry {..}

instance Aeson.ToJSON MachineEntry where
    toJSON MachineEntry{..} =
        let code = map renderCompactPretty entryExpressions
        in Aeson.object
            [ "expressions" .= code
            , "previous" .= Ipfs.ipldLink entryPrevious
            ]

-- | Identifies a 'MachineEntry' stored on IPFS. Wraps 'CID'.
newtype MachineEntryIndex = MachineEntryIndex CID
    deriving (Show, Eq)

instance Aeson.ToJSON MachineEntryIndex where
  toJSON (MachineEntryIndex cid) = Ipfs.ipldLink cid

instance Aeson.FromJSON MachineEntryIndex where
  parseJSON = fmap MachineEntryIndex . Ipfs.parseIpldLink


-- * Ipfs helpers

-- | Write and pin some inputs to an IPFS machine.
-- TODO: we might want to make this safer by taking the expected head
-- MachineEntryIndex as an argument.
writeIpfs :: (MonadMachineIpfs m) => MachineId -> [Value] -> m MachineEntryIndex
writeIpfs (MachineId ipnsId) values = do
    Ipfs.NameResolveResponse cid <- Ipfs.nameResolve ipnsId
    Ipfs.DagPutResponse newEntryCid <- Ipfs.dagPut $ MachineEntry values cid
    Ipfs.namePublish ipnsId $ Ipfs.AddressIpfs newEntryCid
    pure $ MachineEntryIndex newEntryCid

newtype Topic = Topic { getTopic :: Text }

-- | The IPFS pubsub topic associated to a machine.
machineTopic :: MachineId -> Topic
machineTopic (MachineId id) = Topic ("radicle:machine:" <> id)

-- | Publish a 'Message' on a machine's IPFS pubsub topic.
publish :: (MonadMachineIpfs m) => MachineId -> Message -> m ()
publish id msg = Ipfs.publish (getTopic (machineTopic id)) (Aeson.encode msg)

-- | Subscribe to messages on a machine's IPFS pubsub topic.
subscribeForever :: (MonadMachineIpfs m) => MachineId -> (Either Text Message -> IO ()) -> m ()
subscribeForever id messageHandler = Ipfs.subscribe topic pubsubHandler
  where
    Topic topic = machineTopic id
    pubsubHandler Ipfs.PubsubMessage{..} = messageHandler $ case decodeStrict messageData of
      Just msg -> Right msg
      Nothing  -> Left (toS messageData)

-- | Get inputs of an IPFS machine from least to most recent.
--
-- The returned 'Ipfs.MachineEntryIndex' is the index of the most
-- recent input.
--
-- If @maybeFrom@ is @Just index@ all inputs after (but not
-- including) @index@ are returned. Otherwise all inputs are returned.
machineInputsFrom
    :: forall m. (MonadMachineIpfs m)
    => MachineId -> Maybe MachineEntryIndex -> m (MachineEntryIndex, [Value])
machineInputsFrom (MachineId ipnsId) maybeFrom = do
    let MachineEntryIndex fromCid = fromMaybe (MachineEntryIndex emptyMachineCid) maybeFrom
    Ipfs.NameResolveResponse cid <- Ipfs.nameResolve ipnsId
    blocks <- getBlocks cid fromCid
    pure $ (MachineEntryIndex cid, blocks)
  where
    getBlocks :: CID -> CID -> m [Value]
    getBlocks cid fromCid = do
        if cid == fromCid || cid == emptyMachineCid
        then pure []
        else do
            let addr = Ipfs.AddressIpfs cid
            entry <- Ipfs.dagGet addr
            _ <- Ipfs.pinAdd addr
            rest <- getBlocks (entryPrevious entry) fromCid
            pure $ rest <> entryExpressions entry


-- | If a machine points to this ID then its log is considered empty.
-- The first entry in a machine log also points to this entry.
--
-- This is the CID produced by the document @{"radicle": true}@.
emptyMachineCid :: CID
emptyMachineCid =
    case cidFromText "zdpuAyyGtvC37aeZid2zh7LAGKCbFTn9MzdqoPpbNQm3BCwWT" of
        Left e    -> panic $ toS e
        Right cid -> cid


-- | Create an IPFS machine and return its ID.
--
-- Generates a new IPNS key and sets the IPNS record to the empty
-- machine DAG node.
createMachine :: (MonadMachineIpfs m) => m MachineId
createMachine = do
    uuid <- liftIO UUID.uuid
    Ipfs.KeyGenResponse ipnsId <- Ipfs.keyGen uuid
    Ipfs.namePublish ipnsId $ Ipfs.AddressIpfs emptyMachineCid
    pure $ MachineId ipnsId

-- | Publish to IPNS a machine entry index for a machine. Should only be issued
-- by the writer.
ipnsPublish :: (MonadMachineIpfs m) => MachineId -> MachineEntryIndex -> m ()
ipnsPublish id (MachineEntryIndex cid) = Ipfs.namePublish (getMachineId id) $ Ipfs.AddressIpfs cid

-- * Topic subscriptions

type MsgHandler = Message -> IO ()

type RegisteredHandler = Unique.Unique

newtype TopicSubscription = TopicSubscription
  { handlers :: MVar (Map RegisteredHandler MsgHandler)
  }

-- | Given a machine ID, creates a subscription for that machine's
-- pubsub topic. This allows adding and removing handlers for messages
-- on that topic.
--
-- @logParseError@ is called with the raw message content if a message
-- cannot be parsed.
initSubscription :: (MonadMachineIpfs m) => MachineId -> (Text -> IO ()) -> m TopicSubscription
initSubscription id logParseError = do
    hdlrs <- liftIO $ newMVar Map.empty
    _ <- async $ subscribeForever id (mainHdlr hdlrs)
    pure $ TopicSubscription hdlrs
  where
    mainHdlr hdlrs = \case
        Left rawMessage -> logParseError rawMessage
        Right msg -> do
          hs <- readMVar hdlrs
          traverse_ ($ msg) (Map.elems hs)

-- | Add a message handler to a topic subscription.
addHandler :: TopicSubscription -> MsgHandler -> IO RegisteredHandler
addHandler ts h = do
  u <- Unique.newUnique
  modifyMVar (handlers ts) (pure . (,()) . Map.insert u h)
  pure u

-- | Remove a message handler from a topic subscription.
removeHandler :: TopicSubscription -> RegisteredHandler -> IO ()
removeHandler ts u =
  modifyMVar (handlers ts) (pure . (,()) . Map.delete u)

-- | Block while waiting for a matching message.
-- If no matching message arrives within the given timeout (in
-- milliseconds) then @Nothing@ is returned.
subscribeOne :: TopicSubscription -> Int64 -> (Message -> Maybe a) -> IO (Maybe a)
subscribeOne subscription t matchMessage = do
    timeout (fromIntegral t * 1000) $ do
        msgVar <- newEmptyMVar
        let onMsg msg = case matchMessage msg of
                            Just a  -> putMVar msgVar a
                            Nothing -> pure ()
        bracket
            (addHandler subscription onMsg)
            (removeHandler subscription)
            (\_ -> readMVar msgVar)

emptyMachineEntryIndex :: MachineEntryIndex
emptyMachineEntryIndex = MachineEntryIndex emptyMachineCid