Esempio n. 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
}
Esempio n. 2
0
// updates the revision to now
func (this *RouterTable) UpdateRevision() (previous, current int64) {
	prev := this.Revision
	this.Revision = time.Now().Unix()
	//reset the dynmap
	this.DynMap = dynmap.NewDynMap()
	return prev, this.Revision
}
Esempio n. 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
}
Esempio n. 4
0
// Creates a new server config with a default routematcher
func NewServerConfig() *ServerConfig {
	return &ServerConfig{
		dynmap.NewDynMap(),
		NewDefaultRouter(),
		make([]ControllerFilter, 0),
	}
}
Esempio n. 5
0
func (this *Services) Load() error {
	//attempt to load from datadir

	filename := fmt.Sprintf("%s/%s", this.DataDir, "services.json")
	bytes, err := ioutil.ReadFile(filename)
	if err != nil {
		return err
	}
	mp := dynmap.NewDynMap()
	err = mp.UnmarshalJSON(bytes)
	if err != nil {
		return err
	}

	for k, _ := range mp.Map {
		rt, ok := mp.GetDynMap(k)
		if !ok {
			continue
		}
		table, err := shards.ToRouterTable(rt)
		if err != nil {
			log.Println(err)
			continue
		}
		this.services[k] = table
	}
	return nil
}
Esempio n. 6
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
}
Esempio n. 7
0
// We keep this private scope, so external controllers never use it directly
// they should all use request.NewResponse
func newResponse() *Response {
	response := &Response{*dynmap.NewDynMap()}
	response.SetStatusMessage("OK")
	response.SetStatusCode(200)
	response.SetTxnStatus("completed")
	response.PutWithDot("strest.v", StrestVersion)
	return response
}
Esempio n. 8
0
func NewRouterTable(service string) *RouterTable {
	return &RouterTable{
		Service:           service,
		DynMap:            dynmap.NewDynMap(),
		Revision:          time.Now().Unix(),
		TotalPartitions:   0,
		ReplicationFactor: 2,
	}
}
Esempio n. 9
0
func NewTxn(request *Request, writer Writer, filters []ControllerFilter, serverConfig *ServerConfig) *Txn {
	return &Txn{
		Request:      request,
		Writer:       writer,
		Session:      dynmap.NewDynMap(),
		Filters:      filters,
		ServerConfig: serverConfig,
	}
}
Esempio n. 10
0
// We keep this private scope, so external controllers never use it directly
// they should all use request.NewResponse
func newResponse() *Response {
	response := &Response{
		DynMap:        *dynmap.NewDynMap(),
		statusMessage: "OK",
		statusCode:    200,
		txnStatus:     "completed",
	}
	return response
}
Esempio n. 11
0
func (this *Services) Save() error {
	mp := dynmap.NewDynMap()

	for k, v := range this.services {
		mp.Put(k, v.ToDynMap())
	}

	bytes, err := mp.MarshalJSON()
	if err != nil {
		this.Logger.Printf("Error marshalling services table -- %s", err)
		return err
	}
	err = ioutil.WriteFile(fmt.Sprintf("%s/%s", this.DataDir, "services.json"), bytes, 0644)
	return err
}
Esempio n. 12
0
//internal use.
//skips the cached version
func (this *RouterTable) toDynMap() *dynmap.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)
	mp.Put("partition_keys", this.PartitionKeys)

	entries := make([]*dynmap.DynMap, 0)
	for _, e := range this.Entries {
		entries = append(entries, e.ToDynMap())
	}
	mp.Put("entries", entries)
	this.DynMap = mp
	return mp
}
Esempio n. 13
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
}
Esempio n. 14
0
func (this *HttpClient) ApiCallSync(req *cheshire.Request, timeout time.Duration) (*cheshire.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 = &cheshire.Response{*dynmap.NewDynMap()}
	err = response.UnmarshalJSON(body)
	if err != nil {
		return nil, err
	}
	return response, nil
}
Esempio n. 15
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)
	mp.Put("last_seen_at", this.LastSeenAt)
	this.DynMap = mp
	return mp
}
Esempio n. 16
0
func Flash(txn *Txn, severity, message string) {
	d := dynmap.NewDynMap()
	d.Put("severity", severity)
	d.Put("message", message)
	txn.Session.AddToSlice("_flash", d)
}