Custom structures client

async-opcua-client/src/session/mod.rs

@@ -463,13 +463,13 @@ impl Session {
     }
 
     /// Return index of supplied namespace url from cache
-    pub fn get_namespace_index_from_cache(&mut self, url: &str) -> Option<u16> {
+    pub fn get_namespace_index_from_cache(&self, url: &str) -> Option<u16> {
         self.encoding_context.read().namespaces().get_index(url)
     }
 
     /// Return index of supplied namespace url
     /// by first looking at namespace cache and querying server if necessary
-    pub async fn get_namespace_index(&mut self, url: &str) -> Result<u16, Error> {
+    pub async fn get_namespace_index(&self, url: &str) -> Result<u16, Error> {
         if let Some(idx) = self.get_namespace_index_from_cache(url) {
             return Ok(idx);
         };

async-opcua-server/src/node_manager/memory/simple.rs

@@ -14,8 +14,8 @@ use crate::{
 };
 use opcua_core::sync::RwLock;
 use opcua_types::{
-    AttributeId, DataValue, MonitoringMode, NodeId, NumericRange, StatusCode, TimestampsToReturn,
-    Variant,
+    AttributeId, DataValue, MonitoringMode, NodeClass, NodeId, NumericRange, StatusCode,
+    TimestampsToReturn, Variant,
 };
 
 use super::{
@@ -363,19 +363,30 @@ impl SimpleNodeManagerImpl {
                 return;
             }
         };
-
-        let (NodeType::Variable(var), AttributeId::Value) = (node, write.value().attribute_id)
-        else {
+        if node.node_class() != NodeClass::Variable
+            || write.value().attribute_id != AttributeId::Value
+        {
             write.set_status(StatusCode::BadNotWritable);
             return;
-        };
+        }
 
-        let Some(cb) = cbs.get(var.node_id()) else {
-            write.set_status(StatusCode::BadNotWritable);
+        if let Some(cb) = cbs.get(node.as_node().node_id()) {
+            write.set_status(cb(write.value().value.clone(), &write.value().index_range));
             return;
         };
 
-        write.set_status(cb(write.value().value.clone(), &write.value().index_range));
+        if let Some(value) = &write.value().value.value {
+            let res = node
+                .as_mut_node()
+                .set_attribute(AttributeId::Value, value.clone());
+            if let Err(status_code) = res {
+                write.set_status(status_code);
+            }
+            write.set_status(StatusCode::Good);
+            return;
+        }
+
+        write.set_status(StatusCode::BadNothingToDo);
     }
 
     /// Add a callback called on `Write` for the node given by `id`.

async-opcua-types/src/errors.rs

@@ -5,17 +5,43 @@
 
 use thiserror::Error;
 
-use crate::VariantScalarTypeId;
+use crate::{StatusCode, VariantScalarTypeId};
 
 /// Rust OpcUa specific errors
 #[allow(missing_docs)]
 #[derive(Error, Debug)]
-pub enum OpcUAError {
+pub enum OpcUaError {
     #[error("Received an unexpected variant type")]
     UnexpectedVariantType {
         variant_id: Option<VariantScalarTypeId>,
         message: String,
     },
     #[error("The requested namespace does not exists")]
     NamespaceDoesNotExist(String),
+    #[error("Namespace is out of range of a u16.")]
+    NamespaceOutOfRange,
+    #[error("Supplied node resolver was unable to resolve a reference type.")]
+    UnresolvedReferenceType,
+    #[error("Path does not match a node.")]
+    NoMatch,
+    #[error("Path segment is unusually long and has been rejected.")]
+    PathSegmentTooLong,
+    #[error("Number of elements in relative path is too large.")]
+    TooManyElementsInPath,
+    #[error("Request returned a StatusCode Error.")]
+    StatusCodeError(StatusCode),
+    #[error("Generic Error.")]
+    Error(crate::Error),
+}
+
+impl From<StatusCode> for OpcUaError {
+    fn from(value: StatusCode) -> Self {
+        OpcUaError::StatusCodeError(value)
+    }
+}
+
+impl From<crate::Error> for OpcUaError {
+    fn from(value: crate::Error) -> Self {
+        OpcUaError::Error(value)
+    }
 }

async-opcua-types/src/impls.rs

@@ -15,11 +15,11 @@
     status_code::StatusCode,
     string::UAString,
     variant::Variant,
-    AnonymousIdentityToken, ApplicationDescription, CallMethodRequest, DataTypeId,
+    AnonymousIdentityToken, ApplicationDescription, CallMethodRequest, DataTypeId, DataValue,
     EndpointDescription, Error, ExpandedNodeId, HistoryUpdateType, IdentityCriteriaType,
     MessageSecurityMode, MonitoredItemCreateRequest, MonitoringMode, MonitoringParameters,
     NumericRange, ObjectId, ReadValueId, ServiceCounterDataType, ServiceFault, SignatureData,
-    UserNameIdentityToken, UserTokenPolicy, UserTokenType,
+    UserNameIdentityToken, UserTokenPolicy, UserTokenType, WriteValue,
 };
 
 use super::PerformUpdateType;
@@ -414,3 +414,29 @@
         Self::Anonymous
     }
 }
+
+impl WriteValue {
+    pub fn new(
+        node_id: NodeId,
+        attribute_id: AttributeId,
+        index_range: UAString,
+        value: DataValue,
+    ) -> Self {
+        Self {
+            node_id,
+            attribute_id: attribute_id as u32,
+            index_range,
+            value,
+        }
+    }
+
+    /// return a WriteValue with AttributeId::Value, which is the most common case
+    pub fn value_attr(node_id: NodeId, val: Variant) -> Self {
+        Self {
+            node_id,
+            attribute_id: AttributeId::Value as u32,
+            index_range: UAString::null(),
+            value: val.into(),
+        }
+    }
+}

async-opcua-types/src/namespaces.rs

@@ -2,7 +2,7 @@
 
 use hashbrown::HashMap;
 
-use crate::{errors::OpcUAError, ExpandedNodeId, NodeId, Variant};
+use crate::{errors::OpcUaError, ExpandedNodeId, NodeId, Variant};
 
 /// Utility for handling assignment of namespaces on server startup.
 #[derive(Debug, Default, Clone)]
@@ -28,15 +28,15 @@ impl NamespaceMap {
 
     /// Create a new namespace map from a vec of variant as we get when reading
     /// the namespace array from the server
-    pub fn new_from_variant_array(array: &[Variant]) -> Result<Self, OpcUAError> {
+    pub fn new_from_variant_array(array: &[Variant]) -> Result<Self, OpcUaError> {
         let known_namespaces: HashMap<String, u16> = array
             .iter()
             .enumerate()
             .map(|(idx, v)| {
                 if let Variant::String(s) = v {
                     Ok((s.value().clone().unwrap_or(String::new()), idx as u16))
                 } else {
-                    Err(OpcUAError::UnexpectedVariantType {
+                    Err(OpcUaError::UnexpectedVariantType {
                         variant_id: v.scalar_type_id(),
                         message: "Namespace array on server contains invalid data".to_string(),
                     })

async-opcua-types/src/node_id.rs

@@ -595,7 +595,7 @@ impl PartialEq<DataTypeId> for NodeId {
     }
 }
 
-static NEXT_NODE_ID_NUMERIC: AtomicUsize = AtomicUsize::new(0);
+static NEXT_NODE_ID_NUMERIC: AtomicUsize = AtomicUsize::new(1);
 
 impl Default for NodeId {
     fn default() -> Self {

async-opcua-types/src/relative_path.rs

@@ -13,6 +13,7 @@ use log::error;
 use regex::Regex;
 
 use crate::{
+    errors::OpcUaError,
     node_id::{Identifier, NodeId},
     qualified_name::QualifiedName,
     string::UAString,
@@ -28,7 +29,7 @@ impl RelativePath {
     /// Converts a string into a relative path. Caller must supply a `node_resolver` which will
     /// be used to look up nodes from their browse name. The function will reject strings
     /// that look unusually long or contain too many elements.
-    pub fn from_str<CB>(path: &str, node_resolver: &CB) -> Result<RelativePath, RelativePathError>
+    pub fn from_str<CB>(path: &str, node_resolver: &CB) -> Result<RelativePath, OpcUaError>
     where
         CB: Fn(u16, &str) -> Option<NodeId>,
     {
@@ -66,14 +67,14 @@ impl RelativePath {
             }
             if token.len() > Self::MAX_TOKEN_LEN {
                 error!("Path segment seems unusually long and has been rejected");
-                return Err(RelativePathError::PathSegmentTooLong);
+                return Err(OpcUaError::PathSegmentTooLong);
             }
         }
 
         if !token.is_empty() {
             if elements.len() == Self::MAX_ELEMENTS {
                 error!("Number of elements in relative path is too long, rejecting it");
-                return Err(RelativePathError::TooManyElements);
+                return Err(OpcUaError::TooManyElementsInPath);
             }
             elements.push(RelativePathElement::from_str(&token, node_resolver)?);
         }
@@ -84,6 +85,50 @@ impl RelativePath {
     }
 }
 
+impl From<&[QualifiedName]> for RelativePath {
+    fn from(value: &[QualifiedName]) -> Self {
+        let elements = value
+            .iter()
+            .map(|qn| RelativePathElement {
+                reference_type_id: ReferenceTypeId::HierarchicalReferences.into(),
+                is_inverse: false,
+                include_subtypes: true,
+                target_name: qn.clone(),
+            })
+            .collect();
+        Self {
+            elements: Some(elements),
+        }
+    }
+}
+// Cannot use
+//impl<T: AsRef<str>> TryFrom<T> for RelativePath {
+// for some strange reasons so implementing all thee manually here
+//
+impl TryFrom<&str> for RelativePath {
+    type Error = OpcUaError;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        RelativePath::from_str(value, &RelativePathElement::default_node_resolver)
+    }
+}
+
+impl TryFrom<&String> for RelativePath {
+    type Error = OpcUaError;
+
+    fn try_from(value: &String) -> Result<Self, Self::Error> {
+        RelativePath::from_str(value, &RelativePathElement::default_node_resolver)
+    }
+}
+
+impl TryFrom<String> for RelativePath {
+    type Error = OpcUaError;
+
+    fn try_from(value: String) -> Result<Self, Self::Error> {
+        RelativePath::from_str(&value, &RelativePathElement::default_node_resolver)
+    }
+}
+
 impl<'a> From<&'a RelativePathElement> for String {
     fn from(element: &'a RelativePathElement) -> String {
         let mut result = element
@@ -226,10 +271,7 @@ impl RelativePathElement {
     /// * `<!NonHierarchicalReferences>foo`
     /// * `<#!2:MyReftype>2:blah`
     ///
-    pub fn from_str<CB>(
-        path: &str,
-        node_resolver: &CB,
-    ) -> Result<RelativePathElement, RelativePathError>
+    pub fn from_str<CB>(path: &str, node_resolver: &CB) -> Result<RelativePathElement, OpcUaError>
     where
         CB: Fn(u16, &str) -> Option<NodeId>,
     {
@@ -270,7 +312,7 @@ impl RelativePathElement {
                             node_resolver(namespace, browse_name)
                         } else {
                             error!("Namespace {} is out of range", namespace);
-                            return Err(RelativePathError::NamespaceOutOfRange);
+                            return Err(OpcUaError::NamespaceOutOfRange);
                         }
                     } else {
                         node_resolver(0, browse_name)
@@ -280,7 +322,7 @@ impl RelativePathElement {
                             "Supplied node resolver was unable to resolve a reference type from {}",
                             path
                         );
-                        return Err(RelativePathError::UnresolvedReferenceType);
+                        return Err(OpcUaError::UnresolvedReferenceType);
                     }
                     (reference_type_id.unwrap(), include_subtypes, is_inverse)
                 }
@@ -293,7 +335,7 @@ impl RelativePathElement {
             })
         } else {
             error!("Path {} does not match a relative path", path);
-            Err(RelativePathError::NoMatch)
+            Err(OpcUaError::NoMatch)
         }
     }
 
@@ -340,21 +382,6 @@ impl RelativePathElement {
     }
 }
 
-#[derive(Debug, Clone)]
-/// Error returned from parsing a relative path.
-pub enum RelativePathError {
-    /// Namespace is out of range of a u16.
-    NamespaceOutOfRange,
-    /// Supplied node resolver was unable to resolve a reference type.
-    UnresolvedReferenceType,
-    /// Path does not match a relative path.
-    NoMatch,
-    /// Path segment is unusually long and has been rejected.
-    PathSegmentTooLong,
-    /// Number of elements in relative path is too large.
-    TooManyElements,
-}
-
 impl<'a> From<&'a RelativePath> for String {
     fn from(path: &'a RelativePath) -> String {
         if let Some(ref elements) = path.elements {
@@ -398,7 +425,7 @@ fn unescape_browse_name(name: &str) -> String {
 /// * 0:foo
 /// * bar
 ///
-fn target_name(target_name: &str) -> Result<QualifiedName, RelativePathError> {
+fn target_name(target_name: &str) -> Result<QualifiedName, OpcUaError> {
     static RE: LazyLock<Regex> =
         LazyLock::new(|| Regex::new(r"((?P<nsidx>[0-9+]):)?(?P<name>.*)").unwrap());
     if let Some(captures) = RE.captures(target_name) {
@@ -410,7 +437,7 @@ fn target_name(target_name: &str) -> Result<QualifiedName, RelativePathError> {
                     "Namespace {} for target name is out of range",
                     namespace.as_str()
                 );
-                return Err(RelativePathError::NamespaceOutOfRange);
+                return Err(OpcUaError::NamespaceOutOfRange);
             }
         } else {
             0

samples/custom-structures-client/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "opcua-structure-client"
+version = "0.13.0"                    # OPCUARustVersion
+authors = ["Rust-OpcUa contributors"]
+edition = "2021"
+
+[dependencies]
+pico-args = "0.5"
+tokio = { version = "1.36.0", features = ["full"] }
+log = { workspace = true }
+
+[dependencies.async-opcua]
+path = "../../async-opcua"
+version = "0.13.0"                       # OPCUARustVersion
+features = ["client", "console-logging"]
+default-features = false
+
+[features]
+default = ["json", "xml"]
+json = ["async-opcua/json"]
+xml = ["async-opcua/xml"]

samples/custom-structures-client/README.md

@@ -0,0 +1,6 @@
+To run this sample:
+
+1. Launch `samples/demo-server` as that server exposes custom enums and variables
+2. Run as `cargo run`
+
+The client connects to the server, reads a variable and disconnects.