msggen: add override for connect notification in cln-rpc aswell

Changelog-None

Author: daywalker90

cln-rpc/src/notifications.rs

@@ -44,37 +44,37 @@ pub struct ChannelOpenedNotification {
 /// ['Direction of the connection']
 #[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
-pub enum ConnectDirection {
+pub enum PeerConnectDirection {
     #[serde(rename = "in")]
     IN = 0,
     #[serde(rename = "out")]
     OUT = 1,
 }
 
-impl TryFrom<i32> for ConnectDirection {
+impl TryFrom<i32> for PeerConnectDirection {
     type Error = anyhow::Error;
-    fn try_from(c: i32) -> Result<ConnectDirection, anyhow::Error> {
+    fn try_from(c: i32) -> Result<PeerConnectDirection, anyhow::Error> {
         match c {
-    0 => Ok(ConnectDirection::IN),
-    1 => Ok(ConnectDirection::OUT),
-            o => Err(anyhow::anyhow!("Unknown variant {} for enum ConnectDirection", o)),
+    0 => Ok(PeerConnectDirection::IN),
+    1 => Ok(PeerConnectDirection::OUT),
+            o => Err(anyhow::anyhow!("Unknown variant {} for enum PeerConnectDirection", o)),
         }
     }
 }
 
-impl ToString for ConnectDirection {
+impl ToString for PeerConnectDirection {
     fn to_string(&self) -> String {
         match self {
-            ConnectDirection::IN => "IN",
-            ConnectDirection::OUT => "OUT",
+            PeerConnectDirection::IN => "IN",
+            PeerConnectDirection::OUT => "OUT",
         }.to_string()
     }
 }
 
 /// ['Type of connection (*torv2*/*torv3* only if **direction** is *out*)']
 #[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
 #[allow(non_camel_case_types)]
-pub enum ConnectAddressType {
+pub enum PeerConnectAddressType {
     #[serde(rename = "local socket")]
     LOCAL_SOCKET = 0,
     #[serde(rename = "ipv4")]
@@ -87,28 +87,28 @@ pub enum ConnectAddressType {
     TORV3 = 4,
 }
 
-impl TryFrom<i32> for ConnectAddressType {
+impl TryFrom<i32> for PeerConnectAddressType {
     type Error = anyhow::Error;
-    fn try_from(c: i32) -> Result<ConnectAddressType, anyhow::Error> {
+    fn try_from(c: i32) -> Result<PeerConnectAddressType, anyhow::Error> {
         match c {
-    0 => Ok(ConnectAddressType::LOCAL_SOCKET),
-    1 => Ok(ConnectAddressType::IPV4),
-    2 => Ok(ConnectAddressType::IPV6),
-    3 => Ok(ConnectAddressType::TORV2),
-    4 => Ok(ConnectAddressType::TORV3),
-            o => Err(anyhow::anyhow!("Unknown variant {} for enum ConnectAddressType", o)),
+    0 => Ok(PeerConnectAddressType::LOCAL_SOCKET),
+    1 => Ok(PeerConnectAddressType::IPV4),
+    2 => Ok(PeerConnectAddressType::IPV6),
+    3 => Ok(PeerConnectAddressType::TORV2),
+    4 => Ok(PeerConnectAddressType::TORV3),
+            o => Err(anyhow::anyhow!("Unknown variant {} for enum PeerConnectAddressType", o)),
         }
     }
 }
 
-impl ToString for ConnectAddressType {
+impl ToString for PeerConnectAddressType {
     fn to_string(&self) -> String {
         match self {
-            ConnectAddressType::LOCAL_SOCKET => "LOCAL_SOCKET",
-            ConnectAddressType::IPV4 => "IPV4",
-            ConnectAddressType::IPV6 => "IPV6",
-            ConnectAddressType::TORV2 => "TORV2",
-            ConnectAddressType::TORV3 => "TORV3",
+            PeerConnectAddressType::LOCAL_SOCKET => "LOCAL_SOCKET",
+            PeerConnectAddressType::IPV4 => "IPV4",
+            PeerConnectAddressType::IPV6 => "IPV6",
+            PeerConnectAddressType::TORV2 => "TORV2",
+            PeerConnectAddressType::TORV3 => "TORV3",
         }.to_string()
     }
 }

contrib/msggen/msggen/gen/rpc/notification.py

@@ -5,6 +5,7 @@
 from msggen.model import Service
 from msggen.gen.generator import IGenerator
 from msggen.gen.rpc.rust import gen_composite
+from msggen.gen.grpc.util import notification_typename_overrides
 
 
 class NotificationGenerator(IGenerator):
@@ -43,7 +44,7 @@ def generate(self, service: Service) -> None:
         self.write("\n\n")
 
         for notification in service.notifications:
-            _, resp_decl = gen_composite(notification.response, self.meta)
+            _, resp_decl = gen_composite(notification.response, self.meta, notification_typename_overrides)
             self.write(resp_decl)
 
         self.write("pub mod requests{\n")

contrib/msggen/msggen/gen/rpc/rust.py

@@ -71,22 +71,22 @@ def normalize_varname(field):
     return field
 
 
-def gen_field(field, meta):
+def gen_field(field, meta, override=None):
     if field.omit():
         return ("", "")
     if isinstance(field, CompositeField):
-        return gen_composite(field, meta)
+        return gen_composite(field, meta, override)
     elif isinstance(field, EnumField):
-        return gen_enum(field, meta)
+        return gen_enum(field, meta, override)
     elif isinstance(field, ArrayField):
-        return gen_array(field, meta)
+        return gen_array(field, meta, override)
     elif isinstance(field, PrimitiveField):
         return gen_primitive(field)
     else:
         raise TypeError(f"Unmanaged type {field}")
 
 
-def gen_enum(e, meta):
+def gen_enum(e, meta, override):
     defi, decl = "", ""
 
     if e.omit():
@@ -95,14 +95,21 @@ def gen_enum(e, meta):
     if e.description != "":
         decl += f"/// {e.description}\n"
 
+    if override is None:
+        message_name = e.typename.name
+        override = lambda x: x
+        typename = override(str(e.typename))
+    else:
+        typename = override(str(e.typename))
+        message_name = typename
+
     if e.deprecated:
         decl += "#[deprecated]\n"
-    decl += f"#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]\n#[allow(non_camel_case_types)]\npub enum {e.typename} {{\n"
+    decl += f"#[derive(Copy, Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]\n#[allow(non_camel_case_types)]\npub enum {typename} {{\n"
 
     m = meta["grpc-field-map"]
     m2 = meta["grpc-enum-map"]
 
-    message_name = e.typename.name
     assert not (message_name in m and message_name in m2)
     if message_name in m:
         m = m[message_name]
@@ -130,9 +137,9 @@ def gen_enum(e, meta):
     # representation
     decl += dedent(
         f"""\
-    impl TryFrom<i32> for {e.typename} {{
+    impl TryFrom<i32> for {typename} {{
         type Error = anyhow::Error;
-        fn try_from(c: i32) -> Result<{e.typename}, anyhow::Error> {{
+        fn try_from(c: i32) -> Result<{typename}, anyhow::Error> {{
             match c {{
     """
     )
@@ -141,16 +148,16 @@ def gen_enum(e, meta):
         for v in sorted_variants:
             norm = v.normalized()
             # decl += f"    #[serde(rename = \"{v}\")]\n"
-            decl += f"    {m[str(v)]} => Ok({e.typename}::{norm}),\n"
+            decl += f"    {m[str(v)]} => Ok({typename}::{norm}),\n"
     else:
         for i, v in enumerate(e.variants):
             norm = v.normalized()
             # decl += f"    #[serde(rename = \"{v}\")]\n"
-            decl += f"    {i} => Ok({e.typename}::{norm}),\n"
+            decl += f"    {i} => Ok({typename}::{norm}),\n"
 
     decl += dedent(
         f"""\
-                o => Err(anyhow::anyhow!("Unknown variant {{}} for enum {e.typename}", o)),
+                o => Err(anyhow::anyhow!("Unknown variant {{}} for enum {typename}", o)),
             }}
         }}
     }}
@@ -162,14 +169,14 @@ def gen_enum(e, meta):
     # appear in the schemas.
     decl += dedent(
         f"""\
-    impl ToString for {e.typename} {{
+    impl ToString for {typename} {{
         fn to_string(&self) -> String {{
             match self {{
     """
     )
     for v in e.variants:
         norm = v.normalized()
-        decl += f'            {e.typename}::{norm} => "{norm}",\n'
+        decl += f'            {typename}::{norm} => "{norm}",\n'
     decl += dedent(
         f"""\
             }}.to_string()
@@ -179,8 +186,6 @@ def gen_enum(e, meta):
     """
     )
 
-    typename = e.typename
-
     if e.override() is not None:
         decl = ""  # No declaration if we have an override
         typename = e.override()
@@ -220,10 +225,10 @@ def rename_if_necessary(original, name):
         return f""
 
 
-def gen_array(a, meta):
+def gen_array(a, meta, override=None):
     name = a.name.normalized().replace("[]", "")
     logger.debug(f"Generating array field {a.name} -> {name} ({a.path})")
-    _, decl = gen_field(a.itemtype, meta)
+    _, decl = gen_field(a.itemtype, meta, override)
 
     if a.override():
         decl = ""  # No declaration if we have an override
@@ -254,11 +259,11 @@ def gen_array(a, meta):
     return (defi, decl)
 
 
-def gen_composite(c, meta) -> Tuple[str, str]:
+def gen_composite(c, meta, override=None) -> Tuple[str, str]:
     logger.debug(f"Generating composite field {c.name} ({c.path})")
     fields = []
     for f in c.fields:
-        fields.append(gen_field(f, meta))
+        fields.append(gen_field(f, meta, override))
     fields = sorted(fields)
 
     r = "".join([f[1] for f in fields])