examples/go: http handler & http server

examples/go/http_server.go

+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package main
+
+import (
+        "fmt"
+        "log"
+        "net"
+        "net/http"
+        "time"
+
+        "golang.org/x/mobile/app"
+
+        "mojo/public/go/application"
+        "mojo/public/go/bindings"
+        "mojo/public/go/system"
+
+        "mojo/services/network/public/interfaces/net_address"
+        "mojo/services/network/public/interfaces/network_service"
+        "mojo/services/network/public/interfaces/tcp_bound_socket"
+        "mojo/services/network/public/interfaces/tcp_connected_socket"
+        "mojo/services/network/public/interfaces/tcp_server_socket"
+)
+
+//#include "mojo/public/c/system/types.h"
+import "C"
+
+type MojoConnection struct {
+        sendStream    system.ProducerHandle
+        receiveStream system.ConsumerHandle
+        socket        system.MessagePipeHandle
+        localAddr     net.Addr
+        remoteAddr    net.Addr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Read(b []byte) (int, error) {
+        l := len(b)
+        r, read := c.receiveStream.BeginReadData(l, system.MOJO_READ_DATA_FLAG_NONE)
+        if r != system.MOJO_RESULT_OK {
+                return 0, fmt.Errorf("can't read %v bytes: %v", l, r)
+        }
+        if l > len(read) {
+                l = len(read)
+        }
+        copy(b, read[:l])
+        if r := c.receiveStream.EndReadData(l); r != system.MOJO_RESULT_OK {
+                return 0, fmt.Errorf("can't read %v bytes: %v", l, r)
+        }
+        return l, nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Write(b []byte) (int, error) {
+        l := len(b)
+        r, buf := c.sendStream.BeginWriteData(l, system.MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)
+        if r != system.MOJO_RESULT_OK {
+                return 0, fmt.Errorf("can't write %v bytes: %v", l, r)
+        }
+        copy(buf, b)
+        if r := c.sendStream.EndWriteData(l); r != system.MOJO_RESULT_OK {
+                return 0, fmt.Errorf("can't write %v bytes: %v", l, r)
+        }
+        return l, nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) Close() error {
+        c.sendStream.Close()
+        c.receiveStream.Close()
+        c.socket.Close()
+        return nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) LocalAddr() net.Addr {
+        return c.localAddr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) RemoteAddr() net.Addr {
+        return c.remoteAddr
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetDeadline(t time.Time) error {
+        if err := c.SetReadDeadline(t); err != nil {
+                return err
+        }
+        return c.SetWriteDeadline(t)
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetReadDeadline(t time.Time) error {
+        // Do nothing.
+        return nil
+}
+
+// Implements net.Conn.
+func (c *MojoConnection) SetWriteDeadline(t time.Time) error {
+        // Do nothing.
+        return nil
+}
+
+type MojoListener struct {
+        serverSocket *tcp_server_socket.TcpServerSocketProxy
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Accept() (net.Conn, error) {
+        r, sendProducer, sendConsumer := system.GetCore().CreateDataPipe(nil)
+        if r != system.MOJO_RESULT_OK {
+                panic(fmt.Sprintf("can't create data pipe: %v", r))
+        }
+        r, receiveProducer, receiveConsumer := system.GetCore().CreateDataPipe(nil)
+        if r != system.MOJO_RESULT_OK {
+                panic(fmt.Sprintf("can't create data pipe: %v", r))
+        }
+        request, pointer := tcp_connected_socket.CreateMessagePipeForTcpConnectedSocket()
+        networkError, remoteAddress, err := l.serverSocket.Accept(sendConsumer, receiveProducer, request)
+        if err != nil {
+                return nil, err
+        }
+        if networkError.Code != 0 {
+                return nil, fmt.Errorf("%s", *networkError.Description)
+        }
+
+        var addr net.Addr
+        if remoteAddress.Ipv4 != nil {
+                addr = &net.TCPAddr{
+                        IP:   remoteAddress.Ipv4.Addr[:4],
+                        Port: int(remoteAddress.Ipv4.Port),
+                }
+        } else {
+                addr = &net.TCPAddr{
+                        IP:   remoteAddress.Ipv6.Addr[:16],
+                        Port: int(remoteAddress.Ipv6.Port),
+                }
+        }
+        return &MojoConnection{
+                sendProducer,
+                receiveConsumer,
+                pointer.PassMessagePipe(),
+                l.Addr(),
+                addr,
+        }, nil
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Close() error {
+        l.serverSocket.Close_proxy()
+        return nil
+}
+
+// Implements net.Listener.
+func (l *MojoListener) Addr() net.Addr {
+        return &net.TCPAddr{
+                IP:   []byte{127, 0, 0, 1},
+                Port: 8080,
+        }
+}
+
+type HttpServerDelegate struct {
+        networkService *network_service.NetworkServiceProxy
+        tcpBoundSocket *tcp_bound_socket.TcpBoundSocketProxy
+        serverSocket   *tcp_server_socket.TcpServerSocketProxy
+}
+
+func (d *HttpServerDelegate) InitTCPBoundSocket() error {
+        addr := &net_address.NetAddress{
+                net_address.NetAddressFamily_IpV4,
+                &net_address.NetAddressIPv4{
+                        8080,
+                        [4]uint8{127, 0, 0, 1},
+                },
+                nil,
+        }
+        request, pointer := tcp_bound_socket.CreateMessagePipeForTcpBoundSocket()
+        networkError, _, err := d.networkService.CreateTcpBoundSocket(addr, request)
+        if err != nil {
+                return err
+        }
+        if networkError.Code != 0 {
+                return fmt.Errorf("%s", *networkError.Description)
+        }
+        d.tcpBoundSocket = tcp_bound_socket.NewTcpBoundSocketProxy(pointer, bindings.GetAsyncWaiter())
+        return nil
+}
+
+func (d *HttpServerDelegate) InitServerSocket() error {
+        request, pointer := tcp_server_socket.CreateMessagePipeForTcpServerSocket()
+        networkError, err := d.tcpBoundSocket.StartListening(request)
+        if err != nil {
+                return err
+        }
+        if networkError.Code != 0 {
+                return fmt.Errorf("%s", *networkError.Description)
+        }
+        d.serverSocket = tcp_server_socket.NewTcpServerSocketProxy(pointer, bindings.GetAsyncWaiter())
+        return nil
+}
+
+func (d *HttpServerDelegate) Initialize(ctx application.Context) {
+        request, pointer := network_service.CreateMessagePipeForNetworkService()
+        ctx.ConnectToApplication("mojo:network_service").ConnectToService(&request)
+        d.networkService = network_service.NewNetworkServiceProxy(pointer, bindings.GetAsyncWaiter())
+
+        if err := d.InitTCPBoundSocket(); err != nil {
+                log.Printf("can't create TCP socket: %v\n", err)
+                return
+        }
+        if err := d.InitServerSocket(); err != nil {
+                log.Printf("can't create server socket: %v\n", err)
+                return
+        }
+
+        http.HandleFunc("/go", func(w http.ResponseWriter, r *http.Request) {
+                fmt.Fprintf(w, "Hello, Go http server!")
+        })
+        l := &MojoListener{d.serverSocket}
+        if err := http.Serve(l, nil); err != nil {
+                log.Printf("can't serve request: %v\n", err)
+                return
+        }
+}
+
+func (d *HttpServerDelegate) AcceptConnection(c *application.Connection) {
+        c.Close()
+}
+
+func (d *HttpServerDelegate) Quit() {
+        d.networkService.Close_proxy()
+        d.tcpBoundSocket.Close_proxy()
+        d.serverSocket.Close_proxy()
+}
+
+//export MojoMain
+func MojoMain(handle C.MojoHandle) C.MojoResult {
+        application.Run(&HttpServerDelegate{}, system.MojoHandle(handle))
+        return C.MOJO_RESULT_OK
+}
+
+func main() {
+        app.Run(app.Callbacks{})
+}