常連

以下のようなソースコードを書いているのですが、struct Aでエラーが起きてしまいます。
エラー文から対処方法を解読できず、なにを実装すればいいのか悩んでいます。
多少強引な方法でも良いので、解決方法を教えていただきたいです。

```Rust
#[derive(Serialize, Deserialize)]
pub enum MyEnum{
    A,
    B,
    C,
    D,
    E,
}

#[derive(Serialize, Deserialize)]
pub struct B{
    pub num: u32,
    pub level: i32,
    pub param: MyEnum,
}

#[derive(Serialize, Deserialize)]
struct A<'a> {
    data: &'a [B], // ここでエラー[E0227]
    index: usize,
}
```
```error
[E0277] the trait bound `&'a [B]: Deserialize<'_>` is not satisfied. 
[Note] the trait `Deserialize<'_>` is not implemented for `&'a [B]`
```

serdeのバージョン:
serde = { version = "^1.0.126", features = ["derive"] }
serde_json = "^1.0.64"

Rustのserdeで&'a [T]をフィールドに持つ構造体をデシリアライズする方法

### 前提・実現したいこと
[MVC参考記事](https://cafbit.com/post/cursive_writing_terminal_applications_in_rust/)
上記の参考記事のようにデータとview構造を分けたいと思い、mpscを利用して、view側に通知するコードを書きました。
しかし、view側へ参照のvecを渡そうとするとライフタイムのエラーが出てしまい、ライフタイムの問題を解決できませんでした。
mpsc, HashMapの値がVecという条件でライフタイムを解決するにはどのようにすれば良いのでしょうか？

以下がやりたいことのデータ構造の大まかな流れです。
- ui側からeventを受け取る。(ここではソースコードは関係ないので省略しています。)
- controllerはそのeventデータを元にui側にHashMapから取得したvecを渡す。 (今回の問題点です。)
- ui側はその情報を描画する (ここではソースコードは関係ないので省略しています。)

以上お手数ですが、よろしくお願いいたします。

### 発生している問題・エラーメッセージ
HashMapで値を取得できるようにexec関数のselfのライフタイムを&'a mut selfにすると以下のようなエラーが出ました。

```
error[E0597]: `controller_sample` does not live long enough
 --> src/main.rs:7:5
  |
7 |     controller_sample.exec(); // &'a mut selfにするとエラーが出てしまう。
  |     ^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
8 | }
  | -
  | |
  | `controller_sample` dropped here while still borrowed
  | borrow might be used here, when `controller_sample` is dropped and runs the destructor for type `ControllerSample<'_>`

```

### 該当のソースコード

```rust
use std::collections::HashMap;
use std::sync::mpsc;


fn main() {
    let mut controller_sample = ControllerSample::new();
    controller_sample.exec(); // &'a mut selfにするとエラーが出てしまう。
}

struct ControllerSample<'a> {
    map: HashMap<String, Vec<i32>>,
    ui: UiSample<'a>,
}

impl<'a> ControllerSample<'a> {
    fn new() -> ControllerSample<'a> {
        let mut map: HashMap<String, Vec<i32>> = HashMap::new();
        map.insert(String::from("sample"), vec![1, 2, 3]);
        ControllerSample {
            map: map,
            ui: UiSample::new(),
        }
    }

    // fn test(&'a mut self) {
    fn exec(&'a mut self) {
        // key: keyはui側からイベントで送られる想定ですが、ここでは暫定的に以下のものにしています。
        let key = &String::from("sample");

        // &'a mut selfで'aを明示しないとコンパイルエラー "cannot infer"
        let v = self.map.get(key).unwrap();
        
        // ui側に送信する。 (※受信側は省略しています。)
        self.ui
            .ui_tx
            .send(UiMessageSample::UpdateContents(v))
            .unwrap();
    }
}

struct UiSample<'a> {
    ui_tx: mpsc::Sender<UiMessageSample<'a>>,
}

impl<'a> UiSample<'a> {
    fn new() -> UiSample<'a> {
        let (ui_tx, _) = mpsc::channel::<UiMessageSample>();
        UiSample {
            ui_tx: ui_tx,
        }
    }
}

enum UiMessageSample<'a> {
    // 毎度値をコピーして渡すのは嫌だったので参照にしたい。
    UpdateContents(&'a Vec<i32>),
}
```

### 試したこと
- controller_sample.exec()のエラーを消すために&'a mut selfを& mut selfにするとエラーは消えるのですが、今度はexec関数の中のHashMapから値を取得する箇所でライフタイムを推測できないとエラーが出てしまいます。
- 逆にHashMapのエラーを消すためにexec関数で&'a mut selfと指定すると、HashMapのエラーが消えるのですが、controller_sample.exec()でエラーが出てしまいます。

### 補足情報
上記のコードは以下のplay groundで試せます。
[Play Ground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=db6116c9239b9e82eda771aa76302155)

Rust: mpscで参照のVecを渡すとライフタイムのエラーが出る

## 追記
より短い再現コードを作りました。

[https://github.com/techno-tanoC/progress_test](https://github.com/techno-tanoC/progress_test)

ダウンロードが途中で止まり、 `pg.to_item` の結果がずっと表示されるようになります。

![イメージ説明](e6ffbb8e3f3a241b2822329e95cfac95.png)

## 前提・実現したいこと

以前、 [Rust - tokio::sync::Mutex を使った型に AsyncWrite を実装したい｜teratail](https://teratail.com/questions/247576) にて AsyncWrite の実装方法を教えていただいたのですが、実際に使ってみると問題が発生しました。

REST API で操作できるファイルダウンローダを作っています。大まかな動作は以下のようなものです。

1. URL を含む情報を POST する
2. reqwest で与えられた URL からデータを `Stream` として取得
3. File とダウンロードしたバイト数を保持する型 [Progress](https://github.com/techno-tanoC/azusa/blob/master/src/progress.rs) に `tokio::io::copy` で `Stream` を流し込む
4. ダウンロードしている最中に GET を行うと Progress が保持しているバイト数を取得する
5. `Stream` が終わったら `Progress` が持つ File を別のディレクトリにコピーする

リポジトリ: [techno-tanoC/azusa](https://github.com/techno-tanoC/azusa)

## 発生している問題

フロントエンドから進捗を確認しているとダウンロードが止まることがあります。

[ダウンロードが止まることがある · Issue #34 · techno-tanoC/azusa](https://github.com/techno-tanoC/azusa/issues/34) という issue で現象の調査を行いました。その結果、 `Progress::to_item` を呼ぶと問題が発生するようなのですが、原因の検討がつきません。

![イメージ説明](5c7f452824592c11d5cdaf2178131abf.png)

ダウンロードが止まった後も `Progress::to_item` は動いているので Mutex が駆動していないというよりは AsyncWrite が駆動していない印象を受けます。

## 当該のソースコード

[Progress](https://github.com/techno-tanoC/azusa/blob/master/src/progress.rs) の `to_item` や `poll_write` 辺りが怪しいと思っているのですが、どこが悪いのかハッキリとは分かっていません。現象からして `Progress` 内に問題がある可能性が高いと思います。

```rust
use futures::future::FutureExt;
use std::fmt;
use std::io::SeekFrom;
use std::pin::Pin;
use std::sync::Arc;
use std::task::{Poll, Context};
use tokio::io::{AsyncSeek, Result, ErrorKind};
use tokio::prelude::*;
use tokio::sync::Mutex;

use crate::item::Item;

struct ProgressInner<T> {
    name: String,
    total: u64,
    size: u64,
    canceled: bool,
    buf: T,
}

impl<T> fmt::Debug for ProgressInner<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("ProgressInner")
            .field("name", &self.name)
            .field("total", &self.total)
            .field("size", &self.size)
            .field("canceled", &self.canceled)
            .finish()
    }
}

pub struct Progress<T> {
    inner: Arc<Mutex<ProgressInner<T>>>,
}

impl<T> std::clone::Clone for Progress<T> {
    fn clone(&self) -> Self {
        Progress { inner: self.inner.clone() }
    }
}

impl<T> Progress<T> {
    pub fn new(name: impl ToString, buf: T) -> Self {
        let inner = Arc::new(Mutex::new(ProgressInner {
            name: name.to_string(),
            total: 0,
            size: 0,
            canceled: false,
            buf,
        }));
        Progress { inner }
    }

    pub async fn set_total(&mut self, total: u64) {
        self.inner.lock().await.total = total;
    }

    pub async fn cancel(&mut self) {
        self.inner.lock().await.canceled = true
    }

    pub async fn to_item(&self, id: impl ToString) -> Item {
        let pg = self.inner.lock().await;
        Item {
            id: id.to_string(),
            name: pg.name.clone(),
            total: pg.total,
            size: pg.size,
            canceled: pg.canceled,
        }
    }
}

impl<T: AsyncRead + Unpin + Send> AsyncRead for Progress<T> {
    fn poll_read(
        self: Pin<&mut Self>,
        cx: &mut Context,
        buf: &mut [u8]
    ) -> Poll<Result<usize>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                Pin::new(&mut s.buf).poll_read(cx, buf)
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }
}

impl<T: AsyncWrite + Unpin + Send> AsyncWrite for Progress<T> {
    fn poll_write(
        self: Pin<&mut Self>,
        cx: &mut Context,
        buf: &[u8]
    ) -> Poll<Result<usize>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                if s.canceled {
                    Poll::Ready(Err(io::Error::new(ErrorKind::Interrupted, "canceled")))
                } else {
                    let poll = Pin::new(&mut s.buf).poll_write(cx, buf);
                    if let Poll::Ready(Ok(n)) = poll {
                        s.size += n as u64;
                    }
                    poll
                }
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }

    fn poll_flush(
        self: Pin<&mut Self>,
        cx: &mut Context
    ) -> Poll<Result<()>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                Pin::new(&mut s.buf).poll_flush(cx)
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }

    fn poll_shutdown(
        self: Pin<&mut Self>,
        cx: &mut Context
    ) -> Poll<Result<()>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                Pin::new(&mut s.buf).poll_shutdown(cx)
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }
}

impl<T: AsyncSeek + Unpin + Send> AsyncSeek for Progress<T> {
    fn start_seek(
        self: Pin<&mut Self>,
        cx: &mut Context,
        position: SeekFrom
    ) -> Poll<Result<()>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                Pin::new(&mut s.buf).start_seek(cx, position)
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }

    fn poll_complete(
        self: Pin<&mut Self>,
        cx: &mut Context
    ) -> Poll<Result<u64>> {
        match self.inner.lock().boxed().as_mut().poll(cx) {
            Poll::Ready(mut s) => {
                Pin::new(&mut s.buf).poll_complete(cx)
            },
            Poll::Pending => {
                Poll::Pending
            }
        }
    }
}
```


## 試したこと
基本的に [issue](https://github.com/techno-tanoC/azusa/issues/34) に書いてあります。

## 環境
rustc: 1.43.0
tokio: 0.2.20

tokio::io::AsyncWriteが駆動しない(?)ことがある

### 前提・実現したいこと

私はこれまでC言語とPerlを使って趣味でプログラムを作ってきました。Rustは初心者です。

構造体のフィールドに、別の構造体Ａ又はＢのポインタ(Box)を持たせたいと思い
コードを自作してみたのですが、コンパイルが通りませんでした。
エラーメッセージから、型注釈が必要、matchのアームが同じ型になっていない、というあたりを
汲み取ってネットで検索したり、書籍を頼ったりしたのですが、解決できません。
型を抽象化しないといけないのではと思いimpl Traitを調べたり、
トレイトオブジェクトを調べたり、クロージャを調べたり…したのですが、
コードがどんどん複雑になってエラーも増える一方で、手に負えませんでした。

Rustにおける定番の書き方のようなものがあれば、教えて頂けないでしょうか。

### 該当のソースコード

```Rust
fn main() {
    let x = StructX::new( TypeA );
    let y = StructX::new( TypeB );
}

enum EnumX {
    TypeA,
    TypeB,
}
use self::EnumX::*;

struct StructA {} //StructXのフィールドに入れたい構造体A
struct StructB {} //StructXのフィールドに入れたい構造体B

struct StructX<T> {
    box_pt: Box<T>, // Boxで StructA 又は StructB をくるみたい
}

impl<T> StructX<T> {
    fn new( t: EnumX ) -> Self {
        let pt = match t {
            TypeA => Box::new( StructA {} ),
            TypeB => Box::new( StructB {} ),
        };
        StructX {
            box_pt: pt,
        }
    }
}
```

### 発生している問題・エラーメッセージ

```
error[E0282]: type annotations needed for `StructX<T>`
 --> src/main.rs:2:13
  |
2 |     let x = StructX::new( TypeA );
  |         -   ^^^^^^^^^^^^ cannot infer type for type parameter `T`
  |         |
  |         consider giving `x` the explicit type `StructX<T>`, where the type parameter `T` is specified

error[E0308]: match arms have incompatible types
  --> src/main.rs:23:22
   |
21 |           let pt = match t {
   |  __________________-
22 | |             TypeA => Box::new( StructA {} ),
   | |                      ---------------------- this is found to be of type `std::boxed::Box<StructA>`
23 | |             TypeB => Box::new( StructB {} ),
   | |                      ^^^^^^^^^^^^^^^^^^^^^^ expected struct `StructA`, found struct `StructB`
24 | |         };
   | |_________- `match` arms have incompatible types
   |
   = note: expected type `std::boxed::Box<StructA>`
            found struct `std::boxed::Box<StructB>`

error: aborting due to 2 previous errors

Some errors have detailed explanations: E0282, E0308.
For more information about an error, try `rustc --explain E0282`.
error: could not compile `tmp2`.

To learn more, run the command again with --verbose.
```

### 補足情報（FW/ツールのバージョンなど）

OS： Windows10 ＋ WSL1 ＋ Ubuntu
Rust：1.41.0

構造体に別の構造体Ａ又はＢのポインタを持たせたい

### 前提・実現したいこと
現在、設計中の業務システムで扱ってる商材で、数m巻にまかれた生地があります。
それを必要な長さと枚数で、どう動的に最安の組み合わせになるかというアルゴリズムに苦戦しております。
ナップザック問題や、欲張り法など調べてますが、どうも今回のパターンにうまく当てはめることができません。

その生地は、以下のような特徴があります。
1ロールあたりの巻数の種類 : 12m巻き 30m巻き　（これは生地によって変わりますので例です。）
それぞれの原価
 12m巻   8,000円
 30m巻  19,000円
 ※ 巻数が大きいものの方がm単価は安くなります。

例えばお客様から、長さ5.5mの生地を20枚ほしいと注文があった場合、
12m巻の生地を長さ5.5mづつカットすると、作成可能枚数は、2枚で、0.5m 端生地が余ります。
30m巻の生地を長さ5.5mづつカットすると、作成可能枚数は、5枚で、2.5m 端生地ります。

上記の中から最も金額を安くする最適な巻数の組み合わせを動的に算出する計算式になります。

### 例

例えば、いくつか例です。

**長さ5mを５枚必要な場合**
　パターン①　12m巻でまかなうと、３ロール必要、8,000円ｘ3ロール=24,000円
　パターン②　30m巻でまかなうと、1ロール必要、19,000円x1ロール=19,000円

　この場合は、パターン②の30m巻を1ロール購入するのが正解です。

**長さ5mを７枚必要な場合**
  パターン①　12m巻のみでまかなうと、4ロール必要、8,000円x４ロール＝32,000円
  パターン②　30m巻のみでまかなうと、２ロール必要、19,000円x2ロール＝38,000円  
　パターン③　30m巻と12m巻でまかなうと、30m巻1ロール、12m巻1ロール= 8,000円＋19,000円=27,000円

　この場合は、パターン③の30mと12mを組み合わせるパターンが最も安くなります。

このような動的で最適なパターンの算出を行うために、どのような方法がありますでしょうか。
どうかお知恵を貸してください。

最適な組み合わせの巻数を動的に算出するアルゴリズム

cythonでリストの型定義をしたいです

numpyのarrayリストには型定義ができることはわかっています
しかし、普通のリストをarrayリストにしたときに呼び出しなどに
時間がかかるので、大きな計算をしない場合には普通のリストで行いたいと思っています

仮にarrayリストでしか、型定義できないが
普通のリストを実装するよりも速いなら
arrayリストでcythonを実装したいと思います

よろしくお願いします

cythonでリストに型定義するには

`lastb`コマンドでログインに失敗した履歴を見てみると、rootだけで四万回くらいアクセスがありました。
サーバーへの負荷が心配なので対策をしたいと思っています。

アクセスの多かった怪しいIPはSSH接続出来ないように設定しようと思い、
参考サイト様：[CentOS6、7でSSHのIP制限をする方法](https://www.logw.jp/server/6938.html) をもとに`hosts.deny`に該当のIPを記述しました。

これだけで指定したIPからの攻撃によるサーバーへの負荷は下がるものなのでしょうか？

別の方は、参考サイト様:[特定のIPからの通信を破棄](https://www.softel.co.jp/blogs/tech/archives/4933) のように、iptablesにIPを記述して通信を破棄するという対策をされていました。

どちらもしておくべきなのか、片方でいいのか、影響範囲がわからないためご教授頂けますと幸いです。

どうぞよろしくお願い致します。