go coap Télécharger - go coap Téléchargement du code source

go coap

Autres catégories

v3.3.6

Télécharger

Go-CoAP

Le Constrained Application Protocol (CoAP) est un protocole de transfert Web spécialisé destiné à être utilisé avec des nœuds contraints et des réseaux contraints dans l'Internet des objets. Le protocole est conçu pour les applications machine-to-machine (M2M) telles que l'énergie intelligente et l'automatisation des bâtiments.

Le go-coap fournit des serveurs et des clients pour DTLS, TCP-TLS, UDP, TCP en langage golang.

Caractéristiques

CoAP sur UDP RFC 7252.
CoAP sur TCP/TLS RFC 8232
Observer les ressources dans CoAP RFC 7641
Transferts par blocs dans CoAP RFC 7959
demande de multiplexeur
multidiffusion
Option CoAP NoResponse dans CoAP RFC 7967
CoAP sur pion/dtls DTLS
Trop de requêtes, code de réponse RFC 8516

Exigences

Passez à 1.20 ou supérieur

Échantillons

Simple

Serveur UDP/TCP

    // Server

    // Middleware function, which will be called for each request.
    func loggingMiddleware ( next mux. Handler ) mux. Handler {
        return mux . HandlerFunc ( func ( w mux. ResponseWriter , r * mux. Message ) {
            log . Printf ( "ClientAddress %v, %v n " , w . Conn (). RemoteAddr (), r . String ())
            next . ServeCOAP ( w , r )
        })
    }

    // See /examples/simple/server/main.go
    func handleA ( w mux. ResponseWriter , req * mux. Message ) {
        err := w . SetResponse ( codes . GET , message . TextPlain , bytes . NewReader ([] byte ( "hello world" )))
        if err != nil {
            log . Printf ( "cannot set response: %v" , err )
        }
    }

    func main () {
        r := mux . NewRouter ()
        r . Use ( loggingMiddleware )
        r . Handle ( "/a" , mux . HandlerFunc ( handleA ))
        r . Handle ( "/b" , mux . HandlerFunc ( handleB ))

        log . Fatal ( coap . ListenAndServe ( "udp" , ":5688" , r ))


        // for tcp
        // log.Fatal(coap.ListenAndServe("tcp", ":5688",  r))

        // for tcp-tls
        // log.Fatal(coap.ListenAndServeTLS("tcp", ":5688", &tls.Config{...}, r))

        // for udp-dtls
        // log.Fatal(coap.ListenAndServeDTLS("udp", ":5688", &dtls.Config{...}, r))
    }

Client

    // Client
    // See /examples/simpler/client/main.go
    func main () {
        co , err := udp . Dial ( "localhost:5688" )

        // for tcp
        // co, err := tcp.Dial("localhost:5688")

        // for tcp-tls
        // co, err := tcp.Dial("localhost:5688", tcp.WithTLS(&tls.Config{...}))

        // for dtls
        // co, err := dtls.Dial("localhost:5688", &dtls.Config{...}))

        if err != nil {
            log . Fatalf ( "Error dialing: %v" , err )
        }
        ctx , cancel := context . WithTimeout ( context . Background (), time . Second )
        defer cancel ()
        resp , err := co . Get ( ctx , "/a" )
        if err != nil {
            log . Fatalf ( "Cannot get response: %v" , err )
            return
        }
        log . Printf ( "Response: %+v" , resp )
    }