-- |
-- A Haskell Extism host
--
-- Requires a libextism installation, see [https://extism.org/docs/install](https://extism.org/docs/install)
module Extism
  ( module Extism.Manifest,
    module Extism.Encoding,
    Function (..),
    Plugin (..),
    CancelHandle (..),
    LogLevel (..),
    Error (..),
    Result (..),
    extismVersion,
    newPlugin,
    newCompiledPlugin,
    newPluginFromCompiled,
    isValid,
    setConfig,
    setLogFile,
    functionExists,
    call,
    call',
    callWithHostContext,
    callWithHostContext',
    cancelHandle,
    cancel,
    pluginID,
    unwrap,
    ToBytes (..),
    FromBytes (..),
    JSON (..),
    PluginInput (..),
    reset,
  )
where

import qualified Data.ByteString as B
import Data.ByteString.Internal (c2w, unsafePackLenAddress, w2c)
import qualified Data.ByteString.Lazy as BL
import Data.ByteString.Unsafe (unsafeUseAsCString)
import Data.Int
import qualified Data.UUID (UUID, fromByteString, toString)
import Data.Word
import Extism.Bindings
import Extism.Encoding
import Extism.JSON
import Extism.Manifest (Manifest)
import Foreign.C.String
import Foreign.Concurrent
import Foreign.ForeignPtr
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Ptr
import Foreign.StablePtr
import Foreign.Storable
import GHC.Ptr
import qualified Text.JSON (JSValue (JSNull, JSString), Result (..), decode, encode, toJSObject, toJSString)

-- | Host function, see 'Extism.HostFunction.hostFunction'
data Function = Function (ForeignPtr ExtismFunction) (StablePtr ()) deriving (Function -> Function -> Bool
(Function -> Function -> Bool)
-> (Function -> Function -> Bool) -> Eq Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Function -> Function -> Bool
== :: Function -> Function -> Bool
$c/= :: Function -> Function -> Bool
/= :: Function -> Function -> Bool
Eq)

-- | Plugins can be used to call WASM function
newtype Plugin = Plugin (ForeignPtr ExtismPlugin) deriving (Plugin -> Plugin -> Bool
(Plugin -> Plugin -> Bool)
-> (Plugin -> Plugin -> Bool) -> Eq Plugin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Plugin -> Plugin -> Bool
== :: Plugin -> Plugin -> Bool
$c/= :: Plugin -> Plugin -> Bool
/= :: Plugin -> Plugin -> Bool
Eq, Int -> Plugin -> ShowS
[Plugin] -> ShowS
Plugin -> String
(Int -> Plugin -> ShowS)
-> (Plugin -> String) -> ([Plugin] -> ShowS) -> Show Plugin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Plugin -> ShowS
showsPrec :: Int -> Plugin -> ShowS
$cshow :: Plugin -> String
show :: Plugin -> String
$cshowList :: [Plugin] -> ShowS
showList :: [Plugin] -> ShowS
Show)

-- | CompiledPlugins can be used to create multiple plugin instances from a single pre-compiled plugin
newtype CompiledPlugin = CompiledPlugin (ForeignPtr ExtismCompiledPlugin) deriving (CompiledPlugin -> CompiledPlugin -> Bool
(CompiledPlugin -> CompiledPlugin -> Bool)
-> (CompiledPlugin -> CompiledPlugin -> Bool) -> Eq CompiledPlugin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompiledPlugin -> CompiledPlugin -> Bool
== :: CompiledPlugin -> CompiledPlugin -> Bool
$c/= :: CompiledPlugin -> CompiledPlugin -> Bool
/= :: CompiledPlugin -> CompiledPlugin -> Bool
Eq, Int -> CompiledPlugin -> ShowS
[CompiledPlugin] -> ShowS
CompiledPlugin -> String
(Int -> CompiledPlugin -> ShowS)
-> (CompiledPlugin -> String)
-> ([CompiledPlugin] -> ShowS)
-> Show CompiledPlugin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompiledPlugin -> ShowS
showsPrec :: Int -> CompiledPlugin -> ShowS
$cshow :: CompiledPlugin -> String
show :: CompiledPlugin -> String
$cshowList :: [CompiledPlugin] -> ShowS
showList :: [CompiledPlugin] -> ShowS
Show)

-- | Cancellation handle for Plugins
newtype CancelHandle = CancelHandle (Ptr ExtismCancelHandle) deriving (CancelHandle -> CancelHandle -> Bool
(CancelHandle -> CancelHandle -> Bool)
-> (CancelHandle -> CancelHandle -> Bool) -> Eq CancelHandle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CancelHandle -> CancelHandle -> Bool
== :: CancelHandle -> CancelHandle -> Bool
$c/= :: CancelHandle -> CancelHandle -> Bool
/= :: CancelHandle -> CancelHandle -> Bool
Eq, Int -> CancelHandle -> ShowS
[CancelHandle] -> ShowS
CancelHandle -> String
(Int -> CancelHandle -> ShowS)
-> (CancelHandle -> String)
-> ([CancelHandle] -> ShowS)
-> Show CancelHandle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CancelHandle -> ShowS
showsPrec :: Int -> CancelHandle -> ShowS
$cshow :: CancelHandle -> String
show :: CancelHandle -> String
$cshowList :: [CancelHandle] -> ShowS
showList :: [CancelHandle] -> ShowS
Show)

-- | Log level
data LogLevel = LogError | LogWarn | LogInfo | LogDebug | LogTrace deriving (Int -> LogLevel -> ShowS
[LogLevel] -> ShowS
LogLevel -> String
(Int -> LogLevel -> ShowS)
-> (LogLevel -> String) -> ([LogLevel] -> ShowS) -> Show LogLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LogLevel -> ShowS
showsPrec :: Int -> LogLevel -> ShowS
$cshow :: LogLevel -> String
show :: LogLevel -> String
$cshowList :: [LogLevel] -> ShowS
showList :: [LogLevel] -> ShowS
Show, LogLevel -> LogLevel -> Bool
(LogLevel -> LogLevel -> Bool)
-> (LogLevel -> LogLevel -> Bool) -> Eq LogLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LogLevel -> LogLevel -> Bool
== :: LogLevel -> LogLevel -> Bool
$c/= :: LogLevel -> LogLevel -> Bool
/= :: LogLevel -> LogLevel -> Bool
Eq)

-- | Get the Extism version string
extismVersion :: () -> IO String
extismVersion :: () -> IO String
extismVersion () = do
  v <- IO CString
extism_version
  peekCString v

-- | Defines types that can be used to pass Wasm data into a plugin
class PluginInput a where
  pluginInput :: a -> B.ByteString

instance PluginInput B.ByteString where
  pluginInput :: ByteString -> ByteString
pluginInput = ByteString -> ByteString
forall a. a -> a
id

instance PluginInput Manifest where
  pluginInput :: Manifest -> ByteString
pluginInput Manifest
m = String -> ByteString
toByteString (String -> ByteString) -> String -> ByteString
forall a b. (a -> b) -> a -> b
$ Manifest -> String
forall a. JSON a => a -> String
Text.JSON.encode Manifest
m

-- | Create a 'Plugin' from a WASM module, `useWasi` determines if WASI should
-- | be linked
newPlugin :: (PluginInput a) => a -> [Function] -> Bool -> IO (Result Plugin)
newPlugin :: forall a.
PluginInput a =>
a -> [Function] -> Bool -> IO (Result Plugin)
newPlugin a
input [Function]
functions Bool
useWasi = do
  funcs <- (Function -> IO (Ptr ExtismFunction))
-> [Function] -> IO [Ptr ExtismFunction]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\(Function ForeignPtr ExtismFunction
ptr StablePtr ()
_) -> ForeignPtr ExtismFunction
-> (Ptr ExtismFunction -> IO (Ptr ExtismFunction))
-> IO (Ptr ExtismFunction)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismFunction
ptr Ptr ExtismFunction -> IO (Ptr ExtismFunction)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return) [Function]
functions
  alloca $ \Ptr CString
e -> do
    let errmsg :: Ptr CString
errmsg = (Ptr CString
e :: Ptr CString)
    p <- ByteString
-> (CString -> IO (Ptr ExtismPlugin)) -> IO (Ptr ExtismPlugin)
forall a. ByteString -> (CString -> IO a) -> IO a
unsafeUseAsCString ByteString
wasm ((CString -> IO (Ptr ExtismPlugin)) -> IO (Ptr ExtismPlugin))
-> (CString -> IO (Ptr ExtismPlugin)) -> IO (Ptr ExtismPlugin)
forall a b. (a -> b) -> a -> b
$ \CString
s ->
      [Ptr ExtismFunction]
-> (Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismPlugin))
-> IO (Ptr ExtismPlugin)
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [Ptr ExtismFunction]
funcs ((Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismPlugin))
 -> IO (Ptr ExtismPlugin))
-> (Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismPlugin))
-> IO (Ptr ExtismPlugin)
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ExtismFunction)
funcs ->
        Ptr Word8
-> Word64
-> Ptr (Ptr ExtismFunction)
-> Word64
-> CBool
-> Ptr CString
-> IO (Ptr ExtismPlugin)
extism_plugin_new (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
s) Word64
length' Ptr (Ptr ExtismFunction)
funcs Word64
nfunctions CBool
wasi Ptr CString
errmsg

    if p == nullPtr
      then do
        err <- peek errmsg
        e <- peekCString err
        extism_plugin_new_error_free err
        return $ Left (ExtismError e)
      else do
        ptr <- Foreign.Concurrent.newForeignPtr p (extism_plugin_free p)
        return $ Right (Plugin ptr)
  where
    wasm :: ByteString
wasm = a -> ByteString
forall a. PluginInput a => a -> ByteString
pluginInput a
input
    nfunctions :: Word64
nfunctions = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Function] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Function]
functions)
    length' :: Word64
length' = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
wasm)
    wasi :: CBool
wasi = Integer -> CBool
forall a. Num a => Integer -> a
fromInteger (if Bool
useWasi then Integer
1 else Integer
0)

-- | Create a 'Plugin' from a WASM module, `useWasi` determines if WASI should
-- | be linked
newCompiledPlugin :: (PluginInput a) => a -> [Function] -> Bool -> IO (Result CompiledPlugin)
newCompiledPlugin :: forall a.
PluginInput a =>
a -> [Function] -> Bool -> IO (Result CompiledPlugin)
newCompiledPlugin a
input [Function]
functions Bool
useWasi = do
  funcs <- (Function -> IO (Ptr ExtismFunction))
-> [Function] -> IO [Ptr ExtismFunction]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\(Function ForeignPtr ExtismFunction
ptr StablePtr ()
_) -> ForeignPtr ExtismFunction
-> (Ptr ExtismFunction -> IO (Ptr ExtismFunction))
-> IO (Ptr ExtismFunction)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismFunction
ptr Ptr ExtismFunction -> IO (Ptr ExtismFunction)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return) [Function]
functions
  alloca $ \Ptr CString
e -> do
    let errmsg :: Ptr CString
errmsg = (Ptr CString
e :: Ptr CString)
    p <- ByteString
-> (CString -> IO (Ptr ExtismCompiledPlugin))
-> IO (Ptr ExtismCompiledPlugin)
forall a. ByteString -> (CString -> IO a) -> IO a
unsafeUseAsCString ByteString
wasm ((CString -> IO (Ptr ExtismCompiledPlugin))
 -> IO (Ptr ExtismCompiledPlugin))
-> (CString -> IO (Ptr ExtismCompiledPlugin))
-> IO (Ptr ExtismCompiledPlugin)
forall a b. (a -> b) -> a -> b
$ \CString
s ->
      [Ptr ExtismFunction]
-> (Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismCompiledPlugin))
-> IO (Ptr ExtismCompiledPlugin)
forall a b. Storable a => [a] -> (Ptr a -> IO b) -> IO b
withArray [Ptr ExtismFunction]
funcs ((Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismCompiledPlugin))
 -> IO (Ptr ExtismCompiledPlugin))
-> (Ptr (Ptr ExtismFunction) -> IO (Ptr ExtismCompiledPlugin))
-> IO (Ptr ExtismCompiledPlugin)
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr ExtismFunction)
funcs ->
        Ptr Word8
-> Word64
-> Ptr (Ptr ExtismFunction)
-> Word64
-> CBool
-> Ptr CString
-> IO (Ptr ExtismCompiledPlugin)
extism_compiled_plugin_new (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
s) Word64
length' Ptr (Ptr ExtismFunction)
funcs Word64
nfunctions CBool
wasi Ptr CString
errmsg

    if p == nullPtr
      then do
        err <- peek errmsg
        e <- peekCString err
        extism_plugin_new_error_free err
        return $ Left (ExtismError e)
      else do
        ptr <- Foreign.Concurrent.newForeignPtr p (extism_compiled_plugin_free p)
        return $ Right (CompiledPlugin ptr)
  where
    wasm :: ByteString
wasm = a -> ByteString
forall a. PluginInput a => a -> ByteString
pluginInput a
input
    nfunctions :: Word64
nfunctions = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Function] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Function]
functions)
    length' :: Word64
length' = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
wasm)
    wasi :: CBool
wasi = Integer -> CBool
forall a. Num a => Integer -> a
fromInteger (if Bool
useWasi then Integer
1 else Integer
0)

-- | Create a new plugin from a `CompiledPlugin`
newPluginFromCompiled :: CompiledPlugin -> IO (Result Plugin)
newPluginFromCompiled :: CompiledPlugin -> IO (Result Plugin)
newPluginFromCompiled (CompiledPlugin ForeignPtr ExtismCompiledPlugin
compiled) = do
  (Ptr CString -> IO (Result Plugin)) -> IO (Result Plugin)
forall a b. Storable a => (Ptr a -> IO b) -> IO b
alloca ((Ptr CString -> IO (Result Plugin)) -> IO (Result Plugin))
-> (Ptr CString -> IO (Result Plugin)) -> IO (Result Plugin)
forall a b. (a -> b) -> a -> b
$ \Ptr CString
e -> do
    let errmsg :: Ptr CString
errmsg = (Ptr CString
e :: Ptr CString)
    p <- ForeignPtr ExtismCompiledPlugin
-> (Ptr ExtismCompiledPlugin -> IO (Ptr ExtismPlugin))
-> IO (Ptr ExtismPlugin)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismCompiledPlugin
compiled ((Ptr ExtismCompiledPlugin -> IO (Ptr ExtismPlugin))
 -> IO (Ptr ExtismPlugin))
-> (Ptr ExtismCompiledPlugin -> IO (Ptr ExtismPlugin))
-> IO (Ptr ExtismPlugin)
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismCompiledPlugin
c ->
      Ptr ExtismCompiledPlugin -> Ptr CString -> IO (Ptr ExtismPlugin)
extism_plugin_new_from_compiled Ptr ExtismCompiledPlugin
c Ptr CString
errmsg
    if p == nullPtr
      then do
        err <- peek errmsg
        e <- peekCString err
        extism_plugin_new_error_free err
        return $ Left (ExtismError e)
      else do
        ptr <- Foreign.Concurrent.newForeignPtr p (extism_plugin_free p)
        return $ Right (Plugin ptr)

-- | Same as `newPlugin` but converts the error case to an exception
newPlugin' :: (PluginInput a) => a -> [Function] -> Bool -> IO Plugin
newPlugin' :: forall a. PluginInput a => a -> [Function] -> Bool -> IO Plugin
newPlugin' a
input [Function]
functions Bool
useWasi = do
  Result Plugin -> Plugin
forall {b}. Either Error b -> b
unwrap (Result Plugin -> Plugin) -> IO (Result Plugin) -> IO Plugin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [Function] -> Bool -> IO (Result Plugin)
forall a.
PluginInput a =>
a -> [Function] -> Bool -> IO (Result Plugin)
newPlugin a
input [Function]
functions Bool
useWasi

-- | Same as `newPluginFromCompiled` but converts the error case to an exception
newPluginFromCompiled' :: CompiledPlugin -> IO Plugin
newPluginFromCompiled' :: CompiledPlugin -> IO Plugin
newPluginFromCompiled' CompiledPlugin
c =
  Result Plugin -> Plugin
forall {b}. Either Error b -> b
unwrap (Result Plugin -> Plugin) -> IO (Result Plugin) -> IO Plugin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CompiledPlugin -> IO (Result Plugin)
newPluginFromCompiled CompiledPlugin
c

-- | Check if a 'Plugin' is valid
isValid :: Plugin -> IO Bool
isValid :: Plugin -> IO Bool
isValid (Plugin ForeignPtr ExtismPlugin
p) = ForeignPtr ExtismPlugin -> (Ptr ExtismPlugin -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
p (\Ptr ExtismPlugin
x -> Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr ExtismPlugin
x Ptr ExtismPlugin -> Ptr ExtismPlugin -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ExtismPlugin
forall a. Ptr a
nullPtr))

-- | Set configuration values for a plugin
setConfig :: Plugin -> [(String, Maybe String)] -> IO Bool
setConfig :: Plugin -> [(String, Maybe String)] -> IO Bool
setConfig (Plugin ForeignPtr ExtismPlugin
plugin) [(String, Maybe String)]
x =
  ByteString -> (CString -> IO Bool) -> IO Bool
forall a. ByteString -> (CString -> IO a) -> IO a
unsafeUseAsCString ByteString
bs ((CString -> IO Bool) -> IO Bool)
-> (CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \CString
s ->
    ForeignPtr ExtismPlugin -> (Ptr ExtismPlugin -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin ((Ptr ExtismPlugin -> IO Bool) -> IO Bool)
-> (Ptr ExtismPlugin -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismPlugin
plugin' -> do
      b <- Ptr ExtismPlugin -> Ptr Word8 -> Int64 -> IO CBool
extism_plugin_config Ptr ExtismPlugin
plugin' (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
s) Int64
length'
      print b
      return $ b /= 0
  where
    mk :: Maybe String -> JSValue
mk = JSValue -> (String -> JSValue) -> Maybe String -> JSValue
forall b a. b -> (a -> b) -> Maybe a -> b
maybe JSValue
Text.JSON.JSNull (JSString -> JSValue
Text.JSON.JSString (JSString -> JSValue) -> (String -> JSString) -> String -> JSValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> JSString
Text.JSON.toJSString)
    obj :: JSObject JSValue
obj = [(String, JSValue)] -> JSObject JSValue
forall a. [(String, a)] -> JSObject a
Text.JSON.toJSObject [(String
k, Maybe String -> JSValue
mk Maybe String
v) | (String
k, Maybe String
v) <- [(String, Maybe String)]
x]
    bs :: ByteString
bs = String -> ByteString
toByteString (JSObject JSValue -> String
forall a. JSON a => a -> String
Text.JSON.encode JSObject JSValue
obj)
    length' :: Int64
length' = Int -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
bs)

levelStr :: LogLevel -> String
levelStr LogLevel
LogError = String
"error"
levelStr LogLevel
LogDebug = String
"debug"
levelStr LogLevel
LogWarn = String
"warn"
levelStr LogLevel
LogTrace = String
"trace"
levelStr LogLevel
LogInfo = String
"info"

-- | Set the log file and level, this is a global configuration
setLogFile :: String -> LogLevel -> IO Bool
setLogFile :: String -> LogLevel -> IO Bool
setLogFile String
filename LogLevel
level =
  String -> (CString -> IO Bool) -> IO Bool
forall a. String -> (CString -> IO a) -> IO a
withCString String
filename ((CString -> IO Bool) -> IO Bool)
-> (CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \CString
f ->
    String -> (CString -> IO Bool) -> IO Bool
forall a. String -> (CString -> IO a) -> IO a
withCString String
s ((CString -> IO Bool) -> IO Bool)
-> (CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \CString
l -> do
      b <- CString -> CString -> IO CBool
extism_log_file CString
f CString
l
      return $ b /= 0
  where
    s :: String
s = LogLevel -> String
levelStr LogLevel
level

-- | Check if a function exists in the given plugin
functionExists :: Plugin -> String -> IO Bool
functionExists :: Plugin -> String -> IO Bool
functionExists (Plugin ForeignPtr ExtismPlugin
plugin) String
name =
  ForeignPtr ExtismPlugin -> (Ptr ExtismPlugin -> IO Bool) -> IO Bool
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin ((Ptr ExtismPlugin -> IO Bool) -> IO Bool)
-> (Ptr ExtismPlugin -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismPlugin
plugin' -> do
    b <- String -> (CString -> IO CBool) -> IO CBool
forall a. String -> (CString -> IO a) -> IO a
withCString String
name (Ptr ExtismPlugin -> CString -> IO CBool
extism_plugin_function_exists Ptr ExtismPlugin
plugin')
    if b == 1 then return True else return False

--- | Call a function provided by the given plugin
call :: (ToBytes a, FromBytes b) => Plugin -> String -> a -> IO (Result b)
call :: forall a b.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> IO (Result b)
call (Plugin ForeignPtr ExtismPlugin
plugin) String
name a
inp =
  ForeignPtr ExtismPlugin
-> (Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin ((Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b))
-> (Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b)
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismPlugin
plugin' -> do
    rc <- String -> (CString -> IO Int32) -> IO Int32
forall a. String -> (CString -> IO a) -> IO a
withCString String
name ((CString -> IO Int32) -> IO Int32)
-> (CString -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \CString
name' ->
      ByteString -> (CString -> IO Int32) -> IO Int32
forall a. ByteString -> (CString -> IO a) -> IO a
unsafeUseAsCString ByteString
input ((CString -> IO Int32) -> IO Int32)
-> (CString -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \CString
input' ->
        Ptr ExtismPlugin -> CString -> Ptr Word8 -> Word64 -> IO Int32
extism_plugin_call Ptr ExtismPlugin
plugin' CString
name' (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
input') Word64
length'
    err <- extism_error plugin'
    if err /= nullPtr
      then do
        e <- peekCString err
        return $ Left (ExtismError e)
      else
        if rc == 0
          then do
            len <- extism_plugin_output_length plugin'
            Ptr ptr <- extism_plugin_output_data plugin'
            x <- unsafePackLenAddress (fromIntegral len) ptr
            return $ fromBytes x
          else return $ Left (ExtismError "Call failed")
  where
    input :: ByteString
input = a -> ByteString
forall a. ToBytes a => a -> ByteString
toBytes a
inp
    length' :: Word64
length' = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
input)

call' :: (ToBytes a, FromBytes b) => Plugin -> String -> a -> IO b
call' :: forall a b.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> IO b
call' Plugin
plugin String
name a
inp = do
  Either Error b -> b
forall {b}. Either Error b -> b
unwrap (Either Error b -> b) -> IO (Either Error b) -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plugin -> String -> a -> IO (Either Error b)
forall a b.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> IO (Result b)
call Plugin
plugin String
name a
inp

--- | Call a function provided by the given plugin with a host context value
callWithHostContext :: (ToBytes a, FromBytes b) => Plugin -> String -> a -> c -> IO (Result b)
callWithHostContext :: forall a b c.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> c -> IO (Result b)
callWithHostContext (Plugin ForeignPtr ExtismPlugin
plugin) String
name a
inp c
ctx =
  ForeignPtr ExtismPlugin
-> (Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin ((Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b))
-> (Ptr ExtismPlugin -> IO (Result b)) -> IO (Result b)
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismPlugin
plugin' -> do
    sptr <- c -> IO (StablePtr c)
forall a. a -> IO (StablePtr a)
newStablePtr c
ctx
    let ptr = StablePtr c -> Ptr ()
forall a. StablePtr a -> Ptr ()
castStablePtrToPtr StablePtr c
sptr
    rc <- withCString name $ \CString
name' ->
      ByteString -> (CString -> IO Int32) -> IO Int32
forall a. ByteString -> (CString -> IO a) -> IO a
unsafeUseAsCString ByteString
input ((CString -> IO Int32) -> IO Int32)
-> (CString -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \CString
input' ->
        Ptr ExtismPlugin
-> CString -> Ptr Word8 -> Word64 -> Ptr () -> IO Int32
extism_plugin_call_with_host_context Ptr ExtismPlugin
plugin' CString
name' (CString -> Ptr Word8
forall a b. Ptr a -> Ptr b
castPtr CString
input') Word64
length' Ptr ()
ptr
    freeStablePtr sptr
    err <- extism_error plugin'
    if err /= nullPtr
      then do
        e <- peekCString err
        return $ Left (ExtismError e)
      else
        if rc == 0
          then do
            len <- extism_plugin_output_length plugin'
            Ptr ptr <- extism_plugin_output_data plugin'
            x <- unsafePackLenAddress (fromIntegral len) ptr
            return $ fromBytes x
          else return $ Left (ExtismError "Call failed")
  where
    input :: ByteString
input = a -> ByteString
forall a. ToBytes a => a -> ByteString
toBytes a
inp
    length' :: Word64
length' = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
B.length ByteString
input)

callWithHostContext' :: (ToBytes a, FromBytes b) => Plugin -> String -> a -> c -> IO b
callWithHostContext' :: forall a b c.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> c -> IO b
callWithHostContext' Plugin
plugin String
name a
inp c
ctx = do
  Either Error b -> b
forall {b}. Either Error b -> b
unwrap (Either Error b -> b) -> IO (Either Error b) -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Plugin -> String -> a -> c -> IO (Either Error b)
forall a b c.
(ToBytes a, FromBytes b) =>
Plugin -> String -> a -> c -> IO (Result b)
callWithHostContext Plugin
plugin String
name a
inp c
ctx

-- | Create a new 'CancelHandle' that can be used to cancel a running plugin
-- | from another thread.
cancelHandle :: Plugin -> IO CancelHandle
cancelHandle :: Plugin -> IO CancelHandle
cancelHandle (Plugin ForeignPtr ExtismPlugin
plugin) = do
  handle <- ForeignPtr ExtismPlugin
-> (Ptr ExtismPlugin -> IO (Ptr ExtismCancelHandle))
-> IO (Ptr ExtismCancelHandle)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin Ptr ExtismPlugin -> IO (Ptr ExtismCancelHandle)
extism_plugin_cancel_handle
  return (CancelHandle handle)

-- | Cancel a running plugin using a 'CancelHandle'
cancel :: CancelHandle -> IO Bool
cancel :: CancelHandle -> IO Bool
cancel (CancelHandle Ptr ExtismCancelHandle
handle) =
  Ptr ExtismCancelHandle -> IO Bool
extism_plugin_cancel Ptr ExtismCancelHandle
handle

pluginID :: Plugin -> IO Data.UUID.UUID
pluginID :: Plugin -> IO UUID
pluginID (Plugin ForeignPtr ExtismPlugin
plugin) =
  ForeignPtr ExtismPlugin -> (Ptr ExtismPlugin -> IO UUID) -> IO UUID
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin ((Ptr ExtismPlugin -> IO UUID) -> IO UUID)
-> (Ptr ExtismPlugin -> IO UUID) -> IO UUID
forall a b. (a -> b) -> a -> b
$ \Ptr ExtismPlugin
plugin' -> do
    ptr <- Ptr ExtismPlugin -> IO (Ptr Word8)
extism_plugin_id Ptr ExtismPlugin
plugin'
    buf <- B.packCStringLen (castPtr ptr, 16)
    case Data.UUID.fromByteString (BL.fromStrict buf) of
      Maybe UUID
Nothing -> String -> IO UUID
forall a. HasCallStack => String -> a
error String
"Invalid Plugin ID"
      Just UUID
x -> UUID -> IO UUID
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return UUID
x

reset :: Plugin -> IO ()
reset :: Plugin -> IO ()
reset (Plugin ForeignPtr ExtismPlugin
plugin) =
  ForeignPtr ExtismPlugin -> (Ptr ExtismPlugin -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
withForeignPtr ForeignPtr ExtismPlugin
plugin Ptr ExtismPlugin -> IO ()
extism_plugin_reset

unwrap :: Either Error b -> b
unwrap (Right b
x) = b
x
unwrap (Left (ExtismError String
msg)) =
  String -> b
forall a. HasCallStack => String -> a
error String
msg