(if you can t read this, move closer!) The high-performance protocol construction toolkit. Peter Royal

Transcription

1 (if you can t read this, move closer!) Apache The high-performance protocol construction toolkit. Peter Royal <proyal@apache.org> Originally presented at ApacheCon US 2007 in Atlanta, GA 1

2 Hi, I m Peter 2

3 MINA hacker since Fall

4 Radar Networks 4

5 San Francisco 5

6 Apache Member 6

7 What is MINA? 7

8 MINA? 8

9 Multipurpose Infrastructure Networked Applications 9

10 Built on Java NIO 10

11 Non-Blocking 11

12 Asynchronous 12

13 Event-Driven (SEDA!) 13

14 Multiple Transports (framework is really agnostic) 14

15 TCP 15

16 UDP (being re-written for 2.0) 16

17 In-VM (great for testing) 17

18 Apache Portable Runtime (APR) (under development, alternate TCP/UDP implementation) 18

19 (and more..) 19

20 Smartly Designed 20

21 Follows Inversion of Control Pattern (plays nicely with PicoContainer, Spring, etc) 21

22 Separation of Concerns 22

23 Wire Protocol Application Logic Rather than this... 23

24 Wire Protocol Application Logic Concerns are Separated 24

25 Stable and Production- Ready v1.0 released Fall 2006 v1.1 released April 2007 Same API as v1.0 but uses Java 5 Concurrency primitives v2.0 this year API simplification based on lessons learned Performance boosts too! 25

26 Many Protocols & Users (here are a few...) 26

27 Apache Directory LDAPv3, NTP, DNS, DHCP and Kerberos 27

28 SubEthaSTMP SMTP 28

29 Apache (incubating) Qpid Advanced Messaging Queuing Protocol (AMQP) (from Wall Street!) 29

30 Openfire products/openfire/ XMPP 30

31 red5 RTMP (talk to Flash player) 31

32 ...and more! (maybe you, next time!) 32

33 Key Concepts 33

34 ByteBuffer Core NIO construct MINA version that wraps and provides additional convenience methods auto-expanding, string encoding MINA gives control... allocate from the Heap or Stack optional Pooling (in v2, will be non-pooled and heap-only, as it provides the best performance) 34

35 Future Represents a function call that completes asynchronously Provides blocking functions to retrieve the result MINA allows callbacks to be invoked upon completion, so invoking thread can fire and forget (unlike the Java 5 Future) 35

36 Writes IoHandler IoProcessor IoService Reads 36

37 Writes IoHandler IoProcessor IoService Reads Two Versions 37

38 Writes IoHandler IoProcessor IoService Reads IoAcceptor act as server single thread for new connections 38

39 Writes IoHandler IoProcessor IoService Reads IoConnector act as client 39

40 Writes IoHandler IoProcessor IoService Reads Connection instance is an IoSession 40

41 Writes IoHandler IoProcessor IoService Reads Handles reads and writes 41

42 Writes IoHandler IoProcessor IoService Reads Instance count scales with CPU/Load 42

43 Writes IoHandler IoProcessor IoService Reads Session fixed to an Instance (under review for v2) 43

44 Writes IoHandler IoProcessor IoService Reads Chain of s 44

45 Writes IoHandler IoProcessor IoService Reads Per Connection 45

46 Writes IoHandler IoProcessor IoService Reads Reusable 46

47 Writes IoHandler IoProcessor IoService Reads Hot Deployable 47

48 Writes IoHandler IoProcessor IoService Reads Filter all events Read / Write / Idle / etc 48

49 Writes IoHandler IoProcessor IoService Reads Application Logic Lives Here 49

50 Large Library of s 50

51 Protocol Conversion Framework to plug in your own codecs to handle conversion to/from a ByteBuffer Existing codecs Text-based Java Serialization 51

52 Blacklist 52

53 Logging (great for debugging!) 53

54 SSL / TLS 54

55 Compression 55

56 Read Throttling (write throttling is in 2.0) 56

57 Thread Models (a necessary evil) 57

58 single threaded 58

59 One IoProcessor Thread 59

60 Scalability sucks 60

61 Add more IoProcessor Threads (at least one per CPU core) 61

62 Lowest latency Scales nicely (connection latency to be addressed in v2) 62

63 multi threaded 63

64 use ExecutorFilter 64

65 IoProcessor threads only do reads & writes (the intent) 65

66 Filters execute on a different thread. (filter location is key!) 66

67 Work for a session is serialized (queued per session) 67

68 Work is delegated to an Executor (generally a java.util.concurrent.threadpoolexecutor) 68

69 Size thread pool to active session count (too much in queue == OOM! Use the Read Throttle filter) 69

70 recommended application pattern use ExecutorFilter as first in chain unless you need really low latency use ProtocolCodecFilter convert the wire protocol into a Java representation put application logic into an IoHandler store state in the IoSession minimum of Java 5 java.util.concurrent rocks! 70

71 Example Time! 71

72 Everybody loves a Haiku 72

73 This is our Haiku validator 73

74 Simple Protocol Connect Send 3 lines of text Receive HAIKU! or NOT A HAIKU: (plus a little reason why not) 74

75 ProtocolCodecFilter + TextLineCodecFactory Bytes to Java String s. For free! 75

76 ToHaiku Three String s to a Haiku 76

77 Filter is very testable (mock objects rock!) 77

78 IoHandler is very simple Validate Haiku, send result 78

79 Also very testable 79

80 Very easy to hook it all up 80

81 Questions? (I m here all week!) 81

82 Thank You! 82

83 83