overseer becomes orchestra (#5542)

* rename overseer-gen to orchestra

Also drop `gum` and use `tracing`.

* make orchestra compile as standalone

* introduce Spawner trait to split from sp_core

Finalizes the independence of orchestra from polkadot-overseer

* slip of the pen

* other fixins

* remove unused import

* Update node/overseer/orchestra/proc-macro/src/impl_builder.rs

Co-authored-by: Vsevolod Stakhov <vsevolod.stakhov@parity.io>

* Update node/overseer/orchestra/proc-macro/src/impl_builder.rs

Co-authored-by: Vsevolod Stakhov <vsevolod.stakhov@parity.io>

* orchestra everywhere

* leaky data

* Bump scale-info from 2.1.1 to 2.1.2 (#5552)

Bumps [scale-info](https://github.com/paritytech/scale-info) from 2.1.1 to 2.1.2.
- [Release notes](https://github.com/paritytech/scale-info/releases)
- [Changelog](https://github.com/paritytech/scale-info/blob/master/CHANGELOG.md)
- [Commits](https://github.com/paritytech/scale-info/compare/v2.1.1...v2.1.2)

---
updated-dependencies:
- dependency-name: scale-info
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Add missing markdown code block delimiter (#5555)

* bitfield-signing: remove util::jobs usage  (#5523)

* Switch to pooling copy-on-write instantiation strategy for WASM (companion for Substrate#11232) (#5337)

* Switch to pooling copy-on-write instantiation strategy for WASM

* Fix compilation of `polkadot-test-service`

* Update comments

* Move `max_memory_size` to `Semantics`

* Rename `WasmInstantiationStrategy` to `WasmtimeInstantiationStrategy`

* Update a safety comment

* update lockfile for {"substrate"}

Co-authored-by: parity-processbot <>

* Fix build

Co-authored-by: Vsevolod Stakhov <vsevolod.stakhov@parity.io>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Malte Kliemann <mail@maltekliemann.com>
Co-authored-by: Chris Sosnin <48099298+slumber@users.noreply.github.com>
Co-authored-by: Koute <koute@users.noreply.github.com>

polkadot/node/overseer/orchestra/examples/duo.rs

@@ -0,0 +1,89 @@
+#![allow(dead_code)] // orchestra events are not used
+
+//! A dummy to be used with cargo expand
+
+use orchestra::{self as orchestra, Spawner, *};
+use std::collections::HashMap;
+mod misc;
+
+pub use self::misc::*;
+
+/// Concrete subsystem implementation for `MsgStrukt` msg type.
+#[derive(Default)]
+pub struct AwesomeSubSys;
+
+#[orchestra::subsystem(Awesome, error=Yikes)]
+impl<Context> AwesomeSubSys {
+	fn start(self, mut ctx: Context) -> SpawnedSubsystem<Yikes> {
+		let mut sender = ctx.sender().clone();
+		ctx.spawn(
+			"AwesomeSubsys",
+			Box::pin(async move {
+				sender.send_message(Plinko).await;
+			}),
+		)
+		.unwrap();
+		unimplemented!("starting yay!")
+	}
+}
+
+#[derive(Default)]
+pub struct Fortified;
+
+#[orchestra::subsystem(GoblinTower, error=Yikes)]
+impl<Context> Fortified {
+	fn start(self, mut ctx: Context) -> SpawnedSubsystem<Yikes> {
+		let mut sender = ctx.sender().clone();
+		ctx.spawn(
+			"GoblinTower",
+			Box::pin(async move {
+				sender.send_message(MsgStrukt(8u8)).await;
+			}),
+		)
+		.unwrap();
+		unimplemented!("welcum")
+	}
+}
+
+#[orchestra(signal=SigSigSig, event=EvX, error=Yikes, gen=AllMessages)]
+struct Duo<T> {
+	#[subsystem(consumes: MsgStrukt, sends: [Plinko])]
+	sub0: Awesome,
+
+	#[subsystem(blocking, consumes: Plinko, sends: [MsgStrukt])]
+	plinkos: GoblinTower,
+
+	i_like_pi: f64,
+	i_like_generic: T,
+	i_like_hash: HashMap<f64, f64>,
+}
+
+fn main() {
+	use futures::{executor, pin_mut};
+
+	executor::block_on(async move {
+		let (orchestra, _handle): (Duo<_, f64>, _) = Duo::builder()
+			.sub0(AwesomeSubSys::default())
+			.plinkos(Fortified::default())
+			.i_like_pi(::std::f64::consts::PI)
+			.i_like_generic(42.0)
+			.i_like_hash(HashMap::new())
+			.spawner(DummySpawner)
+			.build()
+			.unwrap();
+
+		assert_eq!(orchestra.i_like_pi.floor() as i8, 3);
+		assert_eq!(orchestra.i_like_generic.floor() as i8, 42);
+		assert_eq!(orchestra.i_like_hash.len() as i8, 0);
+
+		let orchestra_fut = orchestra
+			.running_subsystems
+			.into_future()
+			.timeout(std::time::Duration::from_millis(300))
+			.fuse();
+
+		pin_mut!(orchestra_fut);
+
+		orchestra_fut.await
+	});
+}

polkadot/node/overseer/orchestra/examples/misc.rs

@@ -0,0 +1,69 @@
+use orchestra::{Spawner, *};
+
+#[derive(Debug, Clone, Copy)]
+pub enum SigSigSig {
+	Conclude,
+	Foo,
+}
+
+#[derive(Debug, Clone)]
+pub struct DummySpawner;
+
+impl Spawner for DummySpawner {
+	fn spawn_blocking(
+		&self,
+		task_name: &'static str,
+		subsystem_name: Option<&'static str>,
+		_future: futures::future::BoxFuture<'static, ()>,
+	) {
+		unimplemented!("spawn blocking {} {}", task_name, subsystem_name.unwrap_or("default"))
+	}
+
+	fn spawn(
+		&self,
+		task_name: &'static str,
+		subsystem_name: Option<&'static str>,
+		_future: futures::future::BoxFuture<'static, ()>,
+	) {
+		unimplemented!("spawn {} {}", task_name, subsystem_name.unwrap_or("default"))
+	}
+}
+
+/// The external event.
+#[derive(Debug, Clone)]
+pub struct EvX;
+
+impl EvX {
+	pub fn focus<'a, T>(&'a self) -> Result<EvX, ()> {
+		unimplemented!("focus")
+	}
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Yikes;
+
+impl std::fmt::Display for Yikes {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		writeln!(f, "yikes!")
+	}
+}
+
+impl std::error::Error for Yikes {}
+
+impl From<orchestra::OrchestraError> for Yikes {
+	fn from(_: orchestra::OrchestraError) -> Yikes {
+		Yikes
+	}
+}
+
+impl From<orchestra::mpsc::SendError> for Yikes {
+	fn from(_: orchestra::mpsc::SendError) -> Yikes {
+		Yikes
+	}
+}
+
+#[derive(Debug, Clone)]
+pub struct MsgStrukt(pub u8);
+
+#[derive(Debug, Clone, Copy)]
+pub struct Plinko;

polkadot/node/overseer/orchestra/examples/solo.rs

@@ -0,0 +1,54 @@
+#![allow(dead_code)] // orchestra events are not used
+
+//! A minimal demo to be used with cargo expand.
+
+use orchestra::{self as orchestra, Spawner, *};
+mod misc;
+
+pub use self::misc::*;
+
+#[orchestra(signal=SigSigSig, event=EvX, error=Yikes, gen=AllMessages)]
+struct Solo<T> {
+	#[subsystem(consumes: Plinko, sends: [MsgStrukt])]
+	goblin_tower: GoblinTower,
+}
+
+#[derive(Default)]
+pub struct Fortified;
+
+#[orchestra::subsystem(GoblinTower, error=Yikes)]
+impl<Context> Fortified {
+	fn start(self, mut ctx: Context) -> SpawnedSubsystem<Yikes> {
+		let mut sender = ctx.sender().clone();
+		ctx.spawn(
+			"GoblinTower",
+			Box::pin(async move {
+				sender.send_message(MsgStrukt(8u8)).await;
+			}),
+		)
+		.unwrap();
+		unimplemented!("welcum")
+	}
+}
+
+fn main() {
+	use futures::{executor, pin_mut};
+
+	executor::block_on(async move {
+		let (orchestra, _handle): (Solo<_>, _) = Solo::builder()
+			.goblin_tower(Fortified::default())
+			.spawner(DummySpawner)
+			.build()
+			.unwrap();
+
+		let orchestra_fut = orchestra
+			.running_subsystems
+			.into_future()
+			.timeout(std::time::Duration::from_millis(300))
+			.fuse();
+
+		pin_mut!(orchestra_fut);
+
+		orchestra_fut.await
+	});
+}