package main
import (
"bufio"
"fmt"
"log"
"net"
"os"
)
type Client struct {
writer *bufio.Writer
}
func (client *Client) Write(data string) error {
fmt.Println("client write")
_, err := client.writer.WriteString(data)
err = client.writer.Flush()
return err
}
func NewClient(connection net.Conn) *Client {
writer := bufio.NewWriter(connection)
client := &Client{
writer: writer,
}
return client
}
type ChatRoom struct {
clients []*Client
}
func (chatRoom *ChatRoom) Broadcast(data string) {
deleted := 0
for i := range chatRoom.clients {
j := i - deleted
if err := chatRoom.clients[j].Write(data); err != nil {
fmt.Println(err, "deleted error")
chatRoom.clients = chatRoom.clients[:j+copy(chatRoom.clients[j:], chatRoom.clients[j+1:])]
deleted++
}
}
}
func (chatRoom *ChatRoom) Join(connection net.Conn) {
client := NewClient(connection)
chatRoom.clients = append(chatRoom.clients, client)
}
func NewChatRoom() *ChatRoom {
chatRoom := &ChatRoom{
clients: make([]*Client, 0),
}
return chatRoom
}
func main() {
chatRoom := NewChatRoom()
listener, _ := net.Listen("tcp4", ":3333")
go readAndSend(chatRoom)
for {
conn, err := listener.Accept()
if err != nil {
continue
}
chatRoom.Join(conn)
}
}
func readAndSend(chatRoom *ChatRoom) {
reader := bufio.NewReader(os.Stdin)
for {
fmt.Print("Enter text: ")
text, _ := reader.ReadString('\n')
log.Print(text)
chatRoom.Broadcast(text)
}
}
package main
import (
"bufio"
"fmt"
"io"
"log"
"net"
"os"
"strconv"
"strings"
)
var messages chan string
func main() {
messages = make(chan string, 10)
var port int = 3333
listen, err := net.Listen("tcp4", ":"+strconv.Itoa(port))
defer listen.Close()
if err != nil {
log.Fatalf("Прослушивание порта %d не удалось,\r\n\r\n %s", port, err)
os.Exit(1)
}
go func() {
log.Printf("Сервер слушает порт: %d", port)
reader := bufio.NewReader(os.Stdin)
for {
fmt.Print("Enter text: ")
text, _ := reader.ReadString('\n')
log.Print(text)
messages <- text
}
}()
for {
conn, err := listen.Accept()
if err != nil {
log.Fatalln(err)
continue
}
go handler(conn)
}
}
func handler(conn net.Conn) {
defer conn.Close()
var (
buf = make([]byte, 1024)
r = bufio.NewReader(conn)
w = bufio.NewWriter(conn)
)
ILOOP:
for {
n, err := r.Read(buf)
data := string(buf[:n])
switch err {
case io.EOF:
break ILOOP
case nil:
log.Println("Получил:", data)
if isTransportOver(data) {
break ILOOP
}
default:
log.Fatalf("Ошибка при получении:%s", err)
return
}
}
//данные из канала
msg := <-messages
w.Write([]byte(msg))
w.Flush()
}
func isTransportOver(data string) (over bool) {
over = strings.HasSuffix(data, "\r\n\r\n")
return
}
package main
import (
"path_to_pkg/pkg"
"github.com/gin-gonic/gin"
)
var r *gin.Engine
func init() {
r = gin.New()
pkg.Concon(r.Group("/pkg"))
}
func main() {
r.Run(":8080")
}
package pkg
import "github.com/gin-gonic/gin"
func Concon(g *gin.RouterGroup) {
g.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
}
package main
import (
"html/template"
"io/ioutil"
"net/http"
)
func hello(res http.ResponseWriter, req *http.Request) {
bs, err := ioutil.ReadFile("TestPage.txt")
if err != nil {
return
}
str := string(bs)
t := template.New("Test Template")
t, _ = t.Parse(str)
p := map[string]string{
"H": "Hydrogen",
"He": "Helium",
}
res.Header().Set(
"Content-Type",
"text/html",
)
t.Execute(res, p)
}
func main() {
http.HandleFunc("/hello", hello)
http.ListenAndServe(":8080", nil)
}