Esempio n. 1
0
// Handle the data from a single imported data stream, which will
// have the form
//	(response, data)*
// The response identifies by name which channel is receiving data.
// TODO: allow an importer to send.
func (imp *Importer) run() {
	// Loop on responses; requests are sent by ImportNValues()
	resp := new(response)
	for {
		if err := imp.decode(resp); err != nil {
			log.Stderr("importer response decode:", err)
			break
		}
		if resp.error != "" {
			log.Stderr("importer response error:", resp.error)
			// TODO: tear down connection
			break
		}
		imp.chanLock.Lock()
		ich, ok := imp.chans[resp.name]
		imp.chanLock.Unlock()
		if !ok {
			log.Stderr("unknown name in request:", resp.name)
			break
		}
		if ich.dir != Recv {
			log.Stderr("TODO: import send unimplemented")
			break
		}
		// Create a new value for each received item.
		val := reflect.MakeZero(ich.ptr.Type().(*reflect.PtrType).Elem())
		ich.ptr.PointTo(val)
		if err := imp.decode(ich.ptr.Interface()); err != nil {
			log.Stderr("importer value decode:", err)
			return
		}
		ich.ch.Send(val)
	}
}
Esempio n. 2
0
func main() {

	// create the client.  Here we are using a synchronous client.
	// Using the default ConnectionSpec, we are specifying the client to connect
	// to db 13 (e.g. SELECT 13), and a password of go-redis (e.g. AUTH go-redis)

	spec := redis.DefaultSpec().Db(13).Password("go-redis")
	client, e := redis.NewSynchClientWithSpec(spec)
	if e != nil {
		log.Stderr("failed to create the client", e)
		return
	}

	key := "examples/hello/user.name"
	value, e := client.Get(key)
	if e != nil {
		log.Stderr("error on Get", e)
		return
	}

	if value == nil {
		fmt.Printf("\nHello, don't believe we've met before!\nYour name? ")
		reader := bufio.NewReader(os.Stdin)
		user, _ := reader.ReadString(byte('\n'))
		if len(user) > 1 {
			user = user[0 : len(user)-1]
			value = []byte(user)
			client.Set(key, value)
		} else {
			fmt.Printf("vafanculo!\n")
			return
		}
	}
	fmt.Printf("Hey, ciao %s!\n", fmt.Sprintf("%s", value))
}
Esempio n. 3
0
// WriteHeader sends an HTTP response header with status code.
// If WriteHeader is not called explicitly, the first call to Write
// will trigger an implicit WriteHeader(http.StatusOK).
// Thus explicit calls to WriteHeader are mainly used to
// send error codes.
func (c *Conn) WriteHeader(code int) {
	if c.hijacked {
		log.Stderr("http: Conn.WriteHeader on hijacked connection")
		return
	}
	if c.wroteHeader {
		log.Stderr("http: multiple Conn.WriteHeader calls")
		return
	}
	c.wroteHeader = true
	c.status = code
	c.written = 0
	if !c.Req.ProtoAtLeast(1, 0) {
		return
	}
	proto := "HTTP/1.0"
	if c.Req.ProtoAtLeast(1, 1) {
		proto = "HTTP/1.1"
	}
	codestring := strconv.Itoa(code)
	text, ok := statusText[code]
	if !ok {
		text = "status code " + codestring
	}
	io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n")
	for k, v := range c.header {
		io.WriteString(c.buf, k+": "+v+"\r\n")
	}
	io.WriteString(c.buf, "\r\n")
}
Esempio n. 4
0
// Send all the data on a single channel to a client asking for a Recv
func (client *expClient) serveRecv(req *request) {
	exp := client.exp
	resp := new(response)
	resp.name = req.name
	var ok bool
	exp.chanLock.Lock()
	ech, ok := exp.chans[req.name]
	exp.chanLock.Unlock()
	if !ok {
		resp.error = "no such channel: " + req.name
		log.Stderr("export:", resp.error)
		client.encode(resp, nil) // ignore any encode error, hope client gets it
		return
	}
	for {
		if ech.dir != Send {
			log.Stderr("TODO: recv export unimplemented")
			break
		}
		val := ech.ch.Recv()
		if err := client.encode(resp, val.Interface()); err != nil {
			log.Stderr("error encoding client response:", err)
			break
		}
		if req.count > 0 {
			req.count--
			if req.count == 0 {
				break
			}
		}
	}
}
Esempio n. 5
0
// WriteHeader sends an HTTP response header with status code.
// If WriteHeader is not called explicitly, the first call to Write
// will trigger an implicit WriteHeader(http.StatusOK).
// Thus explicit calls to WriteHeader are mainly used to
// send error codes.
func (c *Conn) WriteHeader(code int) {
	if c.hijacked {
		log.Stderr("http: Conn.WriteHeader on hijacked connection")
		return
	}
	if c.wroteHeader {
		log.Stderr("http: multiple Conn.WriteHeader calls")
		return
	}
	c.wroteHeader = true
	c.status = code
	if code == StatusNotModified {
		// Must not have body.
		c.header["Content-Type"] = "", false
		c.header["Transfer-Encoding"] = "", false
	}
	c.written = 0
	if !c.Req.ProtoAtLeast(1, 0) {
		return
	}
	proto := "HTTP/1.0"
	if c.Req.ProtoAtLeast(1, 1) {
		proto = "HTTP/1.1"
	}
	codestring := strconv.Itoa(code)
	text, ok := statusText[code]
	if !ok {
		text = "status code " + codestring
	}
	io.WriteString(c.buf, proto+" "+codestring+" "+text+"\r\n")
	for k, v := range c.header {
		io.WriteString(c.buf, k+": "+v+"\r\n")
	}
	io.WriteString(c.buf, "\r\n")
}
Esempio n. 6
0
func proxyMuxer() {
	proxyMap := make(map[string]*proxy)
	for {
		select {
		case pp := <-queue:
			key := make([]byte, keyLen)
			// read key
			n, err := pp.r.Body.Read(key)
			if n != keyLen || err != nil {
				log.Stderr("Couldn't read key", key)
				continue
			}
			// find proxy
			p, ok := proxyMap[string(key)]
			if !ok {
				log.Stderr("Couldn't find proxy", key)
				continue
			}
			// handle
			p.handle(pp)
		case p := <-createQueue:
			proxyMap[p.key] = p
		}
	}
}
Esempio n. 7
0
func serveConnection(serverName string, secure bool, handler web.Handler, netConn net.Conn) {
	br := bufio.NewReader(netConn)
	for {
		c := conn{
			serverName: serverName,
			secure:     secure,
			netConn:    netConn,
			br:         br}
		if err := c.prepare(); err != nil {
			if err != os.EOF {
				log.Stderr("twister/sever: prepare failed", err)
			}
			break
		}
		handler.ServeWeb(c.req)
		if c.hijacked {
			return
		}
		if err := c.finish(); err != nil {
			log.Stderr("twister/sever: finish failed", err)
			break
		}
		if c.closeAfterResponse {
			break
		}
	}
	netConn.Close()
}
Esempio n. 8
0
func managementTask (c *asyncConnHdl, ctl workerCtl) (sig *interrupt_code, te *taskStatus) {
/* TODO:
connected:
	clearChannels();
	startWokers();
disconnected:
	?
on_fault:
	disconnect();
	goto disconnected;
on_exit:
	?
*/
	log.Stderr("MGR: do task ...");
	select {
		case stat:= <-c.feedback:
		log.Stderr("MGR: Feedback from one of my minions: ", stat);
		// do the shutdown for now -- TODO: try reconnect
		if stat.event == faulted {
			log.Stderr("MGR: Shutting down due to fault in ", stat.id);
			go func() { c.reqProcCtl <- stop; } ();
			go func() { c.rspProcCtl <- stop; } ();
			go func() { c.heartbeatCtl <- stop; } ();
			
			log.Stderr("MGR: Signal SHUTDOWN ... ");
			c.shutdown <- true;
			// stop self // TODO: should manager really be a task or a FSM?
			c.managerCtl <- stop;
		}
	case s := <- ctl:
		return &s, &ok_status;
	}
	
	return nil, &ok_status;
}
Esempio n. 9
0
// Manage sends and receives for a single client.  For each (client Recv) request,
// this will launch a serveRecv goroutine to deliver the data for that channel,
// while (client Send) requests are handled as data arrives from the client.
func (client *expClient) run() {
	hdr := new(header)
	req := new(request)
	error := new(error)
	for {
		if err := client.decode(hdr); err != nil {
			log.Stderr("error decoding client header:", err)
			// TODO: tear down connection
			return
		}
		switch hdr.payloadType {
		case payRequest:
			if err := client.decode(req); err != nil {
				log.Stderr("error decoding client request:", err)
				// TODO: tear down connection
				return
			}
			switch req.dir {
			case Recv:
				go client.serveRecv(*hdr, req.count)
			case Send:
				// Request to send is clear as a matter of protocol
				// but not actually used by the implementation.
				// The actual sends will have payload type payData.
				// TODO: manage the count?
			default:
				error.error = "export request: can't handle channel direction"
				log.Stderr(error.error, req.dir)
				client.encode(hdr, payError, error)
			}
		case payData:
			client.serveSend(*hdr)
		}
	}
}
Esempio n. 10
0
func heartbeatTask (c *asyncConnHdl, ctl workerCtl) (sig *interrupt_code, te *taskStatus) {
	var async AsyncConnection = c;
	select {
	case <-NewTimer (ns1Sec * c.super.spec.heartbeat): 
		response, e := async.QueueRequest(&PING, [][]byte{});
		if e != nil {
			return nil, &taskStatus {reqerr, e};
		}
		stat, re, ok := response.future.(FutureBool).TryGet(ns1Sec);
		if re != nil { 
			log.Stderr ("ERROR: Heartbeat recieved error response on PING");
			return nil, &taskStatus {error, re}; 
		}
		else if !ok {
			log.Stderr ("Warning: Heartbeat timeout on get PING response.")
		}
		else {
			// flytrap
			if stat != true {
				log.Stderr ("<BUG> Heartbeat recieved false stat on PING while response error was nil");
				return nil, &taskStatus {error, NewError(SYSTEM_ERR, "BUG false stat on PING w/out error")}; 
			}
		}
	case sig := <- ctl:
		return &sig, &ok_status;
	}
	return nil, &ok_status;
}
Esempio n. 11
0
func handleMessage(s net.Conn, reqChannel chan MCRequest) (ret bool) {
	log.Stdoutf("Handling a message...")
	hdrBytes := make([]byte, HDR_LEN)
	ret = false

	log.Stdoutf("Reading header...")
	bytesRead, err := io.ReadFull(s, hdrBytes)
	if err != nil || bytesRead != HDR_LEN {
		log.Stderr("Error reading message: %s (%d bytes)", err, bytesRead)
		return
	}

	req := grokHeader(hdrBytes)

	readContents(s, req)

	log.Stdout("Processing message %s", req)
	req.ResponseChannel = make(chan MCResponse)
	reqChannel <- req
	res := <-req.ResponseChannel
	ret = !res.Fatal
	if ret {
		log.Stdoutf("Got response %s", res)
		transmitResponse(s, req, res)
	} else {
		log.Stderr("Something went wrong, hanging up...")
	}

	return
}
Esempio n. 12
0
func main() {
	flag.Parse()

	listener, err := net.Listen("tcp", *listenAddr)
	if err != nil {
		panic(err)
	}

	conn, err := listener.Accept()
	if err != nil {
		panic(err)
	}

	buf := new(bytes.Buffer)

	// initiate new session and read key
	log.Stderr("Attempting connect", *destAddr)
	buf.Write([]byte(*destAddr))
	resp, err := http.Post(
		"http://"+*httpAddr+"/create",
		"text/plain",
		buf)
	if err != nil {
		panic(err)
	}
	key, _ := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	log.Stderr("Connected, key", key)

	// ticker to set a rate at which to hit the server
	tick := time.NewTicker(int64(*tickInterval) * 1e6)
	read := makeReadChan(conn, bufSize)
	buf.Reset()
	for {
		select {
		case <-tick.C:
			// write buf to new http request
			req := bytes.NewBuffer(key)
			buf.WriteTo(req)
			resp, err := http.Post(
				"http://"+*httpAddr+"/ping",
				"application/octet-stream",
				req)
			if err != nil {
				log.Stderr(err.String())
				continue
			}
			// write http response response to conn
			io.Copy(conn, resp.Body)
			resp.Body.Close()
		case b := <-read:
			buf.Write(b)
		}
	}
}
Esempio n. 13
0
// This could find a happy home in a generalized worker package ...
// TODO
func (c *asyncConnHdl) worker(id int, name string, task workerTask, ctl workerCtl, fb chan workerStatus) {
	var signal interrupt_code
	var tstat *taskStatus

	// todo: add startup hook for worker

await_signal:
	log.Stdout(name, "_worker: await_signal.")
	signal = <-ctl

on_interrupt:
	//		log.Stdout(name, "_worker: on_interrupt: ", signal);
	switch signal {
	case stop:
		goto before_stop
	case pause:
		goto await_signal
	case start:
		goto work
	}

work:
	//		log.Stdout(name, "_worker: work!");
	select {
	case signal = <-ctl:
		goto on_interrupt
	default:
		is, stat := task(c, ctl) // todo is a task context type
		if stat == nil {
			log.Stderr("<BUG> nil stat from worker ", name)
		}
		if stat.code != ok {
			log.Stdout(name, "_worker: task error!")
			tstat = stat
			goto on_error
		} else if is != nil {
			signal = *is
			goto on_interrupt
		}
		goto work
	}

on_error:
	log.Stdout(name, "_worker: on_error!")
	// TODO: log it, send it, and go back to wait_start:
	log.Stderr(name, "_worker task raised error: ", tstat)
	fb <- workerStatus{id, faulted, tstat, &ctl}
	goto await_signal

before_stop:
	log.Stdout(name, "_worker: before_stop!")
	// TODO: add shutdown hook for worker

	log.Stdout(name, "_worker: STOPPED!")
}
Esempio n. 14
0
func NewProxy(key, destAddr string) (p *proxy, err os.Error) {
	p = &proxy{C: make(chan proxyPacket), key: key}
	log.Stderr("Attempting connect", destAddr)
	p.conn, err = net.Dial("tcp", "", destAddr)
	if err != nil {
		return
	}
	p.conn.SetReadTimeout(readTimeout)
	log.Stderr("Connected", destAddr)
	return
}
Esempio n. 15
0
File: server.go Progetto: royger/DAD
func signalListener(end chan bool) {
	for {
		if n := <-signal.Incoming; strings.HasPrefix(n.String(), "SIGINT") {
			log.Stderr("Received SIGINT, ending execution")
			end <- true
			return
		} else {
			log.Stderr("Received singal", n, "ignoring")
		}
	}
}
Esempio n. 16
0
func main() {
	var m int
	var user g9p.User
	var file *g9pc.File

	flag.Parse()
	user = g9p.OsUsers.Uid2User(os.Geteuid())
	c, err := g9pc.Mount("tcp", *addr, "", user, nil)
	if err != nil {
		goto error
	}

	if flag.NArg() != 1 {
		log.Stderr("invalid arguments")
		return
	}

	file, err = c.FOpen(flag.Arg(0), g9p.OWRITE|g9p.OTRUNC)
	if err != nil {
		file, err = c.FCreate(flag.Arg(0), 0666, g9p.OWRITE)
		if err != nil {
			goto error
		}
	}

	buf := make([]byte, 8192)
	for {
		n, oserr := os.Stdin.Read(buf)
		if oserr != nil && oserr != io.EOF {
			err = &g9p.Error{oserr.String(), 0}
			goto error
		}

		if n == 0 {
			break
		}

		m, err = file.Write(buf[0:n])
		if err != nil {
			goto error
		}

		if m != n {
			err = &g9p.Error{"short write", 0}
			goto error
		}
	}

	file.Close()
	return

error:
	log.Stderr(fmt.Sprintf("Error: %v", err))
}
Esempio n. 17
0
// Redis PING command.
func (c *syncClient) Ping() (err Error) {
	if c == nil {
		log.Stderr("FAULT in synchclient.Ping(): why is c nil?")
		return NewError(SYSTEM_ERR, "c *syncClient is NIL!")
	} else if c.conn == nil {
		log.Stderr("FAULT in synchclient.Ping(): why is c.conn nil?")
		return NewError(SYSTEM_ERR, "c.conn *SynchConnection is NIL!")
	}
	_, err = c.conn.ServiceRequest(&PING, [][]byte{})
	return
}
Esempio n. 18
0
// Wait for incoming connections, start a new runner for each
func (exp *Exporter) listen() {
	for {
		conn, err := exp.listener.Accept()
		if err != nil {
			log.Stderr("exporter.listen:", err)
			break
		}
		log.Stderr("accepted call from", conn.RemoteAddr())
		client := newClient(exp, conn)
		go client.run()
	}
}
Esempio n. 19
0
func (server *serverType) input(conn io.ReadWriteCloser) {
	dec := gob.NewDecoder(conn)
	enc := gob.NewEncoder(conn)
	sending := new(sync.Mutex)
	for {
		// Grab the request header.
		req := new(Request)
		err := dec.Decode(req)
		if err != nil {
			if err == os.EOF || err == io.ErrUnexpectedEOF {
				log.Stderr("rpc: ", err)
				break
			}
			s := "rpc: server cannot decode request: " + err.String()
			sendResponse(sending, req, invalidRequest, enc, s)
			continue
		}
		serviceMethod := strings.Split(req.ServiceMethod, ".", 0)
		if len(serviceMethod) != 2 {
			s := "rpc: service/method request ill:formed: " + req.ServiceMethod
			sendResponse(sending, req, invalidRequest, enc, s)
			continue
		}
		// Look up the request.
		server.Lock()
		service, ok := server.serviceMap[serviceMethod[0]]
		server.Unlock()
		if !ok {
			s := "rpc: can't find service " + req.ServiceMethod
			sendResponse(sending, req, invalidRequest, enc, s)
			continue
		}
		mtype, ok := service.method[serviceMethod[1]]
		if !ok {
			s := "rpc: can't find method " + req.ServiceMethod
			sendResponse(sending, req, invalidRequest, enc, s)
			continue
		}
		// Decode the argument value.
		argv := _new(mtype.argType)
		replyv := _new(mtype.replyType)
		err = dec.Decode(argv.Interface())
		if err != nil {
			log.Stderr("rpc: tearing down", serviceMethod[0], "connection:", err)
			sendResponse(sending, req, replyv.Interface(), enc, err.String())
			continue
		}
		go service.call(sending, mtype, req, argv, replyv, enc)
	}
	conn.Close()
}
Esempio n. 20
0
// ImportNValues imports a channel of the given type and specified direction
// and then receives or transmits up to n values on that channel.  A value of
// n==0 implies an unbounded number of values.  The channel to be bound to
// the remote site's channel is provided in the call and may be of arbitrary
// channel type.
// Despite the literal signature, the effective signature is
//	ImportNValues(name string, chT chan T, dir Dir, pT T)
// where T must be a struct, pointer to struct, etc.  pT may be more indirect
// than the value type of the channel (e.g.  chan T, pT *T) but it must be a
// pointer.
// Example usage:
//	imp, err := NewImporter("tcp", "netchanserver.mydomain.com:1234")
//	if err != nil { log.Exit(err) }
//	ch := make(chan myType)
//	err := imp.ImportNValues("name", ch, Recv, new(myType), 1)
//	if err != nil { log.Exit(err) }
//	fmt.Printf("%+v\n", <-ch)
// (TODO: Can we eliminate the need for pT?)
func (imp *Importer) ImportNValues(name string, chT interface{}, dir Dir, pT interface{}, n int) os.Error {
	ch, err := checkChan(chT, dir)
	if err != nil {
		return err
	}
	// Make sure pT is a pointer (to a pointer...) to a struct.
	rt := reflect.Typeof(pT)
	if _, ok := rt.(*reflect.PtrType); !ok {
		return os.ErrorString("not a pointer:" + rt.String())
	}
	if _, ok := reflect.Indirect(reflect.NewValue(pT)).(*reflect.StructValue); !ok {
		return os.ErrorString("not a pointer to a struct:" + rt.String())
	}
	imp.chanLock.Lock()
	defer imp.chanLock.Unlock()
	_, present := imp.chans[name]
	if present {
		return os.ErrorString("channel name already being imported:" + name)
	}
	ptr := reflect.MakeZero(reflect.Typeof(pT)).(*reflect.PtrValue)
	imp.chans[name] = &importChan{ch, dir, ptr, n}
	// Tell the other side about this channel.
	req := new(request)
	req.name = name
	req.dir = dir
	req.count = n
	if err := imp.encode(req, nil); err != nil {
		log.Stderr("importer request encode:", err)
		return err
	}
	return nil
}
Esempio n. 21
0
func (c *asyncConnHdl) QueueRequest (cmd *Command, args [][]byte) (*PendingResponse, Error) {
	select {
	case <- c.shutdown:
		log.Stderr("<DEBUG> we're shutdown and not accepting any more requests ...");
		return nil, NewError(SYSTEM_ERR, "Connection is shutdown.");
	default: 
	}
	
	future := CreateFuture (cmd);
	
	request := &asyncRequestInfo{0, 0, cmd, nil, future, nil};
	buff, e1 := CreateRequestBytes(cmd, args);
	if e1 == nil {
		request.outbuff = &buff;
		c.pendingReqs<- request;
	} 
	else {
		errmsg:= fmt.Sprintf("Failed to create asynchrequest - %s aborted", cmd.Code);	
		request.stat = inierr;
		request.error = NewErrorWithCause(SYSTEM_ERR, errmsg, e1); // only makes sense if using go ...
		request.future.(FutureResult).onError(request.error);	
		
		return nil, request.error; // remove if restoring go
	}
//}();	
	// done.
	return &PendingResponse {future}, nil;
}
Esempio n. 22
0
// Task: 
// process one pending response at a time
// - can be interrupted while waiting on the pending responses queue
// - buffered reader takes care of minimizing network io
//
// KNOWN BUG: 
// until we figure out what's the problem with read timeout, can not 
// be interrupted if hanging on a read
func rspProcessingTask (c *asyncConnHdl, ctl workerCtl) (sig *interrupt_code, te *taskStatus) {

	var req asyncReqPtr;	
	select {
	case sig := <- ctl:
		// interrupted
		return &sig, &ok_status;
	case req = <-c.pendingResps:
		// continue to process
	}
	
	// process response to asyncRequest
	reader:= c.super.reader;
	cmd:= req.cmd;
	
	resp, e3:= GetResponse (reader, cmd);
	if e3!= nil {
		// system error
		log.Stderr("<TEMP DEBUG> Request sent to faults chan on error in GetResponse: ", e3);
		req.stat = rcverr;
		req.error = NewErrorWithCause (SYSTEM_ERR, "GetResponse os.Error", e3);
		c.faults <- req;
		return nil, &taskStatus {rcverr, e3};
	}
	SetFutureResult (req.future, cmd, resp);

	return nil, &ok_status;
}
Esempio n. 23
0
func main() {
	var response *http.Response
	var err error

	api := notifo.New("gotest", "a25c4f206494150bddf2e716705c8bedcad0cb16")
	//api.SetEndpoint("http://localhost:8000/v1/");

	if response, err = api.SubscribeUser("devcamcar"); err != nil {
		log.Stderr("ERROR")
		log.Stderr(err)
	} else {
		dump, _ := httputil.DumpResponse(response, true)
		log.Stdout(response.StatusCode)
		log.Stdout(string(dump))
	}
}
Esempio n. 24
0
// receives ?returnto=/replies etc.
func CALLBACK(c *http.Conn, req *http.Request, auth_client *oauth.AuthClient) {
	log.Stderr("CALLBACK!");
	req.ParseForm();
	for k,v := range req.Header {
		log.Stderrf("header:%s:%s", k, v);
	}
	for k,vs := range req.Form {
		log.Stderrf("form:%s::", k);
		for i := range vs {
			log.Stderrf("::%s", vs[i]);
		}
	}

	var auth_token = req.FormValue("oauth_token");
	var auth_verifier = req.FormValue("oauth_verifier");
	log.Stderrf("CALLBACK:auth_token:%s:", auth_token);
	log.Stderrf("CALLBACK:auth_verifier:%s:", auth_verifier);

	user_info := auth_client.GetUserInfo(auth_token, auth_verifier);

	log.Stderrf("USER_INFO:");
	for k,v := range user_info {
		log.Stderrf("k:%s v:%s", k, v);
	}

	session_service.StartSession(c, req, user_info);
	var url = "/";
	returnto := req.FormValue("returnto");
	if returnto != "" {
		url = returnto;
	}
	http.Redirect(c, url, http.StatusFound); // should be 303 instead of 302?
}
Esempio n. 25
0
func TWITTER_REPLIES(c *http.Conn, req *http.Request) {
	log.Stderrf(">REPLIES:");
	s := session_service.GetSession(c,req);
	for k,v := range s.Data {
		log.Stderrf("session kv:%s:%s", k, v);
	}
	auth_token, atx := s.Data["oauth_token"];
	if atx {
		log.Stderrf("TOKEN FOUND!");
		auth_token_secret := s.Data["oauth_token_secret"];
		r, finalUrl, err := twitter_client.MakeRequest("http://twitter.com/statuses/mentions.json", map[string]string{"oauth_token":auth_token}, auth_token_secret, false); //{"since_id":s.last_reply_id})
		if err != nil {
			log.Stderrf(":REPLIES:err:%s",err);
		}
		else {
			log.Stderrf(":REPLIES:r:%s:finalUrl:%s", r, finalUrl);
			b, _ := io.ReadAll(r.Body);
			print ("REPLIES!");
			str := bytes.NewBuffer(b).String();
       			println (str);
			j, ok, errtok := json.StringToJson(str);
			log.Stderr("REPLIES:j:%s:ok:%s:errtok:%s", j, ok, errtok);
			c.Write(strings.Bytes(j.String()));
		}
	
	}
	else {
		log.Stderrf("NO TOKEN FOUND!");
		http.Redirect(c, "/login/twitter?returnto=/twitter/replies", http.StatusFound); // should be 303 instead of 302?
	}
}
Esempio n. 26
0
func main() {
	in := bufio.NewReader(os.Stdin)
	lines := vector.StringVector(make([]string, 0, 500))

	for {
		for {
			l, err := in.ReadString('\n')

			if err != nil {
				log.Stderr("Error reading map, expected more input\n")
				return
			}

			if l == "go\n" {
				pw := ParseGameState(lines)
				DoTurn(pw)
				pw.EndTurn()
				break
			} else {
				lines.Push(l)
			}
		}

		lines = lines[0:0]
	}
}
Esempio n. 27
0
func ParseGameState(lines []string) *PlanetWars {
	pw := &PlanetWars{make([]*Planet, len(lines)), make([]*Fleet, len(lines))}
	pNum, fNum := 0, 0

	for _, ln := range lines {

		switch ln[0] {
		case 'P':
			p := &Planet{ID: pNum}
			read, e := fmt.Sscanf(ln[2:], "%f %f %d %d %d", &p.X, &p.Y, &p.Owner, &p.NumShips, &p.GrowthRate)

			if read < 5 || e != nil {
				log.Stderrf("Bad line in input: %s\n", ln)
			}
			pw.Planets[pNum] = p
			pNum++
		case 'F':
			f := &Fleet{ID: fNum}
			read, e := fmt.Sscanf(ln[2:], "%d %d %d %d %d", &f.Owner, &f.NumShips, &f.Source, &f.Dest, &f.TripLength, &f.TurnsRemaining)

			if read < 5 || e != nil {
				log.Stderrf("Bad line in input: %s\n", ln)
			}
			pw.Fleets[fNum] = f
			fNum++
		default:
			log.Stderr("Error parsing gamestate: First char of line not 'P' or 'F'\n")
			return nil
		}
	}

	pw.Fleets = pw.Fleets[0:fNum]
	pw.Planets = pw.Planets[0:pNum]
	return pw
}
Esempio n. 28
0
func (client *Client) input() {
	var err os.Error;
	for err == nil {
		response := new(Response);
		err = client.dec.Decode(response);
		if err != nil {
			if err == os.EOF {
				err = io.ErrUnexpectedEOF;
			}
			break;
		}
		seq := response.Seq;
		client.mutex.Lock();
		c := client.pending[seq];
		client.pending[seq] = c, false;
		client.mutex.Unlock();
		err = client.dec.Decode(c.Reply);
		c.Error = os.ErrorString(response.Error);
		// We don't want to block here.  It is the caller's responsibility to make
		// sure the channel has enough buffer space. See comment in Go().
		_ = c.Done <- c;	// do not block
	}
	// Terminate pending calls.
	client.mutex.Lock();
	client.shutdown = err;
	for _, call := range client.pending {
		call.Error = err;
		_ = call.Done <- call;	// do not block
	}
	client.mutex.Unlock();
	log.Stderr("client protocol error:", err);
}
Esempio n. 29
0
func withNewError(m string) os.Error {
	e := os.NewError(m)
	if debug() {
		log.Stderr(e)
	}
	return e
}
Esempio n. 30
0
// Write writes the data to the connection as part of an HTTP reply.
// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)
// before writing the data.
func (c *Conn) Write(data []byte) (n int, err os.Error) {
	if c.hijacked {
		log.Stderr("http: Conn.Write on hijacked connection")
		return 0, ErrHijacked
	}
	if !c.wroteHeader {
		c.WriteHeader(StatusOK)
	}
	if len(data) == 0 {
		return 0, nil
	}

	c.written += int64(len(data)) // ignoring errors, for errorKludge

	// TODO(rsc): if chunking happened after the buffering,
	// then there would be fewer chunk headers.
	// On the other hand, it would make hijacking more difficult.
	if c.chunking {
		fmt.Fprintf(c.buf, "%x\r\n", len(data)) // TODO(rsc): use strconv not fmt
	}
	n, err = c.buf.Write(data)
	if err == nil && c.chunking {
		if n != len(data) {
			err = io.ErrShortWrite
		}
		if err == nil {
			io.WriteString(c.buf, "\r\n")
		}
	}

	return n, err
}