raft/raft.github.io

website at https://raft.github.io

raft.github.io's Issues

add video of BuildStuff talk

http://www.infoq.com/presentations/raft-consensus-algorithm

link to Jon Gjengset's posts

https://thesquareplanet.com/blog/instructors-guide-to-raft/ and students'

New Go implementation

We recently published a new implementation available here::
https://github.com/hashicorp/raft

Webpage not displaying changes in index.html

I've added a new implementation of raft and updated index.html.
However, the website(raft.github.io) is still displaying the outdated one.

A new full implementation

Based on the TLA+ spec, I implemented a java version of implementation, it supports, Leader Election + Log Replication, Configuration change and Log Compaction.

It could be found at https://github.com/andy-yx-chen/jraft

Name: jraft

License: Apache2

Thanks!

Update repo link to .NEXT Raft implementation

.NEXT Raft has been moved to .NET Foundation organization. Could you please fix the repo location of this implementation?

Old location visible at raft.github.io: https://github.com/sakno/dotNext
New location: https://github.com/dotnet/dotNext

Thanks in advance!

add UW course

https://courses.cs.washington.edu/courses/cse452/16wi/calendar/calendar.html

Error in Figure 2 description?

The description for figure 2 in https://raft.github.io/raft.pdf reads;

"A condensed summary of the Raft consensus algorithm (excluding membership changes and log compaction). The server
behavior in the upper-left box is described as a set of rules that trigger independently and repeatedly."

The second sentence confused me momentarily. I believe it should refer to the "lower-right box" as it does in the original dissertation PDF.

Please update implementation references to reflect their feature updates

I was going through a couple of implementations and to my novice eye, it felt that py-raft by Toby Buress at least conforms to the Leader Election + Log Replication property. They also had an implementation of member changes which I could not really understand. Someone well versed in python and raft should be able to do a quick review of the row.

It'll be great if experts took a look at existing references and update their feature columns in addition to adding references since this github io page is a major reference when someone looks up raft.

Add https://github.com/hortonworks/concur implementation

question about raft implementations

Why is the raft implementation not sorted by the number of GitHub stars count？

`fetch_repo_info.py` should note if repo is archived

new lite-raft link

I moved my raft implementation from google code to github
https://github.com/nackstein/lite-raft

bye!

NuRaft: a new open source C++ Raft core implementation

Hi All,
eBay has released NuRaft, a lightweight C++ Raft Core implementation, under Apache 2.0 license. It was derived from cornerstone C++ Raft, and the primary author is Jung-Sang Ahn.
eBay/NuRaft, Jung-Sang Ahn, C++, Apache 2.0, Yes, Yes, Yes.

Thanks,
Gene

copy Raft paper into this repo

The raft.pdf file should have bookmarks to navigate easier

I am NOT talking about the TOC in the content of the paper, but the metadata of the PDF.
When opening a book in PDF format, we should see something like below.

Raft implementation in Omnet++

In the past months me and a colleague Leonardo Ruzza have worked on an implementation of Raft in Omnet++.

Our main goal was to provide a handy tool to simulate the protocol in action without the need to build a real distributed environment. We think this can be very useful both to understand the protocol functioning and to have a first preview of how a real network of machines using the protocol would behave.
Our repo is private at the moment, but I would like to ask If it can be of use for someone and so made it public; also, it would be an honor to be added to the implementation list.

Edoardo Venir
Leonardo Ruzza

add Juno?

https://github.com/buckie/juno

Advanced Networking in CS @ Saint Louis University is teaching RAFT

Dear all,

In my graduate course "Advanced Networking" in the Department of Computer Science at Saint Louis University I teach Raft.

This is the link for the course:
Link

question about raft visualization

S2 is voted as leader，but its last log never commit。
In the 5th term, S5 is leader. A new request comes from client, S5 do its leader job and commit this entry finally, but this commit request from S5 does not reach S2. At the time, S3 start a new leader election because of time out, but S3 fail to be leader, and the group enter to term 6. After a litter time, S5 time out, and start a new leader with term 7, the propose request contain last log info, whose index is the uncommitted log index. Is that right? finally, S5 become leader

add meatcompute implementation

https://github.com/meatcompute/raft-consensus

Randomization in Electing Leaders

Since Raft uses randomized timers to elect leaders, how can one ensure that the randomization is sufficient random?

How can one ensure that randomization in Raft is not based on pseudo random generator? (Flaw, Deliberate design -- backdoor)

Thank you.

Nathan Aw

a new issue

add kudu implementation

Please, add .NET implementation into raft.github.io

Raft.Net

'eraft' project discontinued

Should probably remove 'eraft' implementation from list:

https://github.com/djui/eraft

The project page says: "Please use ZRaft Lib; the implementation below is incomplete and discontinued."

Courses teaching Raft

University Name: San Jose State University https://msse.sjsu.edu/enterprise-software-technologies
Course Name:CMPE 275 Enterprise Application Development https://msse.sjsu.edu/enterprise-software-technologies Spring 2015
Professor: John Gash https://cmpe.sjsu.edu/profile/john-gash
Details: Includes project to make Distributed file system using RAFT Algorithm for Fault tolerance, log replication and consistency
Project URL: https://github.com/deepmehtait/Distributed-file-system-server-with-RAFT

Another course teaching Raft

University of California, Davis
ECS 265, Distributed Database Systems
Mohammad Sadoghi
Fall 2018
Included the Raft paper as class presentation material.

New Course teaching Raft

Greetings,

The course Distributed Systems at Politecnico of Milano by Gianpaolo Cugola has lectures on Raft.

I'll leave the link to the course information below, but it does not explicity talk about Raft, it is taught under Agreement.

Link

New course teaching RAFT at IIT Bombay

https://www.cse.iitb.ac.in/page134?course=CS+744
https://www.cse.iitb.ac.in/~mythili/os/

This an active course (CS744) here at IITB which teaches RAFT.

New course using raft at UCSD

Hi all,

I've adopted what I would say is a simplified version of Raft at UCSD. I'm teaching a 10-week undergrad networked software course, and include a strong leader, 2-phase commit, and a replicated log. I don't include leader election, but do point those students wishing to go deeper to the Raft paper. Thought it might be of interest to you.

University Name: UC San Diego http://www.cs.ucsd.edu
Course Name: CSE 124: Networked Services http://www.cs.ucsd.edu/~gmporter/classes/fa17/cse124/
Fall 2017
Professor: George Porter http://www.ucsd.edu/~gmporter
Details: Replicated logs, 2PC, strong leader, but no leader election/failure. Project involves building a distributed DropBox-like file storage system called "SurfStore"
Project URL: http://cseweb.ucsd.edu/~gmporter/classes/fa17/cse124/post/project2/

add 15below implementation

add TikV implementation

https://github.com/pingcap/tikv

add Conflux

https://twitter.com/_benng/status/694193253831184386
https://github.com/ben-ng/conflux

A fast Go Raft implementation capable of 10 million IO per second

I just released a new multi-group Raft library in Go named Dragonboat. It is released under the Apache 2 license and available at https://github.com/lni/dragonboat

Could you please add this library to your raft implementation list? Thanks!

It cover almost all features described in the Raft thesis -

• leader election and log replication
• membership change
• log compaction and snapshotting
• ReadIndex based read-only queries
• Leadership transfer
• Non-voting members
• Node quiesce mode
• Client session feature described in the section 6.3 of the Raft PhD thesis.

It is also the fastest open source Raft implementation on github.com, when tested with medium range hardware (3 x 22 cores Xeon servers running at 2.8GHz, each with NVME SSDs) -

• 9 million proposals per second when using 48 Raft groups
• 10 million mixed read/write requests per second at 9:1 read-write ratio

More details are available at https://github.com/lni/dragonboat

New Python implementation

Hi!

My friend Nicola and I just published our Python implementation.
Pls, add our Vesper project to the website list.

Best,
Peng