/*

*Name: Carter Currin

*File: deliver.go

*Description: Continuously pulls Postback objects from the local Redis server on port 6379 for in the following form:

* {

* "method":"GET",

* "url":"http://sample-domain-endpoint.com/data?key={key}&value={value}&foo={bar}",

* "data":

* {

* "key":"Azureus",

* "value":"Dendrobates"

* }

* }

*

* Once the data is parsed, the url has it's {xxx} elements replaced with the values coresponding to xxx keys in data.

* If the key has no match in data then a configurable constant is used (default is empty string).

* The data is then delivered to the endpoint url using the provided method (either GET or POST).

* A GET delivery would look like:

* http://sample-domain-endpoint.com/data?key=Azureus&value=Dendrobates&foo=

* A POST delivery would look like:

* headers:

* (POST) http://sample-domain-endpoint.com/data?key=Azureus&value=Dendrobates&foo=

* HTTP/1.1 1 1

* Content-Type : application/json

* body:

* {

* "bar":"",

* "key":"Phyllobates",

* "value":"Terribilis"

* }

*

* Delivery Time, response code, response time, and response body as well as any warnings and error are logged in

* a log file (default is log file is "deliver.go.log" in same directory as this file).

*/

package main

import (

"fmt"

"bytes"

"strings"

"log"

"os"

"io"

"io/ioutil"

"regexp"

"net/http"

"encoding/json"

"github.com/garyburd/redigo/redis"

)

const (

//Configurable default value for unmatched url {keys}

UNMATCHED_URL_KEY_VALUE = ""

//set to the name of the Redis List to check for Postback Objects

REDIS_LIST_NAME = "request"

//set to where you want the logs written

LOG_FILE_NAME = "deliver.go.log"

//set if you want to see trace log outputs in standard out or discarded

SHOW_TRACES = false

)

var (

//Regular Expression that matches the imbedded keys with postback urls:

//http://sample-domain-endpoint.com/data?key={key}&value={value}&foo={bar}

//(matches) ^^^^^ ^^^^^^^ ^^^^^

curlyBracketMatch = regexp.MustCompile("{.*?}")

Trace *log.Logger

Info *log.Logger

Warning *log.Logger

Error *log.Logger

)

//Used to store the JSON Postback object input from Redis

type PostbackObject struct {

}

//Initializes the different log levels

//example log format:

//HEADER: yyyy/mm/dd hh:mm:ss.mcrsec /the/full/file/path/deliver.go:line#: Hello World!

func InitLoggers(traceHandle io.Writer, infoHandle io.Writer, warningHandle io.Writer, errorHandle io.Writer) {

}

//Finds all the keys in Postback Object's url of the form {xxx} and replaces them with the values they

// correspond to in the Postback Object's data.

//Precondition: postback has the url to be parsed and the data to replace with.

//Postcondition: the postback's url has {xxx}'s replaced with yyy values from xxx keys from data

func matchUrlKeysToValues(postback *PostbackObject) {

}

//Given a sent PostbackObject and the response received from sending it, response information is logged to file.

//Precondition: postback is initialed to the information delivered to the endpoint

// response is initialed to the response received from the delivery

//Postcondition: Response time, code, and body are logged to file using Info log level.

func logEndpointResponseInfo(response *http.Response, postback PostbackObject) {

}

//Delivers a PostbackObject using the HTTP GET method

//Precondition: postback.url is set the the endpoint url to where the postback is delivered and contains the

// desired GET information.

//Postcondition: The postback info is sent via HTTP GET to postback.url

// Delivery time is logged using the Info log level.

// Response info is logged according to logEndpointResponseInfo()

func deliverGet(postback PostbackObject) {

}

//Delivers a PostbackObject using the HTTP POST method

//Precondition: postback.url is set the the endpoint url to where the postback is delivered.

// postback.data is initialed to the data to be sent via POST

//Postcondition: The postback.data is sent via HTTP POST in JSON form to postback.url

// Delivery time is logged using the Info log level

// Response info is logged according to logEndpointResponseInfo()

func deliverPost(postback PostbackObject) {

}

//Processes a Postback object received from the local Redis Server.

//Precondition: redisServer is dialed into a Redis server that is meant to contain postback objects in a

// Redis List called REDIS_LIST_NAME

// Postback Objects received must have one of two acceptable methods: GET or POST

//Postcondition: A Postback Object is read in from the Redis server, its url is parsed with keys being

// replaced with values according to matchUrlKeysToValues(), and it is sent to its endpoint

// via HTTP GET or POST with all relevent information logged.

func processPostbackObject(redisServer redis.Conn) {

}

//Continually processes postback objects from the local Redis database server

//Precondition: The file at LOG_FILE_NAME must be acessable to write logs

// A local Redis database server must be running on port 6379

//Postcondition: Any Postback objects received from the Redis database's List, REDIS_LIST_NAME, are processed

// Log levels are set up for the rest of the program to use, all pertinent inforamtion is logged

func main() {

}