コード例 #1
0
ファイル: mux.go プロジェクト: cdshann/minimega
// mux routes incoming messages from the server based on message type
func mux() {
	// start piping data to minitunnel and trunking it over the ron
	local, remote := net.Pipe()
	defer local.Close()
	defer remote.Close()

	go func() {
		if err := minitunnel.ListenAndServe(local); err != nil {
			log.Error("ListenAndServe: %v", err)
		}
	}()

	go ron.Trunk(remote, Client.UUID, sendMessage)

	// Read messages from gob, mux message to the correct place
	var err error

	log.Debug("starting mux")

	for err == nil {
		var m ron.Message
		if err = Client.dec.Decode(&m); err == io.EOF {
			// server disconnected... try to reconnect
			err = dial()
			continue
		} else if err != nil {
			break
		}

		log.Debug("new message: %v", m.Type)

		switch m.Type {
		case ron.MESSAGE_COMMAND:
			updateClient(&m)
			Client.commandChan <- m.Commands
		case ron.MESSAGE_FILE:
			Client.fileChan <- &m
		case ron.MESSAGE_TUNNEL:
			_, err = remote.Write(m.Tunnel)
		default:
			err = fmt.Errorf("unknown message type: %v", m.Type)
		}
	}

	log.Info("mux exit: %v", err)
}
コード例 #2
0
ファイル: tunnel.go プロジェクト: ITLivLab/minimega
// tunnel transport handler
func (c *Client) handleTunnel(server bool, stop chan bool) {
	log.Debug("handleTunnel: %v", server)

	a, b := net.Pipe()

	c.tunnelData = make(chan []byte, 1024)

	go func() {
		if server {
			var err error
			c.tunnel, err = minitunnel.Dial(a)
			if err != nil {
				log.Errorln("Dial: %v", err)
				a.Close()
				b.Close()
			}
		} else {
			go func() {
				err := minitunnel.ListenAndServe(a)
				if err != nil {
					log.Fatalln("ListenAndServe: %v", err)
				}
			}()
		}
	}()

	go func() {
		for {
			var buf = make([]byte, BUFFER_SIZE)
			n, err := b.Read(buf)
			if err != nil {
				if err != io.ErrClosedPipe {
					log.Errorln(err)
				}
				a.Close()
				b.Close()
				return
			}

			// push it up in a message
			m := &Message{
				Type:   MESSAGE_TUNNEL,
				UUID:   c.UUID,
				Tunnel: buf[:n],
			}

			c.out <- m
		}
	}()

	go func() {
		for {
			data := <-c.tunnelData
			if data == nil {
				return
			}
			_, err := b.Write(data)
			if err != nil {
				log.Errorln(err)
				a.Close()
				b.Close()
				return
			}
		}
	}()

	<-stop
	log.Debug("ron client tunnel close: %v", c.UUID)
	a.Close()
	b.Close()
	close(c.tunnelData)
}