fab

README

Fab.io

Fab.io is a lightweight real-time game backend framework written in Go (Golang).

• MVC Pattern
• Synchronized Loop Based Actor Model
• Powered by socket.io re

Table of Contents

• Getting Started
  • Prerequisites
  • Installation
• Usage
• Resources
• Dependencies
• Roadmap
• License

Getting Started

Prerequisites

To install Fab.io package, you will need to:

1. Have Go installed. Head over to Go's download page here to install it.
2. Setup your Go workspace.

Installation

1. Install Fab.io

$ go get -u github.com/kooinam/fabio

1. Import it in your code:

import (
	fab "github.com/kooinam/fabio"
)

Usage

Example - (Simple JavaScript Chatroom App):

In our first example, we start by creating an simple JavaScript chatroom application which will be connecting to backend services using Fab.io.

Setting up your workspace:

1. Create an empty directory. In this example we shall use fabio-chat-demo:

$ mkdir fabio-chat-demo
$ cd fabio-chat-demo

1. Create an empty directory demo inside fabio-chat-demo to hold our Javascript application codes.

$ mkdir demo

1. Create an HTML file chat.html in the demo folder and copy the snippet content over into chat.html.

Setting up backend services:

Now, let's proceed to setup our backend services.

1. Use the go mod command to manage our package dependencies. Let's go ahead and initialize our package dependencies:

$ go mod init fabio-chat-demo

1. Install Fab.io.

$ go get -u github.com/kooinam/fabio

1. Create an empty directory controllers inside fabio-chat-demo to hold our controllers. A controller is responsible for handling any request and producing the appropriate output. Every controller should implement two functions RegisterBeforeHooks and RegisterActions.

$ mkdir controllers

1. Create an go file chat_controller.go in controllers folder. Put the following snippet content into chat_controller.go.

package controllers

import (
	fab "github.com/kooinam/fabio"
	"github.com/kooinam/fabio/controllers"
)

// ChatController used for chat purposes
type ChatController struct {
}

// RegisterHooksAndActions used to register hooks and actions
func (controller *ChatController) RegisterHooksAndActions(hooksHandler *controllers.HooksHandler, actionsHandler *controllers.ActionsHandler) {
	actionsHandler.RegisterAction("Join", controller.join)
	actionsHandler.RegisterAction("Message", controller.message)
}

// join used for player to join a room
func (controller *ChatController) join(context *controllers.Context) (interface{}, error) {
	var err error
	roomID := context.ParamsStr("roomID")

	// leave all previously joined rooms, and join new room
	context.SingleJoin(roomID)

	return nil, err
}

// message used for player to send message message to room
func (controller *ChatController) message(context *controllers.Context) (interface{}, error) {
	var err error
	roomID := context.ParamsStr("roomID")
	message := context.ParamsStr("message")

	// broadcast message to room
	fab.ControllerManager().BroadcastEvent("chat", roomID, "Message", nil, helpers.H{
		"message": message,
	})

	return nil, err
}

1. Lastly, create main.go in root directory and put the following snippet content into main.go.

package main

import (
	"fabio-chat-demo/controllers"
	"net/http"

	fab "github.com/kooinam/fabio"
)

func main() {
	fab.Setup()

	fab.ControllerManager().RegisterController("chat", &controllers.ChatController{})

	fab.ControllerManager().Serve("8000", func() {
		fs := http.FileServer(http.Dir("./demo"))
		http.Handle("/demo/", http.StripPrefix("/demo/", fs))
	})
}

You are done!

Congrats! Now all that's left to do is run the app!

1. Start our application by running:

go run main.go

1. Navigate to http://localhost:8000/demo/chat.html on your browser to see your chatroom application in action!

Interested on other use cases?

Expore more example use cases by reading our Wiki!

Resources

• Wiki
• https://github.com/kooinam/fabio-chat-demo - An simple chatroom demo with demonstrations of using routings and controllers.
• https://github.com/kooinam/fabio-demo - An simple tic-tac-toe demo with demonstrations of an MVC pattern architecture.

Dependencies

Package	Link
go-socket.io	github.com/googollee/go-socket.io

Roadmap

Some of our upcoming key feature(s)/improvement(s) include:

• Write MORE Tests
• Tutorials and Documentations
• Containerize Solutions
• Distributed Solutions
• Graceful Shutdown
• Actor Model

License

Distributed under the MIT License.

Documentation

Index

• func ActorManager() *actors.Manager
• func ControllerManager() *controllers.Manager
• func ModelManager() *models.Manager
• func Setup()
• type Engine

Functions

func ActorManager

func ActorManager() *actors.Manager

ActorManager used to retrieve actor manager

func ControllerManager

func ControllerManager() *controllers.Manager

ControllerManager used to retrieve controller manager

func ModelManager

func ModelManager() *models.Manager

ModelManager used to retrieve model manager

func Setup

func Setup()

Setup used to setup engine

Types

type Engine

type Engine struct {
	// contains filtered or unexported fields
}

Engine is the core engine for fab.io