playit-gg 0.0.1

Unofficial Rust Wrapper For PlayIt.GG
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

pub mod types;
pub mod utils;
use serde_json::json;
use serde_json::to_string;
// use std::collections::HashMap;
pub use types::*;

pub async fn new(playit_opts: Option<PlayItOpts>) -> Result<PlayIt, String> {
  return PlayIt::new(playit_opts).await;
}

impl PlayIt {
  pub async fn new(playit_opts: Option<PlayItOpts>) -> Result<Self, String> {
    return utils::get_defaults(playit_opts).await;
  }

  #[cfg(feature = "create-tunnels")]
  pub async fn create_tunnel(&self, mut options: CreateTunnelOptions) {
    options.ip = Option::from(options.ip.unwrap_or(String::from("127.0.0.1")));

    println!(
      "{}",
      to_string(&json!({
        "id": null,
        "game": format!("custom-{}", options.proto.to_lowercase()),
        "local_port": options.port,
        "local_ip": options.ip,
        "local_proto": options.proto,
        "agent_id": &self
                      .req_client
                      .get(self.api_path.join("/account/agents").unwrap())
                      .send()
                      .await
                      .unwrap()
                      .json::<Agents>()
                      .await
                      .unwrap()
                      .agents
                      .iter()
                      .position(|agent| agent.key == self.agent_key),
        "domain_id": null
      }))
      .unwrap()
    );

    // let tunnel_id = &self
    //   .req_client
    //   .post(self.api_path.join("/account/tunnels").unwrap())
    //   .body(
    //     to_string(&json!({
    //       "id": null,
    //       "game": format!("custom-{}", options.proto.to_lowercase()),
    //       "local_port": options.port,
    //       "local_ip": options.ip,
    //       "local_proto": options.proto,
    //       "agent_id": &self
    //                     .req_client
    //                     .get(self.api_path.join("/account/agents").unwrap())
    //                     .send()
    //                     .await
    //                     .unwrap()
    //                     .json::<Agents>()
    //                     .await
    //                     .unwrap()
    //                     .agents
    //                     .iter()
    //                     .position(|agent| agent.key == self.agent_key),
    //       "domain_id": null
    //     }))
    //     .unwrap(),
    //   )
    //   .send()
    //   .await
    //   .unwrap()
    //   .text() //.json::<HashMap<String, String>>()
    //   .await
    //   .unwrap(); //["id"];

    // println!("{:#?}", tunnel_id)

    // return Tunnel {};
  }

  #[cfg(feature = "enable-tunnels")]
  pub async fn enable_tunnel(&self, id: i32) {
    self
      .req_client
      .get(
        self
          .api_path
          .join(&format!("/account/tunnels/{}/enable", id))
          .unwrap(),
      )
      .send()
      .await
      .expect(&format!("Failed To Enable The Tunnel"));
  }

  #[cfg(feature = "disable-tunnels")]
  pub async fn disable_tunnel(&self, id: i32) {
    self
      .req_client
      .get(
        self
          .api_path
          .join(&format!("/account/tunnels/{}/disable", id))
          .unwrap(),
      )
      .send()
      .await
      .expect(&format!("Failed To Failed The Tunnel"));
  }

  pub fn as_ref(&self) -> &Self {
    return &self;
  }
}

#[cfg(test)]
mod tests {
  use crate::types::*;
  use std::io::BufRead;
  use std::io::BufReader;
  #[tokio::test]
  async fn start() {
    let mut playit = PlayIt::new(None).await.unwrap();

    let _tunnel = playit
      .create_tunnel(CreateTunnelOptions {
        ip: None,
        proto: String::from("tcp"),
        port: 8080,
      })
      .await;

    print!("\n\n");
    println!("Architexture: {}", playit.arch);
    println!("Operating System: {}", playit.os);
    println!(
      "PlayIt Config File: {}",
      playit.config_file.to_str().unwrap()
    );
    println!("PlayIt Binary: {}", playit.binary.to_str().unwrap());
    println!("PlayIt Version: {}", playit.version);
    println!("PlayIt Agent Key: {}", playit.agent_key);
    println!("PlayIt Server: {}", playit.server);
    println!("PlayIt First Lines Of PlayIt Output: \n{}", {
      let mut command_stderr: Vec<u8> = Vec::new();
      let mut command_stdout: Vec<u8> = Vec::new();

      BufReader::new(playit.playit.stderr.as_mut().unwrap())
        .read_until(b'\n', &mut command_stderr)
        .unwrap();
      BufReader::new(playit.playit.stdout.as_mut().unwrap())
        .read_until(b'\n', &mut command_stdout)
        .unwrap();
      String::from_utf8([command_stdout, command_stderr].concat()).unwrap()
    });
    print!("\n\n");
  }
}