Пример #1
0
// Create a new request object.
// Values are all set to defaults
func NewRequest(uri, method string) *Request {
	request := &Request{*dynmap.NewDynMap()}
	request.PutWithDot("strest.params", dynmap.NewDynMap())
	request.PutWithDot("strest.v", StrestVersion)
	request.PutWithDot("strest.uri", uri)
	request.PutWithDot("strest.method", method)
	request.PutWithDot("strest.txn.accept", "single")
	return request
}
Пример #2
0
func NewRouterTable(service string) *RouterTable {
	return &RouterTable{
		Service:           service,
		DynMap:            dynmap.NewDynMap(),
		ReplicationFactor: 2,
	}
}
Пример #3
0
// fills the passed in dynmap with the values from the yaml map
func toDynMap(mp yaml.Map) *dynmap.DynMap {
	d := dynmap.NewDynMap()
	for k, v := range mp {
		d.Put(k, fromNode(v))
	}
	return d
}
Пример #4
0
func (this *Request) Params() *dynmap.DynMap {
	m, ok := this.GetDynMap("strest.params")
	if !ok {
		this.PutIfAbsentWithDot("strest.params", dynmap.NewDynMap())
		m, ok = this.GetDynMap("strest.params")
	}
	return m
}
Пример #5
0
// Create a new response object.
// Values are all set to defaults
func NewResponse() *Response {
	response := &Response{*dynmap.NewDynMap()}
	response.SetStatusMessage("OK")
	response.SetStatusCode(200)
	response.SetTxnStatus("completed")
	response.PutWithDot("strest.v", StrestVersion)
	return response
}
Пример #6
0
// Translate to a DynMap of the form:
// {
//     "service" : "trendrrdb",
//     "revision" : 898775762309309,
//     "total_partitions" : 256,
//     "entries" : [
//         {/*router entry 1*/},
//         {/*router entry 2*/}
//     ]
// }
func (this *RouterTable) ToDynMap() *dynmap.DynMap {
	if this.DynMap != nil && len(this.DynMap.Map) > 0 {
		return this.DynMap
	}
	mp := dynmap.NewDynMap()
	mp.Put("service", this.Service)
	mp.Put("revision", this.Revision)
	mp.Put("total_partitions", this.TotalPartitions)
	mp.Put("replication_factor", this.ReplicationFactor)
	entries := make([]*dynmap.DynMap, 0)
	for _, e := range this.Entries {
		entries = append(entries, e.ToDynMap())
	}
	mp.Put("entries", entries)
	this.DynMap = mp
	return mp
}
Пример #7
0
// loop that listens for incoming messages.
func (this *cheshireConn) listener() {
	decoder := json.NewDecoder(bufio.NewReader(this.Conn))
	log.Printf("Starting Cheshire Connection %s", this.addr)
	defer func() { this.exitChan <- 1 }()
	for {
		res := &Response{*dynmap.NewDynMap()}
		err := decoder.Decode(res)
		if err == io.EOF {
			log.Print(err)
			break
		} else if err != nil {
			log.Print(err)
			break
		}
		this.incomingChan <- res
	}
}
Пример #8
0
//loads the stored version
func (this *Manager) load() error {
	bytes, err := ioutil.ReadFile(this.filename())
	if err != nil {
		return err
	}
	mp := dynmap.NewDynMap()
	err = mp.UnmarshalJSON(bytes)
	if err != nil {
		return err
	}
	table, err := ToRouterTable(mp)
	if err != nil {
		return err
	}
	this.SetRouterTable(table)
	return nil
}
Пример #9
0
// Translate to a DynMap of the form:
// {
//     "id" : "localhost:8009"
//     "address" : "localhost",
//     "ports" : {
//         "json" : 8009,
//         "http" : 8010
//     }
//     "partitions" : [1,2,3,4,5,6,7,8,9]
// }
func (this *RouterEntry) ToDynMap() *dynmap.DynMap {
	if this.DynMap != nil && len(this.DynMap.Map) > 0 {
		return this.DynMap
	}

	mp := dynmap.NewDynMap()
	mp.Put("address", this.Address)
	if this.JsonPort > 0 {
		mp.PutWithDot("ports.json", this.JsonPort)
	}

	if this.HttpPort > 0 {
		mp.PutWithDot("ports.http", this.HttpPort)
	}
	mp.Put("id", this.Id())
	mp.Put("partitions", this.Partitions)
	this.DynMap = mp
	return mp
}
Пример #10
0
func (this *HttpClient) ApiCallSync(req *Request, timeout time.Duration) (*Response, error) {
	uri := req.Uri()
	pms, err := req.Params().MarshalURL()
	if err != nil {
		return nil, err
	}
	reqBody := strings.NewReader("")

	if req.Method() == "GET" {
		joiner := "&"
		//add params to the uri
		if !strings.Contains(uri, "?") {
			joiner = "?"
		}
		uri = fmt.Sprintf("%s%s%s", uri, joiner, pms)
	} else {
		reqBody = strings.NewReader(pms)
	}
	url := fmt.Sprintf("http://%s%s", this.Address, uri)
	//convert to an http.Request
	request, err := http.NewRequest(req.Method(), url, reqBody)
	if err != nil {
		return nil, err
	}
	res, err := http.DefaultClient.Do(request)

	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	body, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}

	//convert to a strest response2
	var response = &Response{*dynmap.NewDynMap()}
	err = response.UnmarshalJSON(body)
	if err != nil {
		return nil, err
	}
	return response, nil
}
Пример #11
0
// Creates a new server config with a default routematcher
func NewServerConfig() *ServerConfig {
	return &ServerConfig{dynmap.NewDynMap(), NewDefaultRouter()}
}