r22969: fix some more places where we could end up with more than one event
[sfrench/samba-autobuild/.git] / source4 / torture / local / messaging.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    local test for messaging code
5
6    Copyright (C) Andrew Tridgell 2004
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24 #include "lib/events/events.h"
25 #include "lib/messaging/irpc.h"
26 #include "torture/torture.h"
27 #include "cluster/cluster.h"
28
29
30 static uint32_t msg_pong;
31
32 static void ping_message(struct messaging_context *msg, void *private, 
33                          uint32_t msg_type, struct server_id src, DATA_BLOB *data)
34 {
35         NTSTATUS status;
36         status = messaging_send(msg, src, msg_pong, data);
37         if (!NT_STATUS_IS_OK(status)) {
38                 printf("pong failed - %s\n", nt_errstr(status));
39         }
40 }
41
42 static void pong_message(struct messaging_context *msg, void *private, 
43                          uint32_t msg_type, struct server_id src, DATA_BLOB *data)
44 {
45         int *count = private;
46         (*count)++;
47 }
48
49 static void exit_message(struct messaging_context *msg, void *private, 
50                          uint32_t msg_type, struct server_id src, DATA_BLOB *data)
51 {
52         talloc_free(private);
53         exit(0);
54 }
55
56 /*
57   test ping speed
58 */
59 static bool test_ping_speed(struct torture_context *tctx)
60 {
61         struct event_context *ev;
62         struct messaging_context *msg_client_ctx;
63         struct messaging_context *msg_server_ctx;
64         int ping_count = 0;
65         int pong_count = 0;
66         struct timeval tv;
67         int timelimit = torture_setting_int(tctx, "timelimit", 10);
68         uint32_t msg_ping, msg_exit;
69         TALLOC_CTX *mem_ctx = tctx;
70
71         lp_set_cmdline("pid directory", "piddir.tmp");
72
73         ev = tctx->ev;
74
75         msg_server_ctx = messaging_init(mem_ctx, cluster_id(1), ev);
76         
77         torture_assert(tctx, msg_server_ctx != NULL, "Failed to init ping messaging context");
78                 
79         messaging_register_tmp(msg_server_ctx, NULL, ping_message, &msg_ping);
80         messaging_register_tmp(msg_server_ctx, mem_ctx, exit_message, &msg_exit);
81
82         msg_client_ctx = messaging_init(mem_ctx, cluster_id(2), ev);
83
84         torture_assert(tctx, msg_client_ctx != NULL, "msg_client_ctx messaging_init() failed");
85
86         messaging_register_tmp(msg_client_ctx, &pong_count, pong_message, &msg_pong);
87
88         tv = timeval_current();
89
90         torture_comment(tctx, "Sending pings for %d seconds", timelimit);
91         while (timeval_elapsed(&tv) < timelimit) {
92                 DATA_BLOB data;
93                 NTSTATUS status1, status2;
94
95                 data.data = discard_const_p(uint8_t, "testing");
96                 data.length = strlen((const char *)data.data);
97
98                 status1 = messaging_send(msg_client_ctx, cluster_id(1), msg_ping, &data);
99                 status2 = messaging_send(msg_client_ctx, cluster_id(1), msg_ping, NULL);
100
101                 torture_assert_ntstatus_ok(tctx, status1, "msg1 failed");
102                 ping_count++;
103
104                 torture_assert_ntstatus_ok(tctx, status2, "msg2 failed");
105                 ping_count++;
106
107                 while (ping_count > pong_count + 20) {
108                         event_loop_once(ev);
109                 }
110         }
111
112         torture_comment(tctx, "waiting for %d remaining replies (done %d)", 
113                ping_count - pong_count, pong_count);
114         while (timeval_elapsed(&tv) < 30 && pong_count < ping_count) {
115                 event_loop_once(ev);
116         }
117
118         torture_comment(tctx, "sending exit");
119         messaging_send(msg_client_ctx, cluster_id(1), msg_exit, NULL);
120
121         torture_assert_int_equal(tctx, ping_count, pong_count, "ping test failed");
122
123         torture_comment(tctx, "ping rate of %.0f messages/sec", 
124                (ping_count+pong_count)/timeval_elapsed(&tv));
125
126         talloc_free(msg_client_ctx);
127         talloc_free(msg_server_ctx);
128
129         talloc_free(ev);
130         return true;
131 }
132
133 struct torture_suite *torture_local_messaging(TALLOC_CTX *mem_ctx)
134 {
135         struct torture_suite *s = torture_suite_create(mem_ctx, "MESSAGING");
136         torture_suite_add_simple_test(s, "ping_speed", test_ping_speed);
137         return s;
138 }