Une semaine pour coder par soi même : Jour 4

Allez je vais être franc, j'y ai pas trop trop touché aujourd'hui, j'étais occupé par ailleurs. J'ai presque pas lurker sur le Fédiverse et à peine sur les IRC.

J'ai quand même un peu discuté avec Cacatoès qui m'a soufflé que ça serait très probablement un peu mieux en utilisant de la programmation orientée objet. Et après discussion et lecture à droite à gauche, ça pourrait être pas mal plus simple.

Ça m'a également fait remonter quelques vieux souvenirs de Java. Je fais quelques tests sur une version copiée et effectivement ça a l'air jouable.

Du coup, allez hop, je reprends le code d'hier et je commence à y créer une structure pour la gestion de l'IRC. Je commence à faire une première méthode, ça marche, une seconde ça marche. Et là attention, je tente le tout pour le tout et BAM ça marche plus. Le scope des variables de mon objet me pose soucis.

J'ai l'impression que si je modifie une variable de ma structure dans l'une des méthodes (typiquement le net.Conn) dans une autre méthode ça n'a pas été modifié :-( J'ai naïvement pensé que les méthodes d'un struct pouvaient modifier les variables du struct globalement mais visiblement non. Du coup je suis pas spécialement plus avancé. Je voulais créer une méthode qui se connecte au lieu de le mettre dans le New mais du coup je ne peux pas…

J'imagine qu'il y a probablement une subtilité qui m'échappe.

Encore une fois je précise que je débute à 100% et que je compte pas en faire mon métier ni rien, c'est plus pour (re)découvrir et tenter de faire un ptit projet fonctionnel.

Bon et pour avoir l'impression d'avoir un truc un peu mieux qu'hier, j'ai mis le switch.

Voilà rien de transcendant aujourd'hui :-/

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
package main

import (
	"bufio"
	"fmt"
	"net"
	"os"
	"io"
	"strings"
	"time"
    )

var server string = "localhost"
var port string = "6667"
var channel string = "#lms"
var nick string = "bab"
var commander string = ":Lord!Lord@geeknode.fuckyeah"
var onchan bool
var rouge string = "\033[1;31m"
var vert string = "\033[1;32m"
var jaune string = "\033[1;33m"
var cyan string = "\033[1;36m"
var normal string = "\033[0m"
var me string
var ircconn net.Conn
var debug bool


func main() {

	if len(os.Args) > 1 {
		server = os.Args[1]
	}
	ircconn = initIrc(server, port, nick, channel)

	go incoming()
	ircconnbuf := bufio.NewReader(ircconn)
	go io.Copy(ircconn, os.Stdin)

	for {
		msg, err := ircconnbuf.ReadString('\n')
		if err != nil {
    			fmt.Println(err)
			break
		}
		fmt.Print(jaune+"<< "+msg+normal)
		parseIrc(msg)
	}
	
	defer ircconn.Close()
}

// ------------------
// Côté IRC
// ------------------

func initIrc(server string, port string, nick string, channel string) net.Conn{
	conn, err := net.Dial("tcp",server+":"+port)
	fmt.Println(rouge+server+":"+port+normal)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	fmt.Println(rouge+">> NICK "+nick+normal)
	io.WriteString(conn,"NICK "+nick+"\n")
	fmt.Println(rouge+">> USER "+nick+" 0.0.0.0 "+nick+" :"+nick+" bot"+normal)
	io.WriteString(conn,"USER "+nick+" 0.0.0.0 "+nick+" :"+nick+" bot\n")
	go joinChan(conn,channel)
	return conn
}

func joinChan(conn net.Conn,channel string){
	time.Sleep(1000 * time.Millisecond)
	fmt.Println(rouge+">> JOIN "+channel+normal)
	io.WriteString(conn,"JOIN "+channel+"\n")
}

func parseIrc(msg string){
	var elements []string = strings.Fields(msg)
	for i, element := range elements {
		fmt.Print(cyan+"[",i,"|"+normal+element+cyan+"] "+normal )
	}
	fmt.Println("")

		if elements[0] == "PING" {
			fmt.Print(rouge+">> PONG "+strings.TrimPrefix(msg, "PING :")+normal)
			io.WriteString(ircconn,"PONG "+strings.TrimPrefix(msg, "PING :")+"\n")
		}

		switch elements[1] {
        		case "421" :
        			fmt.Println("!! Commande non reconnue par le serveur !!")
        		case "433" :
        			nick = nick+"_"
        			io.WriteString(ircconn,"NICK "+nick+"\n")
        		case "JOIN" :
            			if ":"+nick == stringCut(elements[0],"!"){
					me = strings.TrimPrefix(elements[0],":")
        				fmt.Println(me+" a rejoin le salon "+strings.Trim(elements[2],":"))
        				onchan = true
        				sendIrc("c'est moi que vla!")

            			}
        		case "PART" :
        			fmt.Println("On est parti de "+strings.Trim(elements[2],":"))
        			onchan = false
        		case "KICK" :
        		if elements[3] == nick {
        			fmt.Println("Ptain on s'est fait kicker de "+elements[2]+" par "+elements[4]+" !")
        			io.WriteString(ircconn,"JOIN "+channel+"\n")
        		}
        		case ":Closing" :
        		if elements[2] == "Link:" {
        			// Déconnecté
        			ircconn = initIrc(server, port, nick, channel)
        		}	
		}
}

func sendIrc(msg string){
	msg = strings.TrimSpace(msg)
	fmt.Print(rouge+">> PRIVMSG "+channel+" :"+msg+"\n"+normal)
	io.WriteString(ircconn,"PRIVMSG "+channel+" :"+msg+"\n")

}

// ------------------
// Serveur en écoute
// ------------------

func incoming(){
	in, err :=net.Listen("tcp",":4321")
	defer in.Close()
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	for {
		inconn, err :=in.Accept()
		if err != nil {
			fmt.Println(err)
			continue
		}
		go handleIncoming(inconn)
	}
}

func handleIncoming(in net.Conn){
	fmt.Println(vert+"Incoming from ",in.RemoteAddr(),normal)
	inbuf := bufio.NewReader(in)
	for {
    		inmsg, err := inbuf.ReadString('\n')
    		if err != nil || !onchan || inmsg == "\n" {
			break
    		}
    		fmt.Print(vert+"<<]] "+inmsg+normal)
    		sendIrc(inmsg)
		time.Sleep(500 * time.Millisecond)
	}
}

// ------------
//  Génériques
// ------------

func stringCut(incoming string, pattern string) string{
	var results = strings.Split(incoming, pattern)
	if len(results) < 1 {
		return incoming
	} else {
		return results[0]
	}
}

Le bilan positif de la journée : je n'ai pas plus de ligne de code qu'hier !