"Namespace index {} not in address space" when accessing from libloaded module

[ZJVieth]

Hi,

For a prototype, Im trying to implement a modular OpcUa server using libloading. Im currently working with three crates: 1. main crate (opcua_server), 2. common (utils) crate (opcua_common), 3. device communication module crate (dcm_test). Both the main crate and the dcm crate depend on the common crate to define intefacing traits and utils. DCMs are how I want to scale the server, allowing me to develop isolated libraries, compile them to DLLs and plug any combination of them on servers connected to different machines. Im currently using libloading to load the compiled dlls. I also previously prototyped this using the open62541 wrapper crate, which worked well up until the MethodCallbacks (specifically the obtaining of input arguments inside a libloaded library).

I defined a ServerAccess type that I can pass from the main to the DCM. When I use my access utils from the main crate, I can add nodes to the address_space without issues, but when trying the same from the DCM, I get the following error:

thread '<unnamed>' panicked at <...>\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:219:13:
Namespace index 2 not in address space

According to my console output, the namespace 2 does exist tho at every point I check the namespaces (including right before the error is thrown:

Address from init: 0x2f078b69898
-- {2: "urn:PrototypeServer"}
-- NS Some(2)
Address from access: 0x2f078b69898
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)
Enter libloaded module
Address from access: 0x2f078b69898
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)
Address from Inside Access: 0x2f078b69898
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)

thread '<unnamed>' panicked at <...>\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:219:13:
Namespace index 2 not in address space

Im running on Windows 11, this is the relevant part of the config.toml for the dcm (same dependency config for common and main):

[lib]
crate-type = ["dylib"]

[dependencies.async-opcua]
version = "0.15.1"
features = ["server"]
default-features = false

Im still new to Rust, so Im not sure if my approach to this is actually feasible/advisable. Sorry for the code-dump. Just wondering if I am doing something terribly wrong or there is actually a bug with the address space. Please let me know if you need any additional information.

opcua_server/src/main.rs

#[tokio::main]
async fn main() -> Result<(), GlobalServerError> {

    let server = server::init("./server.conf".into())?;

    let _ = server_util::access(
        &SERVER,
        |address_space, ns, server_api| {

            let mut address_space = address_space.write();

            let line_id = NodeId::new(ns, "line");
            ObjectBuilder::new(&line_id, "Line", "Line")
                .event_notifier(EventNotifier::SUBSCRIBE_TO_EVENTS)
                .organized_by(ObjectId::ObjectsFolder)
                .insert(address_space.deref_mut());

            let object_id = NodeId::new(ns, "main-object");
            ObjectBuilder::new(&object_id, "MainObject", "Main Object")
                .event_notifier(EventNotifier::SUBSCRIBE_TO_EVENTS)
                .organized_by(line_id)
                .insert(address_space.deref_mut());

            let field_id = NodeId::new(ns, "main-object-field-1");
            VariableBuilder::new(&field_id, "Var1", "Var 1")
                .organized_by(&object_id)
                .data_type(DataTypeId::String)
                .value("Initial Value")
                .insert(address_space.deref_mut());

            let fn_node_id = NodeId::new(ns, "main-object-method-1");
            MethodBuilder::new(&fn_node_id, "Method1", "Method 1")
                .component_of(&object_id)
                .executable(true)
                .user_executable(true)
                .input_args(
                    &mut *address_space,
                    &NodeId::new(ns, "main-object-method-1-input"),
                    &[("InputData", DataTypeId::String).into()],
                )
                .output_args(
                    &mut *address_space,
                    &NodeId::new(ns, "main-object-method-1-output"),
                    &[("ResultData", DataTypeId::String).into()]    
                )
                .insert(&mut *address_space);

            server_api.get_node_manager().inner().add_method_callback(fn_node_id, |args| {
                println!("Blub method called");

                let Some(Variant::String(s)) = args.first() else {
                    return Err(StatusCode::BadTypeMismatch);
                };

                Ok(vec![Variant::from(format!("Input was {s}!").to_owned())])
            });

            Ok(true)
        }    
    );

    let _dcm_list = meta::dcms::load_and_init_dcms(
        DCM_DIRECTORY,
    );

    let handle_c = server_util::handle(&SERVER)?;
    tokio::spawn(async move {
        if let Err(_) = tokio::signal::ctrl_c().await {
            return;
        }
        handle_c.cancel();
    });

    server.run().await.unwrap();
        
    Ok(())
}

opcua_server/src/dcms.rs (dcm loading)

pub fn load_and_init_dcms(dir: &str) -> Vec<(Library, &mut dyn DCM)> {
    let mut dcm_list: Vec<(Library, &mut dyn DCM)> = vec![]; 

    match ScanDir::files().read(dir, |iter| {
        for (entry, name) in iter {
            if !name.ends_with(".dll") {
                continue;
            }

            match load_dcm(entry.path()) {
                Ok(dcm) => dcm_list.push((dcm.0, Box::leak(dcm.1))),
                Err(err) => println!("An error occured while trying to load {name}: {err}")
            }
        }
    }) {
        Ok(_) => println!("Finished reading DCM folder successfully."),
        Err(err) => println!("{err}"),
    }

    dcm_list
}

fn load_dcm(dcm_file: PathBuf) -> Result<(Library, Box<dyn DCM>), DCMLoadingError> {

    let dcm_lib = match unsafe { libloading::Library::new(&dcm_file) } {
        Ok(lib) => lib,
        Err(_) => {
            return Err(DCMLoadingError { message: String::from("DCMLoadingFailed") }); 
        },
    };

    let dcm_loader: libloading::Symbol<fn() -> Box<dyn DCM>> =
        match unsafe { dcm_lib.get(b"load_dcm") } {
            Ok(loader) => loader,
            Err(_) => {
                return Err(DCMLoadingError { message: String::from("DCMLoaderAccessError") });
            }
        };

    let mut dcm = dcm_loader();
    
    dcm.set_server_access(&SERVER);
    let init_result = dcm.init();
    if let Err(_) = init_result {
        return Err(DCMLoadingError { message: String::from("DCMInitError") });
    }

    Ok((dcm_lib, dcm))
}

opcua_server/src/server.rs

pub static SERVER: ServerAccess = Mutex::new(None);


pub struct OpcuaServer {
    handle: ServerHandle,
    ns: u16,
    node_manager: Arc<InMemoryNodeManager<SimpleNodeManagerImpl>>
}
impl ServerAPI for OpcuaServer {

    fn get_handle(&self) -> &ServerHandle {
        &self.handle
    }

    fn get_ns(&self) -> u16 {
        self.ns
    }

    fn get_node_manager(&self)
        -> &Arc<InMemoryNodeManager<SimpleNodeManagerImpl>>
    {
        &self.node_manager
    }
}


pub fn init(server_config: PathBuf) -> Result<Server, GlobalServerError> {

    let (server, handle) = ServerBuilder::new()
            .with_config_from(server_config)
            .build_info(BuildInfo {
                product_uri: "https://prototype.co.jp/".into(),
                manufacturer_name: "Prototype".into(),
                product_name: "OPCUA Prototype".into(),
                software_version: "0.1.0".into(),
                build_number: "1".into(),
                build_date: DateTime::now(),
            })
            .with_node_manager(simple_node_manager(
                NamespaceMetadata {
                    namespace_uri: SERVER_NAMESPACE_URN.to_owned(),
                    ..Default::default()
                }, 
                "prototype"
            ))
            .trust_client_certs(true)
            .diagnostics_enabled(true)
            .build()
            .unwrap();

    let node_manager: Arc<InMemoryNodeManager<SimpleNodeManagerImpl>> = handle
        .node_managers()
        .get_of_type::<SimpleNodeManager>()
        .ok_or(GlobalServerError::NodeManagerInitError)?;

    println!("Address from init: {:?}", node_manager.address_space().data_ptr());
    println!("-- {:?}", node_manager.address_space().read().namespaces());
    println!("-- NS {:?}", node_manager.address_space().read().namespace_index(SERVER_NAMESPACE_URN));

    let ns = handle.get_namespace_index(SERVER_NAMESPACE_URN).unwrap();

    *SERVER.lock().unwrap() = Some(Box::new(OpcuaServer {
        handle,
        ns,
        node_manager,
    }));

    Ok(server)
}

opcua_common/src/server_util.rs

use std::sync::{Arc, Mutex};

use opcua::sync::RwLock;
use opcua::server::ServerHandle;
use opcua::server::address_space::AddressSpace;
use opcua::server::node_manager::memory::InMemoryNodeManager;
use opcua::server::node_manager::memory::SimpleNodeManagerImpl;
use opcua::types::NodeId;

pub const SERVER_NAMESPACE_URN: &str = "urn:PrototypeServer";

pub type ServerAccess = Mutex<Option<Box<dyn ServerAPI>>>;
pub const fn empty_server_access() -> ServerAccess {
    Mutex::new(None)
}

pub trait ServerAPI : Send + Sync {
    fn get_handle(&self) -> &ServerHandle;
    fn get_ns(&self) -> u16;
    fn get_node_manager(&self) -> &Arc<InMemoryNodeManager<SimpleNodeManagerImpl>>;
}

#[derive(Debug)]
pub enum GlobalServerError {
    NodeManagerInitError,
    NamespaceNotFoundError,

    AccessError
}

pub fn line_id(ns: u16) -> NodeId {
    NodeId:: new(ns, "line")
}

pub fn handle(server_access: &ServerAccess) -> Result<ServerHandle, GlobalServerError> {

    let unlocked = match server_access.lock() {
        Ok(guard) => guard,
        Err(_) => return Err(GlobalServerError::AccessError),
    };

    let server_api = unlocked
        .as_ref()
        .ok_or(GlobalServerError::AccessError)?;

    Ok(server_api.get_handle().clone())
}

pub fn access(
    server_access: &ServerAccess,
    action: fn(
        address_space: &Arc<RwLock<AddressSpace>>,
        ns: u16,
        server_api: &Box<dyn ServerAPI>
    ) -> Result<bool, GlobalServerError>
) -> Result<bool, GlobalServerError> {

    let unlocked = match server_access.lock() {
        Ok(guard) => guard,
        Err(_) => return Err(GlobalServerError::AccessError),
    };

    let server_api = unlocked
        .as_ref()
        .ok_or(GlobalServerError::AccessError)?;

    let node_manager = server_api.get_node_manager();
    let address_space = node_manager.address_space();

    println!("Address from access: {:?}", address_space.data_ptr());
    println!("-- {:?} // address_space.namespaces()", address_space.read().namespaces());
    println!("-- NS {:?} // address_space.namespace_index(SERVER_NAMESPACE_URN)", address_space.read().namespace_index(SERVER_NAMESPACE_URN));

    // let ns = server_api
    //     .get_handle()
    //     .get_namespace_index(SERVER_NAMESPACE_URN)
    //     .ok_or(GlobalServerError::NamespaceNotFoundError)?;

    action(address_space, server_api.get_ns(), server_api)
}

opcua_common/src/dcm.rs

pub trait DCM {
    fn init(&mut self) -> Result<(), Error>;
    fn set_server_access(&mut self, server_access: &'static ServerAccess);
    fn get_dcm_name(&self) -> &str;
    fn exit(&self) -> ();
}

dcm_test/src/lib.rs

static NON_HANDLER: ServerAccess = server_util::empty_server_access();

#[unsafe(no_mangle)]
pub fn load_dcm() -> Box<dyn DCM> {
    Box::new(DCMTest { server_access: &NON_HANDLER })
}


struct DCMTest<'a> {
    server_access: &'a ServerAccess,
}
impl DCM for DCMTest<'_> {
    fn set_server_access(&mut self, server_access: &'static ServerAccess) {
        self.server_access = server_access;
    }

    fn init(&mut self) -> Result<(), Error> {
        println!("Enter libloaded module");

        self.add_test_nodes();

        Ok(())
    }

    fn get_dcm_name(&self) -> &str { "DCMTest" }
    fn exit(&self) -> () { }
}
impl DCMTest<'_> {

    fn add_test_nodes(&self) {

        match server_util::access(
            self.server_access,
            |address_space, ns, server_api| {

                println!("Address from Inside Access: {:?}", address_space.data_ptr());

                let mut address_space = address_space.write();
                println!("-- {:?} // address_space.namespaces()", address_space.namespaces());
                println!("-- NS {:?} // address_space.namespace_index(SERVER_NAMESPACE_URN)", address_space.namespace_index(SERVER_NAMESPACE_URN));

                let object_id = NodeId::new(ns, "dcm-object");
                ObjectBuilder::new(&object_id, "DCMObject", "DCM Object")
                    .event_notifier(EventNotifier::SUBSCRIBE_TO_EVENTS)
                    .organized_by(server_util::line_id(ns))
                    .insert(&mut *address_space);

                Ok(true)
            }
        ) {
            Ok(_) => println!("Executed server access in dcm."),
            Err(err) => println!("Failed server access in dcm: {:?}", err),
        }

        println!("Finish");

    }

}

[einarmo]

It's a bit hard to tell where this actually happens. Could you share the panic message with the RUST_BACKTRACE=1 environment variable?

[ZJVieth]

This is the full stack trace:

thread '<unnamed>' panicked at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:219:13:
Namespace index 2 not in address space
stack backtrace:
   0: std::panicking::begin_panic_handler
             at /rustc/17067e9ac6d7ecb70e50f92c1944e545188d2359/library\std\src\panicking.rs:697
   1: core::panicking::panic_fmt
             at /rustc/17067e9ac6d7ecb70e50f92c1944e545188d2359/library\core\src\panicking.rs:75
   2: opcua_server::address_space::AddressSpace::assert_namespace
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:219
   3: opcua_server::address_space::impl$1::insert<opcua_nodes::object::Object>
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:494
   4: opcua_nodes::object::ObjectBuilder::insert<opcua_server::address_space::AddressSpace>
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-nodes-0.15.1\src\lib.rs:210
   5: dcm_test::impl$1::add_test_nodes::closure$0
             at C:\Development\Projects\Linevision\Repos\prototype.linevision.architecture\linevision.module.test\DCM\dcm_test\src\lib.rs:55
   6: core::ops::function::FnOnce::call_once<dcm_test::impl$1::add_test_nodes::closure_env$0,tuple$<ref$<alloc::sync::Arc<lock_api::rwlock::RwLock<parking_lot::raw_rwlock::RawRwLock,opcua_server::address_space::AddressSpace>,alloc::alloc::Global> >,u16,ref$<allo
             at C:\Users\zino.vieth_yamadadob\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:250
   7: common_opcua::server_util::access
             at C:\Development\Projects\Linevision\Repos\prototype.linevision.architecture\linevision.common\Opcua\common_opcua\src\server_util.rs:79
   8: dcm_test::DCMTest::add_test_nodes
             at C:\Development\Projects\Linevision\Repos\prototype.linevision.architecture\linevision.module.test\DCM\dcm_test\src\lib.rs:44
   9: dcm_test::impl$0::init
             at C:\Development\Projects\Linevision\Repos\prototype.linevision.architecture\linevision.module.test\DCM\dcm_test\src\lib.rs:32
  10: LineVisionOpcuaServer::meta::dcms::load_dcm
             at .\src\meta\dcms.rs:64
  11: LineVisionOpcuaServer::meta::dcms::load_and_init_dcms::closure$0
             at .\src\meta\dcms.rs:31
  12: scan_dir::ScanDir::read<ref$<str$>,tuple$<>,LineVisionOpcuaServer::meta::dcms::load_and_init_dcms::closure_env$0>
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\scan_dir-0.3.3\src\lib.rs:274
  13: LineVisionOpcuaServer::meta::dcms::load_and_init_dcms
             at .\src\meta\dcms.rs:25
  14: LineVisionOpcuaServer::main::async_block$0
             at .\src\main.rs:76
  15: core::future::future::impl$1::poll<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> >
             at C:\Users\zino.vieth_yamadadob\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\future\future.rs:124
  16: tokio::runtime::park::impl$4::block_on::closure$0<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\park.rs:284
  17: tokio::task::coop::with_budget
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\task\coop\mod.rs:167
  18: tokio::task::coop::budget
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\task\coop\mod.rs:133
  19: tokio::runtime::park::CachedParkThread::block_on<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\park.rs:284
  20: tokio::runtime::context::blocking::BlockingRegionGuard::block_on<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\context\blocking.rs:66
  21: tokio::runtime::scheduler::multi_thread::impl$0::block_on::closure$0<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\scheduler\multi_thread\mod.rs:87
  22: tokio::runtime::context::runtime::enter_runtime<tokio::runtime::scheduler::multi_thread::impl$0::block_on::closure_env$0<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >,enum2$<core::result::
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\context\runtime.rs:65
  23: tokio::runtime::scheduler::multi_thread::MultiThread::block_on<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\scheduler\multi_thread\mod.rs:86
  24: tokio::runtime::runtime::Runtime::block_on_inner<core::pin::Pin<alloc::boxed::Box<enum2$<LineVisionOpcuaServer::main::async_block_env$0>,alloc::alloc::Global> > >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\runtime.rs:358
  25: tokio::runtime::runtime::Runtime::block_on<enum2$<LineVisionOpcuaServer::main::async_block_env$0> >
             at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\tokio-1.45.1\src\runtime\runtime.rs:328
  26: LineVisionOpcuaServer::main
             at .\src\main.rs:90
  27: core::ops::function::FnOnce::call_once<enum2$<core::result::Result<tuple$<>,common_opcua::server_util::GlobalServerError> > (*)(),tuple$<> >
             at C:\Users\zino.vieth_yamadadob\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib\rustlib\src\rust\library\core\src\ops\function.rs:250
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
fatal runtime error: Rust cannot catch foreign exceptions
error: process didn't exit successfully: `C:/Development/lvbuild/LineVisionOpcuaServer\debug\LineVisionOpcuaServer.exe` (exit code: 0xc0000409, STATUS_STACK_BUFFER_OVERRUN)

This seems to be the panic call: \src\address_space\mod.rs:219

On a side note, implementing the actual address_space manipulating operations as part of the ServerAPI trait in the main crate makes it possible to go around this problem, but Id generally prefer to be able to do these operations directly from the modules without having to extend the common ServerAPI for every future use case. Not sure if it would be preferable from a safety point of view though.
Thank you for taking the time to look into this.

[einarmo]

I'll be honest, this makes no sense to me. As you note, the namespaces map contains the key 2, as you show from your logs, and the check that fails here is literally just if !self.namespaces.contains_key(&node_id.namespace) { panic!(...) }.

It's a little hard to debug just by looking at the code. I can try to look into it, but I doubt I'll be able to reproduce.

There's probably something obvious we're both missing. namespaces really isn't allowed to change, it's behind a write-lock.

You may need to do a little investigation here yourself, a super-simple first step would be to just look at what the namespaces map actually contains on line 219 in address_space/mod.rs.

[einarmo]

Maybe there's some form of static randomness in hashbrown::HashMap that doesn't work cross dynamic crate boundary like this?

[einarmo]

You can check that, maybe, by doing

use std::hash::BuildHasher;
let mut hasher = hashbrown::DefaultHashBuilder::default().build_hasher();
2.hash(&mut hasher);
println!("{:?}", hasher.finish());

in each place you already log? If it gives different results, that's the problem.

[ZJVieth]

I added a log to address_space/mod.rs like so:

fn assert_namespace(&self, node_id: &NodeId) {
        let mut hasher = self.namespaces.hasher().build_hasher();
        2.hash(&mut hasher);
        println!("[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => {:?}", hasher.finish());

        if !self.namespaces.contains_key(&node_id.namespace) {
            panic!("Namespace index {} not in address space", node_id.namespace);
        }
    }

This is the output I got:

// .. a bunch of "[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13820054975230529226"
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13820054975230529226
Address from init: 0x150ea88a1c8
-- {2: "urn:PrototypeServer"}
-- NS Some(2)
Address from access: 0x150ea88a1c8
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 13606786323279082766
Enter libloaded module
Address from access: 0x150ea88a1c8
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)
Address from Inside Access: 0x150ea88a1c8
-- {2: "urn:PrototypeServer"} // address_space.namespaces()
-- NS Some(2) // address_space.namespace_index(SERVER_NAMESPACE_URN)
[address_space/mod.rs, 219] self.namespaces.hasher() -> 2.hash => 0

thread '<unnamed>' panicked at C:\Users\zino.vieth_yamadadob\.cargo\registry\src\index.crates.io-1949cf8c6b5b557f\async-opcua-server-0.15.1\src\address_space\mod.rs:219:13:
Namespace index 2 not in address space

The first time I ran the program after these changes, the last call before the crash actually gave a non-0 hash, but every consecutive run since then has given a hash of 0.

[einarmo]

Right. So I'm reasonably sure this is the problem:

• We use hashbrown in a few places for performance, including here.
• hashbrown uses foldhash for hashing by default, using RandomState from that library, which has a static shared random seed, again for performance.
• Since the random seed is static, it is part of the static part of the binary, meaning that each dynamic library has a different copy.
• This means that you get different hashes in different dynamic libraries.

This just happens to be the first place you hit this issue, you would have hit it sooner or later, and in general is something you run into if you dynamically link libraries.

I think changing the behavior on our end is not trivial, but theoretically doable though I'm not sure it will actually fix all your issues. We could continue to use a static hasher, but allow it to be manually initialized. I haven't seen that pattern before. It could be done, but I somewhat hesitate, because I'm not sure if we want to commit to supporting something like this. I'm unsure of what the actual consequences are. We use tokio, which has lots of static stuff for timers and the like, you may run into similar issues there, or in any number of other libraries that have static variables somewhere.

[einarmo]

If you only needed to fix this specific problem, allowing extension libraries to call insert using the server address space, I guess you could implement NodeInsertTarget for some wrapper type ensuring that all actual insertions happen in the same static context, but that wouldn't work if you needed to do anything else.

[ZJVieth]

Yes, I have already run into similar issues with the tokio reactor, or with the open62541-wrapper library for example. I figure that when implementing this kind of dynamic modularity in rust, it would be the most consistent across use-cases to instead expose handlers/apis from the main binary to the dynamic libraries.
I do wonder why this is an issue in rust specifically though. We are currently using a C++ opcua server which is also able to dynamically load separately compiled libraries, and a .NET WPF prism application with plenty of singletons which does the same.

[einarmo]

For .NET the answer is simply that statics are stored in the runtime, not as part of each DLL, AFAIK. For C++ I imagine the difference is that dynamic linking is more common. For rust static linking is the standard, so it's way more common to not care about dynamic linking.