├── .gitignore
├── test
    └── nettyca
    │   └── core_test.clj
├── project.clj
├── resources
    └── logback.xml
├── src
    └── nettyca
    │   ├── cli.clj
    │   ├── core.clj
    │   └── netty.clj
├── README.md
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
 1 | /target
 2 | /classes
 3 | /checkouts
 4 | /logs
 5 | pom.xml
 6 | pom.xml.asc
 7 | *.jar
 8 | *.class
 9 | /.lein-*
10 | /.nrepl-port
11 | 


--------------------------------------------------------------------------------
/test/nettyca/core_test.clj:
--------------------------------------------------------------------------------
1 | (ns nettyca.core-test
2 |   (:require [clojure.test :refer :all]
3 |             [nettyca.core :refer :all]))
4 | 
5 | (deftest a-test
6 |   (testing "FIXME, I fail."
7 |     (is (= 0 1))))
8 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject nettyca "0.1.0-SNAPSHOT"
 2 |   :description "Create simple socket servers using Netty and core.async"
 3 |   :url "http://github.com/marsmining/nettyca"
 4 |   :license {:name "Eclipse Public License"
 5 |             :url "http://www.eclipse.org/legal/epl-v10.html"}
 6 |   :dependencies [[org.clojure/clojure "1.7.0-alpha2"]
 7 |                  [org.clojure/tools.logging "0.3.0"]
 8 |                  [io.netty/netty-handler "5.0.0.Alpha1"]
 9 |                  [org.clojure/core.async "0.1.338.0-5c5012-alpha"]
10 |                  [org.clojure/tools.cli "0.3.1"]]
11 |   :profiles {:dev {:dependencies [[org.clojure/test.check "0.5.8"]
12 |                                   [ch.qos.logback/logback-classic "1.1.2"]]}}
13 |   :main nettyca.cli
14 |   :aot [nettyca.cli]
15 |   :jar-exclusions [#"logback.xml"])
16 | 


--------------------------------------------------------------------------------
/resources/logback.xml:
--------------------------------------------------------------------------------
 1 | <configuration scan="true" scanPeriod="1 seconds" debug="false">
 2 | 
 3 |   <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
 4 |     <encoder>
 5 |       <pattern>%date %6level [%32thread] %-15logger{15} %msg%n</pattern>
 6 |     </encoder>
 7 |   </appender>
 8 | 
 9 |   <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
10 |     <file>logs/nettyca.log</file>
11 |     <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
12 |       <fileNamePattern>logs/old/nettyca.%d{yyyy-MM-dd}.log</fileNamePattern>
13 |       <maxHistory>3</maxHistory>
14 |     </rollingPolicy>
15 |     <encoder>
16 |       <pattern>%date %6level [%32thread] %-15logger{15} %msg%n</pattern>
17 |     </encoder>
18 |   </appender>
19 | 
20 | 
21 |   <logger name="io" level="INFO" />
22 |   <logger name="nettyca" level="DEBUG" />
23 | 
24 |   <root level="DEBUG">
25 |     <appender-ref ref="STDOUT" />
26 |     <appender-ref ref="FILE" />
27 |   </root>
28 | 
29 | </configuration>
30 | 


--------------------------------------------------------------------------------
/src/nettyca/cli.clj:
--------------------------------------------------------------------------------
 1 | (ns nettyca.cli
 2 |   "Basic cli support"
 3 |   (:require [clojure.tools.logging :as log]
 4 |             [clojure.tools.cli :refer [parse-opts]]
 5 |             [clojure.string :as string]
 6 |             [clojure.core.async :as async]
 7 |             [nettyca.core :as nc])
 8 |   (:gen-class))
 9 | 
10 | ;; cli stuff
11 | ;;
12 | 
13 | (def cli-options
14 |   [[nil "--help"]
15 |    ["-s" "--server" "Create server not client"
16 |     :default false]
17 |    ["-n" "--name HOST" "Hostname to bind or connect to"
18 |     :default "127.0.0.1"]
19 |    ["-p" "--port PORT" "Port number"
20 |     :default 9090
21 |     :parse-fn #(Integer/parseInt %)
22 |     :validate [#(< 0 % 0x10000) "Must be a number between 0 and 65536"]]])
23 | 
24 | (defn usage [options-summary]
25 |   (->> ["Nettyca examples program."
26 |         ""
27 |         "Usage: lein run [options]"
28 |         ""
29 |         "Options:"
30 |         options-summary
31 |         ""]
32 |        (string/join \newline)))
33 | 
34 | (defn error-msg [errors]
35 |   (str "The following errors occurred while parsing your command:\n\n"
36 |        (string/join \newline errors)))
37 | 
38 | (defn exit [status msg]
39 |   (println msg)
40 |   (shutdown-agents)
41 |   (System/exit status))
42 | 
43 | (defn -main [& args]
44 |   (log/info "starting..")
45 |   (let [{:keys [options arguments errors summary]}
46 |         (parse-opts args cli-options)
47 |         host (:name options)
48 |         port (:port options)
49 |         type (if (:server options) :server :client)]
50 |     (cond
51 |      (:help options) (exit 0 (usage summary))
52 |      (not= (count arguments) 0) (exit 1 (usage summary))
53 |      errors (exit 1 (error-msg errors)))
54 |     (log/info "starting netty" type "on" host "and" port)
55 |     (let [sys (if (= type :server)
56 |                 (nc/start host port nc/echo-server-timeout :server)
57 |                 (nc/start host port nc/echo-client-test :client))]
58 |       (async/<!! (:go-chan sys)))
59 |     (exit 0 "done. exiting..")))
60 | 


--------------------------------------------------------------------------------
/src/nettyca/core.clj:
--------------------------------------------------------------------------------
 1 | (ns nettyca.core
 2 |   "Echo examples and start/stop plus main fns"
 3 |   (:require [clojure.tools.logging :as log]
 4 |             [nettyca.netty :as netty]
 5 |             [clojure.core.async :refer [chan timeout go go-loop alts!
 6 |                                         <! >! close!] :as async]))
 7 | 
 8 | ;; three echo server impls
 9 | ;;
10 | 
11 | (defn echo-server-simple [r w]
12 |   (async/pipe r w))
13 | 
14 | (defn echo-server-newline [r w]
15 |   (async/pipeline 1 w (map #(str % "\r\n")) r))
16 | 
17 | (defn echo-server-timeout
18 |   "An echo server, loop inside go macro, close chan if timeout"
19 |   [r w]
20 |   (go-loop []
21 |     (if-let [msg (first (alts! [r (timeout 5000)]))]
22 |       (do (log/info "echo: got msg:" msg)
23 |           (>! w (str msg "\r\n"))
24 |           (recur))
25 |       (do (log/info "echo: got timeout or closed chan")
26 |           (close! r) (close! w)))))
27 | 
28 | ;; clients receive a 3rd arg, the connection channel
29 | ;;
30 | 
31 | (defn echo-client-test
32 |   "Client test, sends 42 then waits for response"
33 |   [r w c]
34 |   (go (let [[v _] (alts! [[w "42\r\n"] (timeout 1000)])
35 |             _ (log/info "client-test: wrote:" v)
36 |             [v _] (alts! [r (timeout 1000)])
37 |             _ (log/info "client-test: read:" v)]
38 |         (log/info "client-test: result:" (= v "42"))
39 |         (close! r) (close! w) (close! c))))
40 | 
41 | ;; start/stop
42 | ;;
43 | 
44 | (defn start [host port handler type]
45 |   "Start a tcp client or server"
46 |   (let [ch (async/chan)]
47 |     {:conn-chan ch
48 |      :go-chan (netty/start-netty-core-async
49 |                ch host port handler type)}))
50 | 
51 | (defn stop [sys]
52 |   "Stop the system and clean-up"
53 |   (async/close! (sys :conn-chan)))
54 | 
55 | (comment
56 | 
57 |   ;; call from repl examples, server
58 |   (def ss (start "127.0.0.1" 9090 echo-server-timeout :server))
59 |   (stop ss)
60 | 
61 |   ;; client connection
62 |   (start "127.0.0.1" 9090 echo-client-test :client)
63 |   )
64 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # nettyca
  2 | 
  3 | A bit of code for starting up a [Netty](http://netty.io) tcp client or
  4 | server, which delegates control for each connection to a
  5 | protocol handler function you define. Your protocol function will be
  6 | passed a pair of [core.async](https://github.com/clojure/core.async)
  7 | channels, which you use in your handler for reading and writing to a
  8 | client. This is not for production! Just a way to play with writing
  9 | tcp client and servers in terms of core.async channels. It uses Netty
 10 | 5 and Clojure 1.7 __alpha__ releases.
 11 | 
 12 | ## Usage
 13 | 
 14 | Add `nettyca` as a dependency in your `project.clj` file:
 15 | 
 16 | ```clj
 17 | (defproject example-project "x.y.z"
 18 |   :dependencies [[org.clojure/clojure "1.7.0-alpha2"]
 19 |                  [nettyca "0.1.0-SNAPSHOT"]
 20 |                  [ch.qos.logback/logback-classic "1.1.2"]])
 21 | ```
 22 | 
 23 | Notice the Clojure version is alpha, this is required in order to
 24 | operate on channels with
 25 | [transducers](http://blog.cognitect.com/blog/2014/8/6/transducers-are-coming).
 26 | Also notice, in the example above, included is a Java logging
 27 | implementation. If your project already has one, leave the
 28 | [logback](http://logback.qos.ch/) dependency out.
 29 | 
 30 | ### Quick Start
 31 | 
 32 | To start an echo server and client in the repl, follow these steps:
 33 | 
 34 | ```clj
 35 | (use 'nettyca.core)
 36 | ;; start netty tcp server, passing a fn which accepts two args, r and w chans
 37 | (def sys (start "127.0.0.1" 9090 echo-server-timeout :server))
 38 | ;; try telnet 127.0.0.1 9090 now
 39 | ;; or run an echo tcp client provided as an example
 40 | (start "127.0.0.1" 9090 echo-client-test :client)
 41 | (stop sys)
 42 | ```
 43 | 
 44 | See the [core namespace](src/nettyca/core.clj) for other examples of a simple echo protocol.
 45 | 
 46 | ### Why?
 47 | 
 48 | There already exists a robust and feature complete set of libraries which
 49 | implement a channel abstraction in conjuction with Netty, it is called
 50 | [Aleph](https://github.com/ztellman/aleph). This library, `nettyca` is
 51 | tiny and incompletely emulates just one or two specific cases of Aleph's
 52 | functionality. Therefore this library is only for someone who might want
 53 | to play with the very latest Netty and core.async libraries, without
 54 | re-writing the Java interop code to wire them together.
 55 | 
 56 | ### Server Detail
 57 | 
 58 | To start an echo server in the repl, follow these steps:
 59 | 
 60 | First load and refer in the `nettyca/core` ns:
 61 | 
 62 |     user=> (use 'nettyca.core)
 63 |     ... log messages omitted ...
 64 | 
 65 | Next define an echo server as a function which accepts two arguments,
 66 | the read channel and write channel respectively.
 67 | 
 68 |     user=> (defn echo [r w] (clojure.core.async/pipe r w))
 69 |     #'user/echo
 70 | 
 71 | In this simplest implementation, we just use core.async `pipe`
 72 | function to send values from the read channel to the write channel.
 73 | You'll notice that we could simply pass the `pipe` function directly
 74 | because of the similar arguments expected, but for any protocol less
 75 | trivial, you'll be implementing your own function, as shown here.
 76 | 
 77 | Next, start a Netty server listening on a port:
 78 | 
 79 |     user=> (def sys (start 9090 echo-server-timeout))
 80 |     ... log messages omitted ...
 81 | 
 82 | Now you can telnet to port 9090:
 83 | 
 84 |     $ telnet localhost 9090
 85 |     Trying 127.0.0.1...
 86 |     Connected to localhost.
 87 |     Escape character is '^]'.
 88 |     56
 89 |     56
 90 |     Connection closed by foreign host.
 91 | 
 92 | Finally, stop the server:
 93 | 
 94 |     user=> (stop sys)
 95 |     ... log messages omitted ...
 96 | 
 97 | That's it!
 98 | 
 99 | ### Client Detail
100 | 
101 | With the `nettyca/core` ns loaded and referred:
102 | 
103 | ```clj
104 | (start "127.0.0.1" 9090 echo-client-test :client)
105 | ```
106 | 
107 | You'll notice there is no corresponding stop function for client
108 | connections. The handler for clients is passed 3 channels, read, write
109 | and "connection" respectively. Closing the "connection" channel closes
110 | and cleans up resources associated with the connection.
111 | 
112 | ### Example
113 | 
114 | An example of a program to check existence of mailbox using SMTP can
115 | be found [here](https://github.com/marsmining/evalid/blob/6df45f16c17f1e82f3b860f139e24319b4c53159/src/evalid/core.clj).
116 | 
117 | ### Command Line Interface
118 | 
119 | See the [cli namespace](src/nettyca/cli.clj) for examples of starting
120 | from the cli versus repl.
121 | 
122 | ## License
123 | 
124 | Copyright © 2014 Brandon van Beekum
125 | 
126 | Distributed under the Eclipse Public License either version 1.0 or (at
127 | your option) any later version.
128 | 


--------------------------------------------------------------------------------
/src/nettyca/netty.clj:
--------------------------------------------------------------------------------
  1 | (ns nettyca.netty
  2 |   (:require [clojure.tools.logging :as log]
  3 |             [clojure.core.async :refer [chan timeout go go-loop alts!
  4 |                                         <! >! close!] :as async])
  5 |   (:import (io.netty.bootstrap Bootstrap ServerBootstrap)
  6 |            (io.netty.channel ChannelHandlerAdapter
  7 |                              ChannelInitializer ChannelOption)
  8 |            (io.netty.channel.nio NioEventLoopGroup)
  9 |            (io.netty.channel.socket SocketChannel)
 10 |            (io.netty.channel.socket.nio NioSocketChannel NioServerSocketChannel)
 11 |            (io.netty.handler.codec.string StringEncoder StringDecoder)
 12 |            (io.netty.handler.codec LineBasedFrameDecoder)))
 13 | 
 14 | (defn mk-handler-core-async
 15 |   "Netty `ChannelHandler` which plugs into core async"
 16 |   [conn-chan]
 17 |   (log/info "handler: mk-handler-core-async")
 18 |   (let [rw {:r (chan) :w (chan)}]
 19 |     (proxy [ChannelHandlerAdapter] []
 20 |       (channelActive [ctx]
 21 |         (log/info "handler: channelActive")
 22 |         (go
 23 |           (>! conn-chan rw)
 24 |           (loop []
 25 |             (if-let [msg (<! (rw :w))]
 26 |               (do (log/trace "handler: write on netty channel:" msg)
 27 |                   (.writeAndFlush ctx msg)
 28 |                   (recur))
 29 |               (do (log/info "handler: chan closed!")
 30 |                   (.close ctx))))))
 31 |       (channelRead [ctx msg]
 32 |         (log/trace "handler: channelRead")
 33 |         (go (>! (rw :r) msg)))
 34 |       (exceptionCaught [ctx cause]
 35 |         (log/error cause "handler: error")
 36 |         (.close ctx)))))
 37 | 
 38 | (defn mk-initializer
 39 |   "Line based pipeline"
 40 |   [handler-fn]
 41 |   (proxy [ChannelInitializer] []
 42 |     (initChannel [^SocketChannel ch]
 43 |       (-> (.pipeline ch)
 44 |           (.addLast "frameDecoder" (LineBasedFrameDecoder. (int 1024)))
 45 |           (.addLast "stringDecoder" (StringDecoder.))
 46 |           (.addLast "stringEncoder" (StringEncoder.))
 47 |           (.addLast "myHandler" (handler-fn))))))
 48 | 
 49 | (defn start-netty-client
 50 |   "Start Netty client"
 51 |   [group host port pipeline]
 52 |   (try
 53 |     (log/info "client: starting netty client on port:" port)
 54 |     (let [b (doto (Bootstrap.)
 55 |               (.group group)
 56 |               (.channel NioSocketChannel)
 57 |               (.option ChannelOption/SO_KEEPALIVE true)
 58 |               (.handler pipeline))
 59 |           f (-> b (.connect host (int port)) .sync)]
 60 |       (-> f .channel .closeFuture .sync))
 61 |     (finally
 62 |       (log/info "client: in finally clause..")
 63 |       (.shutdownGracefully group))))
 64 | 
 65 | (defn start-netty-server
 66 |   "Start Netty server, blocking this thread until shutdown"
 67 |   [group host port pipeline]
 68 |   (try
 69 |     (log/info "server: starting netty on port:" port)
 70 |     (let [b (doto (ServerBootstrap.)
 71 |               (.group group)
 72 |               (.channel NioServerSocketChannel)
 73 |               (.childHandler pipeline)
 74 |               (.option ChannelOption/SO_BACKLOG (int 128))
 75 |               (.childOption ChannelOption/SO_KEEPALIVE true))
 76 |           f (-> b (.bind host (int port)) .sync)]
 77 |       (-> f .channel .closeFuture .sync))
 78 |     (finally
 79 |       (log/info "server: in finally clause..")
 80 |       (.shutdownGracefully group))))
 81 | 
 82 | (defn start-netty-off-thread
 83 |   "Start Netty on another thread, return map with handles to shutdown"
 84 |   [host port pipeline type]
 85 |   (let [group (NioEventLoopGroup.)]
 86 |     {:group group
 87 |      :server (future (if (= type :server)
 88 |                        (start-netty-server group host port pipeline)
 89 |                        (start-netty-client group host port pipeline)))
 90 |      :shutdown-fn #(.shutdownGracefully group)}))
 91 | 
 92 | (defn start-netty-core-async
 93 |   "Start Netty server, new connections send r/w channel pair on conn-chan"
 94 |   [conn-chan host port handler type]
 95 |   (let [pre (str (name type) ":")
 96 |         pipeline (mk-initializer #(mk-handler-core-async conn-chan))
 97 |         sys (start-netty-off-thread host port pipeline type)]
 98 |     (go-loop [clients []]
 99 |       (if-let [rw (<! conn-chan)]
100 |         (do (log/info pre "snca: got r/w channel pair..")
101 |             (try (if (= type :server)
102 |                    (handler (rw :r) (rw :w))
103 |                    (handler (rw :r) (rw :w) conn-chan))
104 |                  (catch Throwable t
105 |                    (log/error t pre "snca: err calling handler!")))
106 |             (recur (conj clients rw)))
107 |         (do (log/info pre "snca: recvd nil, conn-chan closed")
108 |             (doseq [lrw clients] (close! (lrw :r)) (close! (lrw :w)))
109 |             (.shutdownGracefully (:group sys)))))))
110 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
  2 | LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
  3 | CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
  4 | 
  5 | 1. DEFINITIONS
  6 | 
  7 | "Contribution" means:
  8 | 
  9 | a) in the case of the initial Contributor, the initial code and
 10 | documentation distributed under this Agreement, and
 11 | 
 12 | b) in the case of each subsequent Contributor:
 13 | 
 14 | i) changes to the Program, and
 15 | 
 16 | ii) additions to the Program;
 17 | 
 18 | where such changes and/or additions to the Program originate from and are
 19 | distributed by that particular Contributor. A Contribution 'originates' from
 20 | a Contributor if it was added to the Program by such Contributor itself or
 21 | anyone acting on such Contributor's behalf. Contributions do not include
 22 | additions to the Program which: (i) are separate modules of software
 23 | distributed in conjunction with the Program under their own license
 24 | agreement, and (ii) are not derivative works of the Program.
 25 | 
 26 | "Contributor" means any person or entity that distributes the Program.
 27 | 
 28 | "Licensed Patents" mean patent claims licensable by a Contributor which are
 29 | necessarily infringed by the use or sale of its Contribution alone or when
 30 | combined with the Program.
 31 | 
 32 | "Program" means the Contributions distributed in accordance with this
 33 | Agreement.
 34 | 
 35 | "Recipient" means anyone who receives the Program under this Agreement,
 36 | including all Contributors.
 37 | 
 38 | 2. GRANT OF RIGHTS
 39 | 
 40 | a) Subject to the terms of this Agreement, each Contributor hereby grants
 41 | Recipient a non-exclusive, worldwide, royalty-free copyright license to
 42 | reproduce, prepare derivative works of, publicly display, publicly perform,
 43 | distribute and sublicense the Contribution of such Contributor, if any, and
 44 | such derivative works, in source code and object code form.
 45 | 
 46 | b) Subject to the terms of this Agreement, each Contributor hereby grants
 47 | Recipient a non-exclusive, worldwide, royalty-free patent license under
 48 | Licensed Patents to make, use, sell, offer to sell, import and otherwise
 49 | transfer the Contribution of such Contributor, if any, in source code and
 50 | object code form.  This patent license shall apply to the combination of the
 51 | Contribution and the Program if, at the time the Contribution is added by the
 52 | Contributor, such addition of the Contribution causes such combination to be
 53 | covered by the Licensed Patents. The patent license shall not apply to any
 54 | other combinations which include the Contribution. No hardware per se is
 55 | licensed hereunder.
 56 | 
 57 | c) Recipient understands that although each Contributor grants the licenses
 58 | to its Contributions set forth herein, no assurances are provided by any
 59 | Contributor that the Program does not infringe the patent or other
 60 | intellectual property rights of any other entity. Each Contributor disclaims
 61 | any liability to Recipient for claims brought by any other entity based on
 62 | infringement of intellectual property rights or otherwise. As a condition to
 63 | exercising the rights and licenses granted hereunder, each Recipient hereby
 64 | assumes sole responsibility to secure any other intellectual property rights
 65 | needed, if any. For example, if a third party patent license is required to
 66 | allow Recipient to distribute the Program, it is Recipient's responsibility
 67 | to acquire that license before distributing the Program.
 68 | 
 69 | d) Each Contributor represents that to its knowledge it has sufficient
 70 | copyright rights in its Contribution, if any, to grant the copyright license
 71 | set forth in this Agreement.
 72 | 
 73 | 3. REQUIREMENTS
 74 | 
 75 | A Contributor may choose to distribute the Program in object code form under
 76 | its own license agreement, provided that:
 77 | 
 78 | a) it complies with the terms and conditions of this Agreement; and
 79 | 
 80 | b) its license agreement:
 81 | 
 82 | i) effectively disclaims on behalf of all Contributors all warranties and
 83 | conditions, express and implied, including warranties or conditions of title
 84 | and non-infringement, and implied warranties or conditions of merchantability
 85 | and fitness for a particular purpose;
 86 | 
 87 | ii) effectively excludes on behalf of all Contributors all liability for
 88 | damages, including direct, indirect, special, incidental and consequential
 89 | damages, such as lost profits;
 90 | 
 91 | iii) states that any provisions which differ from this Agreement are offered
 92 | by that Contributor alone and not by any other party; and
 93 | 
 94 | iv) states that source code for the Program is available from such
 95 | Contributor, and informs licensees how to obtain it in a reasonable manner on
 96 | or through a medium customarily used for software exchange.
 97 | 
 98 | When the Program is made available in source code form:
 99 | 
100 | a) it must be made available under this Agreement; and
101 | 
102 | b) a copy of this Agreement must be included with each copy of the Program.
103 | 
104 | Contributors may not remove or alter any copyright notices contained within
105 | the Program.
106 | 
107 | Each Contributor must identify itself as the originator of its Contribution,
108 | if any, in a manner that reasonably allows subsequent Recipients to identify
109 | the originator of the Contribution.
110 | 
111 | 4. COMMERCIAL DISTRIBUTION
112 | 
113 | Commercial distributors of software may accept certain responsibilities with
114 | respect to end users, business partners and the like. While this license is
115 | intended to facilitate the commercial use of the Program, the Contributor who
116 | includes the Program in a commercial product offering should do so in a
117 | manner which does not create potential liability for other Contributors.
118 | Therefore, if a Contributor includes the Program in a commercial product
119 | offering, such Contributor ("Commercial Contributor") hereby agrees to defend
120 | and indemnify every other Contributor ("Indemnified Contributor") against any
121 | losses, damages and costs (collectively "Losses") arising from claims,
122 | lawsuits and other legal actions brought by a third party against the
123 | Indemnified Contributor to the extent caused by the acts or omissions of such
124 | Commercial Contributor in connection with its distribution of the Program in
125 | a commercial product offering.  The obligations in this section do not apply
126 | to any claims or Losses relating to any actual or alleged intellectual
127 | property infringement. In order to qualify, an Indemnified Contributor must:
128 | a) promptly notify the Commercial Contributor in writing of such claim, and
129 | b) allow the Commercial Contributor tocontrol, and cooperate with the
130 | Commercial Contributor in, the defense and any related settlement
131 | negotiations. The Indemnified Contributor may participate in any such claim
132 | at its own expense.
133 | 
134 | For example, a Contributor might include the Program in a commercial product
135 | offering, Product X. That Contributor is then a Commercial Contributor. If
136 | that Commercial Contributor then makes performance claims, or offers
137 | warranties related to Product X, those performance claims and warranties are
138 | such Commercial Contributor's responsibility alone. Under this section, the
139 | Commercial Contributor would have to defend claims against the other
140 | Contributors related to those performance claims and warranties, and if a
141 | court requires any other Contributor to pay any damages as a result, the
142 | Commercial Contributor must pay those damages.
143 | 
144 | 5. NO WARRANTY
145 | 
146 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON
147 | AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER
148 | EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR
149 | CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A
150 | PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the
151 | appropriateness of using and distributing the Program and assumes all risks
152 | associated with its exercise of rights under this Agreement , including but
153 | not limited to the risks and costs of program errors, compliance with
154 | applicable laws, damage to or loss of data, programs or equipment, and
155 | unavailability or interruption of operations.
156 | 
157 | 6. DISCLAIMER OF LIABILITY
158 | 
159 | EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
160 | CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
161 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
162 | LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
163 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
164 | ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
165 | EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
166 | OF SUCH DAMAGES.
167 | 
168 | 7. GENERAL
169 | 
170 | If any provision of this Agreement is invalid or unenforceable under
171 | applicable law, it shall not affect the validity or enforceability of the
172 | remainder of the terms of this Agreement, and without further action by the
173 | parties hereto, such provision shall be reformed to the minimum extent
174 | necessary to make such provision valid and enforceable.
175 | 
176 | If Recipient institutes patent litigation against any entity (including a
177 | cross-claim or counterclaim in a lawsuit) alleging that the Program itself
178 | (excluding combinations of the Program with other software or hardware)
179 | infringes such Recipient's patent(s), then such Recipient's rights granted
180 | under Section 2(b) shall terminate as of the date such litigation is filed.
181 | 
182 | All Recipient's rights under this Agreement shall terminate if it fails to
183 | comply with any of the material terms or conditions of this Agreement and
184 | does not cure such failure in a reasonable period of time after becoming
185 | aware of such noncompliance. If all Recipient's rights under this Agreement
186 | terminate, Recipient agrees to cease use and distribution of the Program as
187 | soon as reasonably practicable. However, Recipient's obligations under this
188 | Agreement and any licenses granted by Recipient relating to the Program shall
189 | continue and survive.
190 | 
191 | Everyone is permitted to copy and distribute copies of this Agreement, but in
192 | order to avoid inconsistency the Agreement is copyrighted and may only be
193 | modified in the following manner. The Agreement Steward reserves the right to
194 | publish new versions (including revisions) of this Agreement from time to
195 | time. No one other than the Agreement Steward has the right to modify this
196 | Agreement. The Eclipse Foundation is the initial Agreement Steward. The
197 | Eclipse Foundation may assign the responsibility to serve as the Agreement
198 | Steward to a suitable separate entity. Each new version of the Agreement will
199 | be given a distinguishing version number. The Program (including
200 | Contributions) may always be distributed subject to the version of the
201 | Agreement under which it was received. In addition, after a new version of
202 | the Agreement is published, Contributor may elect to distribute the Program
203 | (including its Contributions) under the new version. Except as expressly
204 | stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
205 | licenses to the intellectual property of any Contributor under this
206 | Agreement, whether expressly, by implication, estoppel or otherwise. All
207 | rights in the Program not expressly granted under this Agreement are
208 | reserved.
209 | 
210 | This Agreement is governed by the laws of the State of New York and the
211 | intellectual property laws of the United States of America. No party to this
212 | Agreement will bring a legal action under this Agreement more than one year
213 | after the cause of action arose. Each party waives its rights to a jury trial
214 | in any resulting litigation.
215 | 


--------------------------------------------------------------------------------