Use macros to define messages rather than eval

docs/src/msg.md

@@ -1,18 +1,106 @@
 # Messages
 
-Messages are dictionary-like containers that carry information between agents.
-Keys can be accessed on messages using the property notation (`msg.key`), and
-keys that are absent yield `nothing`. When interacting with Java/Groovy agents,
-messages are mapped to Java/Groovy message classes with fields with the same
-name as the keys in the message.
+Messages are data containers that carry information between agents. When
+interacting with Java/Groovy agents, messages are mapped to Java/Groovy
+message classes with fields with the same name as the keys in the message.
 
-Message types are defined using the `MessageClass` function. For example:
+Message types are defined using the `@message` macro. For example:
 ```julia
-const ShellExecReq = MessageClass(@__MODULE__, "org.arl.fjage.shell.ShellExecReq")
+@message "org.arl.fjage.shell.ShellExecReq" struct ShellExecReq
+  cmd::Union{String,Nothing} = nothing
+  script::Union{String,Nothing} = nothing
+  args::Vector{String} = String[]
+  ans::Bool = false
+end
 ```
 defines a `ShellExecReq` message type that maps to a Java class with the
 package `org.arl.fjage.shell.ShellExecReq`.
 
+All messages are mutable. The `@message` macro also automatically adds a few fields:
+
+- `performative::Symbol`
+- `messageID::String`
+- `inReplyTo::String`
+- `sender::AgentID`
+- `recipient::AgentID`
+- `sentAt::Int64`
+
+Messages can subtype other messages:
+```julia
+julia> abstract type MyAbstractMessage <: Message end
+
+julia> @message "org.arl.fjage.demo.MyConcreteMessage" struct MyConcreteMessage <: MyAbstractMessage
+        a::Int
+      end
+
+julia> MyConcreteMessage(a=1)
+MyConcreteMessage:INFORM[a:1]
+
+julia> MyConcreteMessage(a=1) isa MyAbstractMessage
+true
+```
+
+It is also possible to have a concrete message type that can also be a supertype
+of another message:
+```julia
+julia> abstract type SomeMessage <: Message end
+
+julia> @message "org.arl.fjage.demo.SomeMessage" struct SomeMessage <: SomeMessage
+        a::Int
+      end
+
+julia> @message "org.arl.fjage.demo.SomeExtMessage" struct SomeExtMessage <: SomeMessage
+        a::Int
+        b::Int
+      end
+
+julia> SomeMessage(a=1) isa SomeMessage
+true
+
+julia> SomeExtMessage(a=1, b=2) isa SomeMessage
+true
+```
+
+Performatives are guessed automatically based on message classname. By default,
+the performative is `Performative.INFORM`. If a message classname ends with a
+`Req`, the default performative changes to `Performative.REQUEST`. Performatives
+may be overridden at declaration or at construction (and are mutable):
+```julia
+julia> @message "org.arl.fjage.demo.SomeReq" struct SomeReq end;
+julia> @message "org.arl.fjage.demo.SomeRsp" Performative.AGREE struct SomeRsp end;
+
+julia> SomeReq().performative
+:REQUEST
+
+julia> SomeRsp().performative
+:AGREE
+
+julia> SomeRsp(performative=Performative.INFORM).performative
+:INFORM
+```
+
+When strict typing is not required, one can use the dictionary-like
+`GenericMessage` message type:
+```julia
+julia> msg = GenericMessage("org.arl.fjage.demo.DynamicMessage")
+DynamicMessage:INFORM
+
+julia> msg.a = 1
+1
+
+julia> msg.b = "xyz"
+"xyz"
+
+julia> msg
+DynamicMessage:INFORM[a:1 b:"xyz"]
+
+julia> classname(msg)
+"org.arl.fjage.demo.DynamicMessage"
+
+julia> msg isa GenericMessage
+true
+```
+
 ## API
 
 ```@autodocs

pom.xml

@@ -14,7 +14,7 @@
         <dependency>
             <groupId>com.github.org-arl</groupId>
             <artifactId>fjage</artifactId>
-            <version>1.10.0-SNAPSHOT</version>
+            <version>1.12.2</version>
         </dependency>
     </dependencies>
 </project>

src/Fjage.jl

@@ -34,4 +34,8 @@ include("container.jl")
 include("fsm.jl")
 include("coroutine_behavior.jl")
 
+function __init__()
+  registermessages()
+end
+
 end

src/const.jl

@@ -6,4 +6,9 @@ module Services
 end
 
 "Shell command execution request message."
-const ShellExecReq = MessageClass(@__MODULE__, "org.arl.fjage.shell.ShellExecReq")
+@message "org.arl.fjage.shell.ShellExecReq" struct ShellExecReq
+  cmd::Union{String,Nothing} = nothing
+  script::Union{String,Nothing} = nothing
+  args::Vector{String} = String[]
+  ans::Bool = false
+end

src/container.jl

@@ -673,13 +673,13 @@ function _deliver(c::SlaveContainer, msg::Message, relay::Bool)
   if msg.recipient.name ∈ keys(c.agents)
     _deliver(c.agents[msg.recipient.name], msg)
   elseif relay
-    _prepare!(msg)
+    clazz, data = _prepare(msg)
     json = JSON.json(Dict(
-      "action" => "send",
-      "relay" => true,
-      "message" => Dict(
-        "clazz" => msg.__clazz__,
-        "data" => msg.__data__
+      :action => :send,
+      :relay => true,
+      :message => Dict(
+        :clazz => clazz,
+        :data => data
       )
     ))
     try
@@ -701,22 +701,32 @@ _deliver(c::SlaveContainer, msg::Message) = _deliver(c, msg, true)
 
 ### stacktrace pretty printing & auto-reconnection
 
-function reporterror(src, ex)
-  fname = basename(@__FILE__)
-  bt = String[]
-  for s ∈ stacktrace(catch_backtrace())
-    push!(bt, "    $s")
-    basename(string(s.file)) == fname && s.func == :run && break
-  end
-  bts = join(bt, '\n')
-  if src === nothing
-    @error "$(ex)\n  Stack trace:\n$(bts)"
-  else
-    @error "[$(src)] $(ex)\n  Stack trace:\n$(bts)"
+"""
+    logerror(f::Function)
+    logerror(f::Function, src)
+
+Run function `f()` and log any errors that occur.
+"""
+function logerror(f::Function, src=nothing)
+  try
+    f()
+  catch ex
+    logerror(ex, src)
   end
 end
 
-reporterror(ex) = reporterror(nothing, ex)
+"""
+    logerror(err::Exception)
+    logerror(err::Exception, src)
+
+Log error `err` with a simple stack trace.
+"""
+function logerror(ex::Exception, src=nothing)
+  io = IOBuffer()
+  src === nothing || print(io, "[$src] ")
+  Base.showerror(IOContext(io, :limit => true), ex, Base.catch_backtrace())
+  @error String(take!(io))
+end
 
 reconnect(c::StandaloneContainer, ex) = false
 function reconnect(c::SlaveContainer, ex)
@@ -1443,7 +1453,7 @@ function action(b::OneShotBehavior)
     b.action === nothing || _mutex_call(b.action, b.agent, b)
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   b.done = true
   delete!(b.agent._behaviors, b)
@@ -1496,7 +1506,7 @@ function action(b::CyclicBehavior)
         try
           b.action === nothing || _mutex_call(b.action, b.agent, b)
         catch ex
-          reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+          reconnect(container(b.agent), ex) || logerror(ex, b.agent)
         end
         yield()
       else
@@ -1505,7 +1515,7 @@ function action(b::CyclicBehavior)
     end
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   b.done = true
   delete!(b.agent._behaviors, b)
@@ -1594,7 +1604,7 @@ function action(b::WakerBehavior)
     end
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   b.done = true
   delete!(b.agent._behaviors, b)
@@ -1666,12 +1676,12 @@ function action(b::TickerBehavior)
       try
         b.done || b.action === nothing || _mutex_call(b.action, b.agent, b)
       catch ex
-        reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+        reconnect(container(b.agent), ex) || logerror(ex, b.agent)
       end
     end
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   b.done = true
   delete!(b.agent._behaviors, b)
@@ -1733,12 +1743,12 @@ function action(b::PoissonBehavior)
       try
         b.done || b.action === nothing || _mutex_call(b.action, b.agent, b)
       catch ex
-        reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+        reconnect(container(b.agent), ex) || logerror(ex, b.agent)
       end
     end
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   b.done = true
   delete!(b.agent._behaviors, b)
@@ -1814,12 +1824,12 @@ function action(b::MessageBehavior)
         msg = take!(ch)
         msg === nothing || b.action === nothing ||  _mutex_call(b.action, b.agent, b, msg)
       catch ex
-        reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+        reconnect(container(b.agent), ex) || logerror(ex, b.agent)
       end
     end
     b.onend === nothing || _mutex_call(b.onend, b.agent, b)
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   finally
     _dont_listen(b.agent, ch)
     close(ch)
@@ -2056,10 +2066,10 @@ function _paramreq_action(a::Agent, b::MessageBehavior, msg::ParameterReq)
         end
       end
     catch ex
-      reconnect(container(a), ex) || reporterror(a, ex)
+      reconnect(container(a), ex) || logerror(ex, a)
     end
   end
-  rmsg = ParameterRsp(perf=Performative.INFORM, inReplyTo=msg.messageID, recipient=msg.sender, readonly=ro, index=ndx)
+  rmsg = ParameterRsp(performative=Performative.INFORM, inReplyTo=msg.messageID, recipient=msg.sender, readonly=ro, index=ndx)
   length(rsp) > 0 && ((rmsg.param, rmsg.value) = popfirst!(rsp))
   length(rsp) > 0 && (rmsg.values = Dict(rsp))
   send(a, rmsg)

src/coroutine_behavior.jl

@@ -52,15 +52,13 @@ end
 function action(b::CoroutineBehavior)
     b.control_task = current_task()
     b.action_task = Task() do
-        try
+        logerror(b.agent) do
             b.action(b.agent, b)
-        catch e
-            reporterror(b.agent, e)
         end
         b.done = true
         yieldto(b.control_task)
     end
-    try
+    logerror(b.agent) do
         while !b.done
             if !isnothing(b.block)
                 lock(() -> wait(b.block), b.block)
@@ -69,8 +67,6 @@ function action(b::CoroutineBehavior)
                 yieldto(b.action_task)
             end
         end
-    catch ex
-        reporterror(b.agent, ex)
     end
     b.done = true
     b.control_task = nothing

src/fsm.jl

@@ -214,15 +214,15 @@ function action(b::FSMBehavior)
             _mutex_call(onenter, b.agent, b, b.state)
           end
         catch ex
-          reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+          reconnect(container(b.agent), ex) || logerror(ex, b.agent)
         end
         yield()
       else
         lock(() -> wait(b.block), b.block)
       end
     end
   catch ex
-    reconnect(container(b.agent), ex) || reporterror(b.agent, ex)
+    reconnect(container(b.agent), ex) || logerror(ex, b.agent)
   end
   delete!(b.agent._behaviors, b)
   b.agent = nothing