Rustの学習：AzulとのUDPチャットの方法

アズール

残りのフレームワークの簡単な概要

• Orbtk -Azulとほぼ同じで、ディープアルファでも
• Conrod- ビデオクロスプラットフォームのデスクトップアプリケーションを作成できます。
• YewはWebAssemblyであり、Reactに似ています。 Web開発用。

お客様

ソケットの読み取りおよび書き込み用の補助機能がグループ化されている構造

struct ChatService {} impl ChatService { //1 fn read_data(socket: &Option<UdpSocket>) -> Option<String> { //2 let mut buf = [0u8; 4096]; match socket { Some(s) => { //3 match s.recv(&mut buf) { //4 Ok(count) => Some(String::from_utf8(buf[..count].into()) .expect("can't parse to String")), Err(e) => { //5 println!("Error {}", e); None } } } _ => None, } } //6 fn send_to_socket(message: String, socket: &Option<UdpSocket>) { match socket { //7 Some(s) => { s.send(message.as_bytes()).expect("can't send"); } _ => return, } } } 

1. ソケットからデータを読み取る
2. ソケットから読み取られるデータのバッファー。
3. ブロッキングコール。 ここで、実行スレッドは、データが読み取られるか、タイムアウトが発生するまで停止します。
4. UTF8エンコーディングのバイト配列から文字列を取得します。
5. 接続がタイムアウトによって中断されたか、別のエラーが発生した場合、ここに到達します。
6. 文字列をソケットに送信します。
7. 文字列をUTF8エンコーディングのバイトに変換し、データをソケットに送信します。 ソケットへのデータの書き込みはブロックされません。つまり、 実行のスレッドは作業を継続します。 データを送信できなかった場合、「送信できません」というメッセージでプログラムを中断します。

ユーザーからのイベントを処理し、DataModelを変更するための関数をグループ化する構造

 struct Controller {} //1 const TIMEOUT_IN_MILLIS: u64 = 2000; impl Controller { //2 fn send_pressed(app_state: &mut azul::prelude::AppState<ChatDataModel>, _event: azul::prelude::WindowEvent<ChatDataModel>) -> azul::prelude::UpdateScreen { //3 let data = app_state.data.lock().unwrap(); //4 let message = data.messaging_model.text_input_state.text.clone(); data.messaging_model.text_input_state.text = "".into(); //5 ChatService::send_to_socket(message, &data.messaging_model.socket); //6 azul::prelude::UpdateScreen::Redraw } //7 fn login_pressed(app_state: &mut azul::prelude::AppState<ChatDataModel>, _event: azul::prelude::WindowEvent<ChatDataModel>) -> azul::prelude::UpdateScreen { //8 use std::time::Duration; //9 if let Some(ref _s) = app_state.data.clone().lock().unwrap().messaging_model.socket { return azul::prelude::UpdateScreen::DontRedraw; } //10 app_state.add_task(Controller::read_from_socket_async, &[]); //11 app_state.add_daemon(azul::prelude::Daemon::unique(azul::prelude::DaemonCallback(Controller::redraw_daemon))); //12 let mut data = app_state.data.lock().unwrap(); //13 let local_address = format!("127.0.0.1:{}", data.login_model.port_input.text.clone().trim()); //14 let socket = UdpSocket::bind(&local_address) .expect(format!("can't bind socket to {}", local_address).as_str()); //15 let remote_address = data.login_model.address_input.text.clone().trim().to_string(); //16 socket.connect(&remote_address) .expect(format!("can't connect to {}", &remote_address).as_str()); //17 socket.set_read_timeout(Some(Duration::from_millis(TIMEOUT_IN_MILLIS))) .expect("can't set time out to read"); // 18 data.logged_in = true; // 19 data.messaging_model.socket = Option::Some(socket); //20 azul::prelude::UpdateScreen::Redraw } //21 fn read_from_socket_async(app_data: Arc<Mutex<ChatDataModel>>, _: Arc<()>) { //22 let socket = Controller::get_socket(app_data.clone()); loop { //23 if let Some(message) = ChatService::read_data(&socket) { //24 app_data.modify(|state| { //25 state.messaging_model.has_new_message = true; //26 state.messaging_model.messages.push(message); }); } } } //27 fn redraw_daemon(state: &mut ChatDataModel, _repres: &mut azul::prelude::Apprepres) -> (azul::prelude::UpdateScreen, azul::prelude::TerminateDaemon) { //28 if state.messaging_model.has_new_message { state.messaging_model.has_new_message = false; (azul::prelude::UpdateScreen::Redraw, azul::prelude::TerminateDaemon::Continue) } else { (azul::prelude::UpdateScreen::DontRedraw, azul::prelude::TerminateDaemon::Continue) } } //29 fn get_socket(app_data: Arc<Mutex<ChatDataModel>>) -> Option<UdpSocket> { //30 let ref_model = &(app_data.lock().unwrap().messaging_model.socket); //31 match ref_model { Some(s) => Some(s.try_clone().unwrap()), _ => None } } } 

1. ソケットからの読み取りのブロック操作が中断されるまでのタイムアウト（ミリ秒単位）。
2. この機能は、ユーザーがサーバーに新しいメッセージを送信するときに機能します。
3. データモデルでミューテックスを取得します。 これにより、ミューテックスが解放されるまで、インターフェイスの再描画スレッドがブロックされます。
4. ユーザーが入力したテキストのコピーを作成してさらに転送し、テキスト入力フィールドをクリアします。
5. メッセージを送信しています。
6. このイベントを処理した後、インターフェイスを再描画する必要があることをフレームワークに通知します。
7. この機能は、ユーザーがサーバーに接続するときに機能します。
8. 標準ライブラリからの時間の長さを表すために構造を接続します。
9. すでにサーバーに接続している場合は、関数の実行を中断し、インターフェイスを再描画する必要がないことをフレームワークに通知します。
10. Azulフレームワークのスレッドプールからスレッドで非同期に実行されるタスクを追加します。 データモデルを使用したmutexの呼び出しは、mutexが解放されるまでUIの更新をブロックします。
11. メインスレッドで実行される定期的なタスクを追加します。 このデーモンでの長時間の計算は、インターフェースの更新によってブロックされます。
12. ミューテックスを取得します。
13. ユーザーが入力したポートを読み取り、それに基づいてローカルアドレスを作成し、リッスンします。
14. ローカルアドレスに到着するパケットを読み取るUDPソケットを作成します。
15. ユーザーが入力したサーバーアドレスを読み取ります。
16. このサーバーからのみパケットを読み取るようにUDPソケットに指示します。
17. ソケットからの読み取り操作のタイムアウトを設定します。 ソケットへの書き込みは待機せずに行われます。つまり、データを書き込むだけで何も待たず、ソケットからの読み取り操作はストリームをブロックし、読み取り可能なデータが到着するまで待機します。 タイムアウトを設定しない場合、ソケットからの読み取り操作は無期限に待機します。
18. ユーザーがサーバーに既に接続していることを示すフラグを設定します。
19. 作成したソケットをデータモデルに渡します。
20. このイベントを処理した後、インターフェイスを再描画する必要があることをフレームワークに通知します。
21. Azulフレームワークのスレッドプールで実行される非同期操作。
22. データモデルからソケットのコピーを取得します。
23. ソケットからデータを読み取ろうとしています。 ソケットのコピーを作成せず、データモデルのミューテックスにあるソケットからメッセージが到着するまでここで直接待機する場合、ミューテックスを解放するまでインターフェイス全体の更新が停止します。
24. 何らかのメッセージが表示された場合、データモデルを変更すると、modifyはlock（）と同じことを行います。結果をラムダに渡し、ラムダコードの終了後にミューテックスを解放して、ラップを解除します。
25. 新しいメッセージがあることを示すフラグを設定します。
26. すべてのチャットメッセージの配列にメッセージを追加します。
27. メインスレッドで実行される繰り返し同期操作。
28. 新しいメッセージがある場合は、インターフェイスを最初から再描画してこのデーモンで作業を続ける必要があることをフレームワークに通知します。そうでない場合は、最初からインターフェイスを描画せずに、次のサイクルでこの関数を呼び出します。
29. ミューテックスがデータモデルでロックされないように、ソケットのコピーを作成します。
30. ミューテックスを取得し、ソケットへのリンクを取得します。
31. ソケットのコピーを作成します。 関数を終了すると、ミューテックスは自動的に解放されます。

Azulの非同期データ処理とデーモン

 // Problem - blocks UI :( fn start_connection(app_state: &mut AppState<MyDataModel>, _event: WindowEvent<MyDataModel>) -> UpdateScreen { //   app_state.add_task(start_async_task, &[]); //  app_state.add_daemon(Daemon::unique(DaemonCallback(start_daemon))); UpdateScreen::Redraw } fn start_daemon(state: &mut MyDataModel, _repres: &mut Apprepres) -> (UpdateScreen, TerminateDaemon) { // UI    thread::sleep(Duration::from_secs(10)); state.counter += 10000; (UpdateScreen::Redraw, TerminateDaemon::Continue) } fn start_async_task(app_data: Arc<Mutex<MyDataModel>>, _: Arc<()>) { // simulate slow load app_data.modify(|state| { // UI    thread::sleep(Duration::from_secs(10)); state.counter += 10000; }); } 

 fn start_async_task(app_data: Arc<Mutex<MyDataModel>>, _: Arc<()>) { //  UI.  . thread::sleep(Duration::from_secs(10)); app_data.modify(|state| { state.counter += 10000; }); } 

私たちのスタイル

 const CUSTOM_CSS: &str = " .row { height: 50px; } .orange { background: linear-gradient(to bottom, #f69135, #f37335); font-color: white; border-bottom: 1px solid #8d8d8d; }"; 

実際、ユーザーに表示するDOMを作成するための関数

 impl azul::prelude::Layout for ChatDataModel { //1 fn layout(&self, info: azul::prelude::WindowInfo<Self>) -> azul::prelude::Dom<Self> { //2 if self.logged_in { self.chat_form(info) } else { self.login_form(info) } } } impl ChatDataModel { //3 fn login_form(&self, info: azul::prelude::WindowInfo<Self>) -> azul::prelude::Dom<Self> { //4 let button = azul::widgets::button::Button::with_label("Login") //5 .dom() //6 .with_class("row") //7 .with_class("orange") //8 .with_callback( azul::prelude::On::MouseUp, azul::prelude::Callback(Controller::login_pressed)); //9 let port_label = azul::widgets::label::Label::new("Enter port to listen:") .dom() .with_class("row"); //10 let port = azul::widgets::text_input::TextInput::new() //11 .bind(info.window, &self.login_model.port_input, &self) .dom(&self.login_model.port_input) .with_class("row"); // 9 let address_label = azul::widgets::label::Label::new("Enter server address:") .dom() .with_class("row"); //10 let address = azul::widgets::text_input::TextInput::new() //11 .bind(info.window, &self.login_model.address_input, &self) .dom(&self.login_model.address_input) .with_class("row"); //12 azul::prelude::Dom::new(azul::prelude::NodeType::Div) .with_child(port_label) .with_child(port) .with_child(address_label) .with_child(address) .with_child(button) } //13 fn chat_form(&self, info: azul::prelude::WindowInfo<Self>) -> azul::prelude::Dom<Self> { //14 let button = azul::widgets::button::Button::with_label("Send") .dom() .with_class("row") .with_class("orange") .with_callback(azul::prelude::On::MouseUp, azul::prelude::Callback(Controller::send_pressed)); //15 let text = azul::widgets::text_input::TextInput::new() .bind(info.window, &self.messaging_model.text_input_state, &self) .dom(&self.messaging_model.text_input_state) .with_class("row"); //12 let mut dom = azul::prelude::Dom::new(azul::prelude::NodeType::Div) .with_child(text) .with_child(button); //16 for i in &self.messaging_model.messages { dom.add_child(azul::widgets::label::Label::new(i.clone()).dom().with_class("row")); } dom } } 

1. 最終的なDOMを作成し、インターフェイスを再描画する必要があるたびに呼び出される関数。
2. すでにサーバーに接続している場合は、メッセージを送信および読み取るためのフォームを表示します。それ以外の場合は、サーバーに接続するためのフォームを表示します。
3. サーバーへの接続に必要なデータを入力するためのフォームを作成します。
4. ログインのテキスト碑文でボタンを作成します。
5. それをDOMオブジェクトに変換します。
6. 行クラスを追加します。
7. CSSクラスオレンジを追加します。
8. ボタンをクリックするイベントハンドラーを追加します。
9. ユーザーとcssクラスの行に表示するテキストを含むテキストラベルを作成します。
10. モデルのプロパティとcssクラスの行のテキストを使用してテキストを入力するためのテキストボックスを作成します。
11. テキストフィールドをDataModelのプロパティにバインドします。 これは双方向バインディングです。 TextInputを編集すると、モデルのプロパティ内のテキストが自動的に変更されます。逆も同様です。 モデルのテキストを変更すると、TextInputのテキストも変更されます。
12. UI要素を配置するルートDOM要素を作成します。
13. メッセージを送受信するためのフォームを作成します。
14. クリックすると、テキスト「送信」とクラス「行」、「オレンジ」、CSSを含むボタンを作成します。
15. モデルプロパティself.messaging_model.text_input_stateの双方向バインディングとクラス「row」のcssでテキスト入力フィールドを作成します。
16. チャットで作成されたメッセージを表示するテキストラベルを追加します。

インターフェースの状態を保存するモデル

 //1 #[derive(Debug)] //2 struct ChatDataModel { //3 logged_in: bool, //4 messaging_model: MessagingDataModel, //5 login_model: LoginDataModel, } #[derive(Debug, Default)] struct LoginDataModel { //6 port_input: azul::widgets::text_input::TextInputState, //7 address_input: azul::widgets::text_input::TextInputState, } #[derive(Debug)] struct MessagingDataModel { //8 text_input_state: azul::widgets::text_input::TextInputState, //9 messages: Vec<String>, //10 socket: Option<UdpSocket>, //11 has_new_message: bool, } 

1. これにより、{:?}の形式のテンプレートに文字列として構造を表示できます。
2. データモデル。 Azulで使用できるように。 彼女はレイアウト特性を実装する必要があります。
3. ユーザーがサーバーに接続されているかどうかを確認するフラグ。
4. サーバーにメッセージを送信し、サーバーから受信したメッセージを保存するためのフォームを表示するためのモデル。
5. サーバーに接続するためのフォームを表示するためのモデル。
6. ユーザーが入力したポート。 ソケットでそれをリッスンします。
7. ユーザーが入力したサーバーのアドレス。 接続します。
8. ユーザーメッセージ。 サーバーに送信します。
9. サーバーから送信されたメッセージの配列。
10. サーバーと通信するためのソケット。
11. サーバーから新しいメッセージが到着したかどうかを確認するフラグ。

最後に、アプリケーションへのメインエントリポイント。 GUI描画とユーザー入力処理からサイクルを開始します

 pub fn run() { //1 let app = azul::prelude::App::new(ChatDataModel { logged_in: false, messaging_model: MessagingDataModel { text_input_state: azul::widgets::text_input::TextInputState::new(""), messages: Vec::new(), socket: None, has_new_message: false, }, login_model: LoginDataModel::default(), }, azul::prelude::AppConfig::default()); // 2 let mut style = azul::prelude::css::native(); //3 style.merge(azul::prelude::css::from_str(CUSTOM_CSS).unwrap()); //4 let window = azul::prelude::Window::new(azul::prelude::WindowCreateOptions::default(), style).unwrap(); //5 app.run(window).unwrap(); } 

1. 開始データを使用してアプリケーションを作成します。
2. デフォルトでアプリケーションが使用するスタイル。
3. 独自のスタイルを追加します。
4. アプリケーションを表示するウィンドウを作成します。
5. このウィンドウでアプリケーションを起動します。

サーバー

アプリケーションへのメインエントリポイント

 pub fn run() { //1 let socket = create_socket(); //2 let (sx, rx) = mpsc::channel(); //3 start_sender_thread(rx, socket.try_clone().unwrap()); loop { //4 sx.send(read_data(&socket)).unwrap(); } } 

1. ソケットを作成します。
2. 1つのsxメッセージ送信者と多くのrx受信者で一方向のチャネルを作成します。
3. 別のストリームですべての受信者にメッセージを送信し始めます。
4. ソケットからデータを読み取ってストリームに送信し、サーバーに接続されているクライアントにメッセージを配信します。

クライアントにメッセージを送信するためのストリームを作成する機能

 fn start_sender_thread(rx: mpsc::Receiver<(Vec<u8>, SocketAddr)>, socket: UdpSocket) { //1 thread::spawn(move || { //2 let mut addresses = Vec::<SocketAddr>::new(); //3 loop { //4 let (bytes, pre) = rx.recv().unwrap(); // 5 if !addresses.contains(&pre) { println!(" {} connected to server", pre); addresses.push(pre.clone()); } //6 let result = String::from_utf8(bytes) .expect("can't parse to String") .trim() .to_string(); println!("received {} from {}", result, pre); //7 let message = format!("FROM: {} MESSAGE: {}", pre, result); let data_to_send = message.as_bytes(); //8 addresses .iter() .for_each(|s| { //9 socket.send_to(data_to_send, s) //10 .expect(format!("can't send to {}", pre).as_str()); }); } }); } 

1. 新しいスレッドを開始します。 moveは、変数がそれぞれラムダとフローを引き継ぐことを意味します。 より具体的には、新しいスレッドはrxおよびソケット変数を「吸収」します。
2. 顧客によって私たちに接続されたアドレスのコレクション。 それらすべてにメッセージを送信します。 一般的に、実際のプロジェクトでは、クライアントを私たちから切断し、この配列からアドレスを削除することを処理する必要があります。
3. 無限ループを開始します。
4. チャネルからデータを読み取ります。 ここでは、新しいデータが到着するまでストリームがブロックされます。
5. 配列にそのようなアドレスがない場合は、そこに追加します。
6. バイト配列からUTF8文字列をデコードします。
7. すべての顧客に送信するバイトの配列を作成します。
8. アドレスのコレクションを調べて、全員にデータを送信します。
9. UDPソケットへの書き込み操作はブロックされないため、ここでは、関数は受信者にメッセージが到着してほぼ即座に実行されるまで待機しません。
10. エラーが発生した場合は、指定されたメッセージを使用してプログラムを緊急終了します。

この関数は、ユーザー入力に基づいてソケットを作成します

 const TIMEOUT_IN_MILLIS: u64 = 2000; fn create_socket() -> UdpSocket { println!("Enter port to listen"); //1 let local_port: String = read!("{}\n"); let local_address = format!("127.0.0.1:{}", local_port.trim()); println!("server address {}", &local_address); //2 let socket = UdpSocket::bind(&local_address.trim()) .expect(format!("can't bind socket to {}", &local_address).as_str()); //3 socket.set_read_timeout(Some(Duration::from_millis(TIMEOUT_IN_MILLIS))) .expect("can't set time out to read"); //4 socket } 

1. サーバーがリッスンするポートを読み取り、それに基づいてローカルサーバーアドレスを作成します。
2. このアドレスでリッスンするUDPソケットを作成します。
3. 読み取り操作のタイムアウトを設定します。 読み取り操作はブロックされており、新しいデータが到着するか、タイムアウトが発生するまでフローをブロックします。
4. Functionから作成されたソケットを返します。
5. この関数は、ソケットからデータを読み取り、送信者アドレスとともにそれを返します。

ソケットからデータを読み取る関数

 fn read_data(socket: &UdpSocket) -> (Vec<u8>, SocketAddr) { //1 let mut buf = [0u8; 4096]; //2 loop { match socket.recv_from(&mut buf) { //3 Ok((count, address)) => { //4 return (buf[..count].into(), address); } //5 Err(e) => { println!("Error {}", e); continue; } }; } } 

1. バッファーは、データを読み取る場所です。
2. 有効なデータが読み取られるまで実行されるループを開始します。
3. 読み取られたバイト数と送信者アドレスを取得します。
4. 配列の先頭から読み取ったバイト数までの配列のスライスを作成し、それをバイトベクトルに変換します。
5. タイムアウトまたはその他のエラーが発生した場合は、ループの次の反復に進みます。

アプリケーションのレイヤーについて

 class User { public string FirstName { get; set; } public string LastName { get; set; } public string FullName { get { return FirstName + " " + LastName; } } public bool Equal(User user) { return this.FullName == user.FullName; } } 

 using System; using System.Collections.Generic; using System.Text; //Entities class User { public int Id { get; set; } public string Name { get; set; } } //Data Access Layer class UserRepository { private readonly Dictionary<int, User> _db; public UserRepository() { _db = new Dictionary<int, User>(); } public User Get(int id) { return _db[id]; } public void Save(User user) { _db[user.Id] = user; } } //Business Logic Layer class UserService { private readonly UserRepository _repo; private int _currentId = 0; public UserService() { _repo = new UserRepository(); } public void AddNew() { _currentId++; var user = new User { Id = _currentId, Name = _currentId.ToString() }; _repo.Save(user); } public string GetAll() { StringBuilder sb = new StringBuilder(); for (int i = 1; i <= _currentId; i++) { sb.AppendLine($"Id: {i} Name: {_repo.Get(i).Name}"); } return sb.ToString(); } } //presentation Layer aka Application Layer class UserController { private readonly UserService _service; public UserController() { _service = new UserService(); } public string RunExample() { _service.AddNew(); _service.AddNew(); return _service.GetAll(); } } namespace ConsoleApp1 { class Program { static void Main(string[] args) { var controller = new UserController(); Console.WriteLine(controller.RunExample()); Console.ReadLine(); } } } 

PS