mssf-core 0.5.0

Rust for Azure Service Fabric. Rust safe APIs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// --------------------------------------------------

use mssf_com::FabricClient::{
    IFabricClientConnectionEventHandler, IFabricClientConnectionEventHandler_Impl,
    IFabricGatewayInformationResult,
};

use crate::{WString, types::NodeId};

/// Internal trait that rust code implements that can be bridged into IFabricClientConnectionEventHandler.
/// Not exposed to user.
pub trait ClientConnectionEventHandler: 'static {
    fn on_connected(&self, info: &GatewayInformationResult) -> crate::Result<()>;
    fn on_disconnected(&self, info: &GatewayInformationResult) -> crate::Result<()>;
}

/// FabricClient connection information.
/// Traslated from IFabricGatewayInformationResult
#[derive(Debug, Clone)]
pub struct GatewayInformationResult {
    pub node_address: crate::WString,
    pub node_id: NodeId,
    pub node_instance_id: u64,
    pub node_name: crate::WString,
}

impl From<&IFabricGatewayInformationResult> for GatewayInformationResult {
    fn from(com: &IFabricGatewayInformationResult) -> Self {
        let info = unsafe { com.get_GatewayInformation().as_ref().unwrap() };
        Self {
            node_address: WString::from(info.NodeAddress),
            node_id: info.NodeId.into(),
            node_instance_id: info.NodeInstanceId,
            node_name: WString::from(info.NodeName),
        }
    }
}

/// Bridge for IFabricClientConnectionEventHandler.
/// Turn rust trait into SF com object.
#[windows_core::implement(IFabricClientConnectionEventHandler)]
pub struct ClientConnectionEventHandlerBridge<T>
where
    T: ClientConnectionEventHandler,
{
    inner: T,
}

impl<T> ClientConnectionEventHandlerBridge<T>
where
    T: ClientConnectionEventHandler,
{
    pub fn new(inner: T) -> Self {
        Self { inner }
    }
    pub fn new_com(inner: T) -> IFabricClientConnectionEventHandler {
        Self::new(inner).into()
    }
}

impl<T> IFabricClientConnectionEventHandler_Impl for ClientConnectionEventHandlerBridge_Impl<T>
where
    T: ClientConnectionEventHandler,
{
    fn OnConnected(
        &self,
        gw_info: windows_core::Ref<IFabricGatewayInformationResult>,
    ) -> crate::WinResult<()> {
        let info = GatewayInformationResult::from(gw_info.unwrap());
        self.inner
            .on_connected(&info)
            .map_err(crate::WinError::from)
    }

    fn OnDisconnected(
        &self,
        gw_info: windows_core::Ref<IFabricGatewayInformationResult>,
    ) -> crate::WinResult<()> {
        let info = GatewayInformationResult::from(gw_info.unwrap());
        self.inner
            .on_disconnected(&info)
            .map_err(crate::WinError::from)
    }
}

/// Connection notification function signature to avoid code repeatition.
/// Trait alias feature in rust (not yet stable) would eliminate this trait definition.
pub trait ConnectionNotificationFn:
    Fn(&GatewayInformationResult) -> crate::Result<()> + 'static
{
}
impl<T: Fn(&GatewayInformationResult) -> crate::Result<()> + 'static> ConnectionNotificationFn
    for T
{
}

/// Lambda implementation of the ClientConnectionEventHandler trait.
/// This is used in FabricClientBuilder to build handler from functions.
pub struct LambdaClientConnectionNotificationHandler {
    f_conn: Option<Box<dyn ConnectionNotificationFn>>,
    f_disconn: Option<Box<dyn ConnectionNotificationFn>>,
}

impl LambdaClientConnectionNotificationHandler {
    pub fn new() -> Self {
        Self {
            f_conn: None,
            f_disconn: None,
        }
    }

    /// Set the on_connected callback.
    pub fn set_f_conn(&mut self, f: impl ConnectionNotificationFn) {
        self.f_conn = Some(Box::new(f));
    }

    /// Set the on_disconnected callback.
    pub fn set_f_disconn(&mut self, f: impl ConnectionNotificationFn) {
        self.f_disconn = Some(Box::new(f));
    }
}

impl ClientConnectionEventHandler for LambdaClientConnectionNotificationHandler {
    fn on_connected(&self, info: &GatewayInformationResult) -> crate::Result<()> {
        if let Some(f) = &self.f_conn {
            f(info)
        } else {
            Ok(())
        }
    }

    fn on_disconnected(&self, info: &GatewayInformationResult) -> crate::Result<()> {
        if let Some(f) = &self.f_disconn {
            f(info)
        } else {
            Ok(())
        }
    }
}