393 lines
15 KiB
Rust
393 lines
15 KiB
Rust
// Copyright 2015-2019 Parity Technologies (UK) Ltd.
|
|
// This file is part of Parity Ethereum.
|
|
|
|
// Parity Ethereum is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// Parity Ethereum is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Parity Ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
use std::collections::{BTreeSet, BTreeMap};
|
|
use std::collections::btree_map::Entry;
|
|
use std::net::SocketAddr;
|
|
use std::sync::Arc;
|
|
use ethereum_types::H256;
|
|
use ethkey::Public;
|
|
use key_server_cluster::{KeyServerSet, KeyServerSetSnapshot};
|
|
use key_server_cluster::cluster::{ClusterConfiguration, ServersSetChangeParams};
|
|
use key_server_cluster::cluster_sessions::AdminSession;
|
|
use key_server_cluster::cluster_connections::{Connection};
|
|
use key_server_cluster::cluster_connections_net::{NetConnectionsContainer};
|
|
use types::{Error, NodeId};
|
|
use NodeKeyPair;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
/// Describes which maintain() call is required.
|
|
pub enum Maintain {
|
|
/// We need to maintain() both connections && session.
|
|
SessionAndConnections,
|
|
/// Only call maintain_session.
|
|
Session,
|
|
/// Only call maintain_connections.
|
|
Connections,
|
|
}
|
|
|
|
/// Connection trigger, which executes necessary actions when set of key servers changes.
|
|
pub trait ConnectionTrigger: Send + Sync {
|
|
/// On maintain interval.
|
|
fn on_maintain(&mut self) -> Option<Maintain>;
|
|
/// When connection is established.
|
|
fn on_connection_established(&mut self, node: &NodeId) -> Option<Maintain>;
|
|
/// When connection is closed.
|
|
fn on_connection_closed(&mut self, node: &NodeId) -> Option<Maintain>;
|
|
/// Maintain active sessions. Returns Some if servers set session creation required.
|
|
fn maintain_session(&mut self) -> Option<ServersSetChangeParams>;
|
|
/// Maintain active connections.
|
|
fn maintain_connections(&mut self, connections: &mut NetConnectionsContainer);
|
|
/// Return connector for the servers set change session creator.
|
|
fn servers_set_change_creator_connector(&self) -> Arc<ServersSetChangeSessionCreatorConnector>;
|
|
}
|
|
|
|
/// Servers set change session creator connector.
|
|
pub trait ServersSetChangeSessionCreatorConnector: Send + Sync {
|
|
/// Get actual administrator public key. For manual-migration configuration it is the pre-configured
|
|
/// administrator key. For auto-migration configurations it is the key of actual MigrationSession master node.
|
|
fn admin_public(&self, migration_id: Option<&H256>, new_server_set: BTreeSet<NodeId>) -> Result<Public, Error>;
|
|
/// Set active servers set change session.
|
|
fn set_key_servers_set_change_session(&self, session: Arc<AdminSession>);
|
|
}
|
|
|
|
/// Simple connection trigger, which only keeps connections to current_set.
|
|
pub struct SimpleConnectionTrigger {
|
|
/// Key server set cluster.
|
|
key_server_set: Arc<KeyServerSet>,
|
|
/// Trigger connections.
|
|
connections: TriggerConnections,
|
|
/// Servers set change session creator connector.
|
|
connector: Arc<ServersSetChangeSessionCreatorConnector>,
|
|
}
|
|
|
|
/// Simple Servers set change session creator connector, which will just return
|
|
/// pre-configured administartor public when asked.
|
|
pub struct SimpleServersSetChangeSessionCreatorConnector {
|
|
/// Secret store administrator public key.
|
|
pub admin_public: Option<Public>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq)]
|
|
/// Action with trigger connections.
|
|
pub enum ConnectionsAction {
|
|
/// Connect to nodes from old set only.
|
|
ConnectToCurrentSet,
|
|
/// Connect to nodes from migration set.
|
|
ConnectToMigrationSet,
|
|
}
|
|
|
|
/// Trigger connections.
|
|
pub struct TriggerConnections {
|
|
/// This node key pair.
|
|
pub self_key_pair: Arc<NodeKeyPair>,
|
|
}
|
|
|
|
impl SimpleConnectionTrigger {
|
|
/// Create new simple from cluster configuration.
|
|
pub fn with_config(config: &ClusterConfiguration) -> Self {
|
|
Self::new(config.key_server_set.clone(), config.self_key_pair.clone(), config.admin_public)
|
|
}
|
|
|
|
/// Create new simple connection trigger.
|
|
pub fn new(key_server_set: Arc<KeyServerSet>, self_key_pair: Arc<NodeKeyPair>, admin_public: Option<Public>) -> Self {
|
|
SimpleConnectionTrigger {
|
|
key_server_set: key_server_set,
|
|
connections: TriggerConnections {
|
|
self_key_pair: self_key_pair,
|
|
},
|
|
connector: Arc::new(SimpleServersSetChangeSessionCreatorConnector {
|
|
admin_public: admin_public,
|
|
}),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ConnectionTrigger for SimpleConnectionTrigger {
|
|
fn on_maintain(&mut self) -> Option<Maintain> {
|
|
Some(Maintain::Connections)
|
|
}
|
|
|
|
fn on_connection_established(&mut self, _node: &NodeId) -> Option<Maintain> {
|
|
None
|
|
}
|
|
|
|
fn on_connection_closed(&mut self, _node: &NodeId) -> Option<Maintain> {
|
|
// we do not want to reconnect after every connection close
|
|
// because it could be a part of something bigger
|
|
None
|
|
}
|
|
|
|
fn maintain_session(&mut self) -> Option<ServersSetChangeParams> {
|
|
None
|
|
}
|
|
|
|
fn maintain_connections(&mut self, connections: &mut NetConnectionsContainer) {
|
|
self.connections.maintain(ConnectionsAction::ConnectToCurrentSet, connections, &self.key_server_set.snapshot())
|
|
}
|
|
|
|
fn servers_set_change_creator_connector(&self) -> Arc<ServersSetChangeSessionCreatorConnector> {
|
|
self.connector.clone()
|
|
}
|
|
}
|
|
|
|
impl ServersSetChangeSessionCreatorConnector for SimpleServersSetChangeSessionCreatorConnector {
|
|
fn admin_public(&self, _migration_id: Option<&H256>, _new_server_set: BTreeSet<NodeId>) -> Result<Public, Error> {
|
|
self.admin_public.clone().ok_or(Error::AccessDenied)
|
|
}
|
|
|
|
fn set_key_servers_set_change_session(&self, _session: Arc<AdminSession>) {
|
|
}
|
|
}
|
|
|
|
impl TriggerConnections {
|
|
pub fn maintain(&self, action: ConnectionsAction, data: &mut NetConnectionsContainer, server_set: &KeyServerSetSnapshot) {
|
|
match action {
|
|
ConnectionsAction::ConnectToCurrentSet => {
|
|
adjust_connections(self.self_key_pair.public(), data, &server_set.current_set);
|
|
},
|
|
ConnectionsAction::ConnectToMigrationSet => {
|
|
let migration_set = server_set.migration.as_ref().map(|s| s.set.clone()).unwrap_or_default();
|
|
adjust_connections(self.self_key_pair.public(), data, &migration_set);
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
fn adjust_connections(
|
|
self_node_id: &NodeId,
|
|
data: &mut NetConnectionsContainer,
|
|
required_set: &BTreeMap<NodeId, SocketAddr>
|
|
) {
|
|
if !required_set.contains_key(self_node_id) {
|
|
if !data.is_isolated {
|
|
trace!(target: "secretstore_net", "{}: isolated from cluser", self_node_id);
|
|
}
|
|
|
|
data.is_isolated = true;
|
|
data.connections.clear();
|
|
data.nodes.clear();
|
|
return;
|
|
}
|
|
|
|
data.is_isolated = false;
|
|
for node_to_disconnect in select_nodes_to_disconnect(&data.nodes, required_set) {
|
|
if let Entry::Occupied(entry) = data.connections.entry(node_to_disconnect.clone()) {
|
|
trace!(target: "secretstore_net", "{}: adjusting connections - removing connection to {} at {}",
|
|
self_node_id, entry.get().node_id(), entry.get().node_address());
|
|
entry.remove();
|
|
}
|
|
|
|
data.nodes.remove(&node_to_disconnect);
|
|
}
|
|
|
|
for (node_to_connect, node_addr) in required_set {
|
|
if node_to_connect != self_node_id {
|
|
data.nodes.insert(node_to_connect.clone(), node_addr.clone());
|
|
}
|
|
}
|
|
}
|
|
|
|
fn select_nodes_to_disconnect(current_set: &BTreeMap<NodeId, SocketAddr>, new_set: &BTreeMap<NodeId, SocketAddr>) -> Vec<NodeId> {
|
|
current_set.iter()
|
|
.filter(|&(node_id, node_addr)| match new_set.get(node_id) {
|
|
Some(new_node_addr) => node_addr != new_node_addr,
|
|
None => true,
|
|
})
|
|
.map(|(node_id, _)| node_id.clone())
|
|
.collect()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use std::collections::BTreeSet;
|
|
use std::sync::Arc;
|
|
use ethkey::{Random, Generator};
|
|
use key_server_cluster::{MapKeyServerSet, PlainNodeKeyPair, KeyServerSetSnapshot, KeyServerSetMigration};
|
|
use key_server_cluster::cluster_connections_net::NetConnectionsContainer;
|
|
use super::{Maintain, TriggerConnections, ConnectionsAction, ConnectionTrigger, SimpleConnectionTrigger,
|
|
select_nodes_to_disconnect, adjust_connections};
|
|
|
|
fn default_connection_data() -> NetConnectionsContainer {
|
|
NetConnectionsContainer {
|
|
is_isolated: false,
|
|
nodes: Default::default(),
|
|
connections: Default::default(),
|
|
}
|
|
}
|
|
|
|
fn create_connections() -> TriggerConnections {
|
|
TriggerConnections {
|
|
self_key_pair: Arc::new(PlainNodeKeyPair::new(Random.generate().unwrap())),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn do_not_disconnect_if_set_is_not_changed() {
|
|
let node_id = Random.generate().unwrap().public().clone();
|
|
assert_eq!(select_nodes_to_disconnect(
|
|
&vec![(node_id, "127.0.0.1:8081".parse().unwrap())].into_iter().collect(),
|
|
&vec![(node_id, "127.0.0.1:8081".parse().unwrap())].into_iter().collect()),
|
|
vec![]);
|
|
}
|
|
|
|
#[test]
|
|
fn disconnect_if_address_has_changed() {
|
|
let node_id = Random.generate().unwrap().public().clone();
|
|
assert_eq!(select_nodes_to_disconnect(
|
|
&vec![(node_id.clone(), "127.0.0.1:8081".parse().unwrap())].into_iter().collect(),
|
|
&vec![(node_id.clone(), "127.0.0.1:8082".parse().unwrap())].into_iter().collect()),
|
|
vec![node_id.clone()]);
|
|
}
|
|
|
|
#[test]
|
|
fn disconnect_if_node_has_removed() {
|
|
let node_id = Random.generate().unwrap().public().clone();
|
|
assert_eq!(select_nodes_to_disconnect(
|
|
&vec![(node_id.clone(), "127.0.0.1:8081".parse().unwrap())].into_iter().collect(),
|
|
&vec![].into_iter().collect()),
|
|
vec![node_id.clone()]);
|
|
}
|
|
|
|
#[test]
|
|
fn does_not_disconnect_if_node_has_added() {
|
|
let node_id = Random.generate().unwrap().public().clone();
|
|
assert_eq!(select_nodes_to_disconnect(
|
|
&vec![(node_id.clone(), "127.0.0.1:8081".parse().unwrap())].into_iter().collect(),
|
|
&vec![(node_id.clone(), "127.0.0.1:8081".parse().unwrap()),
|
|
(Random.generate().unwrap().public().clone(), "127.0.0.1:8082".parse().unwrap())]
|
|
.into_iter().collect()),
|
|
vec![]);
|
|
}
|
|
|
|
#[test]
|
|
fn adjust_connections_disconnects_from_all_nodes_if_not_a_part_of_key_server() {
|
|
let self_node_id = Random.generate().unwrap().public().clone();
|
|
let other_node_id = Random.generate().unwrap().public().clone();
|
|
let mut connection_data = default_connection_data();
|
|
connection_data.nodes.insert(other_node_id.clone(), "127.0.0.1:8081".parse().unwrap());
|
|
|
|
let required_set = connection_data.nodes.clone();
|
|
adjust_connections(&self_node_id, &mut connection_data, &required_set);
|
|
assert!(connection_data.nodes.is_empty());
|
|
assert!(connection_data.is_isolated);
|
|
}
|
|
|
|
#[test]
|
|
fn adjust_connections_connects_to_new_nodes() {
|
|
let self_node_id = Random.generate().unwrap().public().clone();
|
|
let other_node_id = Random.generate().unwrap().public().clone();
|
|
let mut connection_data = default_connection_data();
|
|
|
|
let required_set = vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap()),
|
|
(other_node_id.clone(), "127.0.0.1:8082".parse().unwrap())].into_iter().collect();
|
|
adjust_connections(&self_node_id, &mut connection_data, &required_set);
|
|
assert!(connection_data.nodes.contains_key(&other_node_id));
|
|
assert!(!connection_data.is_isolated);
|
|
}
|
|
|
|
#[test]
|
|
fn adjust_connections_reconnects_from_changed_nodes() {
|
|
let self_node_id = Random.generate().unwrap().public().clone();
|
|
let other_node_id = Random.generate().unwrap().public().clone();
|
|
let mut connection_data = default_connection_data();
|
|
connection_data.nodes.insert(other_node_id.clone(), "127.0.0.1:8082".parse().unwrap());
|
|
|
|
let required_set = vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap()),
|
|
(other_node_id.clone(), "127.0.0.1:8083".parse().unwrap())].into_iter().collect();
|
|
adjust_connections(&self_node_id, &mut connection_data, &required_set);
|
|
assert_eq!(connection_data.nodes.get(&other_node_id), Some(&"127.0.0.1:8083".parse().unwrap()));
|
|
assert!(!connection_data.is_isolated);
|
|
}
|
|
|
|
#[test]
|
|
fn adjust_connections_disconnects_from_removed_nodes() {
|
|
let self_node_id = Random.generate().unwrap().public().clone();
|
|
let other_node_id = Random.generate().unwrap().public().clone();
|
|
let mut connection_data = default_connection_data();
|
|
connection_data.nodes.insert(other_node_id.clone(), "127.0.0.1:8082".parse().unwrap());
|
|
|
|
let required_set = vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap())].into_iter().collect();
|
|
adjust_connections(&self_node_id, &mut connection_data, &required_set);
|
|
assert!(connection_data.nodes.is_empty());
|
|
assert!(!connection_data.is_isolated);
|
|
}
|
|
|
|
#[test]
|
|
fn adjust_connections_does_not_connects_to_self() {
|
|
let self_node_id = Random.generate().unwrap().public().clone();
|
|
let mut connection_data = default_connection_data();
|
|
|
|
let required_set = vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap())].into_iter().collect();
|
|
adjust_connections(&self_node_id, &mut connection_data, &required_set);
|
|
assert!(connection_data.nodes.is_empty());
|
|
assert!(!connection_data.is_isolated);
|
|
}
|
|
|
|
#[test]
|
|
fn maintain_connects_to_current_set_works() {
|
|
let connections = create_connections();
|
|
let self_node_id = connections.self_key_pair.public().clone();
|
|
let current_node_id = Random.generate().unwrap().public().clone();
|
|
let migration_node_id = Random.generate().unwrap().public().clone();
|
|
let new_node_id = Random.generate().unwrap().public().clone();
|
|
|
|
let mut connections_data = default_connection_data();
|
|
connections.maintain(ConnectionsAction::ConnectToCurrentSet, &mut connections_data, &KeyServerSetSnapshot {
|
|
current_set: vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap()),
|
|
(current_node_id.clone(), "127.0.0.1:8082".parse().unwrap())].into_iter().collect(),
|
|
new_set: vec![(new_node_id.clone(), "127.0.0.1:8083".parse().unwrap())].into_iter().collect(),
|
|
migration: Some(KeyServerSetMigration {
|
|
set: vec![(migration_node_id.clone(), "127.0.0.1:8084".parse().unwrap())].into_iter().collect(),
|
|
..Default::default()
|
|
}),
|
|
});
|
|
|
|
assert_eq!(vec![current_node_id], connections_data.nodes.keys().cloned().collect::<Vec<_>>());
|
|
}
|
|
|
|
#[test]
|
|
fn maintain_connects_to_migration_set_works() {
|
|
let connections = create_connections();
|
|
let self_node_id = connections.self_key_pair.public().clone();
|
|
let current_node_id = Random.generate().unwrap().public().clone();
|
|
let migration_node_id = Random.generate().unwrap().public().clone();
|
|
let new_node_id = Random.generate().unwrap().public().clone();
|
|
|
|
let mut connections_data = default_connection_data();
|
|
connections.maintain(ConnectionsAction::ConnectToMigrationSet, &mut connections_data, &KeyServerSetSnapshot {
|
|
current_set: vec![(current_node_id.clone(), "127.0.0.1:8082".parse().unwrap())].into_iter().collect(),
|
|
new_set: vec![(new_node_id.clone(), "127.0.0.1:8083".parse().unwrap())].into_iter().collect(),
|
|
migration: Some(KeyServerSetMigration {
|
|
set: vec![(self_node_id.clone(), "127.0.0.1:8081".parse().unwrap()),
|
|
(migration_node_id.clone(), "127.0.0.1:8084".parse().unwrap())].into_iter().collect(),
|
|
..Default::default()
|
|
}),
|
|
});
|
|
|
|
assert_eq!(vec![migration_node_id].into_iter().collect::<BTreeSet<_>>(),
|
|
connections_data.nodes.keys().cloned().collect::<BTreeSet<_>>());
|
|
}
|
|
|
|
#[test]
|
|
fn simple_connections_trigger_only_maintains_connections() {
|
|
let key_server_set = Arc::new(MapKeyServerSet::new(false, Default::default()));
|
|
let self_key_pair = Arc::new(PlainNodeKeyPair::new(Random.generate().unwrap()));
|
|
let mut trigger = SimpleConnectionTrigger::new(key_server_set, self_key_pair, None);
|
|
assert_eq!(trigger.on_maintain(), Some(Maintain::Connections));
|
|
}
|
|
}
|