silentEAG opened a new issue, #707:
URL: https://github.com/apache/rocketmq-clients/issues/707

   ### Before Creating the Bug Report
   
   - [X] I found a bug, not just asking a question, which should be created in 
[GitHub Discussions](https://github.com/apache/rocketmq-clients/discussions).
   
   - [X] I have searched the [GitHub 
Issues](https://github.com/apache/rocketmq-clients/issues) and [GitHub 
Discussions](https://github.com/apache/rocketmq-clients/discussions)  of this 
repository and believe that this is not a duplicate.
   
   - [X] I have confirmed that this bug belongs to the current repository, not 
other repositories of RocketMQ.
   
   
   ### Programming Language of the Client
   
   Rust
   
   ### Runtime Platform Environment
   
   Linux 6.6.16-2-MANJARO
   
   ### RocketMQ Version of the Client/Server
   
   Server 5.2.0 / Rust Client 5.0.0 / Rust version cargo 1.78.0-nightly 
(194a60b29 2024-02-21)
   
   ### Run or Compiler Version
   
   follow https://github.com/apache/rocketmq-docker, use `5.2.0` `alpine`, `sh 
./play-docker-compose.sh`
   
   ### Describe the Bug
   
   I noticed through the logs that it failed to handle the command, resulting 
in `sync settings failed: failed to call rpc: Client is not running at 
session.update_settings, context: { url: localhost:8080 } => session is not 
started, component: client`, as shown in the image:
   
   
![image](https://github.com/apache/rocketmq-clients/assets/45896153/e8fc18df-8a4b-4c06-8616-72d4dc43c767)
   
   If using the same environment, the scripts `play-producer.sh` and 
`play-consumer.sh` inside `rocketmq-docker` do not exhibit this problem.
   
   
   ### Steps to Reproduce
   
   My consumer:
   
   ```rust
   async fn loop_run() -> color_eyre::Result<()> {
   
       let mut producer_option = ProducerOption::default();
       producer_option.set_topics(vec!["response"]);
       
       // set which rocketmq proxy to connect
       let mut client_option = ClientOption::default();
       client_option.set_access_url("localhost:8080");
   
       let mut producer = Producer::new(producer_option, client_option)?;
       producer.start().await?;
   
   
       let mut consumer_option = SimpleConsumerOption::default();
       consumer_option.set_topics(vec!["request"]);
       consumer_option.set_consumer_group("SimpleConsumerGroup");
   
   
       // set which rocketmq proxy to connect
       let mut client_option = ClientOption::default();
       client_option.set_access_url("localhost:8080");
       client_option.set_enable_tls(false);
   
       // build and start simple consumer
       let mut consumer = SimpleConsumer::new(consumer_option, client_option)?;
       consumer.start().await?;
    
       loop {
   
           let receive_result = consumer
           .receive(
               "request".to_string(),
               &FilterExpression::new(FilterType::Tag, "cipher"),
           )
           .await;
   
           if let Err(e) = receive_result {
               eprintln!("error: {}", e);
               continue;
           }
   
           let messages = receive_result.unwrap();
           if messages.is_empty() {
               continue;
           }
   
           for msg in messages {
               consumer.ack(&msg).await.unwrap();
               let body = msg.body();
               let request_mq: RequestMQ = 
serde_json::from_slice(&body).unwrap();
               let solved_bytes = 
cipher::handle_cipher(request_mq.cipher).await;
   
               println!("solved_bytes: {:?}", solved_bytes);
               println!("user_id: {:?}", request_mq.user_id.to_string());
   
               let body = match solved_bytes {
                   Ok(solved_bytes) => {
                       let solved = BASE64_STANDARD.encode(solved_bytes);
                       ResponseMQ::Ok(solved)
                   }
                   Err(e) => {
                       ResponseMQ::Err(e.to_string())
                   }
               };
   
               let message = rocketmq::model::message::MessageBuilder::builder()
                   .set_topic("response")
                   .set_tag(request_mq.user_id.to_string())
                   .set_body(serde_json::to_vec(&body).unwrap())
                   .build().unwrap();
   
               let result = producer.send(message).await.unwrap();
               println!("send message success, message_id={}", 
result.message_id());
           }
       }
   
       Ok(())
   }
   ```
   
   ### What Did You Expect to See?
   
   Work without error log message
   
   ### What Did You See Instead?
   
   nop
   
   ### Additional Context
   
   _No response_


-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: commits-unsubscr...@rocketmq.apache.org.apache.org

For queries about this service, please contact Infrastructure at:
us...@infra.apache.org

Reply via email to