func init() {
/* Initialise configuration instance, w/ GABS. */
log.Debug("Initialise configuration instance")
// This has to be a absolute path.
configurationPath := os.Getenv("RESTAPI_CONFIG")
// Ascertain if the configuration path is inputted.
log.Debug("Testing if the configuration path is inputted.")
if _, err := os.Stat(configurationPath); os.IsNotExist(err) {
log.Crit("The configuration file does not exist!",
log.Ctx{"File": configurationPath})
os.Exit(1)
}
log.Debug("Reading configuration file into RAM.")
configurationFile, err := ioutil.ReadFile(configurationPath)
if err != nil {
log.Error("The JSON config could not be loaded..",
log.Ctx{"Error": err.Error()})
os.Exit(1)
}
log.Debug("Parsing configuration file into a GABS instance.")
config, err = gabs.ParseJSON(configurationFile)
if err != nil {
log.Error("The JSON config could not be parsed.",
log.Ctx{"Error": err.Error()})
os.Exit(1)
}
/* Finish initializing the configuration instance */
}
func StartWebServer() error {
conf, err := config.GetConfig()
if err != nil {
return err
}
var hystrixTimeout time.Duration
conf.Hystrix.Timeout = strings.TrimSpace(conf.Hystrix.Timeout)
if conf.Hystrix.Timeout != "" {
hystrixTimeout, err = time.ParseDuration(conf.Hystrix.Timeout)
if err != nil || hystrixTimeout < time.Millisecond {
hystrixTimeout = time.Second
log15.Error("Use default time", "module", "hystrix", "timeout", hystrixTimeout)
}
}
hystrix.ConfigureCommand("waitFor", hystrix.CommandConfig{
Timeout: int(int64(hystrixTimeout) / int64(time.Millisecond)), // converted into Millisecond.
MaxConcurrentRequests: conf.Hystrix.MaxConcurrentRequests,
ErrorPercentThreshold: conf.Hystrix.ErrorPercentThreshold,
RequestVolumeThreshold: conf.Hystrix.RequestVolumeThreshold,
SleepWindow: conf.Hystrix.SleepWindow,
})
e := echo.New()
e.Post("/api/v1/tweet", createTweetV1)
e.Get("/api/v1/tweets/:id", getAllTweetForV1)
e.Get("/api/v1/wait/:timeout", waitFor)
e.Get("/api/v1/wait_protected/:timeout", waitForProtected)
e.Static("/", "www/static/")
logsrv := log15.New("pid", os.Getpid(), "addr", conf.Web.Address)
return listenAndServer(logsrv, conf.Web.Address, handlers.LoggingHandler(os.Stdout, handlers.CompressHandler(e.Router())))
}
func (p *Player) neededComponents(components []string, num int) bool {
for i := range components {
if i >= num {
return true
}
}
log15.Error("not enough components given to command", "given", components, "needed", num)
return false
}
//create table example.user(id UUID, login text, passwd text, PRIMARY KEY(id));
//create index on example.user(login);
//insert into example.user(id, login, passwd) values (now(), 'admin', 'f807c2b4caa8ca621298907e5372c975a6e07322');
func main() {
log15.Root().SetHandler(log15.CallerStackHandler("%+v", log15.StdoutHandler))
session, err := dao.GetSession()
if err != nil {
log15.Error(err.Error())
os.Exit(1)
}
defer session.Close()
www.StartWebServer()
os.Exit(0)
}
func main() {
rand.Seed(time.Now().UnixNano())
h := &Handler{}
err := bot.Run(func(b *bot.Bot) {
b.Register(irc.PRIVMSG, h)
})
if err != nil {
log15.Error(err.Error())
}
}
func createTweetV1(c *echo.Context) error {
tweet := new(dto.Tweet)
err := c.Bind(tweet)
if err != nil {
log15.Error(err.Error())
return c.JSON(http.StatusBadRequest, nil)
}
tweet.GenerateId()
err = tweet.Insert()
if err != nil {
return c.JSON(http.StatusInternalServerError, err)
}
return c.JSON(http.StatusOK, tweet)
}
func waitForProtected(c *echo.Context) error {
var response *http.Response
hystrix.Do("waitFor", func() error {
var err error
response, err = http.Get("http://127.0.0.1:8080/api/v1/wait/" + c.Param("timeout"))
//response, err = http.Get(fmt.Sprintf("%s://%s%s", c.Request().URL.Scheme, c.Request().URL.Host, c.Request().URL.Path))
if err != nil {
return err
}
r := response.Body
w := c.Response().Writer()
io.Copy(w, r)
return nil
}, func(err error) error {
log15.Error(err.Error())
c.JSON(http.StatusInternalServerError, err.Error())
return nil
})
return nil
}
func Server(srv *context.T) {
log := srv.Log.New("cmp", "dht")
ch := srv.Router.Sub("/dht/join")
tch := srv.Router.Sub("/transaction/mem")
och := srv.Router.Sub("/git/object")
keyAuth, err := newKeyAuth()
if err != nil {
log.Crit("can't generate node key", "err", err)
os.Exit(1)
}
id, err := wendy.NodeIDFromBytes(util.SHA256(keyAuth.Marshal()))
log = log.New("own_node", id)
if err != nil {
log15.Crit("error preparing node id", "err", err)
os.Exit(0)
}
hostname := strings.Split(srv.Config.Network.Hostname, ":")[0]
node := wendy.NewNode(id, "127.0.0.1", hostname, "localhost", srv.Config.Network.Port)
cluster := wendy.NewCluster(node, keyAuth)
cluster.SetLogLevel(wendy.LogLevelError)
cluster.RegisterCallback(&GitchainApp{cluster: cluster, log: log.New(), srv: srv})
go cluster.Listen()
defer cluster.Stop()
log.Info("node started")
for i := range srv.Config.Network.Join {
log.Info("scheduling a connection", "addr", srv.Config.Network.Join[i])
srv.Router.Pub(srv.Config.Network.Join[i], "/dht/join")
}
loop:
select {
case addri := <-ch:
if addr, ok := addri.(string); ok {
log.Debug("received a request to join the cluster", "addr", addr)
addr := strings.Split(addr, ":")
port := 31000
if len(addr) == 2 {
port, err = strconv.Atoi(addr[1])
if err != nil {
log.Error("invalid port number", "addr", addr, "port", addr[1], "err", err)
goto loop
}
}
err = cluster.Join(addr[0], port)
if err != nil {
log.Error("can't join cluster", "addr", addr, "err", err)
goto loop
}
}
case txei := <-tch:
if txe, ok := txei.(*transaction.Envelope); ok {
log.Debug("received transaction", "txn", txe)
if err = broadcast(cluster, txe, MSG_TRANSACTION); err != nil {
log.Error("error broadcasting a transaction message", "txn", txe, "err", err)
} else {
log.Debug("broadcasted transaction", "txn", txe)
}
}
case obji := <-och:
if obj, ok := obji.(git.Object); ok {
id, err := wendy.NodeIDFromBytes(util.SHA256(obj.Hash()))
if err != nil {
log15.Error("error preparing msg id for a git object", "obj", obj, "err", err)
} else {
msg := cluster.NewMessage(MSG_REGULAR|MSG_OBJECT, id, git.ObjectToBytes(obj))
if err = cluster.Send(msg); err != nil {
log.Error("error sending git object", "obj", obj, "err", err)
}
}
}
}
goto loop
}
// Listen for gameclient/websocket requests on http(s)
func listenAndServe(bindAddress, listenPort string) {
err := http.ListenAndServe(bindAddress+":"+listenPort, nil)
if err != nil {
log15.Error("serving http(s) requests", "error", err)
}
}
func main() {
// Command line variables
var debug bool
var daemon bool
var bindAddress string
var listenPort string
var maxPlayers int
flag.BoolVar(&debug, "debug", false, "run server in debug mode")
flag.BoolVar(&daemon, "daemon", false, "run server in daemon mode (no console prompt)")
flag.StringVar(&bindAddress, "bindAddress", "0.0.0.0", "address to bind to")
flag.StringVar(&listenPort, "listenPort", "8080", "port to serve client on")
flag.IntVar(&maxPlayers, "maxPlayers", 4, "max number of players on server simultaneously")
flag.Parse()
// Find executable location
osextDir, err := osext.ExecutableFolder()
if err != nil {
log15.Error("Finding executable location", "error", err)
}
// Configure GameClient distributor
http.Handle("/", http.FileServer(http.Dir(osextDir+"/client")))
// Configure webtron server
webtronServer := server.New(debug, maxPlayers)
defer webtronServer.Shutdown()
// Configure Glue (websocket wrapper) bridge
glueServer := glue.NewServer(glue.Options{
HTTPSocketType: glue.HTTPSocketTypeNone,
HTTPListenAddress: ":" + listenPort,
HTTPHandleURL: "/",
})
defer glueServer.Release()
glueServer.OnNewSocket(webtronServer.ConnectPlayer)
http.HandleFunc("/ws", glueServer.ServeHTTP)
if daemon {
listenAndServe(bindAddress, listenPort)
} else {
// Listen for gameclient/websocket requests on http(s)
go listenAndServe(bindAddress, listenPort)
// Command line input
reader := bufio.NewReader(os.Stdin)
input_loop:
for {
fmt.Print("console@webtron:~$ ")
input, _ := reader.ReadString('\n')
input = strings.Trim(input, "\n")
switch input {
case "":
case "help":
fmt.Println(
"Available commands:\n" +
"help, exit")
case "exit", "quit":
break input_loop
default:
fmt.Println("Unknown command: " + input)
}
}
}
}
// ReadLoop receives data from the player client
func (p *Player) ReadLoop() {
for {
// Wait for available data
data, err := p.Socket.Read()
if err != nil {
// return and release this goroutine if the socket was closed
if err == glue.ErrSocketClosed {
return
}
log15.Error("read error", "error", err)
continue
}
components := strings.Split(data, ":")
switch components[0] {
case msg.CRequestState:
p.Socket.Write(msg.SNewState + ":" + p.Server.Sim.LatestState)
case msg.CSpawn:
if !p.neededComponents(components, 2) {
break
}
if p.Bike != nil && p.Bike.GetState() != "dead" {
log15.Debug("Player attempted to spawn with existing bike", "bike", p.Bike)
break
}
p.Bike = p.Server.Sim.SpawnGridBike(components[1], components[2])
p.Socket.Write(msg.SDisplayMessage + ":")
case msg.CTurn:
if !p.neededComponents(components, 1) {
break
}
if p.Bike == nil || p.Bike.GetState() != "move" {
log15.Debug("Player attemped to turn without existing bike", "bike", p.Bike)
break
}
dir := components[1]
switch dir {
case "RIGHT":
p.Bike.SetTurn(0)
case "DOWN":
p.Bike.SetTurn(math.Pi / 2)
case "LEFT":
p.Bike.SetTurn(math.Pi)
case "UP":
p.Bike.SetTurn(3 * math.Pi / 2)
default:
log15.Error("invalid TURN argument", "arg", dir)
}
// case msg.CBroadcast:
// // Echo the received data to all other clients
// for i := range gs.ConnectedPlayers {
// if gs.ConnectedPlayers[i].Socket.ID() == p.Socket.ID() {
// continue
// }
// gs.ConnectedPlayers[i].Socket.Write(strings.Join(components[1:], ":"))
// }
default:
log15.Info("Returning unknown request to the client", "request", data)
p.Socket.Write(data)
}
}
}
func (c *client) GetAllInto(destination interface {
Add(interface{}) error
Count() int
MaxCreatedAt() time.Time
MaxUpdatedAt() time.Time
}) (err error) {
var response ItembaseResponse
DocumentsReceived := 0
err = c.api.Call("GET", c.url, c.auth, nil, c.params, &response)
if err != nil {
return
}
for _, document := range response.Documents {
if destination.Add != nil {
err = destination.Add(document)
if err != nil {
log.Info("Error when adding document", "error", err)
}
}
}
log.Debug("Documents", "found", response.NumDocumentsFound)
log.Debug("Documents", "returned", response.NumDocumentsReturned)
if response.NumDocumentsFound == response.NumDocumentsReturned {
log.Debug("same amount of documents that were found as returned")
return
} else {
DocumentsReceived = response.NumDocumentsReturned
TotalDocuments := response.NumDocumentsFound
log.Debug("expecting to receive", "NumDocumentsFound", response.NumDocumentsFound)
for DocumentsReceived < TotalDocuments {
log.Debug("expecting", "TotalDocuments", TotalDocuments)
if c.max > 0 {
log.Debug("Max", "max", c.max)
if DocumentsReceived >= c.max {
log.Debug("Max is reached", "DocumentsReceived", DocumentsReceived)
return
}
}
if _, ok := c.params["created_at_from"]; ok {
if c.params["created_at_from"] == destination.MaxCreatedAt().Format(time.RFC3339) {
log.Error("created_at_from equals to previous created_at_from - We got a loop?", "created_at_from", c.params["created_at_from"])
return
}
}
c = c.clientWithNewParam("start_at_document", DocumentsReceived)
err = c.api.Call("GET", c.url, c.auth, nil, c.params, &response)
if err != nil {
log.Error("Error when retrieving paginated results", "error", err)
}
log.Debug("Documents", "found", response.NumDocumentsFound)
log.Debug("Documents", "returned", response.NumDocumentsReturned)
if len(response.Documents) == 0 {
log.Debug("no documents in response", "response.Documents", len(response.Documents))
return
}
for _, document := range response.Documents {
if destination.Add != nil {
destination.Add(document)
if err != nil {
log.Info("Error when adding document", "error", err)
}
}
}
if DocumentsReceived == destination.Count() {
log.Error("Same amount of documents in destination interface as before. Can happen due to created_at collission during pagination.")
return
}
log.Debug("Documents", "saved", destination.Count())
DocumentsReceived = destination.Count()
if len(response.Documents) == 1 {
log.Debug("only 1 document in response", "response.Documents", len(response.Documents))
return
}
}
}
return
}
