eventmachine 1.0.0.beta.2-x86-mingw32

Sign up to get free protection for your applications and to get access to all the features.
Files changed (141) hide show
  1. data/.gitignore +16 -0
  2. data/Gemfile +1 -0
  3. data/README +81 -0
  4. data/Rakefile +11 -0
  5. data/docs/COPYING +60 -0
  6. data/docs/ChangeLog +211 -0
  7. data/docs/DEFERRABLES +246 -0
  8. data/docs/EPOLL +141 -0
  9. data/docs/GNU +281 -0
  10. data/docs/INSTALL +13 -0
  11. data/docs/KEYBOARD +42 -0
  12. data/docs/LEGAL +25 -0
  13. data/docs/LIGHTWEIGHT_CONCURRENCY +130 -0
  14. data/docs/PURE_RUBY +75 -0
  15. data/docs/RELEASE_NOTES +94 -0
  16. data/docs/SMTP +4 -0
  17. data/docs/SPAWNED_PROCESSES +148 -0
  18. data/docs/TODO +8 -0
  19. data/eventmachine.gemspec +33 -0
  20. data/examples/ex_channel.rb +43 -0
  21. data/examples/ex_queue.rb +2 -0
  22. data/examples/ex_tick_loop_array.rb +15 -0
  23. data/examples/ex_tick_loop_counter.rb +32 -0
  24. data/examples/helper.rb +2 -0
  25. data/ext/binder.cpp +124 -0
  26. data/ext/binder.h +46 -0
  27. data/ext/cmain.cpp +838 -0
  28. data/ext/ed.cpp +1884 -0
  29. data/ext/ed.h +418 -0
  30. data/ext/em.cpp +2348 -0
  31. data/ext/em.h +228 -0
  32. data/ext/eventmachine.h +123 -0
  33. data/ext/extconf.rb +157 -0
  34. data/ext/fastfilereader/extconf.rb +85 -0
  35. data/ext/fastfilereader/mapper.cpp +214 -0
  36. data/ext/fastfilereader/mapper.h +59 -0
  37. data/ext/fastfilereader/rubymain.cpp +127 -0
  38. data/ext/kb.cpp +79 -0
  39. data/ext/page.cpp +107 -0
  40. data/ext/page.h +51 -0
  41. data/ext/pipe.cpp +347 -0
  42. data/ext/project.h +155 -0
  43. data/ext/rubymain.cpp +1200 -0
  44. data/ext/ssl.cpp +460 -0
  45. data/ext/ssl.h +94 -0
  46. data/java/.classpath +8 -0
  47. data/java/.project +17 -0
  48. data/java/src/com/rubyeventmachine/EmReactor.java +571 -0
  49. data/java/src/com/rubyeventmachine/EmReactorException.java +40 -0
  50. data/java/src/com/rubyeventmachine/EventableChannel.java +69 -0
  51. data/java/src/com/rubyeventmachine/EventableDatagramChannel.java +189 -0
  52. data/java/src/com/rubyeventmachine/EventableSocketChannel.java +364 -0
  53. data/lib/em/buftok.rb +138 -0
  54. data/lib/em/callback.rb +26 -0
  55. data/lib/em/channel.rb +57 -0
  56. data/lib/em/connection.rb +569 -0
  57. data/lib/em/deferrable.rb +206 -0
  58. data/lib/em/file_watch.rb +54 -0
  59. data/lib/em/future.rb +61 -0
  60. data/lib/em/iterator.rb +270 -0
  61. data/lib/em/messages.rb +66 -0
  62. data/lib/em/process_watch.rb +44 -0
  63. data/lib/em/processes.rb +119 -0
  64. data/lib/em/protocols.rb +36 -0
  65. data/lib/em/protocols/header_and_content.rb +138 -0
  66. data/lib/em/protocols/httpclient.rb +268 -0
  67. data/lib/em/protocols/httpclient2.rb +590 -0
  68. data/lib/em/protocols/line_and_text.rb +125 -0
  69. data/lib/em/protocols/line_protocol.rb +28 -0
  70. data/lib/em/protocols/linetext2.rb +161 -0
  71. data/lib/em/protocols/memcache.rb +323 -0
  72. data/lib/em/protocols/object_protocol.rb +45 -0
  73. data/lib/em/protocols/postgres3.rb +247 -0
  74. data/lib/em/protocols/saslauth.rb +175 -0
  75. data/lib/em/protocols/smtpclient.rb +357 -0
  76. data/lib/em/protocols/smtpserver.rb +640 -0
  77. data/lib/em/protocols/socks4.rb +66 -0
  78. data/lib/em/protocols/stomp.rb +200 -0
  79. data/lib/em/protocols/tcptest.rb +53 -0
  80. data/lib/em/pure_ruby.rb +1013 -0
  81. data/lib/em/queue.rb +62 -0
  82. data/lib/em/spawnable.rb +85 -0
  83. data/lib/em/streamer.rb +130 -0
  84. data/lib/em/tick_loop.rb +85 -0
  85. data/lib/em/timers.rb +57 -0
  86. data/lib/em/version.rb +3 -0
  87. data/lib/eventmachine.rb +1548 -0
  88. data/lib/jeventmachine.rb +258 -0
  89. data/lib/rubyeventmachine.rb +2 -0
  90. data/setup.rb +1585 -0
  91. data/tasks/cpp.rake_example +77 -0
  92. data/tasks/doc.rake +30 -0
  93. data/tasks/package.rake +85 -0
  94. data/tasks/test.rake +6 -0
  95. data/tests/client.crt +31 -0
  96. data/tests/client.key +51 -0
  97. data/tests/test_attach.rb +136 -0
  98. data/tests/test_basic.rb +249 -0
  99. data/tests/test_channel.rb +64 -0
  100. data/tests/test_connection_count.rb +35 -0
  101. data/tests/test_defer.rb +49 -0
  102. data/tests/test_deferrable.rb +35 -0
  103. data/tests/test_epoll.rb +160 -0
  104. data/tests/test_error_handler.rb +35 -0
  105. data/tests/test_errors.rb +82 -0
  106. data/tests/test_exc.rb +55 -0
  107. data/tests/test_file_watch.rb +49 -0
  108. data/tests/test_futures.rb +198 -0
  109. data/tests/test_get_sock_opt.rb +30 -0
  110. data/tests/test_handler_check.rb +37 -0
  111. data/tests/test_hc.rb +190 -0
  112. data/tests/test_httpclient.rb +227 -0
  113. data/tests/test_httpclient2.rb +154 -0
  114. data/tests/test_inactivity_timeout.rb +50 -0
  115. data/tests/test_kb.rb +60 -0
  116. data/tests/test_ltp.rb +190 -0
  117. data/tests/test_ltp2.rb +317 -0
  118. data/tests/test_next_tick.rb +133 -0
  119. data/tests/test_object_protocol.rb +37 -0
  120. data/tests/test_pause.rb +70 -0
  121. data/tests/test_pending_connect_timeout.rb +48 -0
  122. data/tests/test_process_watch.rb +50 -0
  123. data/tests/test_processes.rb +128 -0
  124. data/tests/test_proxy_connection.rb +144 -0
  125. data/tests/test_pure.rb +134 -0
  126. data/tests/test_queue.rb +44 -0
  127. data/tests/test_running.rb +42 -0
  128. data/tests/test_sasl.rb +72 -0
  129. data/tests/test_send_file.rb +251 -0
  130. data/tests/test_servers.rb +76 -0
  131. data/tests/test_smtpclient.rb +83 -0
  132. data/tests/test_smtpserver.rb +85 -0
  133. data/tests/test_spawn.rb +322 -0
  134. data/tests/test_ssl_args.rb +79 -0
  135. data/tests/test_ssl_methods.rb +50 -0
  136. data/tests/test_ssl_verify.rb +82 -0
  137. data/tests/test_tick_loop.rb +59 -0
  138. data/tests/test_timers.rb +160 -0
  139. data/tests/test_ud.rb +36 -0
  140. data/tests/testem.rb +31 -0
  141. metadata +240 -0
@@ -0,0 +1,206 @@
1
+ #--
2
+ #
3
+ # Author:: Francis Cianfrocca (gmail: blackhedd)
4
+ # Homepage:: http://rubyeventmachine.com
5
+ # Date:: 16 Jul 2006
6
+ #
7
+ # See EventMachine and EventMachine::Connection for documentation and
8
+ # usage examples.
9
+ #
10
+ #----------------------------------------------------------------------------
11
+ #
12
+ # Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
13
+ # Gmail: blackhedd
14
+ #
15
+ # This program is free software; you can redistribute it and/or modify
16
+ # it under the terms of either: 1) the GNU General Public License
17
+ # as published by the Free Software Foundation; either version 2 of the
18
+ # License, or (at your option) any later version; or 2) Ruby's License.
19
+ #
20
+ # See the file COPYING for complete licensing information.
21
+ #
22
+ #---------------------------------------------------------------------------
23
+ #
24
+ #
25
+
26
+ module EventMachine
27
+ module Deferrable
28
+
29
+ # Specify a block to be executed if and when the Deferrable object receives
30
+ # a status of :succeeded. See #set_deferred_status for more information.
31
+ #
32
+ # Calling this method on a Deferrable object whose status is not yet known
33
+ # will cause the callback block to be stored on an internal list.
34
+ # If you call this method on a Deferrable whose status is :succeeded, the
35
+ # block will be executed immediately, receiving the parameters given to the
36
+ # prior #set_deferred_status call.
37
+ #
38
+ #--
39
+ # If there is no status, add a callback to an internal list.
40
+ # If status is succeeded, execute the callback immediately.
41
+ # If status is failed, do nothing.
42
+ #
43
+ def callback &block
44
+ return unless block
45
+ @deferred_status ||= :unknown
46
+ if @deferred_status == :succeeded
47
+ block.call(*@deferred_args)
48
+ elsif @deferred_status != :failed
49
+ @callbacks ||= []
50
+ @callbacks.unshift block # << block
51
+ end
52
+ end
53
+
54
+ # Cancels an outstanding callback to &block if any. Undoes the action of #callback.
55
+ #
56
+ def cancel_callback block
57
+ @callbacks ||= []
58
+ @callbacks.delete block
59
+ end
60
+
61
+ # Specify a block to be executed if and when the Deferrable object receives
62
+ # a status of :failed. See #set_deferred_status for more information.
63
+ #--
64
+ # If there is no status, add an errback to an internal list.
65
+ # If status is failed, execute the errback immediately.
66
+ # If status is succeeded, do nothing.
67
+ #
68
+ def errback &block
69
+ return unless block
70
+ @deferred_status ||= :unknown
71
+ if @deferred_status == :failed
72
+ block.call(*@deferred_args)
73
+ elsif @deferred_status != :succeeded
74
+ @errbacks ||= []
75
+ @errbacks.unshift block # << block
76
+ end
77
+ end
78
+
79
+ # Cancels an outstanding errback to &block if any. Undoes the action of #errback.
80
+ #
81
+ def cancel_errback block
82
+ @errbacks ||= []
83
+ @errbacks.delete block
84
+ end
85
+
86
+ # Sets the "disposition" (status) of the Deferrable object. See also the large set of
87
+ # sugarings for this method.
88
+ # Note that if you call this method without arguments,
89
+ # no arguments will be passed to the callback/errback.
90
+ # If the user has coded these with arguments, then the
91
+ # user code will throw an argument exception.
92
+ # Implementors of deferrable classes <b>must</b>
93
+ # document the arguments they will supply to user callbacks.
94
+ #
95
+ # OBSERVE SOMETHING VERY SPECIAL here: you may call this method even
96
+ # on the INSIDE of a callback. This is very useful when a previously-registered
97
+ # callback wants to change the parameters that will be passed to subsequently-registered
98
+ # ones.
99
+ #
100
+ # You may give either :succeeded or :failed as the status argument.
101
+ #
102
+ # If you pass :succeeded, then all of the blocks passed to the object using the #callback
103
+ # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
104
+ # passed to the object using #errback will be discarded.
105
+ #
106
+ # If you pass :failed, then all of the blocks passed to the object using the #errback
107
+ # method (if any) will be executed BEFORE the #set_deferred_status method returns. All of the blocks
108
+ # passed to the object using # callback will be discarded.
109
+ #
110
+ # If you pass any arguments to #set_deferred_status in addition to the status argument,
111
+ # they will be passed as arguments to any callbacks or errbacks that are executed.
112
+ # It's your responsibility to ensure that the argument lists specified in your callbacks and
113
+ # errbacks match the arguments given in calls to #set_deferred_status, otherwise Ruby will raise
114
+ # an ArgumentError.
115
+ #
116
+ #--
117
+ # We're shifting callbacks off and discarding them as we execute them.
118
+ # This is valid because by definition callbacks are executed no more than
119
+ # once. It also has the magic effect of permitting recursive calls, which
120
+ # means that a callback can call #set_deferred_status and change the parameters
121
+ # that will be sent to subsequent callbacks down the chain.
122
+ #
123
+ # Changed @callbacks and @errbacks from push/shift to unshift/pop, per suggestion
124
+ # by Kirk Haines, to work around the memory leak bug that still exists in many Ruby
125
+ # versions.
126
+ #
127
+ # Changed 15Sep07: after processing callbacks or errbacks, CLEAR the other set of
128
+ # handlers. This gets us a little closer to the behavior of Twisted's "deferred,"
129
+ # which only allows status to be set once. Prior to making this change, it was possible
130
+ # to "succeed" a Deferrable (triggering its callbacks), and then immediately "fail" it,
131
+ # triggering its errbacks! That is clearly undesirable, but it's just as undesirable
132
+ # to raise an exception is status is set more than once on a Deferrable. The latter
133
+ # behavior would invalidate the idiom of resetting arguments by setting status from
134
+ # within a callback or errback, but more seriously it would cause spurious errors
135
+ # if a Deferrable was timed out and then an attempt was made to succeed it. See the
136
+ # comments under the new method #timeout.
137
+ #
138
+ def set_deferred_status status, *args
139
+ cancel_timeout
140
+ @errbacks ||= nil
141
+ @callbacks ||= nil
142
+ @deferred_status = status
143
+ @deferred_args = args
144
+ case @deferred_status
145
+ when :succeeded
146
+ if @callbacks
147
+ while cb = @callbacks.pop
148
+ cb.call(*@deferred_args)
149
+ end
150
+ end
151
+ @errbacks.clear if @errbacks
152
+ when :failed
153
+ if @errbacks
154
+ while eb = @errbacks.pop
155
+ eb.call(*@deferred_args)
156
+ end
157
+ end
158
+ @callbacks.clear if @callbacks
159
+ end
160
+ end
161
+
162
+
163
+ # Setting a timeout on a Deferrable causes it to go into the failed state after
164
+ # the Timeout expires (passing no arguments to the object's errbacks).
165
+ # Setting the status at any time prior to a call to the expiration of the timeout
166
+ # will cause the timer to be cancelled.
167
+ def timeout seconds, *args
168
+ cancel_timeout
169
+ me = self
170
+ @deferred_timeout = EventMachine::Timer.new(seconds) {me.fail(*args)}
171
+ end
172
+
173
+ # Cancels an outstanding timeout if any. Undoes the action of #timeout.
174
+ #
175
+ def cancel_timeout
176
+ @deferred_timeout ||= nil
177
+ if @deferred_timeout
178
+ @deferred_timeout.cancel
179
+ @deferred_timeout = nil
180
+ end
181
+ end
182
+
183
+
184
+ # Sugar for set_deferred_status(:succeeded, ...)
185
+ #
186
+ def succeed *args
187
+ set_deferred_status :succeeded, *args
188
+ end
189
+ alias set_deferred_success succeed
190
+
191
+ # Sugar for set_deferred_status(:failed, ...)
192
+ #
193
+ def fail *args
194
+ set_deferred_status :failed, *args
195
+ end
196
+ alias set_deferred_failure fail
197
+ end
198
+
199
+
200
+ # DefaultDeferrable is an otherwise empty class that includes Deferrable.
201
+ # This is very useful when you just need to return a Deferrable object
202
+ # as a way of communicating deferred status to some other part of a program.
203
+ class DefaultDeferrable
204
+ include Deferrable
205
+ end
206
+ end
@@ -0,0 +1,54 @@
1
+ module EventMachine
2
+
3
+ # This is subclassed from EventMachine::Connection for use with the file monitoring API. Read the
4
+ # documentation on the instance methods of this class, and for a full explanation see EventMachine.watch_file.
5
+ class FileWatch < Connection
6
+ # :stopdoc:
7
+ Cmodified = 'modified'.freeze
8
+ Cdeleted = 'deleted'.freeze
9
+ Cmoved = 'moved'.freeze
10
+ # :startdoc:
11
+
12
+ def receive_data(data) #:nodoc:
13
+ case data
14
+ when Cmodified
15
+ file_modified
16
+ when Cdeleted
17
+ file_deleted
18
+ when Cmoved
19
+ file_moved
20
+ end
21
+ end
22
+
23
+ # Returns the path that EventMachine::watch_file was originally called with. The current implementation
24
+ # does not pick up on the new filename after a rename occurs.
25
+ def path
26
+ @path
27
+ end
28
+
29
+ # Should be redefined with the user's custom callback that will be fired when the file is modified.
30
+ def file_modified
31
+ end
32
+
33
+ # Should be redefined with the user's custom callback that will be fired when the file is deleted.
34
+ # When the file is deleted, stop_watching will be called after this to make sure everything is
35
+ # cleaned up correctly.
36
+ #
37
+ # Note that on linux (with inotify), file_deleted will not be called until all open file descriptors to
38
+ # the file have been closed.
39
+ def file_deleted
40
+ end
41
+
42
+ # Should be redefined with the user's custom callback that will be fired when the file is moved or renamed.
43
+ def file_moved
44
+ end
45
+
46
+ # Discontinue monitoring of the file.
47
+ # This involves cleaning up the underlying monitoring details with kqueue/inotify, and in turn firing unbind.
48
+ # This will be called automatically when a file is deleted. User code may call it as well.
49
+ def stop_watching
50
+ EventMachine::unwatch_filename(@signature)
51
+ end
52
+ end
53
+
54
+ end
@@ -0,0 +1,61 @@
1
+ #--
2
+ #
3
+ # Author:: Francis Cianfrocca (gmail: blackhedd)
4
+ # Homepage:: http://rubyeventmachine.com
5
+ # Date:: 16 Jul 2006
6
+ #
7
+ # See EventMachine and EventMachine::Connection for documentation and
8
+ # usage examples.
9
+ #
10
+ #----------------------------------------------------------------------------
11
+ #
12
+ # Copyright (C) 2006-07 by Francis Cianfrocca. All Rights Reserved.
13
+ # Gmail: blackhedd
14
+ #
15
+ # This program is free software; you can redistribute it and/or modify
16
+ # it under the terms of either: 1) the GNU General Public License
17
+ # as published by the Free Software Foundation; either version 2 of the
18
+ # License, or (at your option) any later version; or 2) Ruby's License.
19
+ #
20
+ # See the file COPYING for complete licensing information.
21
+ #
22
+ #---------------------------------------------------------------------------
23
+ #
24
+ #
25
+
26
+ #--
27
+ # This defines EventMachine::Deferrable#future, which requires
28
+ # that the rest of EventMachine::Deferrable has already been seen.
29
+ # (It's in deferrable.rb.)
30
+
31
+ module EventMachine
32
+ module Deferrable
33
+
34
+ # A future is a sugaring of a typical deferrable usage.
35
+ #--
36
+ # Evaluate arg (which may be an expression or a block).
37
+ # What's the class of arg?
38
+ # If arg is an ordinary expression, then return it.
39
+ # If arg is deferrable (responds to :set_deferred_status),
40
+ # then look at the arguments. If either callback or errback
41
+ # are defined, then use them. If neither are defined, then
42
+ # use the supplied block (if any) as the callback.
43
+ # Then return arg.
44
+ def self.future arg, cb=nil, eb=nil, &blk
45
+ arg = arg.call if arg.respond_to?(:call)
46
+
47
+ if arg.respond_to?(:set_deferred_status)
48
+ if cb || eb
49
+ arg.callback(&cb) if cb
50
+ arg.errback(&eb) if eb
51
+ else
52
+ arg.callback(&blk) if blk
53
+ end
54
+ end
55
+
56
+ arg
57
+ end
58
+
59
+ end
60
+ end
61
+
@@ -0,0 +1,270 @@
1
+ module EventMachine
2
+ # A simple iterator for concurrent asynchronous work.
3
+ #
4
+ # Unlike ruby's built-in iterators, the end of the current iteration cycle is signaled manually,
5
+ # instead of happening automatically after the yielded block finishes executing. For example:
6
+ #
7
+ # (0..10).each{ |num| }
8
+ #
9
+ # becomes:
10
+ #
11
+ # EM::Iterator.new(0..10).each{ |num,iter| iter.next }
12
+ #
13
+ # This is especially useful when doing asynchronous work via reactor libraries and
14
+ # functions. For example, given a sync and async http api:
15
+ #
16
+ # response = sync_http_get(url); ...
17
+ # async_http_get(url){ |response| ... }
18
+ #
19
+ # a synchronous iterator such as:
20
+ #
21
+ # responses = urls.map{ |url| sync_http_get(url) }
22
+ # ...
23
+ # puts 'all done!'
24
+ #
25
+ # could be written as:
26
+ #
27
+ # EM::Iterator.new(urls).map(proc{ |url,iter|
28
+ # async_http_get(url){ |res|
29
+ # iter.return(res)
30
+ # }
31
+ # }, proc{ |responses|
32
+ # ...
33
+ # puts 'all done!'
34
+ # })
35
+ #
36
+ # Now, you can take advantage of the asynchronous api to issue requests in parallel. For example,
37
+ # to fetch 10 urls at a time, simply pass in a concurrency of 10:
38
+ #
39
+ # EM::Iterator.new(urls, 10).each do |url,iter|
40
+ # async_http_get(url){ iter.next }
41
+ # end
42
+ #
43
+ class Iterator
44
+ # Create a new parallel async iterator with specified concurrency.
45
+ #
46
+ # i = EM::Iterator.new(1..100, 10)
47
+ #
48
+ # will create an iterator over the range that processes 10 items at a time. Iteration
49
+ # is started via #each, #map or #inject
50
+ #
51
+ def initialize(list, concurrency = 1)
52
+ raise ArgumentError, 'argument must be an array' unless list.respond_to?(:to_a)
53
+ @list = list.to_a.dup
54
+ @concurrency = concurrency
55
+
56
+ @started = false
57
+ @ended = false
58
+ end
59
+
60
+ # Change the concurrency of this iterator. Workers will automatically be spawned or destroyed
61
+ # to accomodate the new concurrency level.
62
+ #
63
+ def concurrency=(val)
64
+ old = @concurrency
65
+ @concurrency = val
66
+
67
+ spawn_workers if val > old and @started and !@ended
68
+ end
69
+ attr_reader :concurrency
70
+
71
+ # Iterate over a set of items using the specified block or proc.
72
+ #
73
+ # EM::Iterator.new(1..100).each do |num, iter|
74
+ # puts num
75
+ # iter.next
76
+ # end
77
+ #
78
+ # An optional second proc is invoked after the iteration is complete.
79
+ #
80
+ # EM::Iterator.new(1..100).each(
81
+ # proc{ |num,iter| iter.next },
82
+ # proc{ puts 'all done' }
83
+ # )
84
+ #
85
+ def each(foreach=nil, after=nil, &blk)
86
+ raise ArgumentError, 'proc or block required for iteration' unless foreach ||= blk
87
+ raise RuntimeError, 'cannot iterate over an iterator more than once' if @started or @ended
88
+
89
+ @started = true
90
+ @pending = 0
91
+ @workers = 0
92
+
93
+ all_done = proc{
94
+ after.call if after and @ended and @pending == 0
95
+ }
96
+
97
+ @process_next = proc{
98
+ # p [:process_next, :pending=, @pending, :workers=, @workers, :ended=, @ended, :concurrency=, @concurrency, :list=, @list]
99
+ unless @ended or @workers > @concurrency
100
+ if @list.empty?
101
+ @ended = true
102
+ @workers -= 1
103
+ all_done.call
104
+ else
105
+ item = @list.shift
106
+ @pending += 1
107
+
108
+ is_done = false
109
+ on_done = proc{
110
+ raise RuntimeError, 'already completed this iteration' if is_done
111
+ is_done = true
112
+
113
+ @pending -= 1
114
+
115
+ if @ended
116
+ all_done.call
117
+ else
118
+ EM.next_tick(@process_next)
119
+ end
120
+ }
121
+ class << on_done
122
+ alias :next :call
123
+ end
124
+
125
+ foreach.call(item, on_done)
126
+ end
127
+ else
128
+ @workers -= 1
129
+ end
130
+ }
131
+
132
+ spawn_workers
133
+
134
+ self
135
+ end
136
+
137
+ # Collect the results of an asynchronous iteration into an array.
138
+ #
139
+ # EM::Iterator.new(%w[ pwd uptime uname date ], 2).map(proc{ |cmd,iter|
140
+ # EM.system(cmd){ |output,status|
141
+ # iter.return(output)
142
+ # }
143
+ # }, proc{ |results|
144
+ # p results
145
+ # })
146
+ #
147
+ def map(foreach, after)
148
+ index = 0
149
+
150
+ inject([], proc{ |results,item,iter|
151
+ i = index
152
+ index += 1
153
+
154
+ is_done = false
155
+ on_done = proc{ |res|
156
+ raise RuntimeError, 'already returned a value for this iteration' if is_done
157
+ is_done = true
158
+
159
+ results[i] = res
160
+ iter.return(results)
161
+ }
162
+ class << on_done
163
+ alias :return :call
164
+ def next
165
+ raise NoMethodError, 'must call #return on a map iterator'
166
+ end
167
+ end
168
+
169
+ foreach.call(item, on_done)
170
+ }, proc{ |results|
171
+ after.call(results)
172
+ })
173
+ end
174
+
175
+ # Inject the results of an asynchronous iteration onto a given object.
176
+ #
177
+ # EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
178
+ # EM.system(cmd){ |output,status|
179
+ # hash[cmd] = status.exitstatus == 0 ? output.strip : nil
180
+ # iter.return(hash)
181
+ # }
182
+ # }, proc{ |results|
183
+ # p results
184
+ # })
185
+ #
186
+ def inject(obj, foreach, after)
187
+ each(proc{ |item,iter|
188
+ is_done = false
189
+ on_done = proc{ |res|
190
+ raise RuntimeError, 'already returned a value for this iteration' if is_done
191
+ is_done = true
192
+
193
+ obj = res
194
+ iter.next
195
+ }
196
+ class << on_done
197
+ alias :return :call
198
+ def next
199
+ raise NoMethodError, 'must call #return on an inject iterator'
200
+ end
201
+ end
202
+
203
+ foreach.call(obj, item, on_done)
204
+ }, proc{
205
+ after.call(obj)
206
+ })
207
+ end
208
+
209
+ private
210
+
211
+ # Spawn workers to consume items from the iterator's enumerator based on the current concurrency level.
212
+ #
213
+ def spawn_workers
214
+ EM.next_tick(start_worker = proc{
215
+ if @workers < @concurrency and !@ended
216
+ # p [:spawning_worker, :workers=, @workers, :concurrency=, @concurrency, :ended=, @ended]
217
+ @workers += 1
218
+ @process_next.call
219
+ EM.next_tick(start_worker)
220
+ end
221
+ })
222
+ nil
223
+ end
224
+ end
225
+ end
226
+
227
+ if __FILE__ == $0
228
+ $:.unshift File.join(File.dirname(__FILE__), '..')
229
+ require 'eventmachine'
230
+
231
+ # TODO: real tests
232
+ # TODO: pass in one object instead of two? .each{ |iter| puts iter.current; iter.next }
233
+ # TODO: support iter.pause/resume/stop/break/continue?
234
+ # TODO: create some exceptions instead of using RuntimeError
235
+ # TODO: support proc instead of enumerable? EM::Iterator.new(proc{ return queue.pop })
236
+
237
+ EM.run{
238
+ EM::Iterator.new(1..50).each{ |num,iter| p num; iter.next }
239
+ EM::Iterator.new([1,2,3], 10).each{ |num,iter| p num; iter.next }
240
+
241
+ i = EM::Iterator.new(1..100, 5)
242
+ i.each(proc{|num,iter|
243
+ p num.to_s
244
+ iter.next
245
+ }, proc{
246
+ p :done
247
+ })
248
+ EM.add_timer(0.03){
249
+ i.concurrency = 1
250
+ }
251
+ EM.add_timer(0.04){
252
+ i.concurrency = 3
253
+ }
254
+
255
+ EM::Iterator.new(100..150).map(proc{ |num,iter|
256
+ EM.add_timer(0.01){ iter.return(num) }
257
+ }, proc{ |results|
258
+ p results
259
+ })
260
+
261
+ EM::Iterator.new(%w[ pwd uptime uname date ], 2).inject({}, proc{ |hash,cmd,iter|
262
+ EM.system(cmd){ |output,status|
263
+ hash[cmd] = status.exitstatus == 0 ? output.strip : nil
264
+ iter.return(hash)
265
+ }
266
+ }, proc{ |results|
267
+ p results
268
+ })
269
+ }
270
+ end