go coap Download - go coap Quellcode herunterladen

go coap

Andere Kategorien

v3.3.6

Herunterladen

Go-CoAP

Das Constrained Application Protocol (CoAP) ist ein spezielles Webübertragungsprotokoll zur Verwendung mit eingeschränkten Knoten und eingeschränkten Netzwerken im Internet der Dinge. Das Protokoll ist für Machine-to-Machine (M2M)-Anwendungen wie intelligente Energie und Gebäudeautomation konzipiert.

Der Go-Coap stellt Server und Clients für DTLS, TCP-TLS, UDP, TCP in Golang-Sprache bereit.

Merkmale

CoAP über UDP RFC 7252.
CoAP über TCP/TLS RFC 8232
Beachten Sie die Ressourcen in CoAP RFC 7641
Blockweise Übertragungen in CoAP RFC 7959
Multiplexer anfordern
Multicast
CoAP NoResponse-Option in CoAP RFC 7967
CoAP über DTLS Pion/Dtls
Zu viele Anfragen, Antwortcode RFC 8516

Anforderungen

Gehen Sie auf 1,20 oder höher

Proben

Einfach

Server-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))
    }

Kunde

    // 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 )
    }