Merge branch 'dev' of feistymeow.org:feisty_meow into dev
[feisty_meow.git] / octopi / library / tests_sockets / test_spocket.cpp
1 /*
2 *  Name   : test_spocket
3 *  Author : Chris Koeritz
4 *  Purpose: This is the "main" program for our sockets tester.  It parses command
5 *  line parameters and starts up the tester class.
6 **
7 * Copyright (c) 2001-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 */
14
15 #include "spocket_tester.h"
16
17 #include <application/hoople_main.h>
18 #include <basis/byte_array.h>
19 #include <basis/astring.h>
20 #include <loggers/file_logger.h>
21 #include <processes/launch_process.h>
22 #include <structures/static_memory_gremlin.h>
23 #include <sockets/internet_address.h>
24 #include <unit_test/unit_base.h>
25
26 #include <stdio.h>
27
28 using namespace application;
29 using namespace basis;
30 using namespace loggers;
31 using namespace mathematics;
32 using namespace processes;
33 using namespace sockets;
34 using namespace structures;
35 using namespace textual;
36 using namespace timely;
37 using namespace unit_test;
38
39 #define LOG(to_print) EMERGENCY_LOG(program_wide_logger().get(), astring(to_print))
40
41 typedef abyte ip_address_holder[4];
42
43 class test_spocket : public virtual application_shell, public virtual unit_base
44 {
45 public:
46   test_spocket() {}
47   DEFINE_CLASS_NAME("test_spocket");
48   virtual int execute();
49
50   bool parse_address(const astring &input, ip_address_holder &ip_address);
51 };
52
53 //hmmm: get into a library; same func as in t_bcast_spocket
54 bool test_spocket::parse_address(const astring &input, ip_address_holder &ip_address)
55 {
56   int index = 0;  // current storage position in our array.
57   int current_byte = 0;
58   const char *last_period = 0;  // helps check for non-empty numbers.
59   bool got_digit = false;
60   for (const char *address = input.s(); *address; address++) {
61     if ( (*address <= '9') && (*address >= '0') ) {
62       current_byte *= 10;  // shift over.
63       current_byte += *address - '0';  // add in current character.
64       got_digit = true;
65     } else if (*address == '.') {
66       got_digit = false;
67       if (last_period + 1 == address) {
68         LOG("The IP address entry has an empty digit.  Exiting.");
69         return false;
70       }
71       last_period = address;  // set our last period location.
72       if (current_byte > 255) {
73         LOG("The IP address entry has an illegal abyte.  Exiting.");
74         return false;
75       }
76       ip_address[index] = abyte(current_byte);  // store current byte.
77       current_byte = 0;  // reset.
78       index++;  // next place in array.
79       if (index > 3) break;
80         // stop if there are too many periods, but keep accumulated address.
81     } else {
82       LOG("The IP address entry has illegal characters.  Exiting.");
83       return false;
84     }
85   }
86   // catch the case where we ran out of chars before adding the last byte.
87   if ( (index == 3) && got_digit) {
88     if (current_byte > 255) {
89       LOG("The IP address entry has an illegal abyte.  Exiting.");
90       return false;
91     }
92     ip_address[index] = current_byte;
93   } else if (index < 4) {
94     LOG("The IP address entry is too short.  Exiting.");
95     return false;
96   }
97   return true;
98 }
99
100 int test_spocket::execute()
101 {
102   FUNCDEF("execute");
103   ip_address_holder ip_address;  // accumulates the source address.
104   int rcv_port = 0;
105   bool is_client = false;
106   int send_size = 0;
107   int send_count = 0;
108
109   const char *DEFAULT_HOST = "127.0.0.1";
110   const int DEFAULT_PORT = 12348;
111   const int DEFAULT_SEND_SIZE = 1008;
112   const int DEFAULT_SEND_COUNT = 10;
113
114   if (_global_argc < 6) {
115     if (_global_argc > 1) {
116       LOG("\
117 This program takes five command line arguments to begin operation.\n\
118 These arguments (in order) are:\n\
119 \tIP address\t\tIn the form w.x.y.z\n\
120 \tPort number\t\tAs a short integer\n\
121 \tTester role\t\tEither \"client\" or \"server\"\n\
122 \tSend size\t\tThe size of the data to exchange.\n\
123 \tSend count\t\tThe number of \"packets\" to exchange.\n\
124 Note: it is expected that the client and server have equal send sizes;\n\
125 this allows the receiver to know when it's gotten all the data that's\n\
126 expected during a cycle.");
127       return 1;  // bail if they provided anything; otherwise we test.
128     } else {
129       parse_address(DEFAULT_HOST, ip_address);
130       rcv_port = DEFAULT_PORT;
131       is_client = false;  // we're a server to start with for unit test.
132       send_size = DEFAULT_SEND_SIZE;
133       send_count = DEFAULT_SEND_COUNT;
134     }
135   }
136
137   // only parse the parameters if we got enough from the user; otherwise we accept our
138   // defaults to do a simple test run.
139   if (_global_argc >= 6) {
140
141     if (!parse_address(_global_argv[1], ip_address)) {
142       LOG("failed to parse source address.");
143       return 9283;
144     }
145
146     LOG(a_sprintf("\tParsed a source of: \"%d.%d.%d.%d\".",
147         (int)ip_address[0], (int)ip_address[1], (int)ip_address[2],
148         (int)ip_address[3]));
149
150     // parse the next parameter: the port.
151     if (sscanf(_global_argv[2], "%d", &rcv_port) < 1) {
152       LOG("The port entry is malformed.  Exiting.");
153       return 3;
154     }
155     LOG(a_sprintf("\tGot a port of %d.", rcv_port));
156
157     // parse the next parameter: the role for this tester.
158     astring arg3 = _global_argv[3];
159     arg3.to_lower();
160     if (arg3 == astring("client")) is_client = true;
161     else if (arg3 == astring("server")) is_client = false;
162     else {
163       LOG("The tester role (client/server) is malformed.  Exiting.");
164       return 4;
165     }
166     if (is_client) LOG("\tTester role is \"client\".")
167     else LOG("\tTester role is \"server\".");
168
169     // parse the next parameter: the size of the sends.
170     if (sscanf(_global_argv[4], "%d", &send_size) < 1) {
171       LOG("The send size entry is malformed.  Exiting.");
172       return 5;
173     }
174     LOG(a_sprintf("\tGot a send size of %d.", send_size));
175
176     // parse the next parameter: the number of sends.
177     if (sscanf(_global_argv[5], "%d", &send_count) < 1) {
178       LOG("The send count entry is malformed.  Exiting.");
179       return 5;
180     }
181     LOG(a_sprintf("\tGot a send count of %d.", send_count));
182   }
183
184   // package our parameters in a form the tester likes.
185   internet_address to_pass(byte_array(4, ip_address), "", rcv_port);
186
187   // now, construct our tester object.
188   spocket_tester *tester = new spocket_tester(to_pass);
189
190   // choose the appropriate action based on our role.
191   bool outcome;
192   if (is_client) {
193     outcome = tester->connect();
194   } else {
195     outcome = tester->accept(_global_argc != 1);
196   }
197   if (!outcome) {
198     const char *action = is_client? "connect" : "accept";
199     LOG(astring("Failed to ") + action + " on the tester.");
200     return 10;
201   }
202
203   if (_global_argc == 1) {
204     // launch a paired duplicate of our test so we can chat.
205     launch_process zingit;
206     un_int kidnum;
207     un_int result = zingit.run(_global_argv[0],
208         astring(DEFAULT_HOST) + " " + a_sprintf("%d", DEFAULT_PORT) + " client "
209         + a_sprintf("%d", DEFAULT_SEND_SIZE) + " " + a_sprintf("%d", DEFAULT_SEND_COUNT),
210         launch_process::RETURN_IMMEDIATELY, kidnum);
211     ASSERT_EQUAL(result, 0, "launching paired process should start successfully");
212
213     // now we try again accepting from our client side.
214     outcome = tester->accept();
215 //hmmm: redundant below.
216     if (!outcome) {
217       const char *action = is_client? "connect" : "accept";
218       LOG(astring("Failed to ") + action + " on the tester.");
219       return 10;
220     }
221   }
222
223   // so, we're connected.  try sending the test packages out.
224   testing_statistics stats;  // to be filled by the tester.
225   outcome = tester->perform_test(send_size, send_count * 2, stats);
226     // multiply send_count since we count each side as one.
227   if (!outcome) {
228     LOG("Failed out of send_data; maybe other side terminated.");
229   }
230
231   stats.total_runs /= 2;  // cut down to the real number of tests.
232
233   if (!stats.total_runs)
234     stats.total_runs = 1;
235
236   // now report on the stats that we get from the data sending.
237   LOG(a_sprintf("Report for %d completed test cycles.", stats.total_runs));
238   LOG("");
239   LOG("\t\tsend stats\t\treceive stats");
240   LOG("\t\t----------\t\t-------------");
241   LOG(a_sprintf("bytes\t\t%d\t\t\t%d", stats.bytes_sent,
242       stats.bytes_received));
243   LOG(a_sprintf("time\t\t%d\t\t\t%d", stats.send_time, stats.receive_time));
244   LOG(a_sprintf("avg. bytes\t%d\t\t\t%d", stats.bytes_sent
245       / stats.total_runs / 2, stats.bytes_received / stats.total_runs / 2));
246   LOG("");
247   LOG(a_sprintf("round trip time: %d ms", stats.round_trip_time));
248 //hmmm: use the bandwidth measurer object!!!
249   double bandwidth = double(stats.bytes_sent + stats.bytes_received)
250       / stats.round_trip_time / 1024.0 * 1000.0;
251   LOG(a_sprintf("bandwidth overall: %f K/s", bandwidth));
252
253   if (_global_argc == 1) return final_report();
254   else return 0;  // no unit test report for non-top-level process
255 }
256
257 HOOPLE_MAIN(test_spocket, );
258