Discoverabiltiy in kuksa.val.v1 API to enable e.g. Autocompletion

kuksa-client/kuksa_client/grpc/__init__.py

@@ -315,7 +315,6 @@ def from_message(cls, message: types_pb2.Datapoint):
             ) if message.HasField('timestamp') else None,
         )
 
-
     def cast_array_values(cast, array):
         """
         Parses array input and cast individual values to wanted type.
@@ -339,7 +338,7 @@ def cast_array_values(cast, array):
             # My Way
             # ... without quotes
             if item.strip() == '':
-                #skip
+                # skip
                 pass
             else:
                 yield cast(item)
@@ -365,7 +364,7 @@ def cast_str(value) -> str:
         new_val = new_val.replace('\\\"', '\"')
         new_val = new_val.replace("\\\'", "\'")
         return new_val
-            
+
     def to_message(self, value_type: DataType) -> types_pb2.Datapoint:
         message = types_pb2.Datapoint()
 
@@ -374,7 +373,6 @@ def set_array_attr(obj, attr, values):
             array.Clear()
             array.values.extend(values)
 
-
         field, set_field, cast_field = {
             DataType.INT8: ('int32', setattr, int),
             DataType.INT16: ('int32', setattr, int),
@@ -388,29 +386,29 @@ def set_array_attr(obj, attr, values):
             DataType.DOUBLE: ('double', setattr, float),
             DataType.BOOLEAN: ('bool', setattr, Datapoint.cast_bool),
             DataType.STRING: ('string', setattr, Datapoint.cast_str),
-            DataType.INT8_ARRAY: ('int32_array', set_array_attr, 
+            DataType.INT8_ARRAY: ('int32_array', set_array_attr,
                                   lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.INT16_ARRAY: ('int32_array', set_array_attr, 
+            DataType.INT16_ARRAY: ('int32_array', set_array_attr,
                                    lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.INT32_ARRAY: ('int32_array', set_array_attr, 
+            DataType.INT32_ARRAY: ('int32_array', set_array_attr,
                                    lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.UINT8_ARRAY: ('uint32_array', set_array_attr, 
+            DataType.UINT8_ARRAY: ('uint32_array', set_array_attr,
                                    lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.UINT16_ARRAY: ('uint32_array', set_array_attr, 
+            DataType.UINT16_ARRAY: ('uint32_array', set_array_attr,
                                     lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.UINT32_ARRAY: ('uint32_array', set_array_attr, 
+            DataType.UINT32_ARRAY: ('uint32_array', set_array_attr,
                                     lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.UINT64_ARRAY: ('uint64_array', set_array_attr, 
+            DataType.UINT64_ARRAY: ('uint64_array', set_array_attr,
                                     lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.INT64_ARRAY: ('int64_array', set_array_attr, 
+            DataType.INT64_ARRAY: ('int64_array', set_array_attr,
                                    lambda array: Datapoint.cast_array_values(int, array)),
-            DataType.FLOAT_ARRAY: ('float_array', set_array_attr, 
+            DataType.FLOAT_ARRAY: ('float_array', set_array_attr,
                                    lambda array: Datapoint.cast_array_values(float, array)),
-            DataType.DOUBLE_ARRAY: ('double_array', set_array_attr, 
+            DataType.DOUBLE_ARRAY: ('double_array', set_array_attr,
                                     lambda array: Datapoint.cast_array_values(float, array)),
-            DataType.BOOLEAN_ARRAY: ('bool_array', set_array_attr, 
+            DataType.BOOLEAN_ARRAY: ('bool_array', set_array_attr,
                                      lambda array: Datapoint.cast_array_values(Datapoint.cast_bool, array)),
-            DataType.STRING_ARRAY: ('string_array', set_array_attr, 
+            DataType.STRING_ARRAY: ('string_array', set_array_attr,
                                     lambda array: Datapoint.cast_array_values(Datapoint.cast_str, array)),
         }.get(value_type, (None, None, None))
         if self.value is not None:
@@ -523,6 +521,7 @@ class ServerInfo:
     def from_message(cls, message: val_pb2.GetServerInfoResponse):
         return cls(name=message.name, version=message.version)
 
+
 class BaseVSSClient:
     def __init__(
         self,
@@ -536,7 +535,6 @@ def __init__(
         connected: bool = False,
         tls_server_name: Optional[str] = None
     ):
-
 
         self.authorization_header = self.get_authorization_header(token)
         self.target_host = f'{host}:{port}'
@@ -559,11 +557,10 @@ def _load_creds(self) -> Optional[grpc.ChannelCredentials]:
                 logger.info("Using client private key and certificates, mutual TLS supported if supported by server")
                 return grpc.ssl_channel_credentials(root_certificates, private_key, certificate_chain)
             else:
-                logger.info(f"No client certificates provided, mutual TLS not supported!")
+                logger.info("No client certificates provided, mutual TLS not supported!")
                 return grpc.ssl_channel_credentials(root_certificates)
-        logger.info(f"No Root CA present, it will not be posible to use a secure connection!")
+        logger.info("No Root CA present, it will not be posible to use a secure connection!")
         return None
-
 
     def _prepare_get_request(self, entries: Iterable[EntryRequest]) -> val_pb2.GetRequest:
         req = val_pb2.GetRequest(entries=[])
@@ -649,7 +646,7 @@ def get_authorization_header(self, token: str):
         return "Bearer " + token
 
     def generate_metadata_header(self, metadata: list, header=None) -> list:
-        if header == None:
+        if header is None:
             header = self.authorization_header
         if metadata:
             metadata = dict(metadata)
@@ -686,20 +683,20 @@ def connect(self, target_host=None):
         creds = self._load_creds()
         if target_host is None:
             target_host = self.target_host
-            
+
         if creds is not None:
             logger.info("Establishing secure channel")
             if self.tls_server_name:
-                logger.info(f"Using TLS server name {self.tls_server_name}")
+                logger.info("Using TLS server name {self.tls_server_name}")
                 options = [('grpc.ssl_target_name_override', self.tls_server_name)]
                 channel = grpc.secure_channel(target_host, creds, options)
             else:
-                logger.debug(f"Not providing explicit TLS server name")
+                logger.debug("Not providing explicit TLS server name")
                 channel = grpc.secure_channel(target_host, creds)
         else:
             logger.info("Establishing insecure channel")
             channel = grpc.insecure_channel(target_host)
-            
+
         self.channel = self.exit_stack.enter_context(channel)
         self.client_stub = val_pb2_grpc.VALStub(self.channel)
         self.connected = True
@@ -973,7 +970,6 @@ def get_server_info(self, **rpc_kwargs) -> Optional[ServerInfo]:
             else:
                 raise VSSClientError.from_grpc_error(exc) from exc
         return None
-
 
     def get_value_types(self, paths: Collection[str], **rpc_kwargs) -> Dict[str, DataType]:
         """

kuksa_databroker/databroker/src/broker.rs

@@ -882,6 +882,48 @@ impl<'a, 'b> DatabaseReadAccess<'a, 'b> {
         }
     }
 
+    pub fn get_entries_by_wildcards_with_regex(
+        &self,
+        regex: regex::Regex
+    ) -> Result<Vec<Entry>, ReadError> {
+        let mut entries: Vec<Entry> = Vec::new();
+        for key in self.db.path_to_id.keys() {
+            if regex.is_match(key) {
+                entries.push(
+                    self.get_entry_by_id(self.db.path_to_id.get(key).unwrap().to_owned())
+                        .unwrap()
+                        .to_owned(),
+                );
+            }
+        }
+        if entries.is_empty() {
+            return Err(ReadError::NotFound);
+        }
+
+        Ok(entries)
+    }
+
+    pub fn get_entries_by_wildcards(
+        &self,
+        sub_path: impl AsRef<str>,
+    ) -> Result<Vec<Entry>, ReadError> {
+        let mut entries: Vec<Entry> = Vec::new();
+        for key in self.db.path_to_id.keys() {
+            if key.contains(sub_path.as_ref()) {
+                entries.push(
+                    self.get_entry_by_id(self.db.path_to_id.get(key).unwrap().to_owned())
+                        .unwrap()
+                        .to_owned(),
+                );
+            }
+        }
+        if entries.is_empty() {
+            return Err(ReadError::NotFound);
+        }
+
+        Ok(entries)
+    }
+
     pub fn get_metadata_by_id(&self, id: i32) -> Option<&Metadata> {
         self.db.entries.get(&id).map(|entry| &entry.metadata)
     }
@@ -1159,6 +1201,24 @@ impl<'a, 'b> AuthorizedAccess<'a, 'b> {
             .cloned()
     }
 
+    pub async fn get_entries_by_wildcards(&self, sub_path: &str) -> Result<Vec<Entry>, ReadError> {
+        self.broker
+            .database
+            .read()
+            .await
+            .authorized_read_access(self.permissions)
+            .get_entries_by_wildcards(sub_path)
+    }
+
+    pub async fn get_entries_by_wildcards_with_regex(&self, regex: &regex::Regex) -> Result<Vec<Entry>, ReadError> {
+        self.broker
+            .database
+            .read()
+            .await
+            .authorized_read_access(self.permissions)
+            .get_entries_by_wildcards_with_regex(regex.clone())
+    }
+
     pub async fn get_entry_by_id(&self, id: i32) -> Result<Entry, ReadError> {
         self.broker
             .database

kuksa_databroker/databroker/src/glob.rs

@@ -13,6 +13,7 @@
 
 use regex::Regex;
 
+#[derive(Debug)]
 pub enum Error {
     RegexError,
 }
@@ -51,3 +52,70 @@ pub fn to_regex(glob: &str) -> Result<Regex, Error> {
     let re = to_regex_string(glob);
     Regex::new(&re).map_err(|_err| Error::RegexError)
 }
+
+pub fn to_regex_string_new(glob: &str) -> String {
+    // Construct regular expression
+
+    // Make sure we match the whole thing
+    // Start from the beginning
+    let mut re = String::from("^");
+
+    // Replace all "standalone" wildcards with ".*"
+    re.push_str(
+        &glob
+            .split('.')
+            .map(|part| match part {
+                "*" => "[^.]+",
+                "**" => ".*",
+                other => other,
+            })
+            .collect::<Vec<&str>>()
+            .join(r"\."),
+    );
+    // And finally, make sure we match until EOL
+    re.push('$');
+
+    re
+}
+
+pub fn to_regex_new(glob: &str) -> Result<Regex, Error> {
+    let re = to_regex_string_new(glob);
+    Regex::new(&re).map_err(|_err| Error::RegexError)
+}
+
+pub fn matches_path_pattern(input: &str) -> bool {
+    let pattern = r"^(?:\w+(?:\.\w+)*)(?:\.\*+)?$";
+    let regex = Regex::new(pattern).unwrap();
+
+    let pattern2 = r"^(\*{2}|\*\.)?[^.]+(\.[^.]+)*\.(\*{2}|\*|[A-Za-z]+)(\.[^.]+)*\.[^.]+$";
+    let regex2 = Regex::new(pattern2).unwrap();
+
+    regex.is_match(input) || regex2.is_match(input)
+}
+
+#[tokio::test]
+async fn test_valid_request_path() {
+    assert_eq!(matches_path_pattern("String.*"), true);
+    assert_eq!(matches_path_pattern("String.**"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String.*"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String.**"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String.String.**"), true);
+    assert_eq!(matches_path_pattern("String.String.String.*.String"), true);
+    assert_eq!(matches_path_pattern("String.String.String.**.String"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String.String.**.String"), true);
+    assert_eq!(matches_path_pattern("String.String.String.String.*.String.String"), true);
+    assert_eq!(matches_path_pattern("String.*.String.String"), true);
+    assert_eq!(matches_path_pattern("String.String.**.String.String"), true);
+    assert_eq!(matches_path_pattern("String.**.String.String"), true);
+    assert_eq!(matches_path_pattern("String.String.String."), false);
+    assert_eq!(matches_path_pattern("String.String.String.String.."), false);
+    assert_eq!(matches_path_pattern("String.*.String.String.."), false);
+    assert_eq!(matches_path_pattern("*.String.String.String.."), false);
+    assert_eq!(matches_path_pattern("*.String.String.String"), true);
+    assert_eq!(matches_path_pattern("**.String.String.String.**"), true);
+    assert_eq!(matches_path_pattern("**.String.String.String.*"), true);
+    assert_eq!(matches_path_pattern("**.String"), true);
+    //assert_eq!(matches_path_pattern("*.String"), true);
+
+}