kemurphy

diff --git a/cmd/zfs_object_agent/zettaobject/Cargo.toml b/cmd/zfs_object_agent/zettaobject/Cargo.toml
index 5f5984f1e..8ff15d8e6 100644
--- a/cmd/zfs_object_agent/zettaobject/Cargo.toml
+++ b/cmd/zfs_object_agent/zettaobject/Cargo.toml
@@ -34,6 +34,6 @@ serde_bytes = "0.11"
 serde_json = "1.0.64"
 stream-reduce = "0.1.0"
 tokio = { version = "1.4", features = ["full"] }
-tokio-stream = "0.1.5"
+tokio-stream = { version = "0.1.5", features = ["time"] }

kemurphy

diff --git a/cmd/zfs_object_agent/zettaobject/src/heartbeat.rs b/cmd/zfs_object_agent/zettaobject/src/heartbeat.rs
index a093d27ee..239f2efb5 100644
--- a/cmd/zfs_object_agent/zettaobject/src/heartbeat.rs
+++ b/cmd/zfs_object_agent/zettaobject/src/heartbeat.rs
@@ -149,21 +149,10 @@ pub async fn start_heartbeat(object_access: ObjectAccess, id: Uuid) -> Heartbeat
         loop {
             interval.tick().await;
             {
-                let fut_opt = {
-                    let mut heartbeats = HEARTBEAT.lock().unwrap();

kemurphy

use std::{
    collections::{btree_map, BTreeMap},
    env,
    fmt::Debug,
    io::Error,
    pin::Pin,
    sync::{Arc, Once},
    task::{Context, Poll},
};

kemurphy

use std::{
    collections::{btree_map, BTreeMap},
    env,
    io::Error,
    sync::{Arc, Once},
};

use anyhow::Context;
use futures::{Sink, Stream, StreamExt};
use log::info;

kemurphy

use std::{
    collections::{btree_map, BTreeMap},
    env,
    io::Error,
    sync::{Arc, Once},
};

use anyhow::{Context};
use futures::{Sink, Stream, StreamExt};
use log::info;

kemurphy

| *                 | 3x inferium essence        |                                                    |
| twilight swamp    | 8x steeleaf                | !!!, mystical: tier 3, 8x essence => 5 leaf        |
| twilight swamp    | 2x fiery ingot             | !!!, mystical: tier 4, 8x essence => 3 ingot       |
| twilight glacier  | 8x arctic fur              | exclusive                                          |
| twilight glacier  | 4x arctic fur              | exclusive                                          |
| twilight glacier  | charm of life ii           |                                                    |
| twilight glacier  | charm of keeping ii        |                                                    |
| blaze             | 2x blaze rod               | better through 2x hellish + bone probably          |
| blaze             | 16x sulfur dust            |                                                    |
| shulker           | 4x shulker shell           | exclusive                            

kemurphy

    // parse an element of a struct definition
    fn parse_struct_decl_field(&self) -> @struct_field {
        let attrs = self.parse_outer_attributes();
        let vis = if self.eat_keyword(keywords::Priv) {
            private
        } else if self.eat_keyword(keywords::Pub) {
            public
        } else {
            inherited
        };

kemurphy

        let replace_id = @mut None;

        let rewriter = @fold::AstFoldFns {
            fold_expr: do fold::wrap |e, fld| {
                match fold_expr(e, fld, self.def_map, replace_id) {
                    Some(f) => {
                        debug!("Rewriting: wrote expr_struct");
                        f
                    }
                    None    => fold::noop_fold_expr(e, fld)

kemurphy

                let mut i: @item = fold::noop_fold_item(i, fld).take_unwrap();
                i.node = match i.node {
                    item_mod(ref m) => {
                        item_mod(self.with_scope(Some(i.ident), || {
                            debug!("Rewriting: with scope %?", i.ident);
                            fld.fold_mod(m)
                        }))
                    },
                    item_foreign_mod(ref foreign_module) => {
                        item_foreign_mod(self.with_scope(Some(i.ident), ||

kemurphy

pub fn rewrite_tuple_struct_or_variant_calls(c: &Crate, dm: DefMap) -> @Crate {
    fn fold_expr(e: &ast::expr_, fld: @fold::ast_fold, dm: DefMap) -> Option<ast::expr_> {
        let fold_unnamed_field = |x| {
            ast::Field {
                ident: special_idents::unnamed_field,
                expr: fld.fold_expr(x),
                span: fld.new_span(x.span),
            }
        };