func ServiceGet(txn *cheshire.Txn) {
routerTable, ok := Servs.RouterTable(txn.Params().MustString("service", ""))
if !ok {
cheshire.SendError(txn, 406, "Service param missing or service not found")
return
}
res := cheshire.NewResponse(txn)
res.Put("router_table", routerTable.ToDynMap())
txn.Write(res)
}
// a demo Firehose controller
func Firehose(txn *cheshire.Txn) {
for i := 0; true; i++ {
response := cheshire.NewResponse(txn)
response.Put("iteration", i)
response.Put("data", "This is a firehose, I never stop")
response.SetTxnStatus("continue") //set the status to continue so clients know to expect more responses
txn.Write(response)
time.Sleep(200 * time.Millisecond)
}
}
func Checkin(txn *cheshire.Txn) {
table, err := manager.RouterTable()
revision := int64(0)
if err == nil {
revision = table.Revision
}
response := cheshire.NewResponse(txn)
response.Put("rt_revision", revision)
response.Put("ts", time.Now())
txn.Write(response)
}
func GetRouterTable(txn *cheshire.Txn) {
log.Println("GetRouterTable")
tble, err := manager.RouterTable()
if err != nil {
cheshire.SendError(txn, 506, fmt.Sprintf("Error: %s", err))
return
}
response := cheshire.NewResponse(txn)
response.Put("router_table", tble.ToDynMap())
txn.Write(response)
}
func Service(txn *cheshire.Txn) {
//create a context map to be passed to the template
context := make(map[string]interface{})
service, ok := Servs.RouterTable(txn.Params().MustString("service", ""))
context["service"] = service
if !ok {
cheshire.Flash(txn, "error", fmt.Sprintf("Cant find service"))
cheshire.Redirect(txn, "/index")
return
}
cheshire.RenderInLayout(txn, "/router_table.html", "/template.html", context)
}
func Unlock(txn *cheshire.Txn) {
partition, ok := txn.Params().GetInt("partition")
if !ok {
cheshire.SendError(txn, 406, fmt.Sprintf("partition param missing"))
return
}
err := manager.UnlockPartition(partition)
if err != nil {
//now send back an error
cheshire.SendError(txn, 406, fmt.Sprintf("Unable to lock partitions (%s)", err))
return
}
response := cheshire.NewResponse(txn)
txn.Write(response)
}
func NewService(txn *cheshire.Txn) {
log.Println(txn.Params())
name, ok := txn.Params().GetString("service-name")
if !ok {
cheshire.Flash(txn, "error", "Service Name is manditory")
}
err := Servs.NewRouterTable(name, 512, 2)
if err != nil {
cheshire.Flash(txn, "error", fmt.Sprintf("%s", err))
} else {
cheshire.Flash(txn, "success", "successfully created router table")
}
cheshire.Redirect(txn, "/index")
}
// Gets any logging messages from the Servs.Events
// sends to client
func ConsoleLog(txn *cheshire.Txn) {
msgChan := make(chan clog.LoggerEvent, 10)
Servs.Logger.Listen(msgChan)
defer Servs.Logger.Unlisten(msgChan)
log.Println("Log Listener Registered")
for {
msg := <-msgChan
res := cheshire.NewResponse(txn)
res.SetTxnStatus("continue")
res.PutWithDot("event.type", msg.Type)
res.PutWithDot("event.message", msg.Message)
_, err := txn.Write(res)
if err != nil {
//try and write an error response
cheshire.SendError(txn, 510, fmt.Sprintf("%s", err))
break
}
}
log.Println("Log Listener unregistered")
}
func SetRouterTable(txn *cheshire.Txn) {
rtmap, ok := txn.Params().GetDynMap("router_table")
if !ok {
cheshire.SendError(txn, 406, "No router_table")
return
}
rt, err := ToRouterTable(rtmap)
if err != nil {
cheshire.SendError(txn, 406, fmt.Sprintf("Unparsable router table (%s)", err))
return
}
_, err = manager.SetRouterTable(rt)
if err != nil {
cheshire.SendError(txn, 406, fmt.Sprintf("Unable to set router table (%s)", err))
return
}
response := cheshire.NewResponse(txn)
txn.Write(response)
}
func DataPull(txn *cheshire.Txn) {
part, ok := txn.Params().GetInt("partition")
if !ok {
cheshire.SendError(txn, 406, fmt.Sprintf("partition param is manditory"))
return
}
dataChan := make(chan *dynmap.DynMap, 10)
finishedChan := make(chan int)
errorChan := make(chan error)
go func() {
for {
select {
case data := <-dataChan:
//send a data packet
res := cheshire.NewResponse(txn)
res.SetTxnStatus("continue")
res.Put("data", data)
txn.Write(res)
case <-finishedChan:
res := cheshire.NewResponse(txn)
res.SetTxnStatus("complete")
txn.Write(res)
return
case err := <-errorChan:
cheshire.SendError(txn, 406, fmt.Sprintf("Unable to unlock (%s)", err))
return
}
}
}()
manager.partitioner.Data(part, dataChan, finishedChan, errorChan)
}
// Do the request
func (this *Router) doReq(txn *cheshire.Txn) {
keyParams := this.connections.RouterTable().PartitionKeys
partitionFound := false
vals := make([]string, len(keyParams))
for i, k := range keyParams {
v, ok := txn.Request.Params().GetString(k)
if ok {
partitionFound = true
}
vals[i] = v
}
if !partitionFound {
//uhh, return error, or broadcast?
}
partitionKey := strings.Join(vals, "|")
log.Printf("partition key %s", partitionKey)
//Now partition
//TODO
partition := 0 //P.Partition(partitionKey)
//Add the required params
txn.Request.Params().Put(shards.P_PARTITION, partition)
txn.Request.Params().Put(shards.P_ROUTER_TABLE_V, this.connections.RouterTable().Revision)
queryType := txn.Request.Params().MustString(shards.P_QUERY_TYPE, "all")
//Do the damn api call!
max := 5
if queryType == "all_q" {
max = 100
}
a := &apiRR{
partition: partition,
queryType: queryType,
responses: make(map[string]*cheshire.Response),
txn: txn,
response: cheshire.NewResponse(txn),
count: 0,
max: max,
}
//send response.
if len(a.responses) == 0 {
// set the error response
a.response.SetStatus(501, "Unable to get a single response.")
}
for k, r := range a.responses {
r.Put("server_id", k)
a.response.AddToSlice("responses", r)
}
//send the response.
txn.Write(a.response)
}
// a demo Ping controller function
func Ping(txn *cheshire.Txn) {
response := cheshire.NewResponse(txn)
response.Put("data", "PONG")
txn.Write(response)
}
// Creates a new shard. Does not register any partitions to it, unless the router table has no entries. in which case this
// gets all the partitions
func ShardNew(txn *cheshire.Txn) {
routerTable, ok := Servs.RouterTable(txn.Params().MustString("service", ""))
if !ok {
cheshire.SendError(txn, 406, "Service param missing or service not found")
return
}
Servs.Logger.Printf("Creating new shard for service: %s", routerTable.Service)
address, ok := txn.Params().GetString("address")
if !ok {
cheshire.SendError(txn, 406, "address param missing")
return
}
jsonPort, ok := txn.Params().GetInt("json_port")
if !ok {
cheshire.SendError(txn, 406, "json_port param missing")
return
}
httpPort, ok := txn.Params().GetInt("http_port")
if !ok {
cheshire.SendError(txn, 406, "http_port param missing")
return
}
entry := &shards.RouterEntry{
Address: address,
JsonPort: jsonPort,
HttpPort: httpPort,
Partitions: make([]int, 0),
}
//check if we can connect!
Servs.Logger.Printf("Attempting to connect to new entry...")
// _, _, err := EntryCheckin(routerTable, entry)
// if err != nil {
// cheshire.SendError(txn, 406, fmt.Sprintf("Unable to contact %s:%d Error(%s)", entry.Address, entry.HttpPort, err))
// return
// }
Servs.Logger.Printf("Success!")
if len(routerTable.Entries) == 0 {
totalPartitions, ok := txn.Params().GetInt("total_partitions")
if !ok {
cheshire.SendError(txn, 406, "total_partitions param is manditory for the first entry")
return
}
//first entry, giving it all the partitions
Servs.Logger.Printf("First Entry! giving it all %d partitions", totalPartitions)
partitions := make([]int, 0)
for p := 0; p < totalPartitions; p++ {
partitions = append(partitions, p)
}
entry.Partitions = partitions
} else {
// not the first entry,
}
routerTable, err := routerTable.AddEntries(entry)
if err != nil {
cheshire.SendError(txn, 501, fmt.Sprintf("Error on add entry %s", err))
return
}
Servs.Logger.Printf("Successfully created new entry: %s", entry.Id())
Servs.SetRouterTable(routerTable)
res := cheshire.NewResponse(txn)
res.Put("router_table", routerTable.ToDynMap())
txn.Write(res)
}