nng 0.1.0.alpha.0 → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: 00d81bda694b3cd8462da25c8164aa36f2f3deef9c193137676685dfcca23b8f
4
- data.tar.gz: cc226d519edf60e5d6c11f07cd712a256f5a2bb38ff173b0d2d35afd308189da
3
+ metadata.gz: '059fd5f5fe9ba741fbbbfc57ead871921b2ead9eb5fb5f9ddce30b99cbcb8e8f'
4
+ data.tar.gz: 6cfb7d0644296c8d2c99f50c7626717139d40a24a59e70c87bb81a29a9db6845
5
5
  SHA512:
6
- metadata.gz: 46a65accea3794de74022cb7d053a80f508089dd10e920e82ba3ff18a02013e21c66010c85bdcc536a07183cf11464a84a0d47e728c9c6d0720f2ad280344e37
7
- data.tar.gz: 85a52e9c5814801b73a2ec7ea8bcba92a1f5d053f3c04dcc56c45c9d7bd8279532fad11b080109d5a08895e51bc7c32e685d70dd0bf40ff86ab717bc31ae2070
6
+ metadata.gz: be9d6c590d943a1396cbe3e3c3cb7b6086d52633fe4cf23e03c7c8664d051c6d8183bea23cfb7daf4121df2cbb86589600f4756b6f3c859bd93c946820a33d85
7
+ data.tar.gz: 4417ea199f3eb0bd1130cd92c375986b5e27ab72c2a68c1cfb7204740fdb3274882e3910bebf99c2b983f4bd803b3e3476e401ea8c57faa12415a3a093f3c7c9
data/ext/rbnng/bus0.c ADDED
@@ -0,0 +1,43 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/bus0/bus.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_bus0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_bus0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ if ((rv = nng_socket_set_ms(p_rbnngSocket->socket, NNG_OPT_RECVTIMEO, 100)) != 0) {
23
+ raise_error(rv);
24
+ return Qnil;
25
+ }
26
+
27
+ return self;
28
+ }
29
+
30
+ void
31
+ rbnng_bus0_Init(VALUE nng_module)
32
+ {
33
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
34
+ VALUE rbnng_SocketBus0Class =
35
+ rb_define_class_under(rbnng_SocketModule, "Bus0", rb_cObject);
36
+ rb_define_alloc_func(rbnng_SocketBus0Class, socket_alloc);
37
+ rb_define_method(
38
+ rbnng_SocketBus0Class, "initialize", socket_bus0_initialize, 0);
39
+ rb_define_method(rbnng_SocketBus0Class, "get_msg", socket_get_msg, 0);
40
+ rb_define_method(rbnng_SocketBus0Class, "send_msg", socket_send_msg, 1);
41
+ rb_define_method(rbnng_SocketBus0Class, "listen", socket_listen, 1);
42
+ rb_define_method(rbnng_SocketBus0Class, "dial", socket_dial, 1);
43
+ }
@@ -0,0 +1,217 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include <nng/nng.h>
6
+ #include <ruby.h>
7
+
8
+ VALUE rbnng_eBase = Qnil;
9
+
10
+ VALUE rbnng_eInterrupted = Qnil;
11
+ VALUE rbnng_eOutOfMemory = Qnil;
12
+ VALUE rbnng_eInvalidArgument = Qnil;
13
+ VALUE rbnng_eResourceBusy = Qnil;
14
+ VALUE rbnng_eTimedOut = Qnil;
15
+ VALUE rbnng_eConnectionRefused = Qnil;
16
+ VALUE rbnng_eObjectClosed = Qnil;
17
+ VALUE rbnng_eTryAgain = Qnil;
18
+ VALUE rbnng_eNotSupported = Qnil;
19
+ VALUE rbnng_eAddressInUse = Qnil;
20
+ VALUE rbnng_eIncorrectState = Qnil;
21
+ VALUE rbnng_eEntryNotFound = Qnil;
22
+ VALUE rbnng_eProtocolError = Qnil;
23
+ VALUE rbnng_eDestinationUnreachable = Qnil;
24
+ VALUE rbnng_eAddressInvalid = Qnil;
25
+ VALUE rbnng_ePermissionDenied = Qnil;
26
+ VALUE rbnng_eMessageTooLarge = Qnil;
27
+ VALUE rbnng_eConnectionReset = Qnil;
28
+ VALUE rbnng_eConnectionAborted = Qnil;
29
+ VALUE rbnng_eOperationCanceled = Qnil;
30
+ VALUE rbnng_eOutOfFiles = Qnil;
31
+ VALUE rbnng_eOutOfSpace = Qnil;
32
+ VALUE rbnng_eResourceAlreadyExists = Qnil;
33
+ VALUE rbnng_eReadOnlyResource = Qnil;
34
+ VALUE rbnng_eWriteOnlyResource = Qnil;
35
+ VALUE rbnng_eCryptographicError = Qnil;
36
+ VALUE rbnng_ePeerCouldNotBeAuthenticated = Qnil;
37
+ VALUE rbnng_eOptionRequiresArgument = Qnil;
38
+ VALUE rbnng_eAmbiguousOption = Qnil;
39
+ VALUE rbnng_eIncorrectType = Qnil;
40
+ VALUE rbnng_eConnectionShutdown = Qnil;
41
+ VALUE rbnng_eInternalErrorDetected = Qnil;
42
+
43
+ void
44
+ rbnng_exceptions_Init(VALUE nng_module)
45
+ {
46
+ VALUE errorModule = rb_define_module_under(nng_module, "Error");
47
+ rbnng_eBase = rb_define_class_under(errorModule, "Error", rb_eRuntimeError);
48
+
49
+ rbnng_eInterrupted =
50
+ rb_define_class_under(errorModule, "Interrupted", rbnng_eBase);
51
+ rbnng_eOutOfMemory =
52
+ rb_define_class_under(errorModule, "OutOfMemory", rbnng_eBase);
53
+ rbnng_eInvalidArgument =
54
+ rb_define_class_under(errorModule, "InvalidArgument", rbnng_eBase);
55
+ rbnng_eResourceBusy =
56
+ rb_define_class_under(errorModule, "ResourceBusy", rbnng_eBase);
57
+ rbnng_eTimedOut = rb_define_class_under(errorModule, "TimedOut", rbnng_eBase);
58
+ rbnng_eConnectionRefused =
59
+ rb_define_class_under(errorModule, "ConnectionRefused", rbnng_eBase);
60
+ rbnng_eObjectClosed =
61
+ rb_define_class_under(errorModule, "ObjectClosed", rbnng_eBase);
62
+ rbnng_eTryAgain = rb_define_class_under(errorModule, "TryAgain", rbnng_eBase);
63
+ rbnng_eNotSupported =
64
+ rb_define_class_under(errorModule, "NotSupported", rbnng_eBase);
65
+ rbnng_eAddressInUse =
66
+ rb_define_class_under(errorModule, "AddressInUse", rbnng_eBase);
67
+ rbnng_eIncorrectState =
68
+ rb_define_class_under(errorModule, "IncorrectState", rbnng_eBase);
69
+ rbnng_eEntryNotFound =
70
+ rb_define_class_under(errorModule, "EntryNotFound", rbnng_eBase);
71
+ rbnng_eProtocolError =
72
+ rb_define_class_under(errorModule, "ProtocolError", rbnng_eBase);
73
+ rbnng_eDestinationUnreachable =
74
+ rb_define_class_under(errorModule, "DestinationUnreachable", rbnng_eBase);
75
+ rbnng_eAddressInvalid =
76
+ rb_define_class_under(errorModule, "AddressInvalid", rbnng_eBase);
77
+ rbnng_ePermissionDenied =
78
+ rb_define_class_under(errorModule, "PermissionDenied", rbnng_eBase);
79
+ rbnng_eMessageTooLarge =
80
+ rb_define_class_under(errorModule, "MessageTooLarge", rbnng_eBase);
81
+ rbnng_eConnectionReset =
82
+ rb_define_class_under(errorModule, "ConnectionReset", rbnng_eBase);
83
+ rbnng_eConnectionAborted =
84
+ rb_define_class_under(errorModule, "ConnectionAborted", rbnng_eBase);
85
+ rbnng_eOperationCanceled =
86
+ rb_define_class_under(errorModule, "OperationCanceled", rbnng_eBase);
87
+ rbnng_eOutOfFiles =
88
+ rb_define_class_under(errorModule, "OutOfFiles", rbnng_eBase);
89
+ rbnng_eOutOfSpace =
90
+ rb_define_class_under(errorModule, "OutOfSpace", rbnng_eBase);
91
+ rbnng_eResourceAlreadyExists =
92
+ rb_define_class_under(errorModule, "ResourceAlreadyExists", rbnng_eBase);
93
+ rbnng_eReadOnlyResource =
94
+ rb_define_class_under(errorModule, "ReadOnlyResource", rbnng_eBase);
95
+ rbnng_eWriteOnlyResource =
96
+ rb_define_class_under(errorModule, "WriteOnlyResource", rbnng_eBase);
97
+ rbnng_eCryptographicError =
98
+ rb_define_class_under(errorModule, "CryptographicError", rbnng_eBase);
99
+ rbnng_ePeerCouldNotBeAuthenticated = rb_define_class_under(
100
+ errorModule, "PeerCouldNotBeAuthenticated", rbnng_eBase);
101
+ rbnng_eOptionRequiresArgument =
102
+ rb_define_class_under(errorModule, "OptionRequiresArgument", rbnng_eBase);
103
+ rbnng_eAmbiguousOption =
104
+ rb_define_class_under(errorModule, "AmbiguousOption", rbnng_eBase);
105
+ rbnng_eIncorrectType =
106
+ rb_define_class_under(errorModule, "IncorrectType", rbnng_eBase);
107
+ rbnng_eConnectionShutdown =
108
+ rb_define_class_under(errorModule, "ConnectionShutdown", rbnng_eBase);
109
+ rbnng_eInternalErrorDetected =
110
+ rb_define_class_under(errorModule, "InternalErrorDetected", rbnng_eBase);
111
+ }
112
+
113
+ void
114
+ raise_error(int nng_errno)
115
+ {
116
+ switch (nng_errno) {
117
+ case NNG_EINTR:
118
+ rb_raise(rbnng_eInterrupted, "");
119
+ break;
120
+ case NNG_ENOMEM:
121
+ rb_raise(rbnng_eOutOfMemory, "");
122
+ break;
123
+ case NNG_EINVAL:
124
+ rb_raise(rbnng_eInvalidArgument, "");
125
+ break;
126
+ case NNG_EBUSY:
127
+ rb_raise(rbnng_eResourceBusy, "");
128
+ break;
129
+ case NNG_ETIMEDOUT:
130
+ rb_raise(rbnng_eTimedOut, "");
131
+ break;
132
+ case NNG_ECONNREFUSED:
133
+ rb_raise(rbnng_eConnectionRefused, "");
134
+ break;
135
+ case NNG_ECLOSED:
136
+ rb_raise(rbnng_eObjectClosed, "");
137
+ break;
138
+ case NNG_EAGAIN:
139
+ rb_raise(rbnng_eTryAgain, "");
140
+ break;
141
+ case NNG_ENOTSUP:
142
+ rb_raise(rbnng_eNotSupported, "");
143
+ break;
144
+ case NNG_EADDRINUSE:
145
+ rb_raise(rbnng_eAddressInUse, "");
146
+ break;
147
+ case NNG_ESTATE:
148
+ rb_raise(rbnng_eIncorrectState, "");
149
+ break;
150
+ case NNG_ENOENT:
151
+ rb_raise(rbnng_eEntryNotFound, "");
152
+ break;
153
+ case NNG_EPROTO:
154
+ rb_raise(rbnng_eProtocolError, "");
155
+ break;
156
+ case NNG_EUNREACHABLE:
157
+ rb_raise(rbnng_eDestinationUnreachable, "");
158
+ break;
159
+ case NNG_EADDRINVAL:
160
+ rb_raise(rbnng_eAddressInvalid, "");
161
+ break;
162
+ case NNG_EPERM:
163
+ rb_raise(rbnng_ePermissionDenied, "");
164
+ break;
165
+ case NNG_EMSGSIZE:
166
+ rb_raise(rbnng_eMessageTooLarge, "");
167
+ break;
168
+ case NNG_ECONNRESET:
169
+ rb_raise(rbnng_eConnectionReset, "");
170
+ break;
171
+ case NNG_ECONNABORTED:
172
+ rb_raise(rbnng_eConnectionAborted, "");
173
+ break;
174
+ case NNG_ECANCELED:
175
+ rb_raise(rbnng_eOperationCanceled, "");
176
+ break;
177
+ case NNG_ENOFILES:
178
+ rb_raise(rbnng_eOutOfFiles, "");
179
+ break;
180
+ case NNG_ENOSPC:
181
+ rb_raise(rbnng_eOutOfSpace, "");
182
+ break;
183
+ case NNG_EEXIST:
184
+ rb_raise(rbnng_eResourceAlreadyExists, "");
185
+ break;
186
+ case NNG_EREADONLY:
187
+ rb_raise(rbnng_eReadOnlyResource, "");
188
+ break;
189
+ case NNG_EWRITEONLY:
190
+ rb_raise(rbnng_eWriteOnlyResource, "");
191
+ break;
192
+ case NNG_ECRYPTO:
193
+ rb_raise(rbnng_eCryptographicError, "");
194
+ break;
195
+ case NNG_EPEERAUTH:
196
+ rb_raise(rbnng_ePeerCouldNotBeAuthenticated, "");
197
+ break;
198
+ case NNG_ENOARG:
199
+ rb_raise(rbnng_eOptionRequiresArgument, "");
200
+ break;
201
+ case NNG_EAMBIGUOUS:
202
+ rb_raise(rbnng_eAmbiguousOption, "");
203
+ break;
204
+ case NNG_EBADTYPE:
205
+ rb_raise(rbnng_eIncorrectType, "");
206
+ break;
207
+ case NNG_ECONNSHUT:
208
+ rb_raise(rbnng_eConnectionShutdown, "");
209
+ break;
210
+ case NNG_EINTERNAL:
211
+ rb_raise(rbnng_eInternalErrorDetected, "");
212
+ break;
213
+ default:
214
+ rb_raise(rbnng_eBase, "errno %d, %s", nng_errno, nng_strerror(nng_errno));
215
+ break;
216
+ }
217
+ }
@@ -0,0 +1,12 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+
6
+ #ifndef RBNNG_EXCEPTIONS_H
7
+ #define RBNNG_EXCEPTIONS_H
8
+
9
+ extern void
10
+ raise_error(int);
11
+
12
+ #endif
data/ext/rbnng/msg.c CHANGED
@@ -2,7 +2,6 @@
2
2
  * Copyright (c) 2021 Adib Saad
3
3
  *
4
4
  */
5
-
6
5
  #include "msg.h"
7
6
  #include <nng/protocol/reqrep0/rep.h>
8
7
  #include <ruby.h>
@@ -11,11 +10,10 @@
11
10
  VALUE rbnng_MsgClass = Qnil;
12
11
 
13
12
  void
14
- msg_free(void* ptr)
13
+ msg_free(RbnngMsg* p_rbnngMsg)
15
14
  {
16
- RbnngMsg* p_rbnngMsg = ptr;
17
- if (p_rbnngMsg->msg) {
18
- nng_msg_free(p_rbnngMsg->msg);
15
+ if (p_rbnngMsg->p_msg) {
16
+ nng_msg_free(p_rbnngMsg->p_msg);
19
17
  }
20
18
  xfree(p_rbnngMsg);
21
19
  }
@@ -32,9 +30,9 @@ msg_body(VALUE self)
32
30
  {
33
31
  RbnngMsg* p_rbnngMsg;
34
32
  Data_Get_Struct(self, RbnngMsg, p_rbnngMsg);
35
- if (p_rbnngMsg->msg) {
36
- return rb_str_new(nng_msg_body(p_rbnngMsg->msg),
37
- nng_msg_len(p_rbnngMsg->msg));
33
+ if (p_rbnngMsg->p_msg) {
34
+ return rb_str_new(nng_msg_body(p_rbnngMsg->p_msg),
35
+ nng_msg_len(p_rbnngMsg->p_msg));
38
36
  } else {
39
37
  return rb_str_new_cstr("");
40
38
  }
@@ -45,9 +43,9 @@ msg_header(VALUE self)
45
43
  {
46
44
  RbnngMsg* p_rbnngMsg;
47
45
  Data_Get_Struct(self, RbnngMsg, p_rbnngMsg);
48
- if (p_rbnngMsg->msg) {
49
- return rb_str_new(nng_msg_header(p_rbnngMsg->msg),
50
- nng_msg_header_len(p_rbnngMsg->msg));
46
+ if (p_rbnngMsg->p_msg) {
47
+ return rb_str_new(nng_msg_header(p_rbnngMsg->p_msg),
48
+ nng_msg_header_len(p_rbnngMsg->p_msg));
51
49
  } else {
52
50
  return rb_str_new_cstr("");
53
51
  }
data/ext/rbnng/msg.h CHANGED
@@ -13,7 +13,7 @@ extern VALUE rbnng_MsgClass;
13
13
 
14
14
  typedef struct
15
15
  {
16
- nng_msg* msg;
16
+ nng_msg* p_msg;
17
17
  } RbnngMsg;
18
18
 
19
19
  extern void
data/ext/rbnng/pair.c ADDED
@@ -0,0 +1,65 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/pair0/pair.h>
9
+ #include <nng/protocol/pair1/pair.h>
10
+ #include <ruby.h>
11
+ #include <ruby/thread.h>
12
+
13
+ static VALUE
14
+ socket_pair0_initialize(VALUE self)
15
+ {
16
+ RbnngSocket* p_rbnngSocket;
17
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
18
+ int rv;
19
+ if ((rv = nng_pair0_open(&p_rbnngSocket->socket)) != 0) {
20
+ raise_error(rv);
21
+ return Qnil;
22
+ }
23
+
24
+ return self;
25
+ }
26
+
27
+ static VALUE
28
+ socket_pair1_initialize(VALUE self)
29
+ {
30
+ RbnngSocket* p_rbnngSocket;
31
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
32
+ int rv;
33
+ if ((rv = nng_pair1_open(&p_rbnngSocket->socket)) != 0) {
34
+ raise_error(rv);
35
+ return Qnil;
36
+ }
37
+
38
+ return self;
39
+ }
40
+
41
+ void
42
+ rbnng_pair_Init(VALUE nng_module)
43
+ {
44
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
45
+
46
+ VALUE rbnng_SocketPair1Class =
47
+ rb_define_class_under(rbnng_SocketModule, "Pair1", rb_cObject);
48
+ rb_define_alloc_func(rbnng_SocketPair1Class, socket_alloc);
49
+ rb_define_method(
50
+ rbnng_SocketPair1Class, "initialize", socket_pair1_initialize, 0);
51
+ rb_define_method(rbnng_SocketPair1Class, "get_msg", socket_get_msg, 0);
52
+ rb_define_method(rbnng_SocketPair1Class, "send_msg", socket_send_msg, 1);
53
+ rb_define_method(rbnng_SocketPair1Class, "listen", socket_listen, 1);
54
+ rb_define_method(rbnng_SocketPair1Class, "dial", socket_dial, 1);
55
+
56
+ VALUE rbnng_SocketPair0Class =
57
+ rb_define_class_under(rbnng_SocketModule, "Pair0", rb_cObject);
58
+ rb_define_alloc_func(rbnng_SocketPair0Class, socket_alloc);
59
+ rb_define_method(
60
+ rbnng_SocketPair0Class, "initialize", socket_pair0_initialize, 0);
61
+ rb_define_method(rbnng_SocketPair0Class, "get_msg", socket_get_msg, 0);
62
+ rb_define_method(rbnng_SocketPair0Class, "send_msg", socket_send_msg, 1);
63
+ rb_define_method(rbnng_SocketPair0Class, "listen", socket_listen, 1);
64
+ rb_define_method(rbnng_SocketPair0Class, "dial", socket_dial, 1);
65
+ }
data/ext/rbnng/pub0.c ADDED
@@ -0,0 +1,36 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/pubsub0/pub.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_pub0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_pub0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ return self;
23
+ }
24
+
25
+ void
26
+ rbnng_pub0_Init(VALUE nng_module)
27
+ {
28
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
29
+ VALUE rbnng_SocketPub0Class =
30
+ rb_define_class_under(rbnng_SocketModule, "Pub0", rb_cObject);
31
+ rb_define_alloc_func(rbnng_SocketPub0Class, socket_alloc);
32
+ rb_define_method(
33
+ rbnng_SocketPub0Class, "initialize", socket_pub0_initialize, 0);
34
+ rb_define_method(rbnng_SocketPub0Class, "send_msg", socket_send_msg, 1);
35
+ rb_define_method(rbnng_SocketPub0Class, "listen", socket_listen, 1);
36
+ }
data/ext/rbnng/pull0.c ADDED
@@ -0,0 +1,36 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/pipeline0/pull.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_pull0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_pull0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ return self;
23
+ }
24
+
25
+ void
26
+ rbnng_pull0_Init(VALUE nng_module)
27
+ {
28
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
29
+ VALUE rbnng_SocketPull0Class =
30
+ rb_define_class_under(rbnng_SocketModule, "Pull0", rb_cObject);
31
+ rb_define_alloc_func(rbnng_SocketPull0Class, socket_alloc);
32
+ rb_define_method(
33
+ rbnng_SocketPull0Class, "initialize", socket_pull0_initialize, 0);
34
+ rb_define_method(rbnng_SocketPull0Class, "get_msg", socket_get_msg, 0);
35
+ rb_define_method(rbnng_SocketPull0Class, "listen", socket_listen, 1);
36
+ }
data/ext/rbnng/push0.c ADDED
@@ -0,0 +1,36 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/pipeline0/push.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_push0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_push0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ return self;
23
+ }
24
+
25
+ void
26
+ rbnng_push0_Init(VALUE nng_module)
27
+ {
28
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
29
+ VALUE rbnng_SocketPush0Class =
30
+ rb_define_class_under(rbnng_SocketModule, "Push0", rb_cObject);
31
+ rb_define_alloc_func(rbnng_SocketPush0Class, socket_alloc);
32
+ rb_define_method(
33
+ rbnng_SocketPush0Class, "initialize", socket_push0_initialize, 0);
34
+ rb_define_method(rbnng_SocketPush0Class, "send_msg", socket_send_msg, 1);
35
+ rb_define_method(rbnng_SocketPush0Class, "dial", socket_dial, 1);
36
+ }
data/ext/rbnng/rbnng.c CHANGED
@@ -2,15 +2,12 @@
2
2
  * Copyright (c) 2021 Adib Saad
3
3
  *
4
4
  */
5
-
6
5
  #include <nng/nng.h>
7
6
  #include <ruby.h>
8
7
 
8
+ #include "msg.h"
9
9
  #include "rbnng.h"
10
10
  #include "socket.h"
11
- #include "msg.h"
12
-
13
- VALUE rbnng_exceptionClass = Qnil;
14
11
 
15
12
  static VALUE
16
13
  library_version(VALUE self_)
@@ -26,9 +23,16 @@ Init_rbnng()
26
23
  {
27
24
  VALUE nng_module = rb_define_module("NNG");
28
25
  rb_define_singleton_method(nng_module, "nng_version", library_version, 0);
29
- rbnng_exceptionClass = rb_define_class_under(nng_module, "Error", rb_eRuntimeError);
30
-
26
+ rbnng_exceptions_Init(nng_module);
27
+ rbnng_msg_Init(nng_module);
31
28
  rbnng_rep0_Init(nng_module);
32
29
  rbnng_req0_Init(nng_module);
33
- rbnng_msg_Init(nng_module);
30
+ rbnng_pub0_Init(nng_module);
31
+ rbnng_sub0_Init(nng_module);
32
+ rbnng_pair_Init(nng_module);
33
+ rbnng_bus0_Init(nng_module);
34
+ rbnng_surveyor0_Init(nng_module);
35
+ rbnng_respondent0_Init(nng_module);
36
+ rbnng_push0_Init(nng_module);
37
+ rbnng_pull0_Init(nng_module);
34
38
  }
data/ext/rbnng/rbnng.h CHANGED
@@ -6,8 +6,28 @@
6
6
  #ifndef RBNNG_H
7
7
  #define RBNNG_H
8
8
 
9
+ #include "exceptions.h"
9
10
  #include <ruby.h>
10
11
 
11
- extern VALUE rbnng_exceptionClass;
12
+ extern void
13
+ rbnng_rep0_Init(VALUE nng_module);
14
+ extern void
15
+ rbnng_req0_Init(VALUE nng_module);
16
+ extern void
17
+ rbnng_pair_Init(VALUE nng_module);
18
+ extern void
19
+ rbnng_pub0_Init(VALUE nng_module);
20
+ extern void
21
+ rbnng_sub0_Init(VALUE nng_module);
22
+ extern void
23
+ rbnng_bus0_Init(VALUE nng_module);
24
+ extern void
25
+ rbnng_surveyor0_Init(VALUE nng_module);
26
+ extern void
27
+ rbnng_respondent0_Init(VALUE nng_module);
28
+ extern void
29
+ rbnng_push0_Init(VALUE nng_module);
30
+ extern void
31
+ rbnng_pull0_Init(VALUE nng_module);
12
32
 
13
33
  #endif
data/ext/rbnng/rep0.c CHANGED
@@ -2,7 +2,6 @@
2
2
  * Copyright (c) 2021 Adib Saad
3
3
  *
4
4
  */
5
-
6
5
  #include "msg.h"
7
6
  #include "rbnng.h"
8
7
  #include "socket.h"
@@ -19,51 +18,49 @@ socket_rep0_listen(VALUE self, VALUE url)
19
18
  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
20
19
  if ((rv = nng_listen(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
21
20
  0) {
22
- rb_raise(rbnng_exceptionClass, "nng_listen %d", rv);
21
+ raise_error(rv);
23
22
  }
24
- return self;
25
23
  }
26
24
 
27
25
  void*
28
- rep0_get_msg_blocking(void* data)
26
+ rep0_get_msg_blocking(RbnngSocket* p_rbnngSocket)
29
27
  {
30
- VALUE self = (VALUE)data;
31
- RbnngSocket* p_rbnngSocket;
32
- Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
33
-
34
28
  nng_aio* p_aio;
35
29
  int rv;
36
30
  if ((rv = nng_aio_alloc(&p_aio, 0, 0)) != 0) {
37
- rb_raise(rbnng_exceptionClass, "nng_aio_alloc %d", rv);
31
+ return rv;
38
32
  }
39
33
 
40
34
  nng_ctx_recv(p_rbnngSocket->ctx, p_aio);
41
35
  nng_aio_wait(p_aio);
42
36
 
43
37
  if ((rv = nng_aio_result(p_aio)) != 0) {
44
- rb_raise(rbnng_exceptionClass, "nng_aio_result %d", rv);
38
+ return rv;
45
39
  }
46
40
 
47
41
  nng_msg* p_msg = nng_aio_get_msg(p_aio);
42
+ p_rbnngSocket->p_getMsgResult = p_msg;
48
43
  nng_aio_free(p_aio);
49
- return p_msg;
44
+ return 0;
50
45
  }
51
46
 
52
47
  static VALUE
53
48
  socket_rep0_get_msg(VALUE self)
54
49
  {
55
- nng_msg* nng_msg_ptr =
56
- rb_thread_call_without_gvl(rep0_get_msg_blocking, self, 0, 0);
50
+ RbnngSocket* p_rbnngSocket;
51
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
52
+ int rv =
53
+ rb_thread_call_without_gvl(rep0_get_msg_blocking, p_rbnngSocket, 0, 0);
57
54
 
58
- if (nng_msg_ptr) {
59
- RbnngMsg* rbnng_new_msg_ptr;
55
+ if (rv == 0) {
56
+ RbnngMsg* p_newMsg;
60
57
  VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
61
- Data_Get_Struct(newMsg, RbnngMsg, rbnng_new_msg_ptr);
62
- rbnng_new_msg_ptr->msg = nng_msg_ptr;
58
+ Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
59
+ p_newMsg->p_msg = p_rbnngSocket->p_getMsgResult;
63
60
  return newMsg;
64
61
  } else {
65
- VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
66
- return newMsg;
62
+ raise_error(rv);
63
+ return Qnil;
67
64
  }
68
65
  }
69
66
 
@@ -77,28 +74,32 @@ rep0_send_msg_blocking(void* data)
77
74
  nng_aio* p_aio;
78
75
  int rv;
79
76
  if ((rv = nng_aio_alloc(&p_aio, 0, 0)) != 0) {
80
- rb_raise(rbnng_exceptionClass, "nng_aio_alloc %d", rv);
77
+ return rv;
81
78
  }
82
79
 
83
80
  nng_msg* p_msg;
84
81
  if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
85
- rb_raise(rbnng_exceptionClass, "nng_msg_alloc %d", rv);
82
+ return rv;
86
83
  }
87
84
 
88
85
  nng_msg_clear(p_msg);
89
- nng_msg_append(p_msg,
90
- StringValuePtr(p_sendMsgReq->nextMsg),
91
- RSTRING_LEN(p_sendMsgReq->nextMsg));
86
+ rv = nng_msg_append(p_msg,
87
+ StringValuePtr(p_sendMsgReq->nextMsg),
88
+ RSTRING_LEN(p_sendMsgReq->nextMsg));
89
+ if (rv != 0) {
90
+ return rv;
91
+ }
92
92
 
93
93
  nng_aio_set_msg(p_aio, p_msg);
94
94
  nng_ctx_send(p_rbnngSocket->ctx, p_aio);
95
95
  nng_aio_wait(p_aio);
96
96
 
97
97
  if ((rv = nng_aio_result(p_aio)) != 0) {
98
- rb_raise(rbnng_exceptionClass, "nng_aio_result %d", rv);
98
+ return rv;
99
99
  }
100
100
 
101
101
  nng_aio_free(p_aio);
102
+ return 0;
102
103
  }
103
104
 
104
105
  static VALUE
@@ -110,21 +111,25 @@ socket_rep0_send_msg(VALUE self, VALUE rb_strMsg)
110
111
  .socketObj = self,
111
112
  .nextMsg = rb_strMsg,
112
113
  };
113
- rb_thread_call_without_gvl(rep0_send_msg_blocking, &sendMsgReq, 0, 0);
114
+ int rv =
115
+ rb_thread_call_without_gvl(rep0_send_msg_blocking, &sendMsgReq, 0, 0);
116
+ if (rv != 0) {
117
+ raise_error(rv);
118
+ }
114
119
  }
115
120
 
116
121
  static VALUE
117
122
  socket_rep0_initialize(VALUE self)
118
123
  {
119
- int rv;
120
124
  RbnngSocket* p_rbnngSocket;
121
125
  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
126
+ int rv;
122
127
  if ((rv = nng_rep0_open(&p_rbnngSocket->socket)) != 0) {
123
- rb_raise(rbnng_exceptionClass, "nng_rep0_open %d", rv);
128
+ raise_error(rv);
124
129
  }
125
130
 
126
131
  if ((rv = nng_ctx_open(&p_rbnngSocket->ctx, p_rbnngSocket->socket)) != 0) {
127
- rb_raise(rbnng_exceptionClass, "nng_ctx_open %d", rv);
132
+ raise_error(rv);
128
133
  }
129
134
 
130
135
  return self;
data/ext/rbnng/req0.c CHANGED
@@ -2,7 +2,6 @@
2
2
  * Copyright (c) 2021 Adib Saad
3
3
  *
4
4
  */
5
-
6
5
  #include "msg.h"
7
6
  #include "rbnng.h"
8
7
  #include "socket.h"
@@ -11,100 +10,16 @@
11
10
  #include <ruby/thread.h>
12
11
 
13
12
  static VALUE
14
- socket_req0_dial(VALUE self, VALUE url)
15
- {
16
- Check_Type(url, T_STRING);
17
- int rv;
18
- RbnngSocket* p_rbnngSocket;
19
- Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
20
- if ((rv = nng_dial(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
21
- 0) {
22
- rb_raise(rbnng_exceptionClass, "nng_dial %d", rv);
23
- }
24
- return self;
25
- }
26
-
27
- void*
28
- req0_get_msg_blocking(void* data)
13
+ socket_req0_initialize(VALUE self)
29
14
  {
30
- VALUE self = (VALUE)data;
31
15
  RbnngSocket* p_rbnngSocket;
32
16
  Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
33
-
34
17
  int rv;
35
- nng_msg* p_msg;
36
- if ((rv = nng_recvmsg(p_rbnngSocket->socket, &p_msg, 0)) != 0) {
37
- rb_raise(rbnng_exceptionClass, "nng_recvmsg %d", rv);
18
+ if ((rv = nng_req0_open(&p_rbnngSocket->socket)) != 0) {
19
+ raise_error(rv);
20
+ return Qnil;
38
21
  }
39
22
 
40
- return p_msg;
41
- }
42
-
43
- static VALUE
44
- socket_req0_get_msg(VALUE self)
45
- {
46
- nng_msg* p_msg =
47
- rb_thread_call_without_gvl(req0_get_msg_blocking, self, 0, 0);
48
-
49
- if (p_msg) {
50
- RbnngMsg* p_newMsg;
51
- VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
52
- Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
53
- p_newMsg->msg = p_msg;
54
- return newMsg;
55
- } else {
56
- VALUE newMsg = rb_funcall(rbnng_MsgClass, rb_intern("new"), 0);
57
- return newMsg;
58
- }
59
- }
60
-
61
- void*
62
- req0_send_msg_blocking(void* data)
63
- {
64
- RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
65
- RbnngSocket* p_rbnngSocket;
66
- Data_Get_Struct(p_sendMsgReq->socketObj, RbnngSocket, p_rbnngSocket);
67
- int rv;
68
- nng_msg* msg;
69
- if ((rv = nng_msg_alloc(&msg, 0)) != 0) {
70
- rb_raise(rbnng_exceptionClass, "nng_msg_alloc %d", rv);
71
- }
72
-
73
- nng_msg_append(msg,
74
- StringValuePtr(p_sendMsgReq->nextMsg),
75
- RSTRING_LEN(p_sendMsgReq->nextMsg));
76
-
77
- if ((rv = nng_sendmsg(p_rbnngSocket->socket, msg, 0)) != 0) {
78
- rb_raise(rbnng_exceptionClass, "nng_sendmsg %d", rv);
79
- }
80
-
81
- nng_msg_free(msg);
82
-
83
- return 0;
84
- }
85
-
86
- static VALUE
87
- socket_req0_send_msg(VALUE self, VALUE rb_strMsg)
88
- {
89
- Check_Type(rb_strMsg, T_STRING);
90
- RbnngSendMsgReq sendMsgReq = {
91
- .socketObj = self,
92
- .nextMsg = rb_strMsg,
93
- };
94
- rb_thread_call_without_gvl(req0_send_msg_blocking, &sendMsgReq, 0, 0);
95
-
96
- return Qnil;
97
- }
98
-
99
- static VALUE
100
- socket_req0_initialize(VALUE self)
101
- {
102
- RbnngSocket* p_rbnngSocket;
103
- Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
104
- int rv = nng_req0_open(&p_rbnngSocket->socket);
105
- if (rv != 0) {
106
- rb_raise(rbnng_exceptionClass, "nng_req0_open %d", rv);
107
- }
108
23
  return self;
109
24
  }
110
25
 
@@ -112,12 +27,12 @@ void
112
27
  rbnng_req0_Init(VALUE nng_module)
113
28
  {
114
29
  VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
115
- VALUE rbnng_SocketRep0Class =
30
+ VALUE rbnng_SocketReq0Class =
116
31
  rb_define_class_under(rbnng_SocketModule, "Req0", rb_cObject);
117
- rb_define_alloc_func(rbnng_SocketRep0Class, socket_alloc);
32
+ rb_define_alloc_func(rbnng_SocketReq0Class, socket_alloc);
118
33
  rb_define_method(
119
- rbnng_SocketRep0Class, "initialize", socket_req0_initialize, 0);
120
- rb_define_method(rbnng_SocketRep0Class, "get_msg", socket_req0_get_msg, 0);
121
- rb_define_method(rbnng_SocketRep0Class, "send_msg", socket_req0_send_msg, 1);
122
- rb_define_method(rbnng_SocketRep0Class, "dial", socket_req0_dial, 1);
34
+ rbnng_SocketReq0Class, "initialize", socket_req0_initialize, 0);
35
+ rb_define_method(rbnng_SocketReq0Class, "get_msg", socket_get_msg, 0);
36
+ rb_define_method(rbnng_SocketReq0Class, "send_msg", socket_send_msg, 1);
37
+ rb_define_method(rbnng_SocketReq0Class, "dial", socket_dial, 1);
123
38
  }
@@ -0,0 +1,40 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/survey0/respond.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_respondent0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_respondent0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ return self;
23
+ }
24
+
25
+ void
26
+ rbnng_respondent0_Init(VALUE nng_module)
27
+ {
28
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
29
+ VALUE rbnng_SocketRespondent0Class =
30
+ rb_define_class_under(rbnng_SocketModule, "Respondent0", rb_cObject);
31
+ rb_define_alloc_func(rbnng_SocketRespondent0Class, socket_alloc);
32
+ rb_define_method(rbnng_SocketRespondent0Class,
33
+ "initialize",
34
+ socket_respondent0_initialize,
35
+ 0);
36
+ rb_define_method(
37
+ rbnng_SocketRespondent0Class, "send_msg", socket_send_msg, 1);
38
+ rb_define_method(rbnng_SocketRespondent0Class, "get_msg", socket_get_msg, 0);
39
+ rb_define_method(rbnng_SocketRespondent0Class, "dial", socket_dial, 1);
40
+ }
data/ext/rbnng/socket.c CHANGED
@@ -3,6 +3,10 @@
3
3
  *
4
4
  */
5
5
  #include "socket.h"
6
+ #include "msg.h"
7
+ #include "rbnng.h"
8
+ #include <ruby.h>
9
+ #include <ruby/thread.h>
6
10
 
7
11
  static void
8
12
  socket_free(void* ptr)
@@ -18,3 +22,105 @@ socket_alloc(VALUE klass)
18
22
  RbnngSocket* p_rbnngSocket = ZALLOC(RbnngSocket);
19
23
  return rb_data_object_wrap(klass, p_rbnngSocket, 0, socket_free);
20
24
  }
25
+
26
+ void*
27
+ socket_get_msg_blocking(RbnngSocket* p_rbnngSocket)
28
+ {
29
+ nng_msg* p_msg = NULL;
30
+ int rv;
31
+ if ((rv = nng_recvmsg(p_rbnngSocket->socket, &p_msg, 0)) != 0) {
32
+ return rv;
33
+ }
34
+
35
+ p_rbnngSocket->p_getMsgResult = p_msg;
36
+ return 0;
37
+ }
38
+
39
+ VALUE
40
+ socket_get_msg(VALUE self)
41
+ {
42
+ RbnngSocket* p_rbnngSocket;
43
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
44
+
45
+ int rv =
46
+ rb_thread_call_without_gvl(socket_get_msg_blocking, p_rbnngSocket, 0, 0);
47
+
48
+ if (rv == 0) {
49
+ RbnngMsg* p_newMsg;
50
+ VALUE newMsg = rb_class_new_instance(0, 0, rbnng_MsgClass);
51
+ Data_Get_Struct(newMsg, RbnngMsg, p_newMsg);
52
+ p_newMsg->p_msg = p_rbnngSocket->p_getMsgResult;
53
+ return newMsg;
54
+ } else {
55
+ raise_error(rv);
56
+ return Qnil;
57
+ }
58
+ }
59
+
60
+ void*
61
+ socket_send_msg_blocking(void* data)
62
+ {
63
+ RbnngSendMsgReq* p_sendMsgReq = (RbnngSendMsgReq*)data;
64
+ RbnngSocket* p_rbnngSocket;
65
+ Data_Get_Struct(p_sendMsgReq->socketObj, RbnngSocket, p_rbnngSocket);
66
+ int rv;
67
+ nng_msg* p_msg;
68
+ if ((rv = nng_msg_alloc(&p_msg, 0)) != 0) {
69
+ return rv;
70
+ }
71
+
72
+ rv = nng_msg_append(p_msg,
73
+ StringValuePtr(p_sendMsgReq->nextMsg),
74
+ RSTRING_LEN(p_sendMsgReq->nextMsg));
75
+ if (rv != 0) {
76
+ return rv;
77
+ }
78
+
79
+ // nng_sendmsg takes ownership of p_msg, so no need to free it afterwards.
80
+ if ((rv = nng_sendmsg(p_rbnngSocket->socket, p_msg, 0)) != 0) {
81
+ return rv;
82
+ }
83
+
84
+ return 0;
85
+ }
86
+
87
+ VALUE
88
+ socket_send_msg(VALUE self, VALUE rb_strMsg)
89
+ {
90
+ Check_Type(rb_strMsg, T_STRING);
91
+ RbnngSendMsgReq sendMsgReq = {
92
+ .socketObj = self,
93
+ .nextMsg = rb_strMsg,
94
+ };
95
+ int rv =
96
+ rb_thread_call_without_gvl(socket_send_msg_blocking, &sendMsgReq, 0, 0);
97
+ if (rv != 0) {
98
+ raise_error(rv);
99
+ }
100
+ }
101
+
102
+ VALUE
103
+ socket_dial(VALUE self, VALUE url)
104
+ {
105
+ Check_Type(url, T_STRING);
106
+ RbnngSocket* p_rbnngSocket;
107
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
108
+ int rv;
109
+ if ((rv = nng_dial(p_rbnngSocket->socket, StringValueCStr(url), 0, 0)) != 0) {
110
+ raise_error(rv);
111
+ }
112
+ }
113
+
114
+ VALUE
115
+ socket_listen(VALUE self, VALUE url)
116
+ {
117
+ Check_Type(url, T_STRING);
118
+ RbnngSocket* p_rbnngSocket;
119
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
120
+
121
+ int rv;
122
+ if ((rv = nng_listen(p_rbnngSocket->socket, StringValueCStr(url), NULL, 0)) !=
123
+ 0) {
124
+ raise_error(rv);
125
+ }
126
+ }
data/ext/rbnng/socket.h CHANGED
@@ -7,27 +7,30 @@
7
7
  #define RBNNG_SOCKET_H
8
8
 
9
9
  #include <nng/nng.h>
10
+ #include <pthread.h>
10
11
  #include <ruby.h>
11
12
  #include <stdbool.h>
12
- #include <pthread.h>
13
13
 
14
14
  typedef struct
15
15
  {
16
16
  nng_socket socket;
17
17
  // Not all socket types will use a context
18
18
  nng_ctx ctx;
19
+
20
+ // for get_msg
21
+ nng_msg* p_getMsgResult;
19
22
  } RbnngSocket;
20
23
 
21
- typedef struct {
24
+ typedef struct
25
+ {
22
26
  VALUE socketObj; // A socket class instnace
23
27
  VALUE nextMsg; // Ruby string
24
28
  } RbnngSendMsgReq;
25
29
 
26
- extern void
27
- rbnng_rep0_Init(VALUE nng_module);
28
- extern void
29
- rbnng_req0_Init(VALUE nng_module);
30
- extern VALUE
31
- socket_alloc(VALUE);
30
+ extern VALUE socket_alloc(VALUE);
31
+ extern VALUE socket_get_msg(VALUE);
32
+ extern VALUE socket_send_msg(VALUE, VALUE);
33
+ extern VALUE socket_dial(VALUE, VALUE);
34
+ extern VALUE socket_listen(VALUE, VALUE);
32
35
 
33
36
  #endif
data/ext/rbnng/sub0.c ADDED
@@ -0,0 +1,41 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+ */
5
+ #include "msg.h"
6
+ #include "rbnng.h"
7
+ #include "socket.h"
8
+ #include <nng/protocol/pubsub0/sub.h>
9
+ #include <ruby.h>
10
+
11
+ static VALUE
12
+ socket_sub0_initialize(VALUE self)
13
+ {
14
+ RbnngSocket* p_rbnngSocket;
15
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
16
+ int rv;
17
+ if ((rv = nng_sub0_open(&p_rbnngSocket->socket)) != 0) {
18
+ raise_error(rv);
19
+ return Qnil;
20
+ }
21
+
22
+ if ((rv = nng_socket_set(p_rbnngSocket->socket, NNG_OPT_SUB_SUBSCRIBE, "", 0)) != 0) {
23
+ raise_error(rv);
24
+ return Qnil;
25
+ }
26
+
27
+ return self;
28
+ }
29
+
30
+ void
31
+ rbnng_sub0_Init(VALUE nng_module)
32
+ {
33
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
34
+ VALUE rbnng_SocketSub0Class =
35
+ rb_define_class_under(rbnng_SocketModule, "Sub0", rb_cObject);
36
+ rb_define_alloc_func(rbnng_SocketSub0Class, socket_alloc);
37
+ rb_define_method(
38
+ rbnng_SocketSub0Class, "initialize", socket_sub0_initialize, 0);
39
+ rb_define_method(rbnng_SocketSub0Class, "get_msg", socket_get_msg, 0);
40
+ rb_define_method(rbnng_SocketSub0Class, "dial", socket_dial, 1);
41
+ }
@@ -0,0 +1,40 @@
1
+ /*
2
+ * Copyright (c) 2021 Adib Saad
3
+ *
4
+
5
+ // NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_SURVEYOR_SURVEYTIME, 50));
6
+ // NUTS_PASS(nng_socket_set_ms(surv, NNG_OPT_RECVTIMEO, 100));
7
+ */
8
+ #include "msg.h"
9
+ #include "rbnng.h"
10
+ #include "socket.h"
11
+ #include <nng/protocol/survey0/survey.h>
12
+ #include <ruby.h>
13
+
14
+ static VALUE
15
+ socket_surveyor0_initialize(VALUE self)
16
+ {
17
+ RbnngSocket* p_rbnngSocket;
18
+ Data_Get_Struct(self, RbnngSocket, p_rbnngSocket);
19
+ int rv;
20
+ if ((rv = nng_surveyor0_open(&p_rbnngSocket->socket)) != 0) {
21
+ raise_error(rv);
22
+ return Qnil;
23
+ }
24
+
25
+ return self;
26
+ }
27
+
28
+ void
29
+ rbnng_surveyor0_Init(VALUE nng_module)
30
+ {
31
+ VALUE rbnng_SocketModule = rb_define_module_under(nng_module, "Socket");
32
+ VALUE rbnng_SocketSurveyor0Class =
33
+ rb_define_class_under(rbnng_SocketModule, "Surveyor0", rb_cObject);
34
+ rb_define_alloc_func(rbnng_SocketSurveyor0Class, socket_alloc);
35
+ rb_define_method(
36
+ rbnng_SocketSurveyor0Class, "initialize", socket_surveyor0_initialize, 0);
37
+ rb_define_method(rbnng_SocketSurveyor0Class, "send_msg", socket_send_msg, 1);
38
+ rb_define_method(rbnng_SocketSurveyor0Class, "get_msg", socket_get_msg, 0);
39
+ rb_define_method(rbnng_SocketSurveyor0Class, "listen", socket_listen, 1);
40
+ }
data/lib/nng/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  module NNG
2
- VERSION = '0.1.0.alpha.0'
2
+ VERSION = '0.1.0'
3
3
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: nng
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.0.alpha.0
4
+ version: 0.1.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Adib Saad
@@ -18,14 +18,24 @@ extensions:
18
18
  - ext/rbnng/extconf.rb
19
19
  extra_rdoc_files: []
20
20
  files:
21
+ - "./ext/rbnng/bus0.c"
22
+ - "./ext/rbnng/exceptions.c"
23
+ - "./ext/rbnng/exceptions.h"
21
24
  - "./ext/rbnng/msg.c"
22
25
  - "./ext/rbnng/msg.h"
26
+ - "./ext/rbnng/pair.c"
27
+ - "./ext/rbnng/pub0.c"
28
+ - "./ext/rbnng/pull0.c"
29
+ - "./ext/rbnng/push0.c"
23
30
  - "./ext/rbnng/rbnng.c"
24
31
  - "./ext/rbnng/rbnng.h"
25
32
  - "./ext/rbnng/rep0.c"
26
33
  - "./ext/rbnng/req0.c"
34
+ - "./ext/rbnng/respondent0.c"
27
35
  - "./ext/rbnng/socket.c"
28
36
  - "./ext/rbnng/socket.h"
37
+ - "./ext/rbnng/sub0.c"
38
+ - "./ext/rbnng/surveyor0.c"
29
39
  - "./lib/nng.rb"
30
40
  - "./lib/nng/version.rb"
31
41
  - ext/rbnng/extconf.rb
@@ -45,9 +55,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
45
55
  version: '0'
46
56
  required_rubygems_version: !ruby/object:Gem::Requirement
47
57
  requirements:
48
- - - ">"
58
+ - - ">="
49
59
  - !ruby/object:Gem::Version
50
- version: 1.3.1
60
+ version: '0'
51
61
  requirements: []
52
62
  rubygems_version: 3.1.6
53
63
  signing_key: