diff --git a/postgres-rds/.gitignore b/postgres-rds/.gitignore new file mode 100644 index 000000000..c53038ec0 --- /dev/null +++ b/postgres-rds/.gitignore @@ -0,0 +1,11 @@ +/target +/classes +/checkouts +pom.xml +pom.xml.asc +*.jar +*.class +/.lein-* +/.nrepl-port +.hgignore +.hg/ diff --git a/postgres-rds/CHANGELOG.md b/postgres-rds/CHANGELOG.md new file mode 100644 index 000000000..102ea7a5c --- /dev/null +++ b/postgres-rds/CHANGELOG.md @@ -0,0 +1,24 @@ +# Change Log +All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/). + +## [Unreleased][unreleased] +### Changed +- Add a new arity to `make-widget-async` to provide a different widget shape. + +## [0.1.1] - 2015-10-12 +### Changed +- Documentation on how to make the widgets. + +### Removed +- `make-widget-sync` - we're all async, all the time. + +### Fixed +- Fixed widget maker to keep working when daylight savings switches over. + +## 0.1.0 - 2015-10-12 +### Added +- Files from the new template. +- Widget maker public API - `make-widget-sync`. + +[unreleased]: https://github.com/your-name/jepsen.postgres-rds/compare/0.1.1...HEAD +[0.1.1]: https://github.com/your-name/jepsen.postgres-rds/compare/0.1.0...0.1.1 diff --git a/postgres-rds/LICENSE b/postgres-rds/LICENSE new file mode 100644 index 000000000..7689f30ef --- /dev/null +++ b/postgres-rds/LICENSE @@ -0,0 +1,214 @@ +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC +LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM +CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +1. DEFINITIONS + +"Contribution" means: + +a) in the case of the initial Contributor, the initial code and +documentation distributed under this Agreement, and + +b) in the case of each subsequent Contributor: + +i) changes to the Program, and + +ii) additions to the Program; + +where such changes and/or additions to the Program originate from and are +distributed by that particular Contributor. A Contribution 'originates' from +a Contributor if it was added to the Program by such Contributor itself or +anyone acting on such Contributor's behalf. Contributions do not include +additions to the Program which: (i) are separate modules of software +distributed in conjunction with the Program under their own license +agreement, and (ii) are not derivative works of the Program. + +"Contributor" means any person or entity that distributes the Program. + +"Licensed Patents" mean patent claims licensable by a Contributor which are +necessarily infringed by the use or sale of its Contribution alone or when +combined with the Program. + +"Program" means the Contributions distributed in accordance with this +Agreement. + +"Recipient" means anyone who receives the Program under this Agreement, +including all Contributors. + +2. GRANT OF RIGHTS + +a) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free copyright license to +reproduce, prepare derivative works of, publicly display, publicly perform, +distribute and sublicense the Contribution of such Contributor, if any, and +such derivative works, in source code and object code form. + +b) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free patent license under +Licensed Patents to make, use, sell, offer to sell, import and otherwise +transfer the Contribution of such Contributor, if any, in source code and +object code form. This patent license shall apply to the combination of the +Contribution and the Program if, at the time the Contribution is added by the +Contributor, such addition of the Contribution causes such combination to be +covered by the Licensed Patents. The patent license shall not apply to any +other combinations which include the Contribution. No hardware per se is +licensed hereunder. + +c) Recipient understands that although each Contributor grants the licenses +to its Contributions set forth herein, no assurances are provided by any +Contributor that the Program does not infringe the patent or other +intellectual property rights of any other entity. Each Contributor disclaims +any liability to Recipient for claims brought by any other entity based on +infringement of intellectual property rights or otherwise. As a condition to +exercising the rights and licenses granted hereunder, each Recipient hereby +assumes sole responsibility to secure any other intellectual property rights +needed, if any. For example, if a third party patent license is required to +allow Recipient to distribute the Program, it is Recipient's responsibility +to acquire that license before distributing the Program. + +d) Each Contributor represents that to its knowledge it has sufficient +copyright rights in its Contribution, if any, to grant the copyright license +set forth in this Agreement. + +3. REQUIREMENTS + +A Contributor may choose to distribute the Program in object code form under +its own license agreement, provided that: + +a) it complies with the terms and conditions of this Agreement; and + +b) its license agreement: + +i) effectively disclaims on behalf of all Contributors all warranties and +conditions, express and implied, including warranties or conditions of title +and non-infringement, and implied warranties or conditions of merchantability +and fitness for a particular purpose; + +ii) effectively excludes on behalf of all Contributors all liability for +damages, including direct, indirect, special, incidental and consequential +damages, such as lost profits; + +iii) states that any provisions which differ from this Agreement are offered +by that Contributor alone and not by any other party; and + +iv) states that source code for the Program is available from such +Contributor, and informs licensees how to obtain it in a reasonable manner on +or through a medium customarily used for software exchange. + +When the Program is made available in source code form: + +a) it must be made available under this Agreement; and + +b) a copy of this Agreement must be included with each copy of the Program. + +Contributors may not remove or alter any copyright notices contained within +the Program. + +Each Contributor must identify itself as the originator of its Contribution, +if any, in a manner that reasonably allows subsequent Recipients to identify +the originator of the Contribution. + +4. COMMERCIAL DISTRIBUTION + +Commercial distributors of software may accept certain responsibilities with +respect to end users, business partners and the like. While this license is +intended to facilitate the commercial use of the Program, the Contributor who +includes the Program in a commercial product offering should do so in a +manner which does not create potential liability for other Contributors. +Therefore, if a Contributor includes the Program in a commercial product +offering, such Contributor ("Commercial Contributor") hereby agrees to defend +and indemnify every other Contributor ("Indemnified Contributor") against any +losses, damages and costs (collectively "Losses") arising from claims, +lawsuits and other legal actions brought by a third party against the +Indemnified Contributor to the extent caused by the acts or omissions of such +Commercial Contributor in connection with its distribution of the Program in +a commercial product offering. The obligations in this section do not apply +to any claims or Losses relating to any actual or alleged intellectual +property infringement. In order to qualify, an Indemnified Contributor must: +a) promptly notify the Commercial Contributor in writing of such claim, and +b) allow the Commercial Contributor tocontrol, and cooperate with the +Commercial Contributor in, the defense and any related settlement +negotiations. The Indemnified Contributor may participate in any such claim +at its own expense. + +For example, a Contributor might include the Program in a commercial product +offering, Product X. That Contributor is then a Commercial Contributor. If +that Commercial Contributor then makes performance claims, or offers +warranties related to Product X, those performance claims and warranties are +such Commercial Contributor's responsibility alone. Under this section, the +Commercial Contributor would have to defend claims against the other +Contributors related to those performance claims and warranties, and if a +court requires any other Contributor to pay any damages as a result, the +Commercial Contributor must pay those damages. + +5. NO WARRANTY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON +AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER +EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR +CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A +PARTICULAR PURPOSE. Each Recipient is solely responsible for determining the +appropriateness of using and distributing the Program and assumes all risks +associated with its exercise of rights under this Agreement , including but +not limited to the risks and costs of program errors, compliance with +applicable laws, damage to or loss of data, programs or equipment, and +unavailability or interruption of operations. + +6. DISCLAIMER OF LIABILITY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY +CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION +LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE +EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY +OF SUCH DAMAGES. + +7. GENERAL + +If any provision of this Agreement is invalid or unenforceable under +applicable law, it shall not affect the validity or enforceability of the +remainder of the terms of this Agreement, and without further action by the +parties hereto, such provision shall be reformed to the minimum extent +necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Program itself +(excluding combinations of the Program with other software or hardware) +infringes such Recipient's patent(s), then such Recipient's rights granted +under Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to +comply with any of the material terms or conditions of this Agreement and +does not cure such failure in a reasonable period of time after becoming +aware of such noncompliance. If all Recipient's rights under this Agreement +terminate, Recipient agrees to cease use and distribution of the Program as +soon as reasonably practicable. However, Recipient's obligations under this +Agreement and any licenses granted by Recipient relating to the Program shall +continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in +order to avoid inconsistency the Agreement is copyrighted and may only be +modified in the following manner. The Agreement Steward reserves the right to +publish new versions (including revisions) of this Agreement from time to +time. No one other than the Agreement Steward has the right to modify this +Agreement. The Eclipse Foundation is the initial Agreement Steward. The +Eclipse Foundation may assign the responsibility to serve as the Agreement +Steward to a suitable separate entity. Each new version of the Agreement will +be given a distinguishing version number. The Program (including +Contributions) may always be distributed subject to the version of the +Agreement under which it was received. In addition, after a new version of +the Agreement is published, Contributor may elect to distribute the Program +(including its Contributions) under the new version. Except as expressly +stated in Sections 2(a) and 2(b) above, Recipient receives no rights or +licenses to the intellectual property of any Contributor under this +Agreement, whether expressly, by implication, estoppel or otherwise. All +rights in the Program not expressly granted under this Agreement are +reserved. + +This Agreement is governed by the laws of the State of New York and the +intellectual property laws of the United States of America. No party to this +Agreement will bring a legal action under this Agreement more than one year +after the cause of action arose. Each party waives its rights to a jury trial +in any resulting litigation. diff --git a/postgres-rds/README.md b/postgres-rds/README.md new file mode 100644 index 000000000..5079a4905 --- /dev/null +++ b/postgres-rds/README.md @@ -0,0 +1,14 @@ +# jepsen.postgres-rds + +A Clojure library designed to ... well, that part is up to you. + +## Usage + +FIXME + +## License + +Copyright © 2015 FIXME + +Distributed under the Eclipse Public License either version 1.0 or (at +your option) any later version. diff --git a/postgres-rds/doc/intro.md b/postgres-rds/doc/intro.md new file mode 100644 index 000000000..7eb28d01f --- /dev/null +++ b/postgres-rds/doc/intro.md @@ -0,0 +1,3 @@ +# Introduction to jepsen.postgres-rds + +TODO: write [great documentation](http://jacobian.org/writing/what-to-write/) diff --git a/postgres-rds/project.clj b/postgres-rds/project.clj new file mode 100644 index 000000000..d64223593 --- /dev/null +++ b/postgres-rds/project.clj @@ -0,0 +1,9 @@ +(defproject jepsen.postgres-rds "0.1.0-SNAPSHOT" + :description "Postgres RDS tests" + :url "http://jepsen.io" + :license {:name "Eclipse Public License" + :url "http://www.eclipse.org/legal/epl-v10.html"} + :dependencies [[org.clojure/clojure "1.7.0"] + [jepsen "0.0.7-SNAPSHOT"] + [org.clojure/java.jdbc "0.4.1"] + [org.postgresql/postgresql "9.4-1204-jdbc42"]]) diff --git a/postgres-rds/src/jepsen/postgres_rds.clj b/postgres-rds/src/jepsen/postgres_rds.clj new file mode 100644 index 000000000..faec5e4c4 --- /dev/null +++ b/postgres-rds/src/jepsen/postgres_rds.clj @@ -0,0 +1,294 @@ +(ns jepsen.postgres-rds + "Tests for Postgres RDS" + (:require [clojure.tools.logging :refer :all] + [clojure.core.reducers :as r] + [clojure.java.io :as io] + [clojure.string :as str] + [clojure.pprint :refer [pprint]] + [knossos.op :as op] + [jepsen [client :as client] + [core :as jepsen] + [db :as db] + [tests :as tests] + [control :as c :refer [|]] + [checker :as checker] + [nemesis :as nemesis] + [generator :as gen] + [util :refer [timeout meh]]] + [jepsen.control.util :as cu] + [jepsen.control.net :as cn] + [jepsen.os.debian :as debian] + [clojure.java.jdbc :as j])) + +(defn open-conn? + "Is this connection open? e.g. does it have a :connection key?" + [conn] + (boolean (:connection conn))) + +(defn open-conn + "Given a JDBC connection spec, opens a new connection unless one already + exists. JDBC represents open connections as a map with a :connection key. + Won't open if a connection is already open." + [spec] + (if (:connection spec) + spec + (j/add-connection spec (j/get-connection spec)))) + +(defn close-conn + "Given a JDBC connection, closes it and returns the underlying spec." + [conn] + (when-let [c (:connection conn)] + (.close c)) + (dissoc conn :connection)) + +(defmacro with-conn + "So here's the deal: we need to hold connections open to re-use them, but we + can't hold them open *forever* or we won't track failovers in stuff like + Postgres RDS. So instead we'll have an atom that can refer to either a + connection *spec*, or a full connection. open-conn and close-conn let us + transform one into the other. This macro takes that atom and binds ai + connection for the duration of its body, automatically reconnecting on any + exception. + + Not re-entrant. Probably full of concurrency bugs. I dunno, this is a gross + hack." + [[conn-sym conn-atom] & body] + `(let [~conn-sym (locking ~conn-atom + (swap! ~conn-atom open-conn))] + (try + ~@body + (catch Throwable t# + ; Reopen + (warn "Lost connection" ~conn-sym ", reconnecting") + (locking ~conn-atom + (swap! ~conn-atom (comp open-conn close-conn))) + (throw t#))))) + +(def galera-rollback-msg + "mariadb drivers have a few exception classes that use this message" + "Deadlock found when trying to get lock; try restarting transaction") + +(defmacro capture-txn-abort + "Converts aborted transactions to an ::abort keyword" + [& body] + `(try ~@body + ; Galera + (catch java.sql.SQLTransactionRollbackException e# + (if (= (.getMessage e#) galera-rollback-msg) + ::abort + (throw e#))) + (catch java.sql.BatchUpdateException e# + (let [m# (.getMessage e#)] + (cond ; Galera + (= m# galera-rollback-msg) + ::abort + + ; Postgres + (re-find #"Batch entry .+ was aborted" m#) + ::abort + + true + (throw e#)))))) + +(defmacro with-txn-retries + "Retries body on rollbacks." + [& body] + `(loop [] + (let [res# (capture-txn-abort ~@body)] + (if (= ::abort res#) + (recur) + res#)))) + +(defmacro with-txn-aborts + "Aborts body on rollbacks." + [op & body] + `(let [res# (capture-txn-abort ~@body)] + (if (= ::abort res#) + (assoc ~op :type :fail) + res#))) + +(defmacro with-error-handling + "Common error handling for Galera errors" + [op & body] + `(try ~@body + ; MariaDB + (catch java.sql.SQLNonTransientConnectionException e# + (condp = (.getMessage e#) + "WSREP has not yet prepared node for application use" + (assoc ~op :type :fail, :value (.getMessage e#)) + + (throw e#))))) + +(defmacro with-txn + "Executes body in a transaction, with a timeout, automatically retrying + conflicts and handling common errors." + [op [c conn-atom] & body] + `(timeout 5000 (assoc ~op :type :info, :value :timed-out) + (with-conn [c# ~conn-atom] + (j/with-db-transaction [~c c# :isolation :serializable] + (with-error-handling ~op + (with-txn-retries + ~@body)))))) + +(defrecord BankClient [conn-spec + conn + node + n + starting-balance + lock-type + in-place?] + client/Client + (setup! [this test node] + (let [conn (atom (conn-spec node))] + (with-conn [c conn] + ; Create table + (j/execute! c ["create table if not exists accounts + (id int not null primary key, + balance bigint not null)"]) + + ; Create initial accts + (dotimes [i n] + (try + (with-txn-retries + (j/insert! c :accounts {:id i, :balance starting-balance})) + (catch java.sql.SQLIntegrityConstraintViolationException e nil) + (catch org.postgresql.util.PSQLException e + (if (re-find #"duplicate key value violates unique constraint" + (.getMessage e)) + nil + (throw e))))))) + + (assoc this :node node, :conn (atom (conn-spec node)))) + + (invoke! [this test op] + (with-txn op [c conn] + (try + (case (:f op) + :read (->> (j/query c [(str "select * from accounts" lock-type)]) + (mapv :balance) + (assoc op :type :ok, :value)) + + :transfer + (let [{:keys [from to amount]} (:value op) + b1 (-> c + (j/query [(str "select * from accounts where id = ?" + lock-type) + from] + :row-fn :balance) + first + (- amount)) + b2 (-> c + (j/query [(str "select * from accounts where id = ?" + lock-type) + to] + :row-fn :balance) + first + (+ amount))] + (cond (neg? b1) + (assoc op :type :fail, :value [:negative from b1]) + + (neg? b2) + (assoc op :type :fail, :value [:negative to b2]) + + true + (if in-place? + (do (j/execute! c ["update accounts set balance = balance - ? where id = ?" amount from]) + (j/execute! c ["update accounts set balance = balance + ? where id = ?" amount to]) + (assoc op :type :ok)) + (do (j/update! c :accounts {:balance b1} ["id = ?" from]) + (j/update! c :accounts {:balance b2} ["id = ?" to]) + (assoc op :type :ok))))))))) + + (teardown! [_ test])) + +(defn bank-client + "Simulates bank account transfers between n accounts, each starting with + starting-balance." + [conn-spec n starting-balance lock-type in-place?] + (map->BankClient {:conn-spec conn-spec + :n n + :starting-balance starting-balance + :lock-type lock-type + :in-place? in-place?})) + +(defn bank-read + "Reads the current state of all accounts without any synchronization." + [_ _] + {:type :invoke, :f :read}) + +(defn bank-transfer + "Transfers a random amount between two randomly selected accounts." + [test process] + (let [n (-> test :client :n)] + {:type :invoke + :f :transfer + :value {:from (rand-int n) + :to (rand-int n) + :amount (rand-int 5)}})) + +(def bank-diff-transfer + "Like transfer, but only transfers between *different* accounts." + (gen/filter (fn [op] (not= (-> op :value :from) + (-> op :value :to))) + bank-transfer)) + +(defn bank-checker + "Balances must all be non-negative and sum to the model's total." + [] + (reify checker/Checker + (check [this test model history] + (let [bad-reads (->> history + (r/filter op/ok?) + (r/filter #(= :read (:f %))) + (r/map (fn [op] + (let [balances (:value op)] + (cond (not= (:n model) (count balances)) + {:type :wrong-n + :expected (:n model) + :found (count balances) + :op op} + + (not= (:total model) + (reduce + balances)) + {:type :wrong-total + :expected (:total model) + :found (reduce + balances) + :op op})))) + (r/filter identity) + (into []))] + {:valid? (empty? bad-reads) + :bad-reads bad-reads})))) + +(defn basic-test + [opts] + (merge tests/noop-test + {:name (str "postgres rds " (:name opts)) + :nodes []} + (dissoc opts :name))) + +(defn bank-test + [node n initial-balance lock-type in-place?] + (basic-test + {:name "bank" + :concurrency 10 + :model {:n n :total (* n initial-balance)} + :client (bank-client (fn conn-spec [_] + ; We ignore the nodes here and just use the AWS node + {:classname "org.postgresql.Driver" + :subprotocol "postgresql" + :subname (str "//" (name node) ":5432/jepsen") + :user "jepsen" + :password "jepsenpw"}) + n initial-balance lock-type in-place?) + :generator (gen/phases + (->> (gen/mix [bank-read bank-diff-transfer]) + (gen/clients) + (gen/stagger 1/10) + (gen/time-limit 20)) + (gen/log "waiting for quiescence") + (gen/sleep 10) + (gen/clients (gen/once bank-read))) + :nemesis nemesis/noop + :checker (checker/compose + {:perf (checker/perf) + :bank (bank-checker)})})) diff --git a/postgres-rds/test/jepsen/postgres_rds_test.clj b/postgres-rds/test/jepsen/postgres_rds_test.clj new file mode 100644 index 000000000..bde7e3926 --- /dev/null +++ b/postgres-rds/test/jepsen/postgres_rds_test.clj @@ -0,0 +1,14 @@ +(ns jepsen.postgres-rds-test + (:require [clojure.test :refer :all] + [jepsen.core :as jepsen] + [jepsen.postgres-rds :refer [bank-test]])) + +(def node "jepsen.ciudayaehbts.us-west-2.rds.amazonaws.com") + +(deftest bank-test' + (is (:valid? (:results (jepsen/run! (bank-test + node + 2 + 10 + "" + false))))))