GithubHelp home page GithubHelp logo

guniorobot / fuzed Goto Github PK

View Code? Open in Web Editor NEW

This project forked from kirindave/fuzed

1.0 2.0 0.0 1.14 MB

A new revision of Fuzed, the Erlang-based frontend for web apps. Check out the mailing list at http://groups.google.com/group/fuzed

License: Other

Ruby 49.06% Erlang 43.76% JavaScript 7.18%

fuzed's Introduction

fuzed
    by Dave Fayram        <dfayram at powerset dot com>,
       Tom Preston-Werner <tom at powerset dot com>,
       Abhay Kumar        <abhay at powerset dot com>
       
    Webiste:      http://fuzed.rubyforge.org
    Mailing List: http://groups.google.com/group/fuzed

== Summary

Fuzed is an Erlang-based clustering system designed to let several
single-threaded processes (which may or may not be reliable) form 
into a pool which can serve requests to remote hosts. These resources
need not be homogeneous, Fuzed breaks them up into homogeneous pools
internally and serves out requests without "crossing the streams"
of different software/versions of software.

This is a release of Powerset's internal clustering software which
has been adapted for use with Rails, but see the generic_json_responder
to see exactly how it is used internally.


== Dependencies

* Erlang: http://www.erlang.org (>= 5.6.1)
* Ruby: http://www.ruby-lang.org (>= 1.8.6)
* Ruby Gems: 
  * rake: http://rake.rubyforge.org (>= 0.8.1)
  * rack: http://rack.rubyforge.org (>= 0.3.0)
  * erlectricity: http://github.com/mojombo/erlectricity (>= 0.2.1)

== Installation

Fuzed is currently only available as a source distribution. A gem will be made
available shortly.

First, clone the source repo from GitHub. The following command will clone the
repo into a directory named 'fuzed' within your current working directory.

$ git clone git://github.com/KirinDave/fuzed.git

Move into the 'fuzed' directory and run the following commands to build fuzed:

$ cd fuzed
$ git submodule init
$ git submodule update
$ rake build_deps
$ rake

You should not see any error messages if the build was successful.

Whenever additional dependencies added, you'll need to run init and update again.

== Setting up a simple Rails cluster on a single machine

Every cluster starts with a 'master' node. From the fuzed root directory, run
the following to start a master. The command will drop you into interactive
mode for the Erlang runtime. It's best to work this way while you familiarize
yourself with the system as it will be easier to see any error messages that
reported.

$ bin/fuzed start -n [email protected]

Replace 'volcano.local' with your hostname. Note: 'localhost' will not work
here, it must be an externally addressable hostname. It's best to always name
your master node 'master'. It makes setting up frontend and backend nodes much
easier.

Next, start and attach a Rails 'frontend' node. This will bind to a TCP port
(default 8080) and serve static assets as well as direct dynamic requests to
your Rails node.

$ bin/fuzed frontend -z volcano.local -r test/app/public -s 'kind=rails' \
  -n [email protected]

Let's break this command down so you understand what each option specifies. -z
denotes the hostname of the master (must match what you used in your `fuzed
start` command. -r specifies the document root for static assets. -s specifies
a details list that will select the proper backend node. For a simple cluster,
leave this alone. -n names the node. Every node that joins a cluster must be
uniquely named. Here I've named it after the port that will be bound. Because
this is a single machine cluster, I use the same hostname as the master. In a
multi-machine setup, you will specify the hostname of the machine that is
running the node.

You should now be able to request a static asset from your cluster. Try
requesting:

http://localhost:8080/robots.txt

Now we'll need a 'rails' node to serve dynamic requests. The following command
will start a single Rails node.

$ bin/fuzed rails -z volcano.local --rails-root=test/app -n [email protected]

Once again -z specifies the master hostname. --rails-root must point to the
Rails root of your app. -n names the node.

At this point, if all is well, you will have a fully assembled and operational
Rails cluster!

fuzed's People

Contributors

mojombo avatar kirindave avatar abhay avatar a-ok avatar dje avatar ggodet-bar avatar

Stargazers

Gun.io Robot avatar

Watchers

Gun.io Robot avatar  avatar

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. ๐Ÿ“Š๐Ÿ“ˆ๐ŸŽ‰

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.