Go for the would be network programmer

go
for the would-be network programmer
@feyeleanor
go for the would-be network programmer 1 http://slides.games-with-brains.net/

twitter://@feyeleanor
leanpub://GoNotebook
go for the would-be network programmer http://slides.games-with-brains.net/

high voltage
networking
concurrency
cryptography
go for the would-be network programmer http://slides.games-with-brains.net/

http

package main
import (
. "fmt"
"net/http"
)
const MESSAGE = "hello world"
const ADDRESS = ":1024"
func main() {
http.HandleFunc("/hello", Hello)
if e := http.ListenAndServe(ADDRESS, nil); e != nil {
Println(e)
}
}
func Hello(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/plain")
Fprintf(w, MESSAGE)
}
go for the would-be network programmer http://5 slides.games-with-brains.net/

package main
import (
. "fmt"
"net/http"
)
func main() {
Println(e)
}
}
Fprintf(w, MESSAGE)
}

package main
import (
. "fmt"
. "net/http"
)
func main() {
HandleFunc("/hello", Hello)
if e := ListenAndServe(ADDRESS, nil); e != nil {
Println(e)
}
}
func Hello(w ResponseWriter, r *Request) {
Fprintf(w, MESSAGE)
}

package main
import (
. "fmt"
. ”net/http"
)
func main() {
Println(e)
}
}
Fprintf(w, MESSAGE)
}

package main
import (
. "fmt"
. "net/http"
)
func main() {
HandleFunc("/hello", func(w ResponseWriter, r *Request) {
Fprintf(w, MESSAGE)
})
ListenAndServe(ADDRESS, nil)
}

package main
import (
. "fmt"
. "net/http"
)
func main() {
Fprintf(w, MESSAGE)
})
ListenAndServe(ADDRESS, nil)
}

package main
import (
. "fmt"
. "net/http"
)
func main() {
message := "hello world"
Fprintf(w, message)
})
ListenAndServeTLS(ADDRESS, "cert.pem", "key.pem", nil)
}

package main
import (
. "fmt"
. "net/http"
)
func main() {
Fprintf(w, message)
})
}

concurrency

package main
import . "fmt"
import . "net/http"
func main() {
Fprintf(w, "hello world")
})
done := make(chan bool)
go func() {
ListenAndServe(":1024", nil)
done <- true
}()
ListenAndServeTLS(":1025", "cert.pem", "key.pem", nil)
<- done
}

package main
import . "fmt"
import . "net/http"
func main() {
})
go func() {
done <- true
}()
<- done
}

package main
import . "fmt"
import . "net/http"
func main() {
})
Spawn(
func() {
},
func() {
},
)
}

package main
import . "fmt"
import . "net/http"
func main() {
})
Spawn(func() {
})
Spawn(func() {
})
}

package main
func Spawn(f ...func()) {
for _, s := range f {
go func(server func()) {
server()
done <- true
}(s)
}
for l := len(f); l > 0; l-- {
<- done
}
}

package main
server()
done <- true
}(s)
}
for l := len(f); l > 0; l-- {
<- done
}
}

waitgroups

package main
import . "fmt"
import . "net/http"
import "sync"
func main() {
HandleFunc("/hello", func(w ResponseWriter, r *Request) {})
var servers sync.WaitGroup
servers.Add(1)
go func() {
defer servers.Done()
}()
servers.Add(1)
go func() {
}()
servers.Wait()
}

package main
import . "fmt"
import . "net/http"
import "sync"
func main() {
servers.Add(1)
go func() {
}()
servers.Add(1)
go func() {
}()
servers.Wait()
}

package main
import . "fmt"
import . "net/http"
import "sync"
func main() {
})
Spawn(func() {
})
Spawn(func() {
})
servers.Wait()
}

package main
servers.Add(1)
server()
}(s)
}
}

tcp

package main
import . "fmt"
import "net"
func main() {
if listener, e := net.Listen("tcp", ":1024"); e == nil {
for {
if connection, e := listener.Accept(); e == nil {
go func(c net.Conn) {
defer c.Close()
Fprintln(c, "hello world")
}(connection)
}
}
}
}

package main
import . "fmt"
import "net"
func main() {
for {
defer c.Close()
}(connection)
}
}
}
}

package main
import . "fmt"
import "net"
func main() {
Listen("tcp", ":1024", func(c net.Conn) {
defer c.Close()
})
}
func Listen(p, a string, f func(net.Conn)) (e error) {
var listener net.Listener
if listener, e = net.Listen(p, a); e == nil {
for {
go f(connection)
}
}
}
return
}

package main
import . "fmt"
import "net"
func main() {
defer c.Close()
})
}
for {
go f(connection)
}
}
}
return
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
if c, e := net.Dial("tcp", ":1024"); e == nil {
defer c.Close()
if m, e := bufio.NewReader(c).ReadString('n'); e == nil {
Printf(m)
}
}
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
defer c.Close()
Printf(m)
}
}
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Dial("tcp", ":1024", func(c net.Conn) {
Printf(m)
}
})
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Printf(m)
}
})
}
func Dial(p, a string, f func(net.Conn)) (e error) {
var c net.Conn
if c, e = net.Dial(p, a); e == nil {
defer c.Close()
f(c)
}
return
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Printf(m)
}
})
}
var c net.Conn
defer c.Close()
f(c)
}
return
}

tcp/tls

package main
import "crypto/tls"
import . "fmt"
func main() {
Listen(":1025", ConfigTLS("scert", "skey"), func(c *tls.Conn) {
})
}

package main
import "crypto/tls"
import . "fmt"
func main() {
})
}

package main
import "crypto/rand"
import "crypto/tls"
func ConfigTLS(c, k string) (r *tls.Config) {
if cert, e := tls.LoadX509KeyPair(c, k); e == nil {
r = &tls.Config{
Certificates: []tls.Certificate{ cert },
Rand: rand.Reader,
}
}
return
}

package main
import "crypto/tls"
r = &tls.Config{
Rand: rand.Reader,
}
}
return
}

package main
import "crypto/tls"
func Listen(a string, conf *tls.Config, f func(*tls.Conn)) {
if listener, e := tls.Listen("tcp", a, conf); e == nil {
for {
go func(c *tls.Conn) {
defer c.Close()
f(c)
}(connection.(*tls.Conn))
}
}
}
}

package main
import "crypto/tls"
for {
defer c.Close()
f(c)
}
}
}
}

package main
import “crypto/tls"
import "net"
func Listen(a string, conf *tls.Config, f func(net.Conn)) {
for {
defer c.Close()
f(c)
}(connection)
}
}
}
}

package main
import "crypto/tls"
import "net"
func Listen(a string, conf *tls.Config, f func(net.Conn)) {
for {
defer c.Close()
f(c)
}(connection)
}
}
}
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Dial(":1025", ConfigTLS("ccert", "ckey"), func(c net.Conn) {
Printf(m)
}
})
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Printf(m)
}
})
}

package main
import "crypto/tls"
r = &tls.Config{
InsecureSkipVerify: true,
}
}
return
}

package main
import "crypto/tls"
r = &tls.Config{
}
}
return
}

package main
import "net"
func Dial(a string, conf *tls.Config, f func(net.Conn)) {
if c, e := tls.Dial("tcp", a, conf); e == nil {
defer c.Close()
f(c)
}
}

udp

package main
import "net"
func main() {
HELLO_WORLD := []byte("Hello Worldn")
Listen(":1024", func(c *net.UDPConn, a *net.UDPAddr, b []byte) {
c.WriteToUDP(HELLO_WORLD, a)
})
}
func Listen(a string, f func(*net.UDPConn, *net.UDPAddr, []byte)) {
if address, e := net.ResolveUDPAddr("udp", a); e == nil {
if conn, e := net.ListenUDP("udp", address); e == nil {
for b := make([]byte, 1024); ; b = make([]byte, 1024) {
if n, client, e := conn.ReadFromUDP(b); e == nil {
go f(conn, client, b[:n])
}
}
}
}
return
}

package main
import "net"
func main() {
HELLO_WORLD := []byte("Hello Worldn”)
})
}
}
}
}
}
return
}

package main
import "net"
func main() {
})
}
}
}
}
}
return
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Dial(":1024", func(conn net.Conn) {
if _, e := conn.Write([]byte("n")); e == nil {
if m, e := bufio.NewReader(conn).ReadString('n'); e == nil {
Printf("%v", m)
}
}
})
}
func Dial(a string, f func(net.Conn)) {
if conn, e := net.DialUDP("udp", nil, address); e == nil {
defer conn.Close()
f(conn)
}
}
}

package main
import "bufio"
import . "fmt"
import "net"
func main() {
Printf("%v", m)
}
}
})
}
defer conn.Close()
f(conn)
}
}
}

rsa

package main
import "net"
func main() {
})
}
}
}
}
}
return
}

package main
import . "bytes"
import "crypto/rsa"
import "encoding/gob"
import "net"
func main() {
HELLO_WORLD := []byte("Hello World")
RSA_LABEL := []byte("served")
var key rsa.PublicKey
if e := gob.NewDecoder(NewBuffer(b)).Decode(&key); e == nil {
if m, e := Encrypt(&key, HELLO_WORLD, RSA_LABEL); e == nil {
c.WriteToUDP(m, a)
}
}
return
})
}

package main
import . "bytes"
import "crypto/rsa"
import "net"
func main() {
c.WriteToUDP(m, a)
}
}
return
})
}

package main
import "crypto/rsa"
import "crypto/sha1"
func Encrypt(key *rsa.PublicKey, m, l []byte) ([]byte, error) {
return rsa.EncryptOAEP(sha1.New(), rand.Reader, key, m, l)
}

package main
import "crypto/rsa"
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
func main() {
Dial(":1025", "ckey", func(c *net.UDPConn, k *rsa.PrivateKey) {
if m, e := ReadStream(c); e == nil {
if m, e := Decrypt(k, m, []byte("served")); e == nil {
Println(string(m))
}
}
})
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
func main() {
Println(string(m))
}
}
})
}

package main
import "crypto/rsa"
func Decrypt(key *rsa.PrivateKey, m, l []byte) ([]byte, error) {
return rsa.DecryptOAEP(sha1.New(), rand.Reader, key, m, l)
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
func main() {
Println(string(m))
}
}
})
}

package main
import "net"
func ReadStream(conn *net.UDPConn) (r []byte, e error) {
m := make([]byte, 1024)
var n int
if n, e = conn.Read(m); e == nil {
r = m[:n]
}
return
}

package main
import "net"
m := make([]byte, 1024)
var n int
r = m[:n]
}
return
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
func main() {
Println(string(m))
}
}
})
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
func Dial(a, file string, f func(*net.UDPConn, *rsa.PrivateKey)) {
if k, e := LoadPrivateKey(file); e == nil {
defer conn.Close()
SendKey(conn, k.PublicKey, func() {
f(conn, k)
})
}
}
}
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
defer conn.Close()
f(conn, k)
})
}
}
}
}

package main
import "crypto/rsa"
import "crypto/x509"
import "encoding/pem"
import "io/ioutil"
func LoadPrivateKey(file string) (r *rsa.PrivateKey, e error) {
if file, e := ioutil.ReadFile(file); e == nil {
if block, _ := pem.Decode(file); block != nil {
if block.Type == "RSA PRIVATE KEY" {
r, e = x509.ParsePKCS1PrivateKey(block.Bytes)
}
}
}
return
}

package main
import "crypto/rsa"
import "io/ioutil"
}
}
}
return
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
defer conn.Close()
f(conn, k)
})
}
}
}
}

package main
import "bytes"
import “crypto/rsa"
import "net"
func SendKey(c *net.UDPConn, k rsa.PublicKey, f func()) {
var b bytes.Buffer
if e := gob.NewEncoder(&b).Encode(k); e == nil {
if _, e = c.Write(b.Bytes()); e == nil {
f()
}
}
}

package main
import "bytes"
import "net"
var b bytes.Buffer
f()
}
}
}

package main
import "crypto/rsa"
import . "fmt"
import "net"
defer conn.Close()
f(conn, k)
})
}
}
}
}

http://golang.org/

twitter://#golang

Go for the would be network programmer

More Related Content

What's hot (20)

Similar to Go for the would be network programmer (20)

More from Eleanor McHugh (20)

Recently uploaded (20)

Go for the would be network programmer