Skip to content

Commit

Permalink
Add subscribe_blocks and subscribe_events
Browse files Browse the repository at this point in the history
  • Loading branch information
@boundless-forest
boundless-forest committed Nov 7, 2023
1 parent 9fffbc9 commit 834184b
Showing 1 changed file with 98 additions and 91 deletions.
189 changes: 98 additions & 91 deletions src/app/dashboard/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,91 +64,55 @@ impl<CI: ChainInfo> DashBoard<CI> {
}
}

pub fn next_tab(&mut self) {
self.index = (self.index + 1) % self.tab_titles.len();
}

pub fn previous_tab(&mut self) {
if self.index > 0 {
self.index -= 1;
} else {
self.index = self.tab_titles.len() - 1;
}
}

pub fn previous_block(&mut self) {
self.blocks.previous();
if let Some(i) = self.blocks.state.selected() {
self.selected_block = self.blocks.items.get(i).cloned();
}
}

pub fn next_block(&mut self) {
self.blocks.next();
if let Some(i) = self.blocks.state.selected() {
self.selected_block = self.blocks.items.get(i).cloned();
async fn subscribe_blocks(&mut self, client: Arc<RpcClient<CI>>) {
if let Ok(header) = self.blocks_rev.try_recv() {
if self.blocks.items.len() == self.blocks.items.capacity() {
self.blocks.items.pop_front();
}
if let Ok(signed_block) = client.get_block(header.hash().into()).await {
self.blocks.items.push_back(signed_block.block);
}
}
}
}

pub async fn run_dashboard<B, CI>(
client: Arc<RpcClient<CI>>,
terminal: &mut Terminal<B>,
mut app: DashBoard<CI>,
) -> io::Result<()>
where
B: Backend,
CI: ChainInfo,
{
fn vec_event_records_type_id(metadata: &mut Metadata) -> Option<u32> {
let event_records_type_id = metadata
.types()
.types
.iter()
.find(|ty| {
ty.ty.path
== Path::from_segments_unchecked(vec![
"frame_system".to_string(),
"EventRecord".to_string(),
])
})
.map(|ty| ty.id)
.unwrap();

let ty_mut = metadata.types_mut();
let vec_event_records_ty = Type::new(
Path::default(),
vec![],
TypeDefSequence::new(event_records_type_id.into()),
vec![],
);
let vec_event_records_type_id = ty_mut.types.len() as u32;
ty_mut
.types
.push(PortableType { id: vec_event_records_type_id, ty: vec_event_records_ty });
async fn subscribe_events(&mut self) {
fn vec_event_records_type_id(metadata: &mut Metadata) -> Option<u32> {
let event_records_type_id = metadata
.types()
.types
.iter()
.find(|ty| {
ty.ty.path
== Path::from_segments_unchecked(vec![
"frame_system".to_string(),
"EventRecord".to_string(),
])
})
.map(|ty| ty.id)
.unwrap();

Some(vec_event_records_type_id)
}
let ty_mut = metadata.types_mut();
let vec_event_records_ty = Type::new(
Path::default(),
vec![],
TypeDefSequence::new(event_records_type_id.into()),
vec![],
);
let vec_event_records_type_id = ty_mut.types.len() as u32;
ty_mut
.types
.push(PortableType { id: vec_event_records_type_id, ty: vec_event_records_ty });

let vec_event_records_type_id = vec_event_records_type_id(&mut app.metadata).unwrap();
loop {
terminal.draw(|f| ui(f, &mut app))?;

if let Ok(header) = app.blocks_rev.try_recv() {
if app.blocks.items.len() == app.blocks.items.capacity() {
app.blocks.items.pop_front();
}
if let Ok(signed_block) = client.get_block(header.hash().into()).await {
app.blocks.items.push_back(signed_block.block);
}
Some(vec_event_records_type_id)
}
let vec_event_records_type_id = vec_event_records_type_id(&mut self.metadata).unwrap();

if let Ok(storage_data) = app.events_rev.try_recv() {
if let Ok(storage_data) = self.events_rev.try_recv() {
for data in storage_data {
let value = decode_as_type(
&mut data.0.as_ref(),
vec_event_records_type_id,
app.metadata.types(),
self.metadata.types(),
);

if let Ok(event_records) = value {
Expand All @@ -167,12 +131,12 @@ where
.collect();

for event in event_values {
if app.events.items.len()
== app.events.items.capacity()
if self.events.items.len()
== self.events.items.capacity()
{
app.events.items.pop_front();
self.events.items.pop_front();
} else {
app.events.items.push_back(event);
self.events.items.push_back(event);
}
}
},
Expand All @@ -187,23 +151,66 @@ where
}
}
}
}

fn next_tab(&mut self) {
self.index = (self.index + 1) % self.tab_titles.len();
}

fn previous_tab(&mut self) {
if self.index > 0 {
self.index -= 1;
} else {
self.index = self.tab_titles.len() - 1;
}
}

fn previous_block(&mut self) {
self.blocks.previous();
if let Some(i) = self.blocks.state.selected() {
self.selected_block = self.blocks.items.get(i).cloned();
}
}

fn next_block(&mut self) {
self.blocks.next();
if let Some(i) = self.blocks.state.selected() {
self.selected_block = self.blocks.items.get(i).cloned();
}
}
}

pub async fn run_dashboard<B, CI>(
client: Arc<RpcClient<CI>>,
terminal: &mut Terminal<B>,
mut dash_board: DashBoard<CI>,
) -> io::Result<()>
where
B: Backend,
CI: ChainInfo,
{
loop {
terminal.draw(|f| ui(f, &mut dash_board))?;

dash_board.subscribe_blocks(client.clone()).await;
dash_board.subscribe_events().await;

if let Event::Key(key) = read()? {
if key.kind == KeyEventKind::Press {
match key.code {
KeyCode::Char('q') => return Ok(()),
KeyCode::Right => app.next_tab(),
KeyCode::Left => app.previous_tab(),
KeyCode::Up => app.previous_block(),
KeyCode::Down => app.next_block(),
KeyCode::Right => dash_board.next_tab(),
KeyCode::Left => dash_board.previous_tab(),
KeyCode::Up => dash_board.previous_block(),
KeyCode::Down => dash_board.next_block(),
_ => {},
}
}
}
}
}

pub(crate) fn ui<B, CI>(f: &mut Frame<B>, app: &mut DashBoard<CI>)
fn ui<B, CI>(f: &mut Frame<B>, dash_board: &mut DashBoard<CI>)
where
B: Backend,
CI: ChainInfo,
Expand All @@ -214,11 +221,11 @@ where
.constraints([Constraint::Percentage(20), Constraint::Percentage(80)].as_ref())
.split(size);

draw_system(f, app, chunks[0]);
draw_tabs(f, app, chunks[1]);
draw_system(f, dash_board, chunks[0]);
draw_tabs(f, dash_board, chunks[1]);
}

fn draw_tabs<B, CI>(f: &mut Frame<B>, app: &mut DashBoard<CI>, area: Rect)
fn draw_tabs<B, CI>(f: &mut Frame<B>, dash_board: &mut DashBoard<CI>, area: Rect)
where
B: Backend,
CI: ChainInfo,
Expand All @@ -227,21 +234,21 @@ where
.direction(Direction::Vertical)
.constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
.split(area);
let titles = app
let titles = dash_board
.tab_titles
.iter()
.map(|t| Line::from(Span::styled(t, Style::default().fg(Color::Yellow).bold())))
.collect();
let tabs = Tabs::new(titles)
.block(Block::default().borders(Borders::ALL).title("Chain Data"))
.select(app.index)
.select(dash_board.index)
.style(Style::default().fg(Color::Yellow))
.highlight_style(Style::default().fg(Color::Cyan));
f.render_widget(tabs, chunks[0]);

match app.index {
0 => draw_blocks_tab(f, app, chunks[1]),
1 => draw_events_tab(f, app, chunks[1]),
match dash_board.index {
0 => draw_blocks_tab(f, dash_board, chunks[1]),
1 => draw_events_tab(f, dash_board, chunks[1]),
_ => {},
};
}
Expand Down

0 comments on commit 834184b

Please sign in to comment.