示例#1
0
/**
 * Handles a request from WS/HTTP
 */
func HandleRequestMessage(inMsg models.BaseMessage) {

	// Create Queue message from original
	msg := models.QueueMessage{
		BaseMessage: inMsg,
		Sender:      inMsg.Source,
	}

	// Lookup message type
	switch msg.Target {

	// Request for data, direct to basic module
	case "data":
		msg.Receiver = "modules.basic"

	// TODO: Add more options here

	// Unknown target
	default:
		fmt.Printf("Unknown message target: %s", msg.Target)
		return
	}

	// Call sender handler
	q.SendMessage(msg)
}
示例#2
0
/**
 * Handles logic for a message coming from a Worker
 */
func handleWorkerMessage(msg models.QueueMessage) {

	// Lookup worker sender
	switch msg.Sender {

	// Coming from DB Worker
	case "workers.db":

		// Lookup Target
		switch msg.Target {

		// Data request target
		case "data":

			// Lookup Action
			switch msg.Action {

			// DB action
			case "index", "post", "get", "update", "delete":

				// TODO: Logic here for needed steps. for now considering one-off tasks

				msg.Receiver = msg.Source

			// TODO: More Worker receivers here

			// Unknown action
			default:
				fmt.Printf("Invalid action '%s' for Basic Module", msg.Action)
				return
			}

		// Unknown target
		default:
			fmt.Printf("Invalid message target '%s' for Basic Module: ", msg.Target)
			return
		}

	// Unknown target
	default:
		fmt.Printf("Invalid message source '%s' for Basic Module: ", msg.Sender)
		return
	}

	// Set the sender to current module
	msg.Sender = ID

	// Send the message to queue
	q.SendMessage(msg)
}
示例#3
0
/**
 * Handles a received message from DB Queue, sending relevant info to connected client
 */
func HandleQueueMessage(msg models.QueueMessage) {

	// Validations
	// TODO: Abstract this please
	if msg.Target == "" || msg.Target != "data" {
		fmt.Println("Invalid or missing target defined in message!")
		return
	}

	if msg.Code == "" {
		fmt.Println("No entity/code defined in message!")
		return
	}

	if msg.Action == "" {
		fmt.Println("No action defined in message!")
		return
	}

	if msg.Data == nil {
		fmt.Println("No data provided in message!")
		return
	}

	// Variables for query result
	var result interface{}
	var err error

	// Check what type of entity we're dealing with
	switch msg.Code {
	case "game":
		err, result = dbModels.Games{}.HandleMessage(msg.BaseMessage)
	default:
		fmt.Printf("Unknown entity: %s\n", msg.Code)
		return
	}

	// Error from query
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	// Parse result from relevant interface model to bytes
	data, err := json.Marshal(result)
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	// Parse previous bytes to generic map
	var outData = make(map[string]interface{})
	if err := json.Unmarshal(data, &outData); err != nil {
		fmt.Println(err.Error())
		return
	}

	// Build base response message and init final one
	msg.Receiver = msg.Sender
	msg.Sender = ID
	msg.Data = outData

	// Send it
	q.SendMessage(msg)
}