コード例 #1
0
ファイル: main.go プロジェクト: gnidan/foodtastechess
func main() {
	log = logger.Log("main")

	app = NewApp()

	log.Notice("Hello!")

	log.Notice("Loading Directory")
	err := app.LoadServices()
	if err != nil {
		log.Fatalf("Could not load directory")
	}

	log.Notice("Starting foodtastechess")
	app.Start()

	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt, syscall.SIGTERM)

	for {
		select {
		case <-app.StopChan:
			log.Notice("Quitting.")
			return
		case <-c:
			fmt.Println("")
			app.Stop()
		}
	}
}
コード例 #2
0
ファイル: buffer.go プロジェクト: gnidan/foodtastechess
func NewQueryBuffer() events.EventSubscriber {
	buffer := new(QueryBuffer)
	buffer.log = logger.Log("querybuffer")
	buffer.queries = make(chan Query, 100)
	buffer.stopChan = make(chan bool, 1)
	return buffer
}
コード例 #3
0
ファイル: events_test.go プロジェクト: gnidan/foodtastechess
func (suite *EventsTestSuite) SetupTest() {
	suite.InitTestConfig()
	suite.log = logger.Log("events_test")

	var (
		d          directory.Directory
		events     *EventsService
		subscriber *MockSubscriber
	)

	events = NewEvents().(*EventsService)
	subscriber = newMockSubscriber().(*MockSubscriber)

	d = directory.New()
	d.AddService("configProvider", suite.ConfigProvider)
	d.AddService("eventSubscriber", subscriber)
	d.AddService("events", events)

	if err := d.Start(); err != nil {
		suite.log.Fatalf("Could not start directory: %v", err)
	}

	suite.events = events
	suite.mockSubscriber = subscriber

	suite.events.ResetTestDB()
}
コード例 #4
0
ファイル: client_test.go プロジェクト: gnidan/foodtastechess
// SetupTest prepares the test suite for running by making a fake system
// query service, providing it to a real client query service (the one we
// are testing)
func (suite *ClientQueriesTestSuite) SetupTest() {
	suite.log = logger.Log("client_test")
	var (
		d directory.Directory

		systemQueries MockSystemQueries
		clientQueries ClientQueryService
		mockUsers     MockUsers
	)

	systemQueries.complete = true

	// Set up a directory with:
	//  - A real ClientQueryService (The one we are testing)
	//  - The mocked SystemQueries implementation
	d = directory.New()
	d.AddService("clientQueries", &clientQueries)
	d.AddService("systemQueries", &systemQueries)
	d.AddService("users", &mockUsers)

	// Populate the directory so that clientQueries knows to use our mocked
	// systemQueries
	if err := d.Start(); err != nil {
		suite.log.Fatalf("Could not start directory (%v)", err)
	}

	// Store references for use in tests
	suite.mockSystemQueries = &systemQueries
	suite.clientQueries = &clientQueries
	suite.mockUsers = &mockUsers
}
コード例 #5
0
ファイル: queries_test.go プロジェクト: gnidan/foodtastechess
func (suite *QueryTestSuite) SetupTest() {
	suite.log = logger.Log("queries_test")

	var (
		d              directory.Directory
		systemQueries  MockSystemQueries
		gameCalculator MockGameCalculator
		events         MockEventsService
		queriesCache   MockQueriesCache
	)

	d = directory.New()
	suite.InitTestConfig()
	d.AddService("configProvider", suite.ConfigProvider)
	d.AddService("systemQueries", &systemQueries)
	d.AddService("gameCalculator", &gameCalculator)
	d.AddService("eventsService", &events)
	d.AddService("queriesCache", &queriesCache)

	if err := d.Start(); err != nil {
		suite.log.Fatalf("Could not start directory: %v", err)
	}

	suite.mockSystemQueries = &systemQueries
	suite.mockGameCalculator = &gameCalculator
	suite.mockEvents = &events
	suite.mockQueriesCache = &queriesCache
}
コード例 #6
0
ファイル: config.go プロジェクト: gnidan/foodtastechess
func (cfg *viperProvider) initLogging() {
	var C logger.LoggerConfig
	err := viper.MarshalKey("logger", &C)
	if err != nil {
		panic(fmt.Errorf("Can't parse: %s \n", err))
	}

	logger.InitLog(C)

	cfg.log = logger.Log("config")
}
コード例 #7
0
ファイル: cache_test.go プロジェクト: gnidan/foodtastechess
func (suite *QueriesCacheTestSuite) SetupTest() {
	suite.InitTestConfig()
	suite.log = logger.Log("cache_test")

	var (
		d     directory.Directory
		cache *queriesCache
	)

	cache = NewQueriesCache().(*queriesCache)

	d = directory.New()
	d.AddService("configProvider", suite.ConfigProvider)
	d.AddService("queriesCache", cache)

	if err := d.Start(); err != nil {
		suite.log.Fatalf("Could not start directory: %v", err)
	}

	suite.cache = cache
	suite.cache.collection.Remove(map[string]string{})
}
コード例 #8
0
ファイル: auth.go プロジェクト: gnidan/foodtastechess
import (
	"errors"
	"fmt"
	"github.com/gorilla/context"
	"github.com/markbates/goth"
	"github.com/markbates/goth/providers/gplus"
	"net/http"
	"net/url"

	"foodtastechess/config"
	"foodtastechess/logger"
	sess "foodtastechess/server/session"
	"foodtastechess/users"
)

var log = logger.Log("auth")

type Authentication interface {
	LoginRequired(res http.ResponseWriter, req *http.Request, next http.HandlerFunc)
}

type authService struct {
	Config        config.AuthConfig    `inject:"authConfig"`
	SessionConfig config.SessionConfig `inject:"sessionConfig"`
	Users         users.Users          `inject:"users"`

	provider goth.Provider
}

func New() Authentication {
	return new(authService)
コード例 #9
0
ファイル: api.go プロジェクト: gnidan/foodtastechess
import (
	"fmt"
	"github.com/ant0ine/go-json-rest/rest"
	"math/rand"
	"net/http"
	"strconv"

	"foodtastechess/commands"
	"foodtastechess/game"
	"foodtastechess/logger"
	"foodtastechess/queries"
	"foodtastechess/users"
)

var log = logger.Log("chessApi")

type ChessApi struct {
	Queries  queries.ClientQueries `inject:"clientQueries"`
	Commands commands.Commands     `inject:"commands"`

	restApi *rest.Api
}

func New() *ChessApi {
	return new(ChessApi)
}

func (api *ChessApi) PostPopulate() error {
	restApi := rest.NewApi()
	restApi.Use(
コード例 #10
0
ファイル: directory.go プロジェクト: gnidan/foodtastechess
package directory

import (
	"errors"
	"fmt"

	"foodtastechess/logger"
)

var log = logger.Log("directory")

type Directory interface {
	AddService(name string, object interface{}) error
	Start(names ...string) error
	Stop(names ...string) error
}

func New() Directory {
	directory := new(graphDirectory)

	directory.graph = newGraph()
	directory.services = make(map[string]lifecycleService)
	directory.populated = false

	return directory
}

type Provider func(name string, value interface{}) error

type graphDirectory struct {
	graph     graph
コード例 #11
0
ファイル: main_test.go プロジェクト: gnidan/foodtastechess
func (suite *IntegrationTestSuite) SetupTest() {
	configProvider := config.NewConfigProvider("testconfig", "./")

	suite.log = logger.Log("integration_test")

	suite.Commands = commands.New()
	suite.Queries = queries.NewClientQueryService()

	systemQueries := queries.NewSystemQueryService().(*queries.SystemQueryService)
	eventsService := events.NewEvents().(*events.EventsService)
	usersService := users.NewUsers().(*users.UsersService)

	d := directory.New()
	d.AddService("configProvider", configProvider)
	d.AddService("gameCalculator", game.NewGameCalculator())
	d.AddService("eventSubscriber", queries.NewQueryBuffer())

	d.AddService("systemQueries", systemQueries)
	d.AddService("events", eventsService)
	d.AddService("users", usersService)

	d.AddService("commands", suite.Commands)
	d.AddService("clientQueries", suite.Queries)

	err := d.Start()
	if err != nil {
		suite.log.Fatalf("Could not start directory: %v", err)
	}

	err = d.Start("eventSubscriber")
	if err != nil {
		msg := fmt.Sprintf("Could not start event subscriber: %v", err)
		log.Error(msg)
		return
	}

	usersService.ResetTestDB()
	eventsService.ResetTestDB()
	systemQueries.Cache.Flush()

	time.Sleep(1 * time.Second)

	white := users.User{
		Uuid:           users.NewId(),
		Name:           "whitePlayer",
		AuthIdentifier: "whiteAuthId",
	}
	usersService.Save(&white)

	black := users.User{
		Uuid:           users.NewId(),
		Name:           "blackPlayer",
		AuthIdentifier: "blackAuthId",
	}
	usersService.Save(&black)

	suite.log.Info("white UUID: %s", white.Uuid)
	suite.log.Info("black UUID: %s", black.Uuid)
	suite.whiteId = white.Uuid
	suite.blackId = black.Uuid
}
コード例 #12
0
ファイル: fixtures.go プロジェクト: gnidan/foodtastechess
package fixtures

import (
	"github.com/op/go-logging"
	"math/rand"
	"time"

	"foodtastechess/events"
	"foodtastechess/game"
	"foodtastechess/logger"
	"foodtastechess/queries"
	"foodtastechess/users"
)

var log *logging.Logger = logger.Log("fixtures")

type Fixtures struct {
	Events  events.Events         `inject:"events"`
	Users   users.Users           `inject:"users"`
	Queries queries.ClientQueries `inject:"clientQueries"`
}

func NewFixtures() *Fixtures {
	return new(Fixtures)
}

func (f *Fixtures) Start() error {
	log.Info("Resetting events")
	eventsService := f.Events.(*events.EventsService)
	eventsService.ResetTestDB()
コード例 #13
0
ファイル: client.go プロジェクト: gnidan/foodtastechess
func NewClientQueryService() *ClientQueryService {
	cqs := new(ClientQueryService)
	cqs.log = logger.Log("clientqueries")
	return cqs
}
コード例 #14
0
ファイル: server.go プロジェクト: gnidan/foodtastechess
	"github.com/codegangsta/negroni"
	"github.com/rs/cors"
	"gopkg.in/tylerb/graceful.v1"
	"net"
	"net/http"
	"time"

	"foodtastechess/config"
	"foodtastechess/directory"
	"foodtastechess/logger"
	"foodtastechess/server/api"
	"foodtastechess/server/auth"
)

var (
	log = logger.Log("server")
)

type Server struct {
	server   *graceful.Server
	Api      *api.ChessApi       `inject:"chessApi"`
	Auth     auth.Authentication `inject:"auth"`
	Config   config.ServerConfig `inject:"serverConfig"`
	StopChan chan bool           `inject:"stopChan"`
}

func New() *Server {
	return new(Server)
}

func (s *Server) PreProvide(provide directory.Provider) error {
コード例 #15
0
ファイル: queries.go プロジェクト: gnidan/foodtastechess
package queries

import (
	"time"

	"foodtastechess/game"
	"foodtastechess/logger"
	"foodtastechess/users"
)

var log = logger.Log("queries")

type Query interface {
	hasResult() bool
	getResult() interface{}

	getDependentQueries() []Query
	computeResult(sqs SystemQueries)

	isExpired(now interface{}) bool
	getExpiration(now interface{}) interface{}

	hash() string
}

type queryRecord struct {
	Hash       string
	ComputedAt time.Time
}

func GameQuery(id game.Id) Query {
コード例 #16
0
ファイル: events.go プロジェクト: gnidan/foodtastechess
func NewEvents() Events {
	service := new(EventsService)
	service.log = logger.Log("events")
	service.gameIdChan = make(chan game.Id, 1)
	return service
}
コード例 #17
0
ファイル: user.go プロジェクト: gnidan/foodtastechess
package users

import (
	"database/sql/driver"
	"fmt"
	"github.com/satori/go.uuid"
	"time"

	"foodtastechess/logger"
)

var log = logger.Log("user")

type Id string

func (u *Id) Scan(value interface{}) error {
	*u = Id(value.([]byte))
	return nil
}

func (u Id) Value() (driver.Value, error) {
	return string(u), nil
}

type User struct {
	Id                int `json:"-"`
	Uuid              Id  `sql:"unique_index" json:"-"`
	Name              string
	AvatarUrl         string
	AuthIdentifier    string `sql:"unique_index" json:"-"`
	AccessToken       string `json:"-"`
コード例 #18
0
ファイル: system.go プロジェクト: gnidan/foodtastechess
func NewSystemQueryService() SystemQueries {
	sqs := new(SystemQueryService)
	sqs.log = logger.Log("systemqueries")
	return sqs
}