Eventsggx

1,757 views
1,657 views

Published on

0 Comments
3 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total views
1,757
On SlideShare
0
From Embeds
0
Number of Embeds
8
Actions
Shares
0
Downloads
21
Comments
0
Likes
3
Embeds 0
No embeds

No notes for slide

Eventsggx

  1. 1. Reactive Grails Event-driven architecture made easyStephane Maldini – Consultant @ SpringSource/VMware* * Changes may apply in the next couple of months
  2. 2. WHY ?!!!!!!!!!!!!!!!! 2
  3. 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. 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. 5. The big picture Application Service Listener Service Listener Point to point Events Bus Service Listener Service Listener Service Listener 5
  6. 6. The big picture Application Service Listener Service Listener Publish/Subscribe Events Bus Service Listener Service Listener Service Listener 6
  7. 7. The big picture Cloud App App Publish/Subscribe Events Bus App App App 7
  8. 8. Boring Robert Fletcher 8
  9. 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. 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. 11. Platform-Core: API Configuration Navigation Security Injection Events 11
  12. 12. Platform-Core : Events 12
  13. 13. Platform-Core : Events•  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 13
  14. 14. Platform-Core : Events•  Add this to your BuildConfig RIGHT NOW : – compile :platform-core:1.0.RC2 14
  15. 15. Events : Sending Events   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)                    }      }   }   15
  16. 16. Events : Listening Events   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")                  }      }   }   16
  17. 17. Events : DSLevents  =  {          //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          }   17
  18. 18. Platform-Core : Events, more!•  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 18
  19. 19. Platform-Core : Simplicity Wins! 19
  20. 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. 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. 22. grails-events-si•  SI => Spring Integration – Implements Enterprise Integration Patterns 22
  23. 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. 24. grails-events-si + Groovy DSL 24
  25. 25. How to send through RabbitMQ in minutesWith this in BuildConfig : runtime ":rabbitmq:1.0.0 " runtime ":events-si:1.0.M4-SNAPSHOT"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) ! !}! 25
  26. 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. 27. grails-events-push ATMOSPHERE SAVES THE WORLD 27
  28. 28. React on server side events 28
  29. 29. grails-events-push : Whitelist 29
  30. 30. grails-vertx : Hipster time 30
  31. 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. 32. grails-vertx•  vertxService bean (vertx instance, container)•  Grails dedicated language factory: – Verticle Hot reloading – Classloader access 32
  33. 33. grails-vertx 33
  34. 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. 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. 36. Demos! 36
  37. 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

×