├── .gitignore
├── doc
    └── intro.md
├── project.clj
├── README.md
├── test
    └── com
    │   └── gearswithingears
    │       └── async_sockets_test.clj
├── src
    └── com
    │   └── gearswithingears
    │       └── async_sockets.clj
└── LICENSE


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


--------------------------------------------------------------------------------
/doc/intro.md:
--------------------------------------------------------------------------------
1 | # Introduction to async-socket-server
2 | 
3 | TODO: write [great documentation](http://jacobian.org/writing/great-documentation/what-to-write/)
4 | 


--------------------------------------------------------------------------------
/project.clj:
--------------------------------------------------------------------------------
 1 | (defproject com.gearswithingears/async-sockets "0.1.0"
 2 |   :description "A Clojure library for working with sockets using core.async channels."
 3 |   :url "https://github.com/bguthrie/async-sockets"
 4 |   :license {:name "The MIT License"
 5 |             :url "http://opensource.org/licenses/MIT"}
 6 |   :dependencies [[org.clojure/core.async "0.1.346.0-17112a-alpha"]
 7 |                  [org.clojure/tools.logging "0.3.1"]]
 8 |   :profiles {:dev {:dependencies [[org.clojure/clojure "1.6.0"]
 9 |                                   [clj-time "0.8.0"]]
10 |                    :global-vars {*warn-on-reflection* true}}})
11 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # async-sockets
 2 | 
 3 | A Clojure library for opening and working with sockets asynchronously.
 4 | 
 5 | ## Releases
 6 | 
 7 | `async-sockets` is published to [clojars.org](https://clojars.org). The latest stable release is `0.1.0`.
 8 | 
 9 | [Leiningen](http://leiningen.org) dependency information:
10 | 
11 | ```
12 | [com.gearswithingears/async-sockets "0.1.0"]
13 | ```
14 | 
15 | ## Usage
16 | 
17 | This library permits the creation of socket servers and remote socket clients in idiomatic Clojure. It uses
18 | `clojure.core.async`  channels for receiving and sending socket data but otherwise leans heavily on `java.net.Socket`
19 | and `java.net.ServerSocket` for most of the heavy lifting. At the moment, it uses a line-based idiom for all socket
20 | interactions; remote data is received and sent a line at a time, and flushed on write. Pull requests gratefully
21 | accepted.
22 | 
23 | Servers are created with `(socket-server <port> [<backlog>] [<bind-addr>])`. The latter two arguments are both optional
24 | and behave as specified by `java.net.SocketServer`. The function returns a record with a channel named `:connections`, 
25 | which yields one `AsyncSocket` per incoming client connection.
26 | 
27 | Clients are created with `(socket-client <port> [<address>])`; `address` is `localhost` by default. Each socket, either
28 | created explicitly using this function or yielded by the `:connections` fields of an `AsyncSocketServer`, exposes two
29 | channels, an `:in` channel for receiving messages and an `:out` channel for sending messages. The raw `java.net.Socket` 
30 | object is also available as `:socket`, should you need it.
31 | 
32 | To connect and send a message to a remote server `example.com`:
33 | 
34 | ```clojure
35 | (ns user
36 |   (:require [async-sockets.core :refer :all]
37 |             [clojure.core.async :as async]))
38 | 
39 | (let [socket (socket-client "example.com" 12345)]
40 |   (async/>!! (:out socket) "Hello, World")
41 |   (close-socket-client socket))
42 | ```
43 | 
44 | To start an asynchronous socket server, which in this case echoes every input received:
45 | 
46 | ```clojure
47 | (ns user
48 |   (:require [async-sockets.core :refer :all]
49 |             [clojure.core.async :as async]))
50 |    
51 | (defn echo-everything [socket]
52 |   (async/go-loop []
53 |     (when-let [line (async/<! (:in socket))]
54 |       (async/>! (:out socket) (str "ECHO: " line))
55 |       (recur))))
56 |    
57 | (let [server (socket-server 12345)]
58 |   (async/go-loop []
59 |     (when-let [connection (async/<! (:connections server))] 
60 |       (echo-everything connection)
61 |       (recur)))))
62 | ```
63 | 
64 | When the underlying socket closes, each channel will close automatically, both for outgoing (client) and incoming
65 | (server) sockets.
66 | 
67 | ## License
68 | 
69 | Copyright © 2014 Brian Guthrie (btguthrie@gmail.com)
70 | 
71 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
72 | 
73 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
74 | 
75 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


--------------------------------------------------------------------------------
/test/com/gearswithingears/async_sockets_test.clj:
--------------------------------------------------------------------------------
  1 | (ns com.gearswithingears.async-sockets-test
  2 |   (:import  [java.net Socket InetAddress])
  3 |   (:require [clojure.test :refer :all]
  4 |             [clojure.core.async :as async]
  5 |             [clojure.tools.logging :as log]
  6 |             [com.gearswithingears.async-sockets :refer :all]
  7 |             [clj-time.core :as time]))
  8 | 
  9 | (def port (int 55555))
 10 | 
 11 | (deftest test-server-in-out
 12 |   (let [server      (socket-server port)
 13 |         client-sock (socket-client port)
 14 |         server-sock (async/<!! (:connections server))]
 15 | 
 16 |     (try
 17 |       (async/>!! (:out client-sock) "Ping")
 18 |       (is (= "Ping" (async/<!! (:in server-sock))))
 19 | 
 20 |       (async/>!! (:out server-sock) "Pong")
 21 |       (is (= "Pong" (async/<!! (:in client-sock))))
 22 | 
 23 |       (finally
 24 |         (stop-socket-server server)
 25 |         (close-socket-client client-sock)))
 26 |     ))
 27 | 
 28 | (deftest test-server-repeated-messages
 29 |   (let [server      (socket-server port)
 30 |         client-sock (socket-client port)
 31 |         server-sock (async/<!! (:connections server))]
 32 | 
 33 |     (try
 34 |       (async/go
 35 |         (async/>! (:out client-sock) "Ping 1")
 36 |         (async/>! (:out client-sock) "Ping 2")
 37 |         (async/>! (:out client-sock) "Ping 3"))
 38 | 
 39 |       (is (= "Ping 1") (async/<!! (:in server-sock)))
 40 |       (is (= "Ping 2") (async/<!! (:in server-sock)))
 41 |       (is (= "Ping 3") (async/<!! (:in server-sock)))
 42 | 
 43 |       (async/go
 44 |         (async/>! (:out server-sock) "Pong 1")
 45 |         (async/>! (:out server-sock) "Pong 2")
 46 |         (async/>! (:out server-sock) "Pong 3"))
 47 | 
 48 |       (is (= "Pong 1") (async/<!! (:in client-sock)))
 49 |       (is (= "Pong 2") (async/<!! (:in client-sock)))
 50 |       (is (= "Pong 3") (async/<!! (:in client-sock)))
 51 | 
 52 |       (finally
 53 |         (stop-socket-server server)
 54 |         (close-socket-client client-sock)))
 55 |     ))
 56 | 
 57 | (deftest test-echo-server
 58 |   (let [server      (socket-server port)
 59 |         client-sock (socket-client port)
 60 |         server-sock (async/<!! (:connections server))]
 61 | 
 62 |     (try
 63 |       (async/go-loop []
 64 |         (when-let [input (async/<! (:in server-sock))]
 65 |           (async/>! (:out server-sock) (str "ECHO: " input))
 66 |           (recur)))
 67 | 
 68 |       (async/>!! (:out client-sock) "Hello, I'm Guybrush Threepwood")
 69 |       (is (= "ECHO: Hello, I'm Guybrush Threepwood") (async/<!! (:in client-sock)))
 70 | 
 71 |       (finally
 72 |         (stop-socket-server server)
 73 |         (close-socket-client client-sock)))
 74 |     ))
 75 | 
 76 | (defn receive-until-secs-elapsed [limit out-chan socket]
 77 |   (let [start-time (time/now)]
 78 |     (async/go-loop [n 0]
 79 |       (let [secs-elapsed (time/in-seconds (time/interval start-time (time/now)))
 80 |             msg (async/<! (:in socket))]
 81 |         (if (or (nil? msg) (= secs-elapsed limit))
 82 |           (do (close-socket-client socket) (async/>! out-chan n))
 83 |           (recur (inc n)))))))
 84 | 
 85 | (defn send-indefinitely [socket id]
 86 |   (async/go-loop [n 0]
 87 |     (when (= 0 (mod n 100000)) (println "Sent" n "messages on socket" id))
 88 |     (async/>! (:out socket) (str "message " n))
 89 |     (recur (inc n))))
 90 | 
 91 | (defn perftest-sockets [socket-count secs-limit]
 92 |   (let [server        (socket-server port)
 93 |         client-socks  (map socket-client (range socket-count))
 94 |         server-socks  (map (fn [_] (async/<!! (:connections server))) (range socket-count))
 95 |         limit-minutes (/ 60 secs-limit)
 96 |         out-chan      (async/chan socket-count)]
 97 | 
 98 |     (try
 99 | 
100 |       (doall
101 |         (map-indexed
102 |           (fn [idx sock] (send-indefinitely sock idx))
103 |           client-socks))
104 | 
105 |       (doall
106 |         (map (partial receive-until-secs-elapsed secs-limit out-chan) server-socks))
107 | 
108 |       (loop [n 0]
109 |         (when (< n socket-count)
110 |           (let [msgs-received (async/<!! out-chan)
111 |                 msgs-per-minute (* msgs-received limit-minutes)]
112 |             (println (format "Socket %d received %d msgs in %d seconds (%f msgs/minute)" n msgs-received secs-limit (float msgs-per-minute)))
113 |             (recur (inc n)))))
114 | 
115 |       (finally
116 |         (stop-socket-server server)
117 |         (doall (map close-socket-client client-socks))))
118 | 
119 |     ))
120 | 
121 | ;(perftest-sockets 4 10)


--------------------------------------------------------------------------------
/src/com/gearswithingears/async_sockets.clj:
--------------------------------------------------------------------------------
  1 | (ns com.gearswithingears.async-sockets
  2 |   (:require [clojure.java.io :as io]
  3 |             [clojure.core.async :as async]
  4 |             [clojure.tools.logging :as log])
  5 |   (:import  [java.net Socket ServerSocket SocketException InetAddress InetSocketAddress]
  6 |             [java.io BufferedReader BufferedWriter]))
  7 | 
  8 | (def system-newline ;; This is in clojure.core but marked private.
  9 |   (System/getProperty "line.separator"))
 10 | 
 11 | (defn- socket-open? [^Socket socket]
 12 |   (not (or (.isClosed socket) (.isInputShutdown socket) (.isOutputShutdown socket))))
 13 | 
 14 | (defn- socket-read-line-or-nil [^Socket socket ^BufferedReader in]
 15 |   (when (socket-open? socket)
 16 |     (try (.readLine in)
 17 |       (catch SocketException e
 18 |         (log/error e)))))
 19 | 
 20 | (defn- socket-write-line [^Socket socket ^BufferedWriter out line]
 21 |   (if (socket-open? socket)
 22 |     (try
 23 |       (.write out (str line system-newline))
 24 |       (when *flush-on-newline* (.flush out))
 25 |       true
 26 |       (catch SocketException e
 27 |         (log/error e)
 28 |         false))
 29 |     false))
 30 | 
 31 | (defrecord AsyncSocket
 32 |   [^Socket socket ^InetSocketAddress address in-ch out-ch])
 33 | (defrecord AsyncSocketServer
 34 |   [^Integer port ^Integer backlog ^InetAddress bind-addr ^ServerSocket server connections])
 35 | 
 36 | (defn- ^InetAddress localhost []
 37 |   (InetAddress/getLocalHost))
 38 | 
 39 | (defn- host-name [^InetAddress address]
 40 |   (.getHostName address))
 41 | 
 42 | (defn- ^InetAddress inet-address [host]
 43 |   (if (instance? InetAddress host) host (InetAddress/getByName host)))
 44 | 
 45 | (def ^Integer default-server-backlog 50) ;; derived from SocketServer.java
 46 | 
 47 | (defn close-socket-client [{:keys [in out socket address] :as this}]
 48 |   (log/info "Closing async socket on address" address)
 49 |   (when-not (.isInputShutdown socket)  (.shutdownInput socket))
 50 |   (when-not (.isOutputShutdown socket) (.shutdownOutput socket))
 51 |   (when-not (.isClosed socket)         (.close socket))
 52 |   (async/close! in)
 53 |   (async/close! out)
 54 |   (assoc this :socket nil :in nil :out nil))
 55 | 
 56 | (defn- init-async-socket [^Socket socket ^InetSocketAddress address]
 57 |   (let [^BufferedReader in (io/reader socket)
 58 |         ^BufferedWriter out (io/writer socket)
 59 |         in-ch (async/chan)
 60 |         out-ch (async/chan)
 61 |         public-socket (map->AsyncSocket {:socket socket :address address :in in-ch :out out-ch})]
 62 | 
 63 |     (async/go-loop []
 64 |       (let [line (socket-read-line-or-nil socket in)]
 65 |         (if-not line
 66 |           (close-socket-client public-socket)
 67 |           (do
 68 |             (async/>! in-ch line)
 69 |             (recur)))))
 70 | 
 71 |     (async/go-loop []
 72 |       (let [line (and (socket-open? socket) (async/<! out-ch))]
 73 |         (if-not (socket-write-line socket out line)
 74 |           (close-socket-client public-socket)
 75 |           (recur))))
 76 | 
 77 |     (log/info "New async socket opened on address" address)
 78 |     public-socket))
 79 | 
 80 | (defn socket-client
 81 |   "Given a port and an optional address (localhost by default), returns an AsyncSocket which must be explicitly
 82 |    started and stopped by the consumer. Observes value of *flush-on-newline* var for purposes of socket flushing."
 83 |   ([port]
 84 |    (socket-client (int port) (host-name (localhost))))
 85 |   ([^Integer port ^String address]
 86 |    (let [socket (Socket.)
 87 |          address (InetSocketAddress. address port)]
 88 | 
 89 |      (.connect socket address)
 90 |      (init-async-socket socket address))))
 91 | 
 92 | (defn server-running? [{:keys [^ServerSocket server]}]
 93 |   (and server (not (.isClosed server))))
 94 | 
 95 | (defn stop-socket-server [{:keys [^ServerSocket server connections port] :as this}]
 96 |   (when (server-running? this)
 97 |     (log/info "Stopping async socket server on port" port)
 98 |     (async/close! connections)
 99 |     (.close server)
100 |     (assoc this :server nil :connections nil)))
101 | 
102 | (defn socket-server
103 |   "Given a port and optional backlog (the maximum queue length of incoming connection indications, 50 by default)
104 |    and an optional bind address (localhost by default), starts and returns a socket server and a :connections channel
105 |    that yields a new socket client on each connection. Observes value of *flush-on-newline* var for purposes of
106 |    socket flushing."
107 |   ([port]
108 |    (socket-server port default-server-backlog nil))
109 |   ([port backlog]
110 |    (socket-server port backlog nil))
111 |   ([port backlog bind-addr]
112 |    (let [java-server (ServerSocket. port backlog bind-addr)
113 |          conns (async/chan backlog)
114 |          public-server (map->AsyncSocketServer
115 |                          {:port        (int port)
116 |                           :backlog     (int backlog)
117 |                           :bind-addr   (when bind-addr (inet-address bind-addr))
118 |                           :connections conns
119 |                           :server      java-server})]
120 |      (log/info "Starting async socket server on port" port)
121 | 
122 |      (async/go-loop []
123 |        (if (and (not (.isClosed java-server)) (.isBound java-server))
124 |          (try
125 |            (async/>! conns
126 |              (init-async-socket (.accept java-server) (.getLocalSocketAddress java-server)))
127 |            (catch SocketException e
128 |              (log/error e)
129 |              (stop-socket-server public-server)))
130 |          (stop-socket-server public-server)))
131 | 
132 |      public-server)))
133 | 


--------------------------------------------------------------------------------
/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 Washington 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 | 


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