Upload a single file to multiple machines tool

#include "mooon/net/libssh2.h"
1. 
   
#include "mooon/sys/stop_watch.h"
2. 
   
#include "mooon/ utils/args_parser.h"
3. 
   
#include "mooon/utils/print_color.h"
4. 
   
#include "mooon/utils/string_utils.h"
5. 
   
#include "mooon/utils/tokener.h"
6. 
   
#include
7. 
   
#include
8. 
   
9. 
   
// Comma separated list of remote hosts
10. 
    
STRING_ARG_DEFINE(h, "", "remote hosts");
11. 
    
// Sshd port number of the remote host
12. 
    
INTEGER_ARG_DEFINE(uint16_t, p, 22, 10, 65535, "remote hosts port");
13. 
    
// Username
14. 
    
STRING_ARG_DEFINE(u, "root", "remote host user");
15. 
    
// Password
16. 
    
STRING_ARG_DEFINE(P , "", "remote host password");
17. 
    
18. 
    
// Uploaded file path
19. 
    
STRING_ARG_DEFINE(s, " ", "the source file uploaded");
20. 
    
// Directory path where the file is stored after uploading
21. 
    
STRING_ARG_DEFINE(d, "", "the directory to store" ; timeout seconds to remote host");
22. 
    
23. 
    
// Result information
24. 
    
struct ResultInfo
25. 
    
{
26. 
    
bool success; // true indicates successful execution
27. 
    
std::string ip; // IP address of the remote host
28. 
    
uint32_t seconds; // The time it takes to run, accurate to seconds
29. 
    
30. 
    
ResultInfo()
31. 
    
: success(false), seconds(0)
32. 
    
{
33. 
    
}
34. 
    
35. 
    
std::string str() const
36. 
    
{
37. 
    
std::string tag = success? "SUCCESS": "FAILURE";
38. 
    
return mooon::utils: :CStringUtils::format_string("[%s %s]: %u seconds", ip.c_str(), tag.c_str(), seconds);
39. 
    
}
40. 
    
};
41. 
    
42. 
    
inline std::ostream& operator <<(std::ostream& out, const struct ResultInfo& result)
43. 
    
{
44. 
    
std::string tag = result.success? "SUCCESS": "FAILURE";
45. 
    
out << "["PRINT_COLOR_YELLOW << result.ip << PRINT_COLOR_NONE" " << tag << "] " << result.seconds << " seconds";
46. 
    
return out;
47. 
    
}
48. 
    
49. 
    
int main(int argc, char* argv[])
50. 
    
{
51. 
    
// Parse command line parameters
52. 
    
std::string errmsg;
53. 
    
if (!mooon::utils: :parse_arguments(argc, argv, &errmsg))
54. 
    
{
55. 
    
fprintf(stderr, "parameter error: %sn", errmsg.c_str());
56. 
    
exit(1);
57. 
    
}
58. 
    
59. 
    
uint16_t port = mooon::argument::p ->value();
60. 
    
std::string source = mooon::argument::s->value();
61. 
    
std::string directory = mooon::argument::d->value();
62. 
    
std::string hosts = mooon::argument::h->value();
63. 
    
std::string user = mooon::argument::u->value();
64. 
    
std::string password = mooon::argument::P->value( );
65. 
    
mooon::utils::CStringUtils::trim(source);
66. 
    
mooon::utils::CStringUtils::trim(directory);
67. 
    
mooon::utils::CStringUtils::trim(hosts);
68. 
    
mooon::utils::CStringUtils::trim(user);
69. 
    
mooon::utils::CStringUtils::trim(password);
70. 
    
71. 
    
// Check parameters (-s)
72. 
    
if (source.empty())
73. 
    
{
74. 
    
fprintf(stderr, "parameter[-s]'s value not setn");
75. 
    
exit(1);
76. 
    
}
77. 
    
78. 
    
// Check parameters (-d)
79. 
    
if (directory.empty())
80. 
    
{
81. 
    
fprintf(stderr, "parameter[-d]'s value not setn") ;
82. 
    
exit(1);
83. 
    
}
84. 
    
85. 
    
// Check parameters (-h )
86. 
    
if (hosts.empty())
87. 
    
{
88. 
    
// Try to get the value from the environment variable
89. 
    
const char* hosts_ = getenv("HOSTS");
90. 
    
if (NULL == hosts_)
91. 
    
{
92. 
    
fprintf(stderr, "parameter[-h]'s value not setn");
93. 
    
exit(1);
94. 
    
}
95. 
    
96. 
    
hosts= hosts_;
97. 
    
mooon::utils::CStringUtils::trim(hosts);
98. 
    
if (hosts .empty())
99. 
    
{
100. 
     
fprintf(stderr, "parameter[-h]'s value not setn");
101. 
     
exit(1);
102. 
     
}
103. 
     
}
104. 
     
105. 
     
// Check parameters (- u)
106. 
     
if (user.empty())
107. 
     
{
109. fprintf(stderr, "parameter[-u]'s value not setn");
     
110. exit(1);
     
111. }
     
112. 
     
113. // 檢查參數(shù)（-P）
     
114. if (password.empty())
     
115. {
     
116. fprintf(stderr, "parameter[-P]'s value not setn");
     
117. exit(1);
     
118. }
     
119. 
     
120. std::vector hosts_ip;
     
121. const std::string& remote_hosts_ip = hosts;
     
122. int num_remote_hosts_ip = mooon::utils::CTokener::split(&hosts_ip, remote_hosts_ip, ",", true);
     
123. if (0 == num_remote_hosts_ip)
     
124. {
     
125. fprintf(stderr, "parameter[-h] errorn");
     
126. exit(1);
     
127. }
     
128. 
     
129. std::string remote_filepath = directory std::string("/") mooon::utils::CStringUtils::extract_filename(source);
     
130. std::vector results(num_remote_hosts_ip);
     
131. for (int i=0; i
132. {
     
133. bool color = true;
     
134. const std::string& remote_host_ip = hosts_ip[i];
     
135. results[i].ip = remote_host_ip;
     
136. results[i].success = false;
     
137. 
     
138. fprintf(stdout, "["PRINT_COLOR_YELLOW"%s"PRINT_COLOR_NONE"]n", remote_host_ip.c_str());
     
139. fprintf(stdout, PRINT_COLOR_GREEN);
     
140. 
     
141. mooon::sys::CStopWatch stop_watch;
     
142. try
     
143. {
     
144. int file_size = 0;
     
145. mooon::net::CLibssh2 libssh2(remote_host_ip, port, user, password, mooon::argument::t->value());
     
146. libssh2.upload(source, remote_filepath, &file_size);
     
147. 
     
148. fprintf(stdout, "["PRINT_COLOR_YELLOW"%s"PRINT_COLOR_NONE"] SUCCESS: %d bytesn", remote_host_ip.c_str(), file_size);
     
149. results[i].success = true;
     
150. }
     
151. catch (mooon::sys::CSyscallException& ex)
     
152. {
     
153. if (color)
     
154. fprintf(stdout, PRINT_COLOR_NONE); // color = true;
     
155. 
     
156. fprintf(stderr, "["PRINT_COLOR_RED"%s"PRINT_COLOR_NONE"] failed: %sn", remote_host_ip.c_str(), ex.str().c_str());
     
157. }
     
158. catch (mooon::utils::CException& ex)
     
159. {
     
160. if (color)
     
161. fprintf(stdout, PRINT_COLOR_NONE); // color = true;
     
162. 
     
163. fprintf(stderr, "["PRINT_COLOR_RED"%s"PRINT_COLOR_NONE"] failed: %sn", remote_host_ip.c_str(), ex.str().c_str());
     
164. }
     
165. 
     
166. results[i].seconds = stop_watch.get_elapsed_microseconds() / 1000000;
     
167. std::cout << std::endl;
     
168. }
     
169. 
     
170. // 輸出總結(jié)
     
171. std::cout << std::endl;
     
172. std::cout << "================================" << std::endl;
     
173. int num_success = 0; // 成功的個(gè)數(shù)
     
174. int num_failure = 0; // 失敗的個(gè)數(shù)
     
175. for (std::vector::size_type i=0; i
176. {
     
177. const struct ResultInfo& result_info = results[i];
     
178. std::cout << result_info << std::endl;
     
179. 
     
180. if (result_info.success)
     
181. num_success;
     
182. else
     
183. num_failure;
     
184. }
     
185. std::cout << "SUCCESS: " << num_success << ", FAILURE: " << num_failure << std::endl;
     
186. 
     
187. return 0;
     
188. }