redstorm 0.6.4 → 0.6.5

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.
Files changed (43) hide show
  1. data/CHANGELOG.md +9 -0
  2. data/README.md +206 -103
  3. data/examples/native/cluster_word_count_topology.rb +5 -5
  4. data/examples/native/local_exclamation_topology.rb +8 -8
  5. data/examples/native/local_exclamation_topology2.rb +7 -7
  6. data/examples/native/local_redis_word_count_topology.rb +7 -8
  7. data/examples/native/local_word_count_topology.rb +5 -5
  8. data/examples/simple/exclamation_topology.rb +7 -11
  9. data/examples/simple/exclamation_topology2.rb +10 -12
  10. data/examples/simple/hello_world_topology.rb +22 -0
  11. data/examples/simple/kafka_topology.rb +2 -1
  12. data/examples/simple/redis_word_count_topology.rb +3 -5
  13. data/examples/simple/ruby_version_topology.rb +7 -1
  14. data/examples/simple/word_count_topology.rb +8 -10
  15. data/ivy/settings.xml +1 -0
  16. data/ivy/storm_dependencies.xml +8 -0
  17. data/ivy/topology_dependencies.xml +7 -0
  18. data/lib/red_storm.rb +1 -0
  19. data/lib/red_storm/application.rb +9 -7
  20. data/lib/red_storm/configurator.rb +1 -1
  21. data/lib/red_storm/proxy/batch_bolt.rb +63 -0
  22. data/lib/red_storm/proxy/batch_committer_bolt.rb +52 -0
  23. data/lib/red_storm/proxy/batch_spout.rb +59 -0
  24. data/lib/red_storm/proxy/proxy_function.rb +40 -0
  25. data/lib/red_storm/proxy/transactional_committer_spout.rb +47 -0
  26. data/lib/red_storm/proxy/transactional_spout.rb +46 -0
  27. data/lib/red_storm/simple_drpc_topology.rb +87 -0
  28. data/lib/red_storm/simple_topology.rb +14 -4
  29. data/lib/red_storm/topology_launcher.rb +22 -3
  30. data/lib/red_storm/version.rb +1 -1
  31. data/lib/tasks/red_storm.rake +66 -104
  32. data/redstorm.gemspec +24 -0
  33. data/src/main/redstorm/storm/jruby/JRubyBatchBolt.java +90 -0
  34. data/src/main/redstorm/storm/jruby/JRubyBatchCommitterBolt.java +9 -0
  35. data/src/main/redstorm/storm/jruby/JRubyBatchSpout.java +88 -0
  36. data/src/main/redstorm/storm/jruby/JRubyProxyFunction.java +51 -0
  37. data/src/main/redstorm/storm/jruby/JRubyShellSpout.java +1 -1
  38. data/src/main/redstorm/storm/jruby/JRubyTransactionalBolt.java +90 -0
  39. data/src/main/redstorm/storm/jruby/JRubyTransactionalCommitterBolt.java +31 -0
  40. data/src/main/redstorm/storm/jruby/JRubyTransactionalCommitterSpout.java +44 -0
  41. data/src/main/redstorm/storm/jruby/JRubyTransactionalSpout.java +89 -0
  42. metadata +35 -14
  43. data/examples/native/Gemfile +0 -2
@@ -0,0 +1,9 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.transactional.ICommitter;
4
+
5
+ public class JRubyBatchCommitterBolt extends JRubyBatchBolt implements ICommitter {
6
+ public JRubyBatchCommitterBolt(String baseClassPath, String realBoltClassName, String[] fields) {
7
+ super(baseClassPath, realBoltClassName, fields);
8
+ }
9
+ }
@@ -0,0 +1,88 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.tuple.Fields;
4
+ import backtype.storm.task.TopologyContext;
5
+ import storm.trident.operation.TridentCollector;
6
+ import storm.trident.spout.IBatchSpout;
7
+ import java.util.Map;
8
+
9
+ /**
10
+ * the JRubySpout class is a simple proxy class to the actual spout implementation in JRuby.
11
+ * this proxy is required to bypass the serialization/deserialization process when dispatching
12
+ * the spout to the workers. JRuby does not yet support serialization from Java
13
+ * (Java serialization call on a JRuby class).
14
+ *
15
+ * Note that the JRuby spout proxy class is instanciated in the open method which is called after
16
+ * deserialization at the worker and in both the declareOutputFields and isDistributed methods which
17
+ * are called once before serialization at topology creation.
18
+ */
19
+ public class JRubyBatchSpout implements IBatchSpout {
20
+ IBatchSpout _proxySpout;
21
+ String _realSpoutClassName;
22
+ String _baseClassPath;
23
+
24
+ /**
25
+ * create a new JRubySpout
26
+ *
27
+ * @param baseClassPath the topology/project base JRuby class file path
28
+ * @param realSpoutClassName the fully qualified JRuby spout implementation class name
29
+ */
30
+ public JRubyBatchSpout(String baseClassPath, String realSpoutClassName) {
31
+ _baseClassPath = baseClassPath;
32
+ _realSpoutClassName = realSpoutClassName;
33
+ }
34
+
35
+ @Override
36
+ public void open(final Map conf, final TopologyContext context) {
37
+ // create instance of the jruby proxy class here, after deserialization in the workers.
38
+ _proxySpout = newProxySpout(_baseClassPath, _realSpoutClassName);
39
+ _proxySpout.open(conf, context);
40
+ }
41
+
42
+ @Override
43
+ public void emitBatch(long batchId, TridentCollector collector) {
44
+ _proxySpout.emitBatch(batchId, collector);
45
+ }
46
+
47
+ @Override
48
+ public void close() {
49
+ _proxySpout.close();
50
+ }
51
+
52
+ @Override
53
+ public void ack(long batchId) {
54
+ _proxySpout.ack(batchId);
55
+ }
56
+
57
+ @Override
58
+ public Fields getOutputFields() {
59
+ if (_proxySpout == null) {
60
+ // getOutputFields is executed in the topology creation time before serialisation.
61
+ // do not set the _proxySpout instance variable here to avoid JRuby serialization
62
+ // issues. Just create tmp spout instance to call getOutputFields.
63
+ IBatchSpout spout = newProxySpout(_baseClassPath, _realSpoutClassName);
64
+ return spout.getOutputFields();
65
+ } else {
66
+ return _proxySpout.getOutputFields();
67
+ }
68
+ }
69
+
70
+ @Override
71
+ public Map<String, Object> getComponentConfiguration() {
72
+ // getComponentConfiguration is executed in the topology creation time before serialisation.
73
+ // do not set the _proxySpout instance variable here to avoid JRuby serialization
74
+ // issues. Just create tmp spout instance to call declareOutputFields.
75
+ IBatchSpout spout = newProxySpout(_baseClassPath, _realSpoutClassName);
76
+ return spout.getComponentConfiguration();
77
+ }
78
+
79
+ private static IBatchSpout newProxySpout(String baseClassPath, String realSpoutClassName) {
80
+ try {
81
+ redstorm.proxy.BatchSpout proxy = new redstorm.proxy.BatchSpout(baseClassPath, realSpoutClassName);
82
+ return proxy;
83
+ }
84
+ catch (Exception e) {
85
+ throw new RuntimeException(e);
86
+ }
87
+ }
88
+ }
@@ -0,0 +1,51 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import storm.trident.tuple.TridentTuple;
4
+ import storm.trident.operation.TridentCollector;
5
+ import java.util.Map;
6
+ import storm.trident.operation.TridentOperationContext;
7
+ import storm.trident.operation.Function;
8
+
9
+ public class JRubyProxyFunction implements Function {
10
+ Function _proxy;
11
+ String _realClassName;
12
+ String _baseClassPath;
13
+
14
+ public JRubyProxyFunction(final String baseClassPath, final String realClassName) {
15
+ _baseClassPath = baseClassPath;
16
+ _realClassName = realClassName;
17
+ }
18
+
19
+
20
+ @Override
21
+ public void execute(final TridentTuple _tridentTuple, final TridentCollector _tridentCollector) {
22
+ if(_proxy == null) {
23
+ _proxy = newProxy(_baseClassPath, _realClassName);
24
+ }
25
+ _proxy.execute(_tridentTuple, _tridentCollector);
26
+ }
27
+
28
+ @Override
29
+ public void cleanup() {
30
+ _proxy.cleanup();
31
+ }
32
+
33
+ @Override
34
+ public void prepare(final Map _map, final TridentOperationContext _tridentOperationContext) {
35
+ if(_proxy == null) {
36
+ _proxy = newProxy(_baseClassPath, _realClassName);
37
+ }
38
+ _proxy.prepare(_map, _tridentOperationContext);
39
+ }
40
+
41
+
42
+ private static Function newProxy(final String baseClassPath, final String realClassName) {
43
+ try {
44
+ redstorm.proxy.ProxyFunction proxy = new redstorm.proxy.ProxyFunction(baseClassPath, realClassName);
45
+ return proxy;
46
+ }
47
+ catch (Exception e) {
48
+ throw new RuntimeException(e);
49
+ }
50
+ }
51
+ }
@@ -1,4 +1,4 @@
1
- package backtype.storm.clojure;
1
+ package redstorm.storm.jruby;
2
2
 
3
3
  import backtype.storm.spout.ShellSpout;
4
4
  import backtype.storm.topology.IRichSpout;
@@ -0,0 +1,90 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.task.OutputCollector;
4
+ import backtype.storm.task.TopologyContext;
5
+ import backtype.storm.transactional.TransactionAttempt;
6
+ import backtype.storm.topology.base.BaseTransactionalBolt;
7
+ import backtype.storm.coordination.BatchOutputCollector;
8
+ import backtype.storm.coordination.IBatchBolt;
9
+ import backtype.storm.topology.OutputFieldsDeclarer;
10
+ import backtype.storm.tuple.Tuple;
11
+ import backtype.storm.tuple.Fields;
12
+ import java.util.Map;
13
+
14
+ /**
15
+ * the JRubyBolt class is a simple proxy class to the actual bolt implementation in JRuby.
16
+ * this proxy is required to bypass the serialization/deserialization process when dispatching
17
+ * the bolts to the workers. JRuby does not yet support serialization from Java
18
+ * (Java serialization call on a JRuby class).
19
+ *
20
+ * Note that the JRuby bolt proxy class is instanciated in the prepare method which is called after
21
+ * deserialization at the worker and in the declareOutputFields method which is called once before
22
+ * serialization at topology creation.
23
+ */
24
+ public class JRubyTransactionalBolt extends BaseTransactionalBolt {
25
+ IBatchBolt _proxyBolt;
26
+ String _realBoltClassName;
27
+ String _baseClassPath;
28
+ String[] _fields;
29
+
30
+ /**
31
+ * create a new JRubyBolt
32
+ *
33
+ * @param baseClassPath the topology/project base JRuby class file path
34
+ * @param realBoltClassName the fully qualified JRuby bolt implementation class name
35
+ */
36
+ public JRubyTransactionalBolt(String baseClassPath, String realBoltClassName, String[] fields) {
37
+ _baseClassPath = baseClassPath;
38
+ _realBoltClassName = realBoltClassName;
39
+ _fields = fields;
40
+ }
41
+
42
+ @Override
43
+ public void prepare(final Map stormConf, final TopologyContext context, final BatchOutputCollector collector, final TransactionAttempt id) {
44
+ // create instance of the jruby class here, after deserialization in the workers.
45
+ _proxyBolt = newProxyBolt(_baseClassPath, _realBoltClassName);
46
+ _proxyBolt.prepare(stormConf, context, collector, id);
47
+ }
48
+
49
+ @Override
50
+ public void execute(Tuple input) {
51
+ _proxyBolt.execute(input);
52
+ }
53
+
54
+ @Override
55
+ public void finishBatch() {
56
+ _proxyBolt.finishBatch();
57
+ }
58
+
59
+ @Override
60
+ public void declareOutputFields(OutputFieldsDeclarer declarer) {
61
+ // declareOutputFields is executed in the topology creation time, before serialisation.
62
+ // do not set the _proxyBolt instance variable here to avoid JRuby serialization
63
+ // issues. Just create tmp bolt instance to call declareOutputFields.
64
+ if (_fields.length > 0) {
65
+ declarer.declare(new Fields(_fields));
66
+ } else {
67
+ IBatchBolt bolt = newProxyBolt(_baseClassPath, _realBoltClassName);
68
+ bolt.declareOutputFields(declarer);
69
+ }
70
+ }
71
+
72
+ @Override
73
+ public Map<String, Object> getComponentConfiguration() {
74
+ // getComponentConfiguration is executed in the topology creation time, before serialisation.
75
+ // do not set the _proxyBolt instance variable here to avoid JRuby serialization
76
+ // issues. Just create tmp bolt instance to call declareOutputFields.
77
+ IBatchBolt bolt = newProxyBolt(_baseClassPath, _realBoltClassName);
78
+ return bolt.getComponentConfiguration();
79
+ }
80
+
81
+ private static IBatchBolt newProxyBolt(String baseClassPath, String realBoltClassName) {
82
+ try {
83
+ redstorm.proxy.BatchBolt proxy = new redstorm.proxy.BatchBolt(baseClassPath, realBoltClassName);
84
+ return proxy;
85
+ }
86
+ catch (Exception e) {
87
+ throw new RuntimeException(e);
88
+ }
89
+ }
90
+ }
@@ -0,0 +1,31 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.coordination.IBatchBolt;
4
+ import backtype.storm.transactional.TransactionAttempt;
5
+ import backtype.storm.transactional.ICommitter;
6
+
7
+ /**
8
+ * the JRubyBolt class is a simple proxy class to the actual bolt implementation in JRuby.
9
+ * this proxy is required to bypass the serialization/deserialization process when dispatching
10
+ * the bolts to the workers. JRuby does not yet support serialization from Java
11
+ * (Java serialization call on a JRuby class).
12
+ *
13
+ * Note that the JRuby bolt proxy class is instanciated in the prepare method which is called after
14
+ * deserialization at the worker and in the declareOutputFields method which is called once before
15
+ * serialization at topology creation.
16
+ */
17
+ public class JRubyTransactionalCommitterBolt extends JRubyTransactionalBolt implements ICommitter {
18
+ public JRubyTransactionalCommitterBolt(String baseClassPath, String realBoltClassName, String[] fields) {
19
+ super(baseClassPath, realBoltClassName, fields);
20
+ }
21
+
22
+ private static IBatchBolt newProxyBolt(String baseClassPath, String realBoltClassName) {
23
+ try {
24
+ redstorm.proxy.BatchCommitterBolt proxy = new redstorm.proxy.BatchCommitterBolt(baseClassPath, realBoltClassName);
25
+ return proxy;
26
+ }
27
+ catch (Exception e) {
28
+ throw new RuntimeException(e);
29
+ }
30
+ }
31
+ }
@@ -0,0 +1,44 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.transactional.ICommitterTransactionalSpout;
4
+ import backtype.storm.transactional.ITransactionalSpout;
5
+ import backtype.storm.task.TopologyContext;
6
+ import java.util.Map;
7
+
8
+ /**
9
+ * the JRubyBolt class is a simple proxy class to the actual bolt implementation in JRuby.
10
+ * this proxy is required to bypass the serialization/deserialization process when dispatching
11
+ * the bolts to the workers. JRuby does not yet support serialization from Java
12
+ * (Java serialization call on a JRuby class).
13
+ *
14
+ * Note that the JRuby bolt proxy class is instanciated in the prepare method which is called after
15
+ * deserialization at the worker and in the declareOutputFields method which is called once before
16
+ * serialization at topology creation.
17
+ */
18
+ public class JRubyTransactionalCommitterSpout extends JRubyTransactionalSpout implements ICommitterTransactionalSpout {
19
+
20
+ ICommitterTransactionalSpout _proxySpout;
21
+
22
+ public JRubyTransactionalCommitterSpout(String baseClassPath, String realSpoutClassName, String[] fields) {
23
+ super(baseClassPath, realSpoutClassName, fields);
24
+ }
25
+
26
+ @Override
27
+ public ICommitterTransactionalSpout.Emitter getEmitter(Map conf, TopologyContext context) {
28
+ // create instance of the jruby class here, after deserialization in the workers.
29
+ if (_proxySpout == null) {
30
+ _proxySpout = newProxySpout(_baseClassPath, _realSpoutClassName);
31
+ }
32
+ return _proxySpout.getEmitter(conf, context);
33
+ }
34
+
35
+ private static ICommitterTransactionalSpout newProxySpout(String baseClassPath, String realSpoutClassName) {
36
+ try {
37
+ redstorm.proxy.TransactionalCommitterSpout proxy = new redstorm.proxy.TransactionalCommitterSpout(baseClassPath, realSpoutClassName);
38
+ return proxy;
39
+ }
40
+ catch (Exception e) {
41
+ throw new RuntimeException(e);
42
+ }
43
+ }
44
+ }
@@ -0,0 +1,89 @@
1
+ package redstorm.storm.jruby;
2
+
3
+ import backtype.storm.spout.SpoutOutputCollector;
4
+ import backtype.storm.task.TopologyContext;
5
+ import backtype.storm.topology.base.BaseTransactionalSpout;
6
+ import backtype.storm.topology.OutputFieldsDeclarer;
7
+ import backtype.storm.transactional.ITransactionalSpout;
8
+ import backtype.storm.tuple.Tuple;
9
+ import backtype.storm.tuple.Fields;
10
+ import java.util.Map;
11
+
12
+ /**
13
+ * the JRubySpout class is a simple proxy class to the actual spout implementation in JRuby.
14
+ * this proxy is required to bypass the serialization/deserialization process when dispatching
15
+ * the spout to the workers. JRuby does not yet support serialization from Java
16
+ * (Java serialization call on a JRuby class).
17
+ *
18
+ * Note that the JRuby spout proxy class is instanciated in the open method which is called after
19
+ * deserialization at the worker and in both the declareOutputFields and isDistributed methods which
20
+ * are called once before serialization at topology creation.
21
+ */
22
+ public class JRubyTransactionalSpout extends BaseTransactionalSpout {
23
+ ITransactionalSpout _proxySpout;
24
+ String _realSpoutClassName;
25
+ String _baseClassPath;
26
+ String[] _fields;
27
+
28
+ /**
29
+ * create a new JRubySpout
30
+ *
31
+ * @param baseClassPath the topology/project base JRuby class file path
32
+ * @param realSpoutClassName the fully qualified JRuby spout implementation class name
33
+ */
34
+ public JRubyTransactionalSpout(String baseClassPath, String realSpoutClassName, String[] fields) {
35
+ _baseClassPath = baseClassPath;
36
+ _realSpoutClassName = realSpoutClassName;
37
+ _fields = fields;
38
+ }
39
+
40
+ @Override
41
+ public ITransactionalSpout.Coordinator getCoordinator(Map conf, TopologyContext context) {
42
+ // create instance of the jruby class here, after deserialization in the workers.
43
+ if (_proxySpout == null) {
44
+ _proxySpout = newProxySpout(_baseClassPath, _realSpoutClassName);
45
+ }
46
+ return _proxySpout.getCoordinator(conf, context);
47
+ }
48
+
49
+ @Override
50
+ public ITransactionalSpout.Emitter getEmitter(Map conf, TopologyContext context) {
51
+ // create instance of the jruby class here, after deserialization in the workers.
52
+ if (_proxySpout == null) {
53
+ _proxySpout = newProxySpout(_baseClassPath, _realSpoutClassName);
54
+ }
55
+ return _proxySpout.getEmitter(conf, context);
56
+ }
57
+
58
+ @Override
59
+ public void declareOutputFields(OutputFieldsDeclarer declarer) {
60
+ // declareOutputFields is executed in the topology creation time before serialisation.
61
+ // do not set the _proxySpout instance variable here to avoid JRuby serialization
62
+ // issues. Just create tmp spout instance to call declareOutputFields.
63
+ if (_fields.length > 0) {
64
+ declarer.declare(new Fields(_fields));
65
+ } else {
66
+ ITransactionalSpout spout = newProxySpout(_baseClassPath, _realSpoutClassName);
67
+ spout.declareOutputFields(declarer);
68
+ }
69
+ }
70
+
71
+ @Override
72
+ public Map<String, Object> getComponentConfiguration() {
73
+ // getComponentConfiguration is executed in the topology creation time before serialisation.
74
+ // do not set the _proxySpout instance variable here to avoid JRuby serialization
75
+ // issues. Just create tmp spout instance to call declareOutputFields.
76
+ ITransactionalSpout spout = newProxySpout(_baseClassPath, _realSpoutClassName);
77
+ return spout.getComponentConfiguration();
78
+ }
79
+
80
+ private static ITransactionalSpout newProxySpout(String baseClassPath, String realSpoutClassName) {
81
+ try {
82
+ redstorm.proxy.TransactionalSpout proxy = new redstorm.proxy.TransactionalSpout(baseClassPath, realSpoutClassName);
83
+ return proxy;
84
+ }
85
+ catch (Exception e) {
86
+ throw new RuntimeException(e);
87
+ }
88
+ }
89
+ }
metadata CHANGED
@@ -1,27 +1,27 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: redstorm
3
3
  version: !ruby/object:Gem::Version
4
+ version: 0.6.5
4
5
  prerelease:
5
- version: 0.6.4
6
6
  platform: ruby
7
7
  authors:
8
8
  - Colin Surprenant
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2012-10-19 00:00:00.000000000 Z
12
+ date: 2013-05-15 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: rspec
16
16
  version_requirements: !ruby/object:Gem::Requirement
17
17
  requirements:
18
- - - ~>
18
+ - - "~>"
19
19
  - !ruby/object:Gem::Version
20
20
  version: 2.11.0
21
21
  none: false
22
22
  requirement: !ruby/object:Gem::Requirement
23
23
  requirements:
24
- - - ~>
24
+ - - "~>"
25
25
  - !ruby/object:Gem::Version
26
26
  version: 2.11.0
27
27
  none: false
@@ -31,15 +31,17 @@ dependencies:
31
31
  name: rake
32
32
  version_requirements: !ruby/object:Gem::Requirement
33
33
  requirements:
34
- - - ! '>='
34
+ - - ">="
35
35
  - !ruby/object:Gem::Version
36
- version: '0'
36
+ version: !binary |-
37
+ MA==
37
38
  none: false
38
39
  requirement: !ruby/object:Gem::Requirement
39
40
  requirements:
40
- - - ! '>='
41
+ - - ">="
41
42
  - !ruby/object:Gem::Version
42
- version: '0'
43
+ version: !binary |-
44
+ MA==
43
45
  none: false
44
46
  prerelease: false
45
47
  type: :runtime
@@ -58,17 +60,25 @@ files:
58
60
  - lib/red_storm/environment.rb
59
61
  - lib/red_storm/loggable.rb
60
62
  - lib/red_storm/simple_bolt.rb
63
+ - lib/red_storm/simple_drpc_topology.rb
61
64
  - lib/red_storm/simple_spout.rb
62
65
  - lib/red_storm/simple_topology.rb
63
66
  - lib/red_storm/topology_launcher.rb
64
67
  - lib/red_storm/version.rb
68
+ - lib/red_storm/proxy/batch_bolt.rb
69
+ - lib/red_storm/proxy/batch_committer_bolt.rb
70
+ - lib/red_storm/proxy/batch_spout.rb
65
71
  - lib/red_storm/proxy/bolt.rb
72
+ - lib/red_storm/proxy/proxy_function.rb
66
73
  - lib/red_storm/proxy/spout.rb
74
+ - lib/red_storm/proxy/transactional_committer_spout.rb
75
+ - lib/red_storm/proxy/transactional_spout.rb
67
76
  - lib/tasks/red_storm.rake
68
77
  - ivy/settings.xml
78
+ - ivy/storm_dependencies.xml
79
+ - ivy/topology_dependencies.xml
69
80
  - examples/native/cluster_word_count_topology.rb
70
81
  - examples/native/exclamation_bolt.rb
71
- - examples/native/Gemfile
72
82
  - examples/native/local_exclamation_topology.rb
73
83
  - examples/native/local_exclamation_topology2.rb
74
84
  - examples/native/local_redis_word_count_topology.rb
@@ -82,6 +92,7 @@ files:
82
92
  - examples/simple/exclamation_bolt.rb
83
93
  - examples/simple/exclamation_topology.rb
84
94
  - examples/simple/exclamation_topology2.rb
95
+ - examples/simple/hello_world_topology.rb
85
96
  - examples/simple/kafka_topology.rb
86
97
  - examples/simple/random_sentence_spout.rb
87
98
  - examples/simple/redis_word_count_topology.rb
@@ -89,11 +100,20 @@ files:
89
100
  - examples/simple/split_sentence_bolt.rb
90
101
  - examples/simple/word_count_bolt.rb
91
102
  - examples/simple/word_count_topology.rb
103
+ - src/main/redstorm/storm/jruby/JRubyBatchBolt.java
104
+ - src/main/redstorm/storm/jruby/JRubyBatchCommitterBolt.java
105
+ - src/main/redstorm/storm/jruby/JRubyBatchSpout.java
92
106
  - src/main/redstorm/storm/jruby/JRubyBolt.java
107
+ - src/main/redstorm/storm/jruby/JRubyProxyFunction.java
93
108
  - src/main/redstorm/storm/jruby/JRubyShellBolt.java
94
109
  - src/main/redstorm/storm/jruby/JRubyShellSpout.java
95
110
  - src/main/redstorm/storm/jruby/JRubySpout.java
111
+ - src/main/redstorm/storm/jruby/JRubyTransactionalBolt.java
112
+ - src/main/redstorm/storm/jruby/JRubyTransactionalCommitterBolt.java
113
+ - src/main/redstorm/storm/jruby/JRubyTransactionalCommitterSpout.java
114
+ - src/main/redstorm/storm/jruby/JRubyTransactionalSpout.java
96
115
  - bin/redstorm
116
+ - redstorm.gemspec
97
117
  - Rakefile
98
118
  - README.md
99
119
  - CHANGELOG.md
@@ -106,15 +126,17 @@ require_paths:
106
126
  - lib
107
127
  required_ruby_version: !ruby/object:Gem::Requirement
108
128
  requirements:
109
- - - ! '>='
129
+ - - ">="
110
130
  - !ruby/object:Gem::Version
111
- version: '0'
131
+ version: !binary |-
132
+ MA==
112
133
  none: false
113
134
  required_rubygems_version: !ruby/object:Gem::Requirement
114
135
  requirements:
115
- - - ! '>='
136
+ - - ">="
116
137
  - !ruby/object:Gem::Version
117
- version: '0'
138
+ version: !binary |-
139
+ MA==
118
140
  none: false
119
141
  requirements: []
120
142
  rubyforge_project: redstorm
@@ -123,4 +145,3 @@ signing_key:
123
145
  specification_version: 3
124
146
  summary: JRuby on Storm
125
147
  test_files: []
126
- ...