Download - Eventsggx
Reactive Grails Event-driven architecture made easy
Stephane Maldini – Consultant @ SpringSource/VMware*
* Changes may apply in the next couple of months
2 2
WHY ?!!!!!!!!!!!!!!!!
3
In Memory use cases
• Loosely coupled – Plugin oriented – Testable handlers without mocking
• Declarative logic – Workflow by contract
• Threading scalability – Scale to multicores without digging too deep in your code
3
4
In Cloud use cases
• Sharing workload – And on demand ! – One machine can handle the task: using a shared work queue
• Synchronizing – All machines need to work: Cache invalidation, indexing...
• Communicating with Service API – Layering at machine level instead of software level
4
5
The big picture
5
Events Bus
Point to point
Service Listener
Service Listener
Service Listener
Service Listener
Service Listener
Application
6
The big picture
6
Events Bus
Publish/Subscribe
Service Listener
Service Listener
Service Listener
Service Listener
Service Listener
Application
7
The big picture
7
Events Bus
Publish/Subscribe
App
App
App
App
App
Cloud
8
Boring
8
Robert Fletcher
9
Grails on bus : current plugins
• Spring Events – Use ApplicationContext to propagate ApplicationEvents – Code boilerplate
• Routing (Apache Camel) – Super flexible – Simple but powerful – Routing DSL but not so “Grailsy”
• Falcone Utils – Fully integrated with Grails – Not maintained
9
10
Platform-Core
• This plugin purpose is to provide key features for todays application development and plugin oriented architecture
• Provided by Marc Palmer and your guest
• Initiated mid 2012, currently version 1.0.RC2: – Nearly complete API stabilization – Integrated with grails development
• Fully extensible, API driven design
10
11
Platform-Core: API
11
Navigation Configuration
Injection Events
Security
12
Platform-Core : Events
12
13
Platform-Core : Events
13
• Grails Apps and Plugins can use Platform-Core/Events to:
– Listen for plugins/app events
– Avoid topic name conflicts using namespacing support
– Do in-memory eventing
– Do Asynchronous calls (default)
– Increase in flexibility if required
14
Platform-Core : Events
14
• Add this to your BuildConfig RIGHT NOW :
– compile “:platform-core:1.0.RC2”
15
Events : Sending Events
15
class UserController{ def registration(){ def user = new User(params).save() if(user){ //non-‐blocking call, will trigger application listeners for this topic event('mailRegistration', user) //blocking call : //event('mailRegistration', user).waitFor() //can also be written like that //event topic:'mailRegistration', data:user //and if you need to reuse the current thread //event topic:'mailRegistration', data:user, fork:false render(view:'sendingRegistrationMail') }else{ render(view:'errorRegistration') } } }
16
Events : Listening Events
16
class UserService{ //use method name 'mailRegistration' as topic name //can also use custom topic name using topic arg: @Listener(topic='test') @grails.events.Listener def mailRegistration(User user){ sendMail{ to user.mail subject "Confirmation" html g.render(template:"userMailConfirmation") } } //Can also receive an EventMessage to get more information on this particular event) @grails.events.Listener(topic="mailRegistration") def mailRegistration2(org.grails.plugin.platform.events.EventMessage msg){ sendMail{ to msg.data.mail subject "Confirmation" html g.render(template:"userMailConfirmation") } } }
17
Events : DSL
17
events = { //prevents any events in gorm namespace '*' namespace:'gorm', disabled:true //filters any events on 'testTopic' where data <= 2 testTopic filter:{it > 2} //filters any events on 'testTopic2' where data is not a TestTopic class type testTopic2 filter:TestTopic //filters any events on 'testTopicX' using boolean method from service testTopicX filter:ctx.myService.&someMethod //only if using events-‐push plugin, allows client-‐side listener on this topic testTopic3 browser:true //Default Error Handling, Global Reply Handling, timeout and fork testTopicD onError:{}, onReply:{}, timeout:1000l testTopicD2 fork:false }
18
Platform-Core : Events, more!
18
• Listen to GORM events – using the same API
• Reply handlers – Return values from your listeners to pass them back to caller
• Errors handler – Listen for any exceptions
19
Platform-Core : Simplicity Wins!
19
20
Events : Plugins
• Leveraging and enriching the Platform-core API
• May update events registering/dispatching engine
• Combine them and achieve kool kombos
• Currently 3 plugins in development – Events-SI : Spring Integration backed events – Events-Push : Events to the browser using Atmosphere – Vertx : Vertx integration and platform-core backed events
20
21
grails-events-si
• Change in-memory default mechanism:
– @Listener now generates a channel + endpoint
– event methods now send through Spring Integration gateway
– This channel can be overriden using the naming convention
– Super flexible, connect to the world
21
22
grails-events-si
• SI => Spring Integration – Implements Enterprise Integration Patterns
22
23
grails-events-si + Groovy DSL
• Based on the excellent module from David Turanski: – https://github.com/SpringSource/spring-integration-dsl-groovy
• Integration with Events plugin registry and publishing – Easy to add queuing behavior – Easy to transform Pub/Sub to Point 2 Point – Additional declarative logic (filtering, system integration etc)
• Still possible to fallback to standard BeanBuilder
23
24
grails-events-si + Groovy DSL
24
25
How to send through RabbitMQ in minutes
25
beans = { ! xmlns siAmqp: 'http://www.springframework.org/schema/integration/amqp' ! ! siAmqp.'publish-subscribe-channel'(id: 'gorm://afterInsert') ! ! siAmqp.'publish-subscribe-channel'(id: 'gorm://afterDelete') ! ! siAmqp.'publish-subscribe-channel'(id: 'gorm://afterUpdate') ! !}!
With this in BuildConfig : runtime ":rabbitmq:1.0.0 " runtime ":events-si:1.0.M4-SNAPSHOT"
26
grails-events-push
• And if you want to listen for events... in Javascript – Like Socket.IO or Vertx
– Like a free bird
– But not so free, prevent from listening everything
– But which damn protocol using ??
26
27
grails-events-push
27
ATMOSPHERE SAVES THE WORLD
28
React on server side events
28
29
grails-events-push : Whitelist
29
30
grails-vertx : Hipster time
30
31
grails-vertx
• No hands clustering – Using Vert.x Hazelcast support
• Super scalable events processor – Mom’ said Event loop is darn good at handling high concurrent
load
• Deploying features as “verticles” – WIN for hot reloading plugins/services
31
32
grails-vertx
• vertxService bean (vertx instance, container)
• Grails dedicated language factory: – Verticle Hot reloading – Classloader access
32
33
grails-vertx
33
34
Roadmaps
• Platform-Core – Work Queue / Point to Point eventing – Response Streaming
• Events-SI – Overridable listeners with Queue channels
• Events-Push – More on filtering – ... per request security (with PlatformCore security)
34
35
Roadmaps
• Some more Vertx love: – Better integration
– Specific DSL to manage verticles
– SockJS support
– request dispatching • Vertx Back / Grails Front • Vertx Front / Grails Back ?
– Rename it Testx
35
36
Demos!
36
37
More info
• w: http://bit.ly/platform-core-docs • w: http://github.com/smaldini
• Grails Todos source: https://github.com/smaldini/grailsTodos
• t: @smaldini
37