id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
10,000 | 256dpi/gomqtt | client/client.go | processSuback | func (c *Client) processSuback(suback *packet.Suback) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, suback.ID)
if err != nil {
return err
}
// get future
subscribeFuture := c.futureStore.Get(suback.ID)
if subscribeFuture == nil {
return nil // ignore a wrongly sent Suback packet
}
// remove future from store
c.futureStore.Delete(suback.ID)
// validate subscriptions if requested
if c.config.ValidateSubs {
for _, code := range suback.ReturnCodes {
if code == packet.QOSFailure {
subscribeFuture.Cancel()
return ErrFailedSubscription
}
}
}
// complete future
subscribeFuture.Data.Store(returnCodesKey, suback.ReturnCodes)
subscribeFuture.Complete()
return nil
} | go | func (c *Client) processSuback(suback *packet.Suback) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, suback.ID)
if err != nil {
return err
}
// get future
subscribeFuture := c.futureStore.Get(suback.ID)
if subscribeFuture == nil {
return nil // ignore a wrongly sent Suback packet
}
// remove future from store
c.futureStore.Delete(suback.ID)
// validate subscriptions if requested
if c.config.ValidateSubs {
for _, code := range suback.ReturnCodes {
if code == packet.QOSFailure {
subscribeFuture.Cancel()
return ErrFailedSubscription
}
}
}
// complete future
subscribeFuture.Data.Store(returnCodesKey, suback.ReturnCodes)
subscribeFuture.Complete()
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processSuback",
"(",
"suback",
"*",
"packet",
".",
"Suback",
")",
"error",
"{",
"// remove packet from store",
"err",
":=",
"c",
".",
"Session",
".",
"DeletePacket",
"(",
"session",
".",
"Outgoing",
",",
"suback",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// get future",
"subscribeFuture",
":=",
"c",
".",
"futureStore",
".",
"Get",
"(",
"suback",
".",
"ID",
")",
"\n",
"if",
"subscribeFuture",
"==",
"nil",
"{",
"return",
"nil",
"// ignore a wrongly sent Suback packet",
"\n",
"}",
"\n\n",
"// remove future from store",
"c",
".",
"futureStore",
".",
"Delete",
"(",
"suback",
".",
"ID",
")",
"\n\n",
"// validate subscriptions if requested",
"if",
"c",
".",
"config",
".",
"ValidateSubs",
"{",
"for",
"_",
",",
"code",
":=",
"range",
"suback",
".",
"ReturnCodes",
"{",
"if",
"code",
"==",
"packet",
".",
"QOSFailure",
"{",
"subscribeFuture",
".",
"Cancel",
"(",
")",
"\n",
"return",
"ErrFailedSubscription",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// complete future",
"subscribeFuture",
".",
"Data",
".",
"Store",
"(",
"returnCodesKey",
",",
"suback",
".",
"ReturnCodes",
")",
"\n",
"subscribeFuture",
".",
"Complete",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Suback packet | [
"handle",
"an",
"incoming",
"Suback",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L559-L590 |
10,001 | 256dpi/gomqtt | client/client.go | processUnsuback | func (c *Client) processUnsuback(unsuback *packet.Unsuback) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, unsuback.ID)
if err != nil {
return err
}
// get future
unsubscribeFuture := c.futureStore.Get(unsuback.ID)
if unsubscribeFuture == nil {
return nil // ignore a wrongly sent Unsuback packet
}
// complete future
unsubscribeFuture.Complete()
// remove future from store
c.futureStore.Delete(unsuback.ID)
return nil
} | go | func (c *Client) processUnsuback(unsuback *packet.Unsuback) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, unsuback.ID)
if err != nil {
return err
}
// get future
unsubscribeFuture := c.futureStore.Get(unsuback.ID)
if unsubscribeFuture == nil {
return nil // ignore a wrongly sent Unsuback packet
}
// complete future
unsubscribeFuture.Complete()
// remove future from store
c.futureStore.Delete(unsuback.ID)
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processUnsuback",
"(",
"unsuback",
"*",
"packet",
".",
"Unsuback",
")",
"error",
"{",
"// remove packet from store",
"err",
":=",
"c",
".",
"Session",
".",
"DeletePacket",
"(",
"session",
".",
"Outgoing",
",",
"unsuback",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// get future",
"unsubscribeFuture",
":=",
"c",
".",
"futureStore",
".",
"Get",
"(",
"unsuback",
".",
"ID",
")",
"\n",
"if",
"unsubscribeFuture",
"==",
"nil",
"{",
"return",
"nil",
"// ignore a wrongly sent Unsuback packet",
"\n",
"}",
"\n\n",
"// complete future",
"unsubscribeFuture",
".",
"Complete",
"(",
")",
"\n\n",
"// remove future from store",
"c",
".",
"futureStore",
".",
"Delete",
"(",
"unsuback",
".",
"ID",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Unsuback packet | [
"handle",
"an",
"incoming",
"Unsuback",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L593-L613 |
10,002 | 256dpi/gomqtt | client/client.go | processPublish | func (c *Client) processPublish(publish *packet.Publish) error {
// call callback for unacknowledged and directly acknowledged messages
if publish.Message.QOS <= 1 {
if c.Callback != nil {
err := c.Callback(&publish.Message, nil)
if err != nil {
return c.die(err, true, true)
}
}
}
// handle qos 1 flow
if publish.Message.QOS == 1 {
// prepare puback packet
puback := packet.NewPuback()
puback.ID = publish.ID
// acknowledge qos 1 publish
err := c.send(puback, true)
if err != nil {
return c.die(err, false, false)
}
}
// handle qos 2 flow
if publish.Message.QOS == 2 {
// store packet
err := c.Session.SavePacket(session.Incoming, publish)
if err != nil {
return c.die(err, true, false)
}
// prepare pubrec packet
pubrec := packet.NewPubrec()
pubrec.ID = publish.ID
// acknowledge qos 2 publish
err = c.send(pubrec, true)
if err != nil {
return c.die(err, false, false)
}
}
return nil
} | go | func (c *Client) processPublish(publish *packet.Publish) error {
// call callback for unacknowledged and directly acknowledged messages
if publish.Message.QOS <= 1 {
if c.Callback != nil {
err := c.Callback(&publish.Message, nil)
if err != nil {
return c.die(err, true, true)
}
}
}
// handle qos 1 flow
if publish.Message.QOS == 1 {
// prepare puback packet
puback := packet.NewPuback()
puback.ID = publish.ID
// acknowledge qos 1 publish
err := c.send(puback, true)
if err != nil {
return c.die(err, false, false)
}
}
// handle qos 2 flow
if publish.Message.QOS == 2 {
// store packet
err := c.Session.SavePacket(session.Incoming, publish)
if err != nil {
return c.die(err, true, false)
}
// prepare pubrec packet
pubrec := packet.NewPubrec()
pubrec.ID = publish.ID
// acknowledge qos 2 publish
err = c.send(pubrec, true)
if err != nil {
return c.die(err, false, false)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPublish",
"(",
"publish",
"*",
"packet",
".",
"Publish",
")",
"error",
"{",
"// call callback for unacknowledged and directly acknowledged messages",
"if",
"publish",
".",
"Message",
".",
"QOS",
"<=",
"1",
"{",
"if",
"c",
".",
"Callback",
"!=",
"nil",
"{",
"err",
":=",
"c",
".",
"Callback",
"(",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// handle qos 1 flow",
"if",
"publish",
".",
"Message",
".",
"QOS",
"==",
"1",
"{",
"// prepare puback packet",
"puback",
":=",
"packet",
".",
"NewPuback",
"(",
")",
"\n",
"puback",
".",
"ID",
"=",
"publish",
".",
"ID",
"\n\n",
"// acknowledge qos 1 publish",
"err",
":=",
"c",
".",
"send",
"(",
"puback",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// handle qos 2 flow",
"if",
"publish",
".",
"Message",
".",
"QOS",
"==",
"2",
"{",
"// store packet",
"err",
":=",
"c",
".",
"Session",
".",
"SavePacket",
"(",
"session",
".",
"Incoming",
",",
"publish",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// prepare pubrec packet",
"pubrec",
":=",
"packet",
".",
"NewPubrec",
"(",
")",
"\n",
"pubrec",
".",
"ID",
"=",
"publish",
".",
"ID",
"\n\n",
"// acknowledge qos 2 publish",
"err",
"=",
"c",
".",
"send",
"(",
"pubrec",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Publish packet | [
"handle",
"an",
"incoming",
"Publish",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L616-L660 |
10,003 | 256dpi/gomqtt | client/client.go | processPubackAndPubcomp | func (c *Client) processPubackAndPubcomp(id packet.ID) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, id)
if err != nil {
return err
}
// get future
publishFuture := c.futureStore.Get(id)
if publishFuture == nil {
return nil // ignore a wrongly sent Puback or Pubcomp packet
}
// complete future
publishFuture.Complete()
// remove future from store
c.futureStore.Delete(id)
return nil
} | go | func (c *Client) processPubackAndPubcomp(id packet.ID) error {
// remove packet from store
err := c.Session.DeletePacket(session.Outgoing, id)
if err != nil {
return err
}
// get future
publishFuture := c.futureStore.Get(id)
if publishFuture == nil {
return nil // ignore a wrongly sent Puback or Pubcomp packet
}
// complete future
publishFuture.Complete()
// remove future from store
c.futureStore.Delete(id)
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPubackAndPubcomp",
"(",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"// remove packet from store",
"err",
":=",
"c",
".",
"Session",
".",
"DeletePacket",
"(",
"session",
".",
"Outgoing",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// get future",
"publishFuture",
":=",
"c",
".",
"futureStore",
".",
"Get",
"(",
"id",
")",
"\n",
"if",
"publishFuture",
"==",
"nil",
"{",
"return",
"nil",
"// ignore a wrongly sent Puback or Pubcomp packet",
"\n",
"}",
"\n\n",
"// complete future",
"publishFuture",
".",
"Complete",
"(",
")",
"\n\n",
"// remove future from store",
"c",
".",
"futureStore",
".",
"Delete",
"(",
"id",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Puback or Pubcomp packet | [
"handle",
"an",
"incoming",
"Puback",
"or",
"Pubcomp",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L663-L683 |
10,004 | 256dpi/gomqtt | client/client.go | processPubrec | func (c *Client) processPubrec(id packet.ID) error {
// prepare pubrel packet
pubrel := packet.NewPubrel()
pubrel.ID = id
// overwrite stored Publish with the Pubrel packet
err := c.Session.SavePacket(session.Outgoing, pubrel)
if err != nil {
return c.die(err, true, false)
}
// send packet
err = c.send(pubrel, true)
if err != nil {
return c.die(err, false, false)
}
return nil
} | go | func (c *Client) processPubrec(id packet.ID) error {
// prepare pubrel packet
pubrel := packet.NewPubrel()
pubrel.ID = id
// overwrite stored Publish with the Pubrel packet
err := c.Session.SavePacket(session.Outgoing, pubrel)
if err != nil {
return c.die(err, true, false)
}
// send packet
err = c.send(pubrel, true)
if err != nil {
return c.die(err, false, false)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPubrec",
"(",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"// prepare pubrel packet",
"pubrel",
":=",
"packet",
".",
"NewPubrel",
"(",
")",
"\n",
"pubrel",
".",
"ID",
"=",
"id",
"\n\n",
"// overwrite stored Publish with the Pubrel packet",
"err",
":=",
"c",
".",
"Session",
".",
"SavePacket",
"(",
"session",
".",
"Outgoing",
",",
"pubrel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// send packet",
"err",
"=",
"c",
".",
"send",
"(",
"pubrel",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Pubrec packet | [
"handle",
"an",
"incoming",
"Pubrec",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L686-L704 |
10,005 | 256dpi/gomqtt | client/client.go | processPubrel | func (c *Client) processPubrel(id packet.ID) error {
// get packet from store
pkt, err := c.Session.LookupPacket(session.Incoming, id)
if err != nil {
return c.die(err, true, false)
}
// get packet from store
publish, ok := pkt.(*packet.Publish)
if !ok {
return nil // ignore a wrongly sent Pubrel packet
}
// call callback
if c.Callback != nil {
err = c.Callback(&publish.Message, nil)
if err != nil {
return c.die(err, true, true)
}
}
// prepare pubcomp packet
pubcomp := packet.NewPubcomp()
pubcomp.ID = publish.ID
// acknowledge Publish packet
err = c.send(pubcomp, true)
if err != nil {
return c.die(err, false, false)
}
// remove packet from store
err = c.Session.DeletePacket(session.Incoming, id)
if err != nil {
return c.die(err, true, false)
}
return nil
} | go | func (c *Client) processPubrel(id packet.ID) error {
// get packet from store
pkt, err := c.Session.LookupPacket(session.Incoming, id)
if err != nil {
return c.die(err, true, false)
}
// get packet from store
publish, ok := pkt.(*packet.Publish)
if !ok {
return nil // ignore a wrongly sent Pubrel packet
}
// call callback
if c.Callback != nil {
err = c.Callback(&publish.Message, nil)
if err != nil {
return c.die(err, true, true)
}
}
// prepare pubcomp packet
pubcomp := packet.NewPubcomp()
pubcomp.ID = publish.ID
// acknowledge Publish packet
err = c.send(pubcomp, true)
if err != nil {
return c.die(err, false, false)
}
// remove packet from store
err = c.Session.DeletePacket(session.Incoming, id)
if err != nil {
return c.die(err, true, false)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPubrel",
"(",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"// get packet from store",
"pkt",
",",
"err",
":=",
"c",
".",
"Session",
".",
"LookupPacket",
"(",
"session",
".",
"Incoming",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// get packet from store",
"publish",
",",
"ok",
":=",
"pkt",
".",
"(",
"*",
"packet",
".",
"Publish",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
"// ignore a wrongly sent Pubrel packet",
"\n",
"}",
"\n\n",
"// call callback",
"if",
"c",
".",
"Callback",
"!=",
"nil",
"{",
"err",
"=",
"c",
".",
"Callback",
"(",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"true",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// prepare pubcomp packet",
"pubcomp",
":=",
"packet",
".",
"NewPubcomp",
"(",
")",
"\n",
"pubcomp",
".",
"ID",
"=",
"publish",
".",
"ID",
"\n\n",
"// acknowledge Publish packet",
"err",
"=",
"c",
".",
"send",
"(",
"pubcomp",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// remove packet from store",
"err",
"=",
"c",
".",
"Session",
".",
"DeletePacket",
"(",
"session",
".",
"Incoming",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Pubrel packet | [
"handle",
"an",
"incoming",
"Pubrel",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L707-L745 |
10,006 | 256dpi/gomqtt | client/client.go | die | func (c *Client) die(err error, close bool, fromCallback bool) error {
c.finish.Do(func() {
err = c.cleanup(err, close, false)
if c.Callback != nil && !fromCallback {
returnedErr := c.Callback(nil, err)
if returnedErr == nil {
err = nil
}
}
})
return err
} | go | func (c *Client) die(err error, close bool, fromCallback bool) error {
c.finish.Do(func() {
err = c.cleanup(err, close, false)
if c.Callback != nil && !fromCallback {
returnedErr := c.Callback(nil, err)
if returnedErr == nil {
err = nil
}
}
})
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"die",
"(",
"err",
"error",
",",
"close",
"bool",
",",
"fromCallback",
"bool",
")",
"error",
"{",
"c",
".",
"finish",
".",
"Do",
"(",
"func",
"(",
")",
"{",
"err",
"=",
"c",
".",
"cleanup",
"(",
"err",
",",
"close",
",",
"false",
")",
"\n\n",
"if",
"c",
".",
"Callback",
"!=",
"nil",
"&&",
"!",
"fromCallback",
"{",
"returnedErr",
":=",
"c",
".",
"Callback",
"(",
"nil",
",",
"err",
")",
"\n",
"if",
"returnedErr",
"==",
"nil",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // used for closing and cleaning up from internal goroutines | [
"used",
"for",
"closing",
"and",
"cleaning",
"up",
"from",
"internal",
"goroutines"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L840-L853 |
10,007 | 256dpi/gomqtt | client/client.go | end | func (c *Client) end(err error, possiblyClosed bool) error {
// close connection
err = c.cleanup(err, true, true)
// shutdown goroutines
c.tomb.Kill(nil)
// wait for all goroutines to exit
// goroutines will send eventual errors through the callback
c.tomb.Wait()
// do cleanup
return err
} | go | func (c *Client) end(err error, possiblyClosed bool) error {
// close connection
err = c.cleanup(err, true, true)
// shutdown goroutines
c.tomb.Kill(nil)
// wait for all goroutines to exit
// goroutines will send eventual errors through the callback
c.tomb.Wait()
// do cleanup
return err
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"end",
"(",
"err",
"error",
",",
"possiblyClosed",
"bool",
")",
"error",
"{",
"// close connection",
"err",
"=",
"c",
".",
"cleanup",
"(",
"err",
",",
"true",
",",
"true",
")",
"\n\n",
"// shutdown goroutines",
"c",
".",
"tomb",
".",
"Kill",
"(",
"nil",
")",
"\n\n",
"// wait for all goroutines to exit",
"// goroutines will send eventual errors through the callback",
"c",
".",
"tomb",
".",
"Wait",
"(",
")",
"\n\n",
"// do cleanup",
"return",
"err",
"\n",
"}"
] | // called by Disconnect and Close | [
"called",
"by",
"Disconnect",
"and",
"Close"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L856-L869 |
10,008 | 256dpi/gomqtt | broker/backend.go | NewMemoryBackend | func NewMemoryBackend() *MemoryBackend {
return &MemoryBackend{
SessionQueueSize: 100,
KillTimeout: 5 * time.Second,
activeClients: make(map[string]*Client),
storedSessions: make(map[string]*memorySession),
temporarySessions: make(map[*Client]*memorySession),
retainedMessages: topic.NewTree(),
}
} | go | func NewMemoryBackend() *MemoryBackend {
return &MemoryBackend{
SessionQueueSize: 100,
KillTimeout: 5 * time.Second,
activeClients: make(map[string]*Client),
storedSessions: make(map[string]*memorySession),
temporarySessions: make(map[*Client]*memorySession),
retainedMessages: topic.NewTree(),
}
} | [
"func",
"NewMemoryBackend",
"(",
")",
"*",
"MemoryBackend",
"{",
"return",
"&",
"MemoryBackend",
"{",
"SessionQueueSize",
":",
"100",
",",
"KillTimeout",
":",
"5",
"*",
"time",
".",
"Second",
",",
"activeClients",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Client",
")",
",",
"storedSessions",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"memorySession",
")",
",",
"temporarySessions",
":",
"make",
"(",
"map",
"[",
"*",
"Client",
"]",
"*",
"memorySession",
")",
",",
"retainedMessages",
":",
"topic",
".",
"NewTree",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewMemoryBackend returns a new MemoryBackend. | [
"NewMemoryBackend",
"returns",
"a",
"new",
"MemoryBackend",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L109-L118 |
10,009 | 256dpi/gomqtt | broker/backend.go | Authenticate | func (m *MemoryBackend) Authenticate(client *Client, user, password string) (bool, error) {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// return error if closing
if m.closing {
return false, ErrClosing
}
// allow all if there are no credentials
if m.Credentials == nil {
return true, nil
}
// check login
if pw, ok := m.Credentials[user]; ok && pw == password {
return true, nil
}
return false, nil
} | go | func (m *MemoryBackend) Authenticate(client *Client, user, password string) (bool, error) {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// return error if closing
if m.closing {
return false, ErrClosing
}
// allow all if there are no credentials
if m.Credentials == nil {
return true, nil
}
// check login
if pw, ok := m.Credentials[user]; ok && pw == password {
return true, nil
}
return false, nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Authenticate",
"(",
"client",
"*",
"Client",
",",
"user",
",",
"password",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// return error if closing",
"if",
"m",
".",
"closing",
"{",
"return",
"false",
",",
"ErrClosing",
"\n",
"}",
"\n\n",
"// allow all if there are no credentials",
"if",
"m",
".",
"Credentials",
"==",
"nil",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"// check login",
"if",
"pw",
",",
"ok",
":=",
"m",
".",
"Credentials",
"[",
"user",
"]",
";",
"ok",
"&&",
"pw",
"==",
"password",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"nil",
"\n",
"}"
] | // Authenticate will authenticates a clients credentials. | [
"Authenticate",
"will",
"authenticates",
"a",
"clients",
"credentials",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L121-L142 |
10,010 | 256dpi/gomqtt | broker/backend.go | Setup | func (m *MemoryBackend) Setup(client *Client, id string, clean bool) (Session, bool, error) {
// acquire setup mutex
m.setupMutex.Lock()
defer m.setupMutex.Unlock()
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// return error if closing
if m.closing {
return nil, false, ErrClosing
}
// apply client settings
client.MaximumKeepAlive = m.ClientMaximumKeepAlive
client.ParallelPublishes = m.ClientParallelPublishes
client.ParallelSubscribes = m.ClientParallelSubscribes
client.InflightMessages = m.ClientInflightMessages
client.TokenTimeout = m.ClientTokenTimeout
// return a new temporary session if id is zero
if len(id) == 0 {
// create session
sess := newMemorySession(m.SessionQueueSize)
sess.owner = client
// save session
m.temporarySessions[client] = sess
return sess, false, nil
}
// client id is available
// retrieve existing client
existingSession, ok := m.storedSessions[id]
if !ok {
if existingClient, ok2 := m.activeClients[id]; ok2 {
existingSession, ok = m.temporarySessions[existingClient]
}
}
// kill existing client if session is taken
if ok && existingSession.owner != nil {
// close client
existingSession.owner.Close()
// release global mutex to allow publish and termination, but leave the
// setup mutex to prevent setups
m.globalMutex.Unlock()
// wait for client to close
var err error
select {
case <-existingSession.owner.Closed():
// continue
case <-time.After(m.KillTimeout):
err = ErrKillTimeout
}
// acquire mutex again
m.globalMutex.Lock()
// return err if set
if err != nil {
return nil, false, err
}
}
// delete any stored session and return a temporary session if a clean
// session is requested
if clean {
// delete any stored session
delete(m.storedSessions, id)
// create new session
sess := newMemorySession(m.SessionQueueSize)
sess.owner = client
// save session
m.temporarySessions[client] = sess
// save client
m.activeClients[id] = client
return sess, false, nil
}
// attempt to reuse a stored session
storedSession, ok := m.storedSessions[id]
if ok {
// reuse session
storedSession.reuse()
storedSession.owner = client
// save client
m.activeClients[id] = client
return storedSession, true, nil
}
// otherwise create fresh session
storedSession = newMemorySession(m.SessionQueueSize)
storedSession.owner = client
// save session
m.storedSessions[id] = storedSession
// save client
m.activeClients[id] = client
return storedSession, false, nil
} | go | func (m *MemoryBackend) Setup(client *Client, id string, clean bool) (Session, bool, error) {
// acquire setup mutex
m.setupMutex.Lock()
defer m.setupMutex.Unlock()
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// return error if closing
if m.closing {
return nil, false, ErrClosing
}
// apply client settings
client.MaximumKeepAlive = m.ClientMaximumKeepAlive
client.ParallelPublishes = m.ClientParallelPublishes
client.ParallelSubscribes = m.ClientParallelSubscribes
client.InflightMessages = m.ClientInflightMessages
client.TokenTimeout = m.ClientTokenTimeout
// return a new temporary session if id is zero
if len(id) == 0 {
// create session
sess := newMemorySession(m.SessionQueueSize)
sess.owner = client
// save session
m.temporarySessions[client] = sess
return sess, false, nil
}
// client id is available
// retrieve existing client
existingSession, ok := m.storedSessions[id]
if !ok {
if existingClient, ok2 := m.activeClients[id]; ok2 {
existingSession, ok = m.temporarySessions[existingClient]
}
}
// kill existing client if session is taken
if ok && existingSession.owner != nil {
// close client
existingSession.owner.Close()
// release global mutex to allow publish and termination, but leave the
// setup mutex to prevent setups
m.globalMutex.Unlock()
// wait for client to close
var err error
select {
case <-existingSession.owner.Closed():
// continue
case <-time.After(m.KillTimeout):
err = ErrKillTimeout
}
// acquire mutex again
m.globalMutex.Lock()
// return err if set
if err != nil {
return nil, false, err
}
}
// delete any stored session and return a temporary session if a clean
// session is requested
if clean {
// delete any stored session
delete(m.storedSessions, id)
// create new session
sess := newMemorySession(m.SessionQueueSize)
sess.owner = client
// save session
m.temporarySessions[client] = sess
// save client
m.activeClients[id] = client
return sess, false, nil
}
// attempt to reuse a stored session
storedSession, ok := m.storedSessions[id]
if ok {
// reuse session
storedSession.reuse()
storedSession.owner = client
// save client
m.activeClients[id] = client
return storedSession, true, nil
}
// otherwise create fresh session
storedSession = newMemorySession(m.SessionQueueSize)
storedSession.owner = client
// save session
m.storedSessions[id] = storedSession
// save client
m.activeClients[id] = client
return storedSession, false, nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Setup",
"(",
"client",
"*",
"Client",
",",
"id",
"string",
",",
"clean",
"bool",
")",
"(",
"Session",
",",
"bool",
",",
"error",
")",
"{",
"// acquire setup mutex",
"m",
".",
"setupMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"setupMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// return error if closing",
"if",
"m",
".",
"closing",
"{",
"return",
"nil",
",",
"false",
",",
"ErrClosing",
"\n",
"}",
"\n\n",
"// apply client settings",
"client",
".",
"MaximumKeepAlive",
"=",
"m",
".",
"ClientMaximumKeepAlive",
"\n",
"client",
".",
"ParallelPublishes",
"=",
"m",
".",
"ClientParallelPublishes",
"\n",
"client",
".",
"ParallelSubscribes",
"=",
"m",
".",
"ClientParallelSubscribes",
"\n",
"client",
".",
"InflightMessages",
"=",
"m",
".",
"ClientInflightMessages",
"\n",
"client",
".",
"TokenTimeout",
"=",
"m",
".",
"ClientTokenTimeout",
"\n\n",
"// return a new temporary session if id is zero",
"if",
"len",
"(",
"id",
")",
"==",
"0",
"{",
"// create session",
"sess",
":=",
"newMemorySession",
"(",
"m",
".",
"SessionQueueSize",
")",
"\n",
"sess",
".",
"owner",
"=",
"client",
"\n\n",
"// save session",
"m",
".",
"temporarySessions",
"[",
"client",
"]",
"=",
"sess",
"\n\n",
"return",
"sess",
",",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"// client id is available",
"// retrieve existing client",
"existingSession",
",",
"ok",
":=",
"m",
".",
"storedSessions",
"[",
"id",
"]",
"\n",
"if",
"!",
"ok",
"{",
"if",
"existingClient",
",",
"ok2",
":=",
"m",
".",
"activeClients",
"[",
"id",
"]",
";",
"ok2",
"{",
"existingSession",
",",
"ok",
"=",
"m",
".",
"temporarySessions",
"[",
"existingClient",
"]",
"\n",
"}",
"\n",
"}",
"\n\n",
"// kill existing client if session is taken",
"if",
"ok",
"&&",
"existingSession",
".",
"owner",
"!=",
"nil",
"{",
"// close client",
"existingSession",
".",
"owner",
".",
"Close",
"(",
")",
"\n\n",
"// release global mutex to allow publish and termination, but leave the",
"// setup mutex to prevent setups",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// wait for client to close",
"var",
"err",
"error",
"\n",
"select",
"{",
"case",
"<-",
"existingSession",
".",
"owner",
".",
"Closed",
"(",
")",
":",
"// continue",
"case",
"<-",
"time",
".",
"After",
"(",
"m",
".",
"KillTimeout",
")",
":",
"err",
"=",
"ErrKillTimeout",
"\n",
"}",
"\n\n",
"// acquire mutex again",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n\n",
"// return err if set",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"false",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// delete any stored session and return a temporary session if a clean",
"// session is requested",
"if",
"clean",
"{",
"// delete any stored session",
"delete",
"(",
"m",
".",
"storedSessions",
",",
"id",
")",
"\n\n",
"// create new session",
"sess",
":=",
"newMemorySession",
"(",
"m",
".",
"SessionQueueSize",
")",
"\n",
"sess",
".",
"owner",
"=",
"client",
"\n\n",
"// save session",
"m",
".",
"temporarySessions",
"[",
"client",
"]",
"=",
"sess",
"\n\n",
"// save client",
"m",
".",
"activeClients",
"[",
"id",
"]",
"=",
"client",
"\n\n",
"return",
"sess",
",",
"false",
",",
"nil",
"\n",
"}",
"\n\n",
"// attempt to reuse a stored session",
"storedSession",
",",
"ok",
":=",
"m",
".",
"storedSessions",
"[",
"id",
"]",
"\n",
"if",
"ok",
"{",
"// reuse session",
"storedSession",
".",
"reuse",
"(",
")",
"\n",
"storedSession",
".",
"owner",
"=",
"client",
"\n\n",
"// save client",
"m",
".",
"activeClients",
"[",
"id",
"]",
"=",
"client",
"\n\n",
"return",
"storedSession",
",",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"// otherwise create fresh session",
"storedSession",
"=",
"newMemorySession",
"(",
"m",
".",
"SessionQueueSize",
")",
"\n",
"storedSession",
".",
"owner",
"=",
"client",
"\n\n",
"// save session",
"m",
".",
"storedSessions",
"[",
"id",
"]",
"=",
"storedSession",
"\n\n",
"// save client",
"m",
".",
"activeClients",
"[",
"id",
"]",
"=",
"client",
"\n\n",
"return",
"storedSession",
",",
"false",
",",
"nil",
"\n",
"}"
] | // Setup will close existing clients and return an appropriate session. | [
"Setup",
"will",
"close",
"existing",
"clients",
"and",
"return",
"an",
"appropriate",
"session",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L145-L258 |
10,011 | 256dpi/gomqtt | broker/backend.go | Subscribe | func (m *MemoryBackend) Subscribe(client *Client, subs []packet.Subscription, ack Ack) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// save subscription
for _, sub := range subs {
client.Session().(*memorySession).subscriptions.Set(sub.Topic, sub)
}
// call ack if provided
if ack != nil {
ack()
}
// get session
sess := client.Session().(*memorySession)
// handle all subscriptions
for _, sub := range subs {
// get retained messages
values := m.retainedMessages.Search(sub.Topic)
// publish messages
for _, value := range values {
// add to temporary queue or return error if queue is full
select {
case sess.temporary <- value.(*packet.Message):
default:
return ErrQueueFull
}
}
}
return nil
} | go | func (m *MemoryBackend) Subscribe(client *Client, subs []packet.Subscription, ack Ack) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// save subscription
for _, sub := range subs {
client.Session().(*memorySession).subscriptions.Set(sub.Topic, sub)
}
// call ack if provided
if ack != nil {
ack()
}
// get session
sess := client.Session().(*memorySession)
// handle all subscriptions
for _, sub := range subs {
// get retained messages
values := m.retainedMessages.Search(sub.Topic)
// publish messages
for _, value := range values {
// add to temporary queue or return error if queue is full
select {
case sess.temporary <- value.(*packet.Message):
default:
return ErrQueueFull
}
}
}
return nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Subscribe",
"(",
"client",
"*",
"Client",
",",
"subs",
"[",
"]",
"packet",
".",
"Subscription",
",",
"ack",
"Ack",
")",
"error",
"{",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// save subscription",
"for",
"_",
",",
"sub",
":=",
"range",
"subs",
"{",
"client",
".",
"Session",
"(",
")",
".",
"(",
"*",
"memorySession",
")",
".",
"subscriptions",
".",
"Set",
"(",
"sub",
".",
"Topic",
",",
"sub",
")",
"\n",
"}",
"\n\n",
"// call ack if provided",
"if",
"ack",
"!=",
"nil",
"{",
"ack",
"(",
")",
"\n",
"}",
"\n\n",
"// get session",
"sess",
":=",
"client",
".",
"Session",
"(",
")",
".",
"(",
"*",
"memorySession",
")",
"\n\n",
"// handle all subscriptions",
"for",
"_",
",",
"sub",
":=",
"range",
"subs",
"{",
"// get retained messages",
"values",
":=",
"m",
".",
"retainedMessages",
".",
"Search",
"(",
"sub",
".",
"Topic",
")",
"\n\n",
"// publish messages",
"for",
"_",
",",
"value",
":=",
"range",
"values",
"{",
"// add to temporary queue or return error if queue is full",
"select",
"{",
"case",
"sess",
".",
"temporary",
"<-",
"value",
".",
"(",
"*",
"packet",
".",
"Message",
")",
":",
"default",
":",
"return",
"ErrQueueFull",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Subscribe will store the subscription and queue retained messages. | [
"Subscribe",
"will",
"store",
"the",
"subscription",
"and",
"queue",
"retained",
"messages",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L266-L301 |
10,012 | 256dpi/gomqtt | broker/backend.go | Unsubscribe | func (m *MemoryBackend) Unsubscribe(client *Client, topics []string, ack Ack) error {
// delete subscriptions
for _, t := range topics {
client.Session().(*memorySession).subscriptions.Empty(t)
}
// call ack if provided
if ack != nil {
ack()
}
return nil
} | go | func (m *MemoryBackend) Unsubscribe(client *Client, topics []string, ack Ack) error {
// delete subscriptions
for _, t := range topics {
client.Session().(*memorySession).subscriptions.Empty(t)
}
// call ack if provided
if ack != nil {
ack()
}
return nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Unsubscribe",
"(",
"client",
"*",
"Client",
",",
"topics",
"[",
"]",
"string",
",",
"ack",
"Ack",
")",
"error",
"{",
"// delete subscriptions",
"for",
"_",
",",
"t",
":=",
"range",
"topics",
"{",
"client",
".",
"Session",
"(",
")",
".",
"(",
"*",
"memorySession",
")",
".",
"subscriptions",
".",
"Empty",
"(",
"t",
")",
"\n",
"}",
"\n\n",
"// call ack if provided",
"if",
"ack",
"!=",
"nil",
"{",
"ack",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Unsubscribe will delete the subscription. | [
"Unsubscribe",
"will",
"delete",
"the",
"subscription",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L304-L316 |
10,013 | 256dpi/gomqtt | broker/backend.go | Publish | func (m *MemoryBackend) Publish(client *Client, msg *packet.Message, ack Ack) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// this implementation is very basic and will block the backend on every
// publish. clients that stay connected but won't drain their queue will
// eventually deadlock the broker
// check retain flag
if msg.Retain {
if len(msg.Payload) > 0 {
// retain message
m.retainedMessages.Set(msg.Topic, msg.Copy())
} else {
// clear already retained message
m.retainedMessages.Empty(msg.Topic)
}
}
// use temporary queue by default
queue := func(s *memorySession) chan *packet.Message {
return s.temporary
}
// use stored queue if qos > 0
if msg.QOS > 0 {
queue = func(s *memorySession) chan *packet.Message {
return s.stored
}
}
// reset retained flag
msg.Retain = false
// add message to temporary sessions
for _, sess := range m.temporarySessions {
if sub := sess.lookupSubscription(msg.Topic); sub != nil {
if sess.owner == client {
// detect deadlock when adding to own queue
select {
case queue(sess) <- msg:
default:
return ErrQueueFull
}
} else {
// wait for room since client is online
select {
case queue(sess) <- msg:
case <-sess.owner.Closed():
case <-client.Closed():
}
}
}
}
// add message to stored sessions
for _, sess := range m.storedSessions {
if sub := sess.lookupSubscription(msg.Topic); sub != nil {
if sess.owner == client {
// detect deadlock when adding to own queue
select {
case queue(sess) <- msg:
default:
return ErrQueueFull
}
} else if sess.owner != nil {
// wait for room if client is online
select {
case queue(sess) <- msg:
case <-sess.owner.Closed():
case <-client.Closed():
}
} else {
// ignore message if stored queue is full
select {
case queue(sess) <- msg:
default:
}
}
}
}
// call ack if available
if ack != nil {
ack()
}
return nil
} | go | func (m *MemoryBackend) Publish(client *Client, msg *packet.Message, ack Ack) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// this implementation is very basic and will block the backend on every
// publish. clients that stay connected but won't drain their queue will
// eventually deadlock the broker
// check retain flag
if msg.Retain {
if len(msg.Payload) > 0 {
// retain message
m.retainedMessages.Set(msg.Topic, msg.Copy())
} else {
// clear already retained message
m.retainedMessages.Empty(msg.Topic)
}
}
// use temporary queue by default
queue := func(s *memorySession) chan *packet.Message {
return s.temporary
}
// use stored queue if qos > 0
if msg.QOS > 0 {
queue = func(s *memorySession) chan *packet.Message {
return s.stored
}
}
// reset retained flag
msg.Retain = false
// add message to temporary sessions
for _, sess := range m.temporarySessions {
if sub := sess.lookupSubscription(msg.Topic); sub != nil {
if sess.owner == client {
// detect deadlock when adding to own queue
select {
case queue(sess) <- msg:
default:
return ErrQueueFull
}
} else {
// wait for room since client is online
select {
case queue(sess) <- msg:
case <-sess.owner.Closed():
case <-client.Closed():
}
}
}
}
// add message to stored sessions
for _, sess := range m.storedSessions {
if sub := sess.lookupSubscription(msg.Topic); sub != nil {
if sess.owner == client {
// detect deadlock when adding to own queue
select {
case queue(sess) <- msg:
default:
return ErrQueueFull
}
} else if sess.owner != nil {
// wait for room if client is online
select {
case queue(sess) <- msg:
case <-sess.owner.Closed():
case <-client.Closed():
}
} else {
// ignore message if stored queue is full
select {
case queue(sess) <- msg:
default:
}
}
}
}
// call ack if available
if ack != nil {
ack()
}
return nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Publish",
"(",
"client",
"*",
"Client",
",",
"msg",
"*",
"packet",
".",
"Message",
",",
"ack",
"Ack",
")",
"error",
"{",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// this implementation is very basic and will block the backend on every",
"// publish. clients that stay connected but won't drain their queue will",
"// eventually deadlock the broker",
"// check retain flag",
"if",
"msg",
".",
"Retain",
"{",
"if",
"len",
"(",
"msg",
".",
"Payload",
")",
">",
"0",
"{",
"// retain message",
"m",
".",
"retainedMessages",
".",
"Set",
"(",
"msg",
".",
"Topic",
",",
"msg",
".",
"Copy",
"(",
")",
")",
"\n",
"}",
"else",
"{",
"// clear already retained message",
"m",
".",
"retainedMessages",
".",
"Empty",
"(",
"msg",
".",
"Topic",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// use temporary queue by default",
"queue",
":=",
"func",
"(",
"s",
"*",
"memorySession",
")",
"chan",
"*",
"packet",
".",
"Message",
"{",
"return",
"s",
".",
"temporary",
"\n",
"}",
"\n\n",
"// use stored queue if qos > 0",
"if",
"msg",
".",
"QOS",
">",
"0",
"{",
"queue",
"=",
"func",
"(",
"s",
"*",
"memorySession",
")",
"chan",
"*",
"packet",
".",
"Message",
"{",
"return",
"s",
".",
"stored",
"\n",
"}",
"\n",
"}",
"\n\n",
"// reset retained flag",
"msg",
".",
"Retain",
"=",
"false",
"\n\n",
"// add message to temporary sessions",
"for",
"_",
",",
"sess",
":=",
"range",
"m",
".",
"temporarySessions",
"{",
"if",
"sub",
":=",
"sess",
".",
"lookupSubscription",
"(",
"msg",
".",
"Topic",
")",
";",
"sub",
"!=",
"nil",
"{",
"if",
"sess",
".",
"owner",
"==",
"client",
"{",
"// detect deadlock when adding to own queue",
"select",
"{",
"case",
"queue",
"(",
"sess",
")",
"<-",
"msg",
":",
"default",
":",
"return",
"ErrQueueFull",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// wait for room since client is online",
"select",
"{",
"case",
"queue",
"(",
"sess",
")",
"<-",
"msg",
":",
"case",
"<-",
"sess",
".",
"owner",
".",
"Closed",
"(",
")",
":",
"case",
"<-",
"client",
".",
"Closed",
"(",
")",
":",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// add message to stored sessions",
"for",
"_",
",",
"sess",
":=",
"range",
"m",
".",
"storedSessions",
"{",
"if",
"sub",
":=",
"sess",
".",
"lookupSubscription",
"(",
"msg",
".",
"Topic",
")",
";",
"sub",
"!=",
"nil",
"{",
"if",
"sess",
".",
"owner",
"==",
"client",
"{",
"// detect deadlock when adding to own queue",
"select",
"{",
"case",
"queue",
"(",
"sess",
")",
"<-",
"msg",
":",
"default",
":",
"return",
"ErrQueueFull",
"\n",
"}",
"\n",
"}",
"else",
"if",
"sess",
".",
"owner",
"!=",
"nil",
"{",
"// wait for room if client is online",
"select",
"{",
"case",
"queue",
"(",
"sess",
")",
"<-",
"msg",
":",
"case",
"<-",
"sess",
".",
"owner",
".",
"Closed",
"(",
")",
":",
"case",
"<-",
"client",
".",
"Closed",
"(",
")",
":",
"}",
"\n",
"}",
"else",
"{",
"// ignore message if stored queue is full",
"select",
"{",
"case",
"queue",
"(",
"sess",
")",
"<-",
"msg",
":",
"default",
":",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// call ack if available",
"if",
"ack",
"!=",
"nil",
"{",
"ack",
"(",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Publish will handle retained messages and add the message to the session queues. | [
"Publish",
"will",
"handle",
"retained",
"messages",
"and",
"add",
"the",
"message",
"to",
"the",
"session",
"queues",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L319-L408 |
10,014 | 256dpi/gomqtt | broker/backend.go | Dequeue | func (m *MemoryBackend) Dequeue(client *Client) (*packet.Message, Ack, error) {
// mutex locking not needed
// get session
sess := client.Session().(*memorySession)
// this implementation is very basic and will dequeue messages immediately
// and not return no ack. messages are lost if the client fails to handle them
// get next message from queue
select {
case msg := <-sess.temporary:
return sess.applyQOS(msg), nil, nil
case msg := <-sess.stored:
return sess.applyQOS(msg), nil, nil
case <-client.Closing():
return nil, nil, nil
}
} | go | func (m *MemoryBackend) Dequeue(client *Client) (*packet.Message, Ack, error) {
// mutex locking not needed
// get session
sess := client.Session().(*memorySession)
// this implementation is very basic and will dequeue messages immediately
// and not return no ack. messages are lost if the client fails to handle them
// get next message from queue
select {
case msg := <-sess.temporary:
return sess.applyQOS(msg), nil, nil
case msg := <-sess.stored:
return sess.applyQOS(msg), nil, nil
case <-client.Closing():
return nil, nil, nil
}
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Dequeue",
"(",
"client",
"*",
"Client",
")",
"(",
"*",
"packet",
".",
"Message",
",",
"Ack",
",",
"error",
")",
"{",
"// mutex locking not needed",
"// get session",
"sess",
":=",
"client",
".",
"Session",
"(",
")",
".",
"(",
"*",
"memorySession",
")",
"\n\n",
"// this implementation is very basic and will dequeue messages immediately",
"// and not return no ack. messages are lost if the client fails to handle them",
"// get next message from queue",
"select",
"{",
"case",
"msg",
":=",
"<-",
"sess",
".",
"temporary",
":",
"return",
"sess",
".",
"applyQOS",
"(",
"msg",
")",
",",
"nil",
",",
"nil",
"\n",
"case",
"msg",
":=",
"<-",
"sess",
".",
"stored",
":",
"return",
"sess",
".",
"applyQOS",
"(",
"msg",
")",
",",
"nil",
",",
"nil",
"\n",
"case",
"<-",
"client",
".",
"Closing",
"(",
")",
":",
"return",
"nil",
",",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Dequeue will get the next message from the temporary or stored queue. | [
"Dequeue",
"will",
"get",
"the",
"next",
"message",
"from",
"the",
"temporary",
"or",
"stored",
"queue",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L411-L429 |
10,015 | 256dpi/gomqtt | broker/backend.go | Terminate | func (m *MemoryBackend) Terminate(client *Client) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// release session if available
sess, ok := client.Session().(*memorySession)
if ok && sess != nil {
sess.owner = nil
}
// remove any temporary session
delete(m.temporarySessions, client)
// remove any saved client
delete(m.activeClients, client.ID())
return nil
} | go | func (m *MemoryBackend) Terminate(client *Client) error {
// acquire global mutex
m.globalMutex.Lock()
defer m.globalMutex.Unlock()
// release session if available
sess, ok := client.Session().(*memorySession)
if ok && sess != nil {
sess.owner = nil
}
// remove any temporary session
delete(m.temporarySessions, client)
// remove any saved client
delete(m.activeClients, client.ID())
return nil
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Terminate",
"(",
"client",
"*",
"Client",
")",
"error",
"{",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// release session if available",
"sess",
",",
"ok",
":=",
"client",
".",
"Session",
"(",
")",
".",
"(",
"*",
"memorySession",
")",
"\n",
"if",
"ok",
"&&",
"sess",
"!=",
"nil",
"{",
"sess",
".",
"owner",
"=",
"nil",
"\n",
"}",
"\n\n",
"// remove any temporary session",
"delete",
"(",
"m",
".",
"temporarySessions",
",",
"client",
")",
"\n\n",
"// remove any saved client",
"delete",
"(",
"m",
".",
"activeClients",
",",
"client",
".",
"ID",
"(",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Terminate will disassociate the session from the client. | [
"Terminate",
"will",
"disassociate",
"the",
"session",
"from",
"the",
"client",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L432-L450 |
10,016 | 256dpi/gomqtt | broker/backend.go | Log | func (m *MemoryBackend) Log(event LogEvent, client *Client, pkt packet.Generic, msg *packet.Message, err error) {
// call logger if available
if m.Logger != nil {
m.Logger(event, client, pkt, msg, err)
}
} | go | func (m *MemoryBackend) Log(event LogEvent, client *Client, pkt packet.Generic, msg *packet.Message, err error) {
// call logger if available
if m.Logger != nil {
m.Logger(event, client, pkt, msg, err)
}
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Log",
"(",
"event",
"LogEvent",
",",
"client",
"*",
"Client",
",",
"pkt",
"packet",
".",
"Generic",
",",
"msg",
"*",
"packet",
".",
"Message",
",",
"err",
"error",
")",
"{",
"// call logger if available",
"if",
"m",
".",
"Logger",
"!=",
"nil",
"{",
"m",
".",
"Logger",
"(",
"event",
",",
"client",
",",
"pkt",
",",
"msg",
",",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // Log will call the associated logger. | [
"Log",
"will",
"call",
"the",
"associated",
"logger",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L453-L458 |
10,017 | 256dpi/gomqtt | broker/backend.go | Close | func (m *MemoryBackend) Close(timeout time.Duration) bool {
// acquire global mutex
m.globalMutex.Lock()
// set closing
m.closing = true
// prepare list
var clients []*Client
// close temporary sessions
for _, sess := range m.temporarySessions {
sess.owner.Close()
clients = append(clients, sess.owner)
}
// closed owned stored sessions
for _, sess := range m.storedSessions {
if sess.owner != nil {
sess.owner.Close()
clients = append(clients, sess.owner)
}
}
// release mutex to allow termination
m.globalMutex.Unlock()
// return early if empty
if len(clients) == 0 {
return true
}
// prepare timeout
tm := time.After(timeout)
// wait for clients to close
for _, client := range clients {
select {
case <-client.Closed():
continue
case <-tm:
return false
}
}
return true
} | go | func (m *MemoryBackend) Close(timeout time.Duration) bool {
// acquire global mutex
m.globalMutex.Lock()
// set closing
m.closing = true
// prepare list
var clients []*Client
// close temporary sessions
for _, sess := range m.temporarySessions {
sess.owner.Close()
clients = append(clients, sess.owner)
}
// closed owned stored sessions
for _, sess := range m.storedSessions {
if sess.owner != nil {
sess.owner.Close()
clients = append(clients, sess.owner)
}
}
// release mutex to allow termination
m.globalMutex.Unlock()
// return early if empty
if len(clients) == 0 {
return true
}
// prepare timeout
tm := time.After(timeout)
// wait for clients to close
for _, client := range clients {
select {
case <-client.Closed():
continue
case <-tm:
return false
}
}
return true
} | [
"func",
"(",
"m",
"*",
"MemoryBackend",
")",
"Close",
"(",
"timeout",
"time",
".",
"Duration",
")",
"bool",
"{",
"// acquire global mutex",
"m",
".",
"globalMutex",
".",
"Lock",
"(",
")",
"\n\n",
"// set closing",
"m",
".",
"closing",
"=",
"true",
"\n\n",
"// prepare list",
"var",
"clients",
"[",
"]",
"*",
"Client",
"\n\n",
"// close temporary sessions",
"for",
"_",
",",
"sess",
":=",
"range",
"m",
".",
"temporarySessions",
"{",
"sess",
".",
"owner",
".",
"Close",
"(",
")",
"\n",
"clients",
"=",
"append",
"(",
"clients",
",",
"sess",
".",
"owner",
")",
"\n",
"}",
"\n\n",
"// closed owned stored sessions",
"for",
"_",
",",
"sess",
":=",
"range",
"m",
".",
"storedSessions",
"{",
"if",
"sess",
".",
"owner",
"!=",
"nil",
"{",
"sess",
".",
"owner",
".",
"Close",
"(",
")",
"\n",
"clients",
"=",
"append",
"(",
"clients",
",",
"sess",
".",
"owner",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// release mutex to allow termination",
"m",
".",
"globalMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// return early if empty",
"if",
"len",
"(",
"clients",
")",
"==",
"0",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"// prepare timeout",
"tm",
":=",
"time",
".",
"After",
"(",
"timeout",
")",
"\n\n",
"// wait for clients to close",
"for",
"_",
",",
"client",
":=",
"range",
"clients",
"{",
"select",
"{",
"case",
"<-",
"client",
".",
"Closed",
"(",
")",
":",
"continue",
"\n",
"case",
"<-",
"tm",
":",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] | // Close will close all active clients and close the backend. The return value
// denotes if the timeout has been reached. | [
"Close",
"will",
"close",
"all",
"active",
"clients",
"and",
"close",
"the",
"backend",
".",
"The",
"return",
"value",
"denotes",
"if",
"the",
"timeout",
"has",
"been",
"reached",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/backend.go#L462-L508 |
10,018 | 256dpi/gomqtt | client/config.go | NewConfig | func NewConfig(url string) *Config {
return &Config{
BrokerURL: url,
CleanSession: true,
KeepAlive: "30s",
ValidateSubs: true,
}
} | go | func NewConfig(url string) *Config {
return &Config{
BrokerURL: url,
CleanSession: true,
KeepAlive: "30s",
ValidateSubs: true,
}
} | [
"func",
"NewConfig",
"(",
"url",
"string",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"BrokerURL",
":",
"url",
",",
"CleanSession",
":",
"true",
",",
"KeepAlive",
":",
"\"",
"\"",
",",
"ValidateSubs",
":",
"true",
",",
"}",
"\n",
"}"
] | // NewConfig creates a new Config using the specified URL. | [
"NewConfig",
"creates",
"a",
"new",
"Config",
"using",
"the",
"specified",
"URL",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/config.go#L44-L51 |
10,019 | 256dpi/gomqtt | client/config.go | NewConfigWithClientID | func NewConfigWithClientID(url, id string) *Config {
config := NewConfig(url)
config.ClientID = id
return config
} | go | func NewConfigWithClientID(url, id string) *Config {
config := NewConfig(url)
config.ClientID = id
return config
} | [
"func",
"NewConfigWithClientID",
"(",
"url",
",",
"id",
"string",
")",
"*",
"Config",
"{",
"config",
":=",
"NewConfig",
"(",
"url",
")",
"\n",
"config",
".",
"ClientID",
"=",
"id",
"\n",
"return",
"config",
"\n",
"}"
] | // NewConfigWithClientID creates a new Config using the specified URL and client ID. | [
"NewConfigWithClientID",
"creates",
"a",
"new",
"Config",
"using",
"the",
"specified",
"URL",
"and",
"client",
"ID",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/config.go#L54-L58 |
10,020 | 256dpi/gomqtt | transport/dialer.go | NewDialer | func NewDialer() *Dialer {
return &Dialer{
DefaultTCPPort: "1883",
DefaultTLSPort: "8883",
DefaultWSPort: "80",
DefaultWSSPort: "443",
webSocketDialer: &websocket.Dialer{
Proxy: http.ProxyFromEnvironment,
Subprotocols: []string{"mqtt"},
},
}
} | go | func NewDialer() *Dialer {
return &Dialer{
DefaultTCPPort: "1883",
DefaultTLSPort: "8883",
DefaultWSPort: "80",
DefaultWSSPort: "443",
webSocketDialer: &websocket.Dialer{
Proxy: http.ProxyFromEnvironment,
Subprotocols: []string{"mqtt"},
},
}
} | [
"func",
"NewDialer",
"(",
")",
"*",
"Dialer",
"{",
"return",
"&",
"Dialer",
"{",
"DefaultTCPPort",
":",
"\"",
"\"",
",",
"DefaultTLSPort",
":",
"\"",
"\"",
",",
"DefaultWSPort",
":",
"\"",
"\"",
",",
"DefaultWSSPort",
":",
"\"",
"\"",
",",
"webSocketDialer",
":",
"&",
"websocket",
".",
"Dialer",
"{",
"Proxy",
":",
"http",
".",
"ProxyFromEnvironment",
",",
"Subprotocols",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewDialer returns a new Dialer. | [
"NewDialer",
"returns",
"a",
"new",
"Dialer",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/dialer.go#L29-L40 |
10,021 | 256dpi/gomqtt | transport/dialer.go | Dial | func (d *Dialer) Dial(urlString string) (Conn, error) {
// ensure write delay default
if d.MaxWriteDelay == 0 {
d.MaxWriteDelay = 10 * time.Millisecond
}
urlParts, err := url.ParseRequestURI(urlString)
if err != nil {
return nil, err
}
host, port, err := net.SplitHostPort(urlParts.Host)
if err != nil {
host = urlParts.Host
port = ""
}
switch urlParts.Scheme {
case "tcp", "mqtt":
if port == "" {
port = d.DefaultTCPPort
}
conn, err := net.Dial("tcp", net.JoinHostPort(host, port))
if err != nil {
return nil, err
}
return NewNetConn(conn, d.MaxWriteDelay), nil
case "tls", "mqtts":
if port == "" {
port = d.DefaultTLSPort
}
conn, err := tls.Dial("tcp", net.JoinHostPort(host, port), d.TLSConfig)
if err != nil {
return nil, err
}
return NewNetConn(conn, d.MaxWriteDelay), nil
case "ws":
if port == "" {
port = d.DefaultWSPort
}
wsURL := fmt.Sprintf("ws://%s:%s%s", host, port, urlParts.Path)
conn, _, err := d.webSocketDialer.Dial(wsURL, d.RequestHeader)
if err != nil {
return nil, err
}
return NewWebSocketConn(conn, d.MaxWriteDelay), nil
case "wss":
if port == "" {
port = d.DefaultWSSPort
}
wsURL := fmt.Sprintf("wss://%s:%s%s", host, port, urlParts.Path)
d.webSocketDialer.TLSClientConfig = d.TLSConfig
conn, _, err := d.webSocketDialer.Dial(wsURL, d.RequestHeader)
if err != nil {
return nil, err
}
return NewWebSocketConn(conn, d.MaxWriteDelay), nil
}
return nil, ErrUnsupportedProtocol
} | go | func (d *Dialer) Dial(urlString string) (Conn, error) {
// ensure write delay default
if d.MaxWriteDelay == 0 {
d.MaxWriteDelay = 10 * time.Millisecond
}
urlParts, err := url.ParseRequestURI(urlString)
if err != nil {
return nil, err
}
host, port, err := net.SplitHostPort(urlParts.Host)
if err != nil {
host = urlParts.Host
port = ""
}
switch urlParts.Scheme {
case "tcp", "mqtt":
if port == "" {
port = d.DefaultTCPPort
}
conn, err := net.Dial("tcp", net.JoinHostPort(host, port))
if err != nil {
return nil, err
}
return NewNetConn(conn, d.MaxWriteDelay), nil
case "tls", "mqtts":
if port == "" {
port = d.DefaultTLSPort
}
conn, err := tls.Dial("tcp", net.JoinHostPort(host, port), d.TLSConfig)
if err != nil {
return nil, err
}
return NewNetConn(conn, d.MaxWriteDelay), nil
case "ws":
if port == "" {
port = d.DefaultWSPort
}
wsURL := fmt.Sprintf("ws://%s:%s%s", host, port, urlParts.Path)
conn, _, err := d.webSocketDialer.Dial(wsURL, d.RequestHeader)
if err != nil {
return nil, err
}
return NewWebSocketConn(conn, d.MaxWriteDelay), nil
case "wss":
if port == "" {
port = d.DefaultWSSPort
}
wsURL := fmt.Sprintf("wss://%s:%s%s", host, port, urlParts.Path)
d.webSocketDialer.TLSClientConfig = d.TLSConfig
conn, _, err := d.webSocketDialer.Dial(wsURL, d.RequestHeader)
if err != nil {
return nil, err
}
return NewWebSocketConn(conn, d.MaxWriteDelay), nil
}
return nil, ErrUnsupportedProtocol
} | [
"func",
"(",
"d",
"*",
"Dialer",
")",
"Dial",
"(",
"urlString",
"string",
")",
"(",
"Conn",
",",
"error",
")",
"{",
"// ensure write delay default",
"if",
"d",
".",
"MaxWriteDelay",
"==",
"0",
"{",
"d",
".",
"MaxWriteDelay",
"=",
"10",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"\n\n",
"urlParts",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"urlString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"host",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"urlParts",
".",
"Host",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"host",
"=",
"urlParts",
".",
"Host",
"\n",
"port",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"switch",
"urlParts",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"port",
"==",
"\"",
"\"",
"{",
"port",
"=",
"d",
".",
"DefaultTCPPort",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"net",
".",
"Dial",
"(",
"\"",
"\"",
",",
"net",
".",
"JoinHostPort",
"(",
"host",
",",
"port",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewNetConn",
"(",
"conn",
",",
"d",
".",
"MaxWriteDelay",
")",
",",
"nil",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"port",
"==",
"\"",
"\"",
"{",
"port",
"=",
"d",
".",
"DefaultTLSPort",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"tls",
".",
"Dial",
"(",
"\"",
"\"",
",",
"net",
".",
"JoinHostPort",
"(",
"host",
",",
"port",
")",
",",
"d",
".",
"TLSConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewNetConn",
"(",
"conn",
",",
"d",
".",
"MaxWriteDelay",
")",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"if",
"port",
"==",
"\"",
"\"",
"{",
"port",
"=",
"d",
".",
"DefaultWSPort",
"\n",
"}",
"\n\n",
"wsURL",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"host",
",",
"port",
",",
"urlParts",
".",
"Path",
")",
"\n\n",
"conn",
",",
"_",
",",
"err",
":=",
"d",
".",
"webSocketDialer",
".",
"Dial",
"(",
"wsURL",
",",
"d",
".",
"RequestHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewWebSocketConn",
"(",
"conn",
",",
"d",
".",
"MaxWriteDelay",
")",
",",
"nil",
"\n",
"case",
"\"",
"\"",
":",
"if",
"port",
"==",
"\"",
"\"",
"{",
"port",
"=",
"d",
".",
"DefaultWSSPort",
"\n",
"}",
"\n\n",
"wsURL",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"host",
",",
"port",
",",
"urlParts",
".",
"Path",
")",
"\n\n",
"d",
".",
"webSocketDialer",
".",
"TLSClientConfig",
"=",
"d",
".",
"TLSConfig",
"\n",
"conn",
",",
"_",
",",
"err",
":=",
"d",
".",
"webSocketDialer",
".",
"Dial",
"(",
"wsURL",
",",
"d",
".",
"RequestHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewWebSocketConn",
"(",
"conn",
",",
"d",
".",
"MaxWriteDelay",
")",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"ErrUnsupportedProtocol",
"\n",
"}"
] | // Dial initiates a connection based in information extracted from an URL. | [
"Dial",
"initiates",
"a",
"connection",
"based",
"in",
"information",
"extracted",
"from",
"an",
"URL",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/dialer.go#L54-L124 |
10,022 | 256dpi/gomqtt | packet/identified.go | identifiedDecode | func identifiedDecode(src []byte, t Type) (int, ID, error) {
total := 0
// decode header
hl, _, rl, err := headerDecode(src, t)
total += hl
if err != nil {
return total, 0, err
}
// check remaining length
if rl != 2 {
return total, 0, makeError(t, "expected remaining length to be 2")
}
// read packet id
packetID := ID(binary.BigEndian.Uint16(src[total:]))
total += 2
// check packet id
if !packetID.Valid() {
return total, 0, makeError(t, "packet id must be grater than zero")
}
return total, packetID, nil
} | go | func identifiedDecode(src []byte, t Type) (int, ID, error) {
total := 0
// decode header
hl, _, rl, err := headerDecode(src, t)
total += hl
if err != nil {
return total, 0, err
}
// check remaining length
if rl != 2 {
return total, 0, makeError(t, "expected remaining length to be 2")
}
// read packet id
packetID := ID(binary.BigEndian.Uint16(src[total:]))
total += 2
// check packet id
if !packetID.Valid() {
return total, 0, makeError(t, "packet id must be grater than zero")
}
return total, packetID, nil
} | [
"func",
"identifiedDecode",
"(",
"src",
"[",
"]",
"byte",
",",
"t",
"Type",
")",
"(",
"int",
",",
"ID",
",",
"error",
")",
"{",
"total",
":=",
"0",
"\n\n",
"// decode header",
"hl",
",",
"_",
",",
"rl",
",",
"err",
":=",
"headerDecode",
"(",
"src",
",",
"t",
")",
"\n",
"total",
"+=",
"hl",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"total",
",",
"0",
",",
"err",
"\n",
"}",
"\n\n",
"// check remaining length",
"if",
"rl",
"!=",
"2",
"{",
"return",
"total",
",",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// read packet id",
"packetID",
":=",
"ID",
"(",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"src",
"[",
"total",
":",
"]",
")",
")",
"\n",
"total",
"+=",
"2",
"\n\n",
"// check packet id",
"if",
"!",
"packetID",
".",
"Valid",
"(",
")",
"{",
"return",
"total",
",",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"total",
",",
"packetID",
",",
"nil",
"\n",
"}"
] | // decodes an identified packet | [
"decodes",
"an",
"identified",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/identified.go#L14-L39 |
10,023 | 256dpi/gomqtt | packet/identified.go | identifiedEncode | func identifiedEncode(dst []byte, id ID, t Type) (int, error) {
total := 0
// check packet id
if !id.Valid() {
return total, makeError(t, "packet id must be grater than zero")
}
// encode header
n, err := headerEncode(dst[total:], 0, 2, identifiedLen(), t)
total += n
if err != nil {
return total, err
}
// write packet id
binary.BigEndian.PutUint16(dst[total:], uint16(id))
total += 2
return total, nil
} | go | func identifiedEncode(dst []byte, id ID, t Type) (int, error) {
total := 0
// check packet id
if !id.Valid() {
return total, makeError(t, "packet id must be grater than zero")
}
// encode header
n, err := headerEncode(dst[total:], 0, 2, identifiedLen(), t)
total += n
if err != nil {
return total, err
}
// write packet id
binary.BigEndian.PutUint16(dst[total:], uint16(id))
total += 2
return total, nil
} | [
"func",
"identifiedEncode",
"(",
"dst",
"[",
"]",
"byte",
",",
"id",
"ID",
",",
"t",
"Type",
")",
"(",
"int",
",",
"error",
")",
"{",
"total",
":=",
"0",
"\n\n",
"// check packet id",
"if",
"!",
"id",
".",
"Valid",
"(",
")",
"{",
"return",
"total",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// encode header",
"n",
",",
"err",
":=",
"headerEncode",
"(",
"dst",
"[",
"total",
":",
"]",
",",
"0",
",",
"2",
",",
"identifiedLen",
"(",
")",
",",
"t",
")",
"\n",
"total",
"+=",
"n",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"total",
",",
"err",
"\n",
"}",
"\n\n",
"// write packet id",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"dst",
"[",
"total",
":",
"]",
",",
"uint16",
"(",
"id",
")",
")",
"\n",
"total",
"+=",
"2",
"\n\n",
"return",
"total",
",",
"nil",
"\n",
"}"
] | // encodes an identified packet | [
"encodes",
"an",
"identified",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/identified.go#L42-L62 |
10,024 | 256dpi/gomqtt | broker/engine.go | NewEngine | func NewEngine(backend Backend) *Engine {
return &Engine{
Backend: backend,
ConnectTimeout: 10 * time.Second,
}
} | go | func NewEngine(backend Backend) *Engine {
return &Engine{
Backend: backend,
ConnectTimeout: 10 * time.Second,
}
} | [
"func",
"NewEngine",
"(",
"backend",
"Backend",
")",
"*",
"Engine",
"{",
"return",
"&",
"Engine",
"{",
"Backend",
":",
"backend",
",",
"ConnectTimeout",
":",
"10",
"*",
"time",
".",
"Second",
",",
"}",
"\n",
"}"
] | // NewEngine returns a new Engine. | [
"NewEngine",
"returns",
"a",
"new",
"Engine",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/engine.go#L34-L39 |
10,025 | 256dpi/gomqtt | broker/engine.go | Accept | func (e *Engine) Accept(server transport.Server) {
e.tomb.Go(func() error {
for {
// return if dying
if !e.tomb.Alive() {
return tomb.ErrDying
}
// accept next connection
conn, err := server.Accept()
if err != nil {
// call error callback if available
if e.OnError != nil {
e.OnError(err)
}
return err
}
// handle connection
if !e.Handle(conn) {
return nil
}
}
})
} | go | func (e *Engine) Accept(server transport.Server) {
e.tomb.Go(func() error {
for {
// return if dying
if !e.tomb.Alive() {
return tomb.ErrDying
}
// accept next connection
conn, err := server.Accept()
if err != nil {
// call error callback if available
if e.OnError != nil {
e.OnError(err)
}
return err
}
// handle connection
if !e.Handle(conn) {
return nil
}
}
})
} | [
"func",
"(",
"e",
"*",
"Engine",
")",
"Accept",
"(",
"server",
"transport",
".",
"Server",
")",
"{",
"e",
".",
"tomb",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"for",
"{",
"// return if dying",
"if",
"!",
"e",
".",
"tomb",
".",
"Alive",
"(",
")",
"{",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n\n",
"// accept next connection",
"conn",
",",
"err",
":=",
"server",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// call error callback if available",
"if",
"e",
".",
"OnError",
"!=",
"nil",
"{",
"e",
".",
"OnError",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// handle connection",
"if",
"!",
"e",
".",
"Handle",
"(",
"conn",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
")",
"\n",
"}"
] | // Accept begins accepting connections from the passed server. | [
"Accept",
"begins",
"accepting",
"connections",
"from",
"the",
"passed",
"server",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/engine.go#L42-L67 |
10,026 | 256dpi/gomqtt | broker/engine.go | Handle | func (e *Engine) Handle(conn transport.Conn) bool {
// check conn
if conn == nil {
panic("passed conn is nil")
}
// acquire mutex
e.mutex.Lock()
defer e.mutex.Unlock()
// close conn immediately when dying
if !e.tomb.Alive() {
_ = conn.Close()
return false
}
// set default read limit
conn.SetReadLimit(e.DefaultReadLimit)
// set initial read timeout
conn.SetReadTimeout(e.ConnectTimeout)
// handle client
NewClient(e.Backend, conn)
return true
} | go | func (e *Engine) Handle(conn transport.Conn) bool {
// check conn
if conn == nil {
panic("passed conn is nil")
}
// acquire mutex
e.mutex.Lock()
defer e.mutex.Unlock()
// close conn immediately when dying
if !e.tomb.Alive() {
_ = conn.Close()
return false
}
// set default read limit
conn.SetReadLimit(e.DefaultReadLimit)
// set initial read timeout
conn.SetReadTimeout(e.ConnectTimeout)
// handle client
NewClient(e.Backend, conn)
return true
} | [
"func",
"(",
"e",
"*",
"Engine",
")",
"Handle",
"(",
"conn",
"transport",
".",
"Conn",
")",
"bool",
"{",
"// check conn",
"if",
"conn",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// acquire mutex",
"e",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"e",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// close conn immediately when dying",
"if",
"!",
"e",
".",
"tomb",
".",
"Alive",
"(",
")",
"{",
"_",
"=",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n\n",
"// set default read limit",
"conn",
".",
"SetReadLimit",
"(",
"e",
".",
"DefaultReadLimit",
")",
"\n\n",
"// set initial read timeout",
"conn",
".",
"SetReadTimeout",
"(",
"e",
".",
"ConnectTimeout",
")",
"\n\n",
"// handle client",
"NewClient",
"(",
"e",
".",
"Backend",
",",
"conn",
")",
"\n\n",
"return",
"true",
"\n",
"}"
] | // Handle takes over responsibility and handles a transport.Conn. It returns
// false if the engine is closing and the connection has been closed. | [
"Handle",
"takes",
"over",
"responsibility",
"and",
"handles",
"a",
"transport",
".",
"Conn",
".",
"It",
"returns",
"false",
"if",
"the",
"engine",
"is",
"closing",
"and",
"the",
"connection",
"has",
"been",
"closed",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/engine.go#L71-L97 |
10,027 | 256dpi/gomqtt | broker/engine.go | Run | func Run(engine *Engine, protocol string) (string, chan struct{}, chan struct{}) {
// launch server
server, err := transport.Launch(protocol + "://localhost:0")
if err != nil {
panic(err)
}
// prepare channels
quit := make(chan struct{})
done := make(chan struct{})
// start accepting connections
engine.Accept(server)
// prepare shutdown
go func() {
// wait for signal
<-quit
// errors from close are ignored
_ = server.Close()
// close broker
engine.Close()
close(done)
}()
// get random port
_, port, _ := net.SplitHostPort(server.Addr().String())
return port, quit, done
} | go | func Run(engine *Engine, protocol string) (string, chan struct{}, chan struct{}) {
// launch server
server, err := transport.Launch(protocol + "://localhost:0")
if err != nil {
panic(err)
}
// prepare channels
quit := make(chan struct{})
done := make(chan struct{})
// start accepting connections
engine.Accept(server)
// prepare shutdown
go func() {
// wait for signal
<-quit
// errors from close are ignored
_ = server.Close()
// close broker
engine.Close()
close(done)
}()
// get random port
_, port, _ := net.SplitHostPort(server.Addr().String())
return port, quit, done
} | [
"func",
"Run",
"(",
"engine",
"*",
"Engine",
",",
"protocol",
"string",
")",
"(",
"string",
",",
"chan",
"struct",
"{",
"}",
",",
"chan",
"struct",
"{",
"}",
")",
"{",
"// launch server",
"server",
",",
"err",
":=",
"transport",
".",
"Launch",
"(",
"protocol",
"+",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// prepare channels",
"quit",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"done",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n\n",
"// start accepting connections",
"engine",
".",
"Accept",
"(",
"server",
")",
"\n\n",
"// prepare shutdown",
"go",
"func",
"(",
")",
"{",
"// wait for signal",
"<-",
"quit",
"\n\n",
"// errors from close are ignored",
"_",
"=",
"server",
".",
"Close",
"(",
")",
"\n\n",
"// close broker",
"engine",
".",
"Close",
"(",
")",
"\n\n",
"close",
"(",
"done",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// get random port",
"_",
",",
"port",
",",
"_",
":=",
"net",
".",
"SplitHostPort",
"(",
"server",
".",
"Addr",
"(",
")",
".",
"String",
"(",
")",
")",
"\n\n",
"return",
"port",
",",
"quit",
",",
"done",
"\n",
"}"
] | // Run runs the passed engine on a random available port and returns a channel
// that can be closed to shutdown the engine. This method is intended to be used
// in testing scenarios. | [
"Run",
"runs",
"the",
"passed",
"engine",
"on",
"a",
"random",
"available",
"port",
"and",
"returns",
"a",
"channel",
"that",
"can",
"be",
"closed",
"to",
"shutdown",
"the",
"engine",
".",
"This",
"method",
"is",
"intended",
"to",
"be",
"used",
"in",
"testing",
"scenarios",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/engine.go#L116-L148 |
10,028 | 256dpi/gomqtt | packet/strings.go | readLPBytes | func readLPBytes(buf []byte, safe bool, t Type) ([]byte, int, error) {
if len(buf) < 2 {
return nil, 0, makeError(t, "insufficient buffer size, expected 2, got %d", len(buf))
}
n, total := 0, 0
n = int(binary.BigEndian.Uint16(buf))
total += 2
total += n
if len(buf) < total {
return nil, total, makeError(t, "insufficient buffer size, expected %d, got %d", total, len(buf))
}
// copy buffer in safe mode
if safe {
newBuf := make([]byte, total-2)
copy(newBuf, buf[2:total])
return newBuf, total, nil
}
return buf[2:total], total, nil
} | go | func readLPBytes(buf []byte, safe bool, t Type) ([]byte, int, error) {
if len(buf) < 2 {
return nil, 0, makeError(t, "insufficient buffer size, expected 2, got %d", len(buf))
}
n, total := 0, 0
n = int(binary.BigEndian.Uint16(buf))
total += 2
total += n
if len(buf) < total {
return nil, total, makeError(t, "insufficient buffer size, expected %d, got %d", total, len(buf))
}
// copy buffer in safe mode
if safe {
newBuf := make([]byte, total-2)
copy(newBuf, buf[2:total])
return newBuf, total, nil
}
return buf[2:total], total, nil
} | [
"func",
"readLPBytes",
"(",
"buf",
"[",
"]",
"byte",
",",
"safe",
"bool",
",",
"t",
"Type",
")",
"(",
"[",
"]",
"byte",
",",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"buf",
")",
"<",
"2",
"{",
"return",
"nil",
",",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"len",
"(",
"buf",
")",
")",
"\n",
"}",
"\n\n",
"n",
",",
"total",
":=",
"0",
",",
"0",
"\n\n",
"n",
"=",
"int",
"(",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"buf",
")",
")",
"\n",
"total",
"+=",
"2",
"\n",
"total",
"+=",
"n",
"\n\n",
"if",
"len",
"(",
"buf",
")",
"<",
"total",
"{",
"return",
"nil",
",",
"total",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"total",
",",
"len",
"(",
"buf",
")",
")",
"\n",
"}",
"\n\n",
"// copy buffer in safe mode",
"if",
"safe",
"{",
"newBuf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"total",
"-",
"2",
")",
"\n",
"copy",
"(",
"newBuf",
",",
"buf",
"[",
"2",
":",
"total",
"]",
")",
"\n",
"return",
"newBuf",
",",
"total",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"buf",
"[",
"2",
":",
"total",
"]",
",",
"total",
",",
"nil",
"\n",
"}"
] | // read length prefixed bytes | [
"read",
"length",
"prefixed",
"bytes"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/strings.go#L10-L33 |
10,029 | 256dpi/gomqtt | packet/strings.go | readLPString | func readLPString(buf []byte, t Type) (string, int, error) {
if len(buf) < 2 {
return "", 0, makeError(t, "insufficient buffer size, expected 2, got %d", len(buf))
}
n, total := 0, 0
n = int(binary.BigEndian.Uint16(buf))
total += 2
total += n
if len(buf) < total {
return "", total, makeError(t, "insufficient buffer size, expected %d, got %d", total, len(buf))
}
return string(buf[2:total]), total, nil
} | go | func readLPString(buf []byte, t Type) (string, int, error) {
if len(buf) < 2 {
return "", 0, makeError(t, "insufficient buffer size, expected 2, got %d", len(buf))
}
n, total := 0, 0
n = int(binary.BigEndian.Uint16(buf))
total += 2
total += n
if len(buf) < total {
return "", total, makeError(t, "insufficient buffer size, expected %d, got %d", total, len(buf))
}
return string(buf[2:total]), total, nil
} | [
"func",
"readLPString",
"(",
"buf",
"[",
"]",
"byte",
",",
"t",
"Type",
")",
"(",
"string",
",",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"buf",
")",
"<",
"2",
"{",
"return",
"\"",
"\"",
",",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"len",
"(",
"buf",
")",
")",
"\n",
"}",
"\n\n",
"n",
",",
"total",
":=",
"0",
",",
"0",
"\n\n",
"n",
"=",
"int",
"(",
"binary",
".",
"BigEndian",
".",
"Uint16",
"(",
"buf",
")",
")",
"\n",
"total",
"+=",
"2",
"\n",
"total",
"+=",
"n",
"\n\n",
"if",
"len",
"(",
"buf",
")",
"<",
"total",
"{",
"return",
"\"",
"\"",
",",
"total",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"total",
",",
"len",
"(",
"buf",
")",
")",
"\n",
"}",
"\n\n",
"return",
"string",
"(",
"buf",
"[",
"2",
":",
"total",
"]",
")",
",",
"total",
",",
"nil",
"\n",
"}"
] | // read length prefixed string | [
"read",
"length",
"prefixed",
"string"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/strings.go#L36-L52 |
10,030 | 256dpi/gomqtt | packet/strings.go | writeLPBytes | func writeLPBytes(buf []byte, b []byte, t Type) (int, error) {
total, n := 0, len(b)
if n > int(maxLPLength) {
return 0, makeError(t, "length (%d) greater than %d bytes", n, maxLPLength)
}
if len(buf) < 2+n {
return 0, makeError(t, "insufficient buffer size, expected %d, got %d", 2+n, len(buf))
}
binary.BigEndian.PutUint16(buf, uint16(n))
total += 2
copy(buf[total:], b)
total += n
return total, nil
} | go | func writeLPBytes(buf []byte, b []byte, t Type) (int, error) {
total, n := 0, len(b)
if n > int(maxLPLength) {
return 0, makeError(t, "length (%d) greater than %d bytes", n, maxLPLength)
}
if len(buf) < 2+n {
return 0, makeError(t, "insufficient buffer size, expected %d, got %d", 2+n, len(buf))
}
binary.BigEndian.PutUint16(buf, uint16(n))
total += 2
copy(buf[total:], b)
total += n
return total, nil
} | [
"func",
"writeLPBytes",
"(",
"buf",
"[",
"]",
"byte",
",",
"b",
"[",
"]",
"byte",
",",
"t",
"Type",
")",
"(",
"int",
",",
"error",
")",
"{",
"total",
",",
"n",
":=",
"0",
",",
"len",
"(",
"b",
")",
"\n\n",
"if",
"n",
">",
"int",
"(",
"maxLPLength",
")",
"{",
"return",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"n",
",",
"maxLPLength",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"buf",
")",
"<",
"2",
"+",
"n",
"{",
"return",
"0",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
",",
"2",
"+",
"n",
",",
"len",
"(",
"buf",
")",
")",
"\n",
"}",
"\n\n",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"buf",
",",
"uint16",
"(",
"n",
")",
")",
"\n",
"total",
"+=",
"2",
"\n\n",
"copy",
"(",
"buf",
"[",
"total",
":",
"]",
",",
"b",
")",
"\n",
"total",
"+=",
"n",
"\n\n",
"return",
"total",
",",
"nil",
"\n",
"}"
] | // write length prefixed bytes | [
"write",
"length",
"prefixed",
"bytes"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/strings.go#L55-L73 |
10,031 | 256dpi/gomqtt | packet/strings.go | writeLPString | func writeLPString(buf []byte, str string, t Type) (int, error) {
return writeLPBytes(buf, []byte(str), t)
} | go | func writeLPString(buf []byte, str string, t Type) (int, error) {
return writeLPBytes(buf, []byte(str), t)
} | [
"func",
"writeLPString",
"(",
"buf",
"[",
"]",
"byte",
",",
"str",
"string",
",",
"t",
"Type",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"writeLPBytes",
"(",
"buf",
",",
"[",
"]",
"byte",
"(",
"str",
")",
",",
"t",
")",
"\n",
"}"
] | // write length prefixed string | [
"write",
"length",
"prefixed",
"string"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/strings.go#L76-L78 |
10,032 | 256dpi/gomqtt | broker/client.go | NewClient | func NewClient(backend Backend, conn transport.Conn) *Client {
// create client
c := &Client{
state: clientConnecting,
backend: backend,
conn: conn,
done: make(chan struct{}),
}
// start processor
c.tomb.Go(c.processor)
// run cleanup goroutine
go func() {
// wait for death and cleanup
_ = c.tomb.Wait()
c.cleanup()
// close channel
close(c.done)
}()
return c
} | go | func NewClient(backend Backend, conn transport.Conn) *Client {
// create client
c := &Client{
state: clientConnecting,
backend: backend,
conn: conn,
done: make(chan struct{}),
}
// start processor
c.tomb.Go(c.processor)
// run cleanup goroutine
go func() {
// wait for death and cleanup
_ = c.tomb.Wait()
c.cleanup()
// close channel
close(c.done)
}()
return c
} | [
"func",
"NewClient",
"(",
"backend",
"Backend",
",",
"conn",
"transport",
".",
"Conn",
")",
"*",
"Client",
"{",
"// create client",
"c",
":=",
"&",
"Client",
"{",
"state",
":",
"clientConnecting",
",",
"backend",
":",
"backend",
",",
"conn",
":",
"conn",
",",
"done",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n\n",
"// start processor",
"c",
".",
"tomb",
".",
"Go",
"(",
"c",
".",
"processor",
")",
"\n\n",
"// run cleanup goroutine",
"go",
"func",
"(",
")",
"{",
"// wait for death and cleanup",
"_",
"=",
"c",
".",
"tomb",
".",
"Wait",
"(",
")",
"\n",
"c",
".",
"cleanup",
"(",
")",
"\n\n",
"// close channel",
"close",
"(",
"c",
".",
"done",
")",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"c",
"\n",
"}"
] | // NewClient takes over a connection and returns a Client. | [
"NewClient",
"takes",
"over",
"a",
"connection",
"and",
"returns",
"a",
"Client",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L257-L280 |
10,033 | 256dpi/gomqtt | broker/client.go | Close | func (c *Client) Close() {
_ = c.conn.Close()
c.tomb.Kill(ErrClientClosed)
} | go | func (c *Client) Close() {
_ = c.conn.Close()
c.tomb.Kill(ErrClientClosed)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Close",
"(",
")",
"{",
"_",
"=",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"c",
".",
"tomb",
".",
"Kill",
"(",
"ErrClientClosed",
")",
"\n",
"}"
] | // Close will immediately close the client. | [
"Close",
"will",
"immediately",
"close",
"the",
"client",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L299-L302 |
10,034 | 256dpi/gomqtt | broker/client.go | processPacket | func (c *Client) processPacket(pkt packet.Generic) error {
// prepare error
var err error
// handle individual packets
switch typedPkt := pkt.(type) {
case *packet.Subscribe:
err = c.processSubscribe(typedPkt)
case *packet.Unsubscribe:
err = c.processUnsubscribe(typedPkt)
case *packet.Publish:
err = c.processPublish(typedPkt)
case *packet.Puback:
err = c.processPubackAndPubcomp(typedPkt.ID)
case *packet.Pubcomp:
err = c.processPubackAndPubcomp(typedPkt.ID)
case *packet.Pubrec:
err = c.processPubrec(typedPkt.ID)
case *packet.Pubrel:
err = c.processPubrel(typedPkt.ID)
case *packet.Pingreq:
err = c.processPingreq()
case *packet.Disconnect:
err = c.processDisconnect()
default:
err = c.die(ClientError, ErrUnexpectedPacket)
}
// return eventual error
if err != nil {
return err // error has already been handled
}
return nil
} | go | func (c *Client) processPacket(pkt packet.Generic) error {
// prepare error
var err error
// handle individual packets
switch typedPkt := pkt.(type) {
case *packet.Subscribe:
err = c.processSubscribe(typedPkt)
case *packet.Unsubscribe:
err = c.processUnsubscribe(typedPkt)
case *packet.Publish:
err = c.processPublish(typedPkt)
case *packet.Puback:
err = c.processPubackAndPubcomp(typedPkt.ID)
case *packet.Pubcomp:
err = c.processPubackAndPubcomp(typedPkt.ID)
case *packet.Pubrec:
err = c.processPubrec(typedPkt.ID)
case *packet.Pubrel:
err = c.processPubrel(typedPkt.ID)
case *packet.Pingreq:
err = c.processPingreq()
case *packet.Disconnect:
err = c.processDisconnect()
default:
err = c.die(ClientError, ErrUnexpectedPacket)
}
// return eventual error
if err != nil {
return err // error has already been handled
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPacket",
"(",
"pkt",
"packet",
".",
"Generic",
")",
"error",
"{",
"// prepare error",
"var",
"err",
"error",
"\n\n",
"// handle individual packets",
"switch",
"typedPkt",
":=",
"pkt",
".",
"(",
"type",
")",
"{",
"case",
"*",
"packet",
".",
"Subscribe",
":",
"err",
"=",
"c",
".",
"processSubscribe",
"(",
"typedPkt",
")",
"\n",
"case",
"*",
"packet",
".",
"Unsubscribe",
":",
"err",
"=",
"c",
".",
"processUnsubscribe",
"(",
"typedPkt",
")",
"\n",
"case",
"*",
"packet",
".",
"Publish",
":",
"err",
"=",
"c",
".",
"processPublish",
"(",
"typedPkt",
")",
"\n",
"case",
"*",
"packet",
".",
"Puback",
":",
"err",
"=",
"c",
".",
"processPubackAndPubcomp",
"(",
"typedPkt",
".",
"ID",
")",
"\n",
"case",
"*",
"packet",
".",
"Pubcomp",
":",
"err",
"=",
"c",
".",
"processPubackAndPubcomp",
"(",
"typedPkt",
".",
"ID",
")",
"\n",
"case",
"*",
"packet",
".",
"Pubrec",
":",
"err",
"=",
"c",
".",
"processPubrec",
"(",
"typedPkt",
".",
"ID",
")",
"\n",
"case",
"*",
"packet",
".",
"Pubrel",
":",
"err",
"=",
"c",
".",
"processPubrel",
"(",
"typedPkt",
".",
"ID",
")",
"\n",
"case",
"*",
"packet",
".",
"Pingreq",
":",
"err",
"=",
"c",
".",
"processPingreq",
"(",
")",
"\n",
"case",
"*",
"packet",
".",
"Disconnect",
":",
"err",
"=",
"c",
".",
"processDisconnect",
"(",
")",
"\n",
"default",
":",
"err",
"=",
"c",
".",
"die",
"(",
"ClientError",
",",
"ErrUnexpectedPacket",
")",
"\n",
"}",
"\n\n",
"// return eventual error",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"// error has already been handled",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Generic | [
"handle",
"an",
"incoming",
"Generic"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L636-L670 |
10,035 | 256dpi/gomqtt | broker/client.go | processPingreq | func (c *Client) processPingreq() error {
// send a pingresp packet
err := c.send(packet.NewPingresp(), true)
if err != nil {
return c.die(TransportError, err)
}
return nil
} | go | func (c *Client) processPingreq() error {
// send a pingresp packet
err := c.send(packet.NewPingresp(), true)
if err != nil {
return c.die(TransportError, err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPingreq",
"(",
")",
"error",
"{",
"// send a pingresp packet",
"err",
":=",
"c",
".",
"send",
"(",
"packet",
".",
"NewPingresp",
"(",
")",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"TransportError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming Pingreq packet | [
"handle",
"an",
"incoming",
"Pingreq",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L673-L681 |
10,036 | 256dpi/gomqtt | broker/client.go | processSubscribe | func (c *Client) processSubscribe(pkt *packet.Subscribe) error {
// acquire subscribe token
select {
case <-c.subscribeTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// prepare suback packet
suback := packet.NewSuback()
suback.ReturnCodes = make([]packet.QOS, len(pkt.Subscriptions))
suback.ID = pkt.ID
// set granted qos
for i, subscription := range pkt.Subscriptions {
suback.ReturnCodes[i] = subscription.QOS
}
// subscribe client to queue
err := c.backend.Subscribe(c, pkt.Subscriptions, func() {
select {
case c.ackQueue <- suback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
return nil
} | go | func (c *Client) processSubscribe(pkt *packet.Subscribe) error {
// acquire subscribe token
select {
case <-c.subscribeTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// prepare suback packet
suback := packet.NewSuback()
suback.ReturnCodes = make([]packet.QOS, len(pkt.Subscriptions))
suback.ID = pkt.ID
// set granted qos
for i, subscription := range pkt.Subscriptions {
suback.ReturnCodes[i] = subscription.QOS
}
// subscribe client to queue
err := c.backend.Subscribe(c, pkt.Subscriptions, func() {
select {
case c.ackQueue <- suback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processSubscribe",
"(",
"pkt",
"*",
"packet",
".",
"Subscribe",
")",
"error",
"{",
"// acquire subscribe token",
"select",
"{",
"case",
"<-",
"c",
".",
"subscribeTokens",
":",
"// continue",
"case",
"<-",
"time",
".",
"After",
"(",
"c",
".",
"TokenTimeout",
")",
":",
"return",
"c",
".",
"die",
"(",
"ClientError",
",",
"ErrTokenTimeout",
")",
"\n",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n\n",
"// prepare suback packet",
"suback",
":=",
"packet",
".",
"NewSuback",
"(",
")",
"\n",
"suback",
".",
"ReturnCodes",
"=",
"make",
"(",
"[",
"]",
"packet",
".",
"QOS",
",",
"len",
"(",
"pkt",
".",
"Subscriptions",
")",
")",
"\n",
"suback",
".",
"ID",
"=",
"pkt",
".",
"ID",
"\n\n",
"// set granted qos",
"for",
"i",
",",
"subscription",
":=",
"range",
"pkt",
".",
"Subscriptions",
"{",
"suback",
".",
"ReturnCodes",
"[",
"i",
"]",
"=",
"subscription",
".",
"QOS",
"\n",
"}",
"\n\n",
"// subscribe client to queue",
"err",
":=",
"c",
".",
"backend",
".",
"Subscribe",
"(",
"c",
",",
"pkt",
".",
"Subscriptions",
",",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"c",
".",
"ackQueue",
"<-",
"suback",
":",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"BackendError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming subscribe packet | [
"handle",
"an",
"incoming",
"subscribe",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L684-L717 |
10,037 | 256dpi/gomqtt | broker/client.go | processUnsubscribe | func (c *Client) processUnsubscribe(pkt *packet.Unsubscribe) error {
// acquire subscribe token
select {
case <-c.subscribeTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// prepare unsuback packet
unsuback := packet.NewUnsuback()
unsuback.ID = pkt.ID
// unsubscribe topics
err := c.backend.Unsubscribe(c, pkt.Topics, func() {
select {
case c.ackQueue <- unsuback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
return nil
} | go | func (c *Client) processUnsubscribe(pkt *packet.Unsubscribe) error {
// acquire subscribe token
select {
case <-c.subscribeTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// prepare unsuback packet
unsuback := packet.NewUnsuback()
unsuback.ID = pkt.ID
// unsubscribe topics
err := c.backend.Unsubscribe(c, pkt.Topics, func() {
select {
case c.ackQueue <- unsuback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processUnsubscribe",
"(",
"pkt",
"*",
"packet",
".",
"Unsubscribe",
")",
"error",
"{",
"// acquire subscribe token",
"select",
"{",
"case",
"<-",
"c",
".",
"subscribeTokens",
":",
"// continue",
"case",
"<-",
"time",
".",
"After",
"(",
"c",
".",
"TokenTimeout",
")",
":",
"return",
"c",
".",
"die",
"(",
"ClientError",
",",
"ErrTokenTimeout",
")",
"\n",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n\n",
"// prepare unsuback packet",
"unsuback",
":=",
"packet",
".",
"NewUnsuback",
"(",
")",
"\n",
"unsuback",
".",
"ID",
"=",
"pkt",
".",
"ID",
"\n\n",
"// unsubscribe topics",
"err",
":=",
"c",
".",
"backend",
".",
"Unsubscribe",
"(",
"c",
",",
"pkt",
".",
"Topics",
",",
"func",
"(",
")",
"{",
"select",
"{",
"case",
"c",
".",
"ackQueue",
"<-",
"unsuback",
":",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"BackendError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming unsubscribe packet | [
"handle",
"an",
"incoming",
"unsubscribe",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L720-L747 |
10,038 | 256dpi/gomqtt | broker/client.go | processPublish | func (c *Client) processPublish(publish *packet.Publish) error {
// handle qos 0 flow
if publish.Message.QOS == 0 {
// publish message
err := c.backend.Publish(c, &publish.Message, nil)
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
return nil
}
// acquire publish token
select {
case <-c.publishTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// handle qos 1 flow
if publish.Message.QOS == 1 {
// prepare puback
puback := packet.NewPuback()
puback.ID = publish.ID
// publish message and queue puback if ack is called
err := c.backend.Publish(c, &publish.Message, func() {
c.backend.Log(MessageAcknowledged, c, nil, &publish.Message, nil)
select {
case c.ackQueue <- puback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
}
// handle qos 2 flow
if publish.Message.QOS == 2 {
// store received publish packet in session
err := c.session.SavePacket(session.Incoming, publish)
if err != nil {
return c.die(SessionError, err)
}
// prepare pubrec packet
pubrec := packet.NewPubrec()
pubrec.ID = publish.ID
// signal qos 2 pubrec
err = c.send(pubrec, true)
if err != nil {
return c.die(TransportError, err)
}
}
return nil
} | go | func (c *Client) processPublish(publish *packet.Publish) error {
// handle qos 0 flow
if publish.Message.QOS == 0 {
// publish message
err := c.backend.Publish(c, &publish.Message, nil)
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
return nil
}
// acquire publish token
select {
case <-c.publishTokens:
// continue
case <-time.After(c.TokenTimeout):
return c.die(ClientError, ErrTokenTimeout)
case <-c.tomb.Dying():
return tomb.ErrDying
}
// handle qos 1 flow
if publish.Message.QOS == 1 {
// prepare puback
puback := packet.NewPuback()
puback.ID = publish.ID
// publish message and queue puback if ack is called
err := c.backend.Publish(c, &publish.Message, func() {
c.backend.Log(MessageAcknowledged, c, nil, &publish.Message, nil)
select {
case c.ackQueue <- puback:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
}
// handle qos 2 flow
if publish.Message.QOS == 2 {
// store received publish packet in session
err := c.session.SavePacket(session.Incoming, publish)
if err != nil {
return c.die(SessionError, err)
}
// prepare pubrec packet
pubrec := packet.NewPubrec()
pubrec.ID = publish.ID
// signal qos 2 pubrec
err = c.send(pubrec, true)
if err != nil {
return c.die(TransportError, err)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPublish",
"(",
"publish",
"*",
"packet",
".",
"Publish",
")",
"error",
"{",
"// handle qos 0 flow",
"if",
"publish",
".",
"Message",
".",
"QOS",
"==",
"0",
"{",
"// publish message",
"err",
":=",
"c",
".",
"backend",
".",
"Publish",
"(",
"c",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"BackendError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"backend",
".",
"Log",
"(",
"MessagePublished",
",",
"c",
",",
"nil",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// acquire publish token",
"select",
"{",
"case",
"<-",
"c",
".",
"publishTokens",
":",
"// continue",
"case",
"<-",
"time",
".",
"After",
"(",
"c",
".",
"TokenTimeout",
")",
":",
"return",
"c",
".",
"die",
"(",
"ClientError",
",",
"ErrTokenTimeout",
")",
"\n",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n\n",
"// handle qos 1 flow",
"if",
"publish",
".",
"Message",
".",
"QOS",
"==",
"1",
"{",
"// prepare puback",
"puback",
":=",
"packet",
".",
"NewPuback",
"(",
")",
"\n",
"puback",
".",
"ID",
"=",
"publish",
".",
"ID",
"\n\n",
"// publish message and queue puback if ack is called",
"err",
":=",
"c",
".",
"backend",
".",
"Publish",
"(",
"c",
",",
"&",
"publish",
".",
"Message",
",",
"func",
"(",
")",
"{",
"c",
".",
"backend",
".",
"Log",
"(",
"MessageAcknowledged",
",",
"c",
",",
"nil",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n\n",
"select",
"{",
"case",
"c",
".",
"ackQueue",
"<-",
"puback",
":",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"BackendError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"backend",
".",
"Log",
"(",
"MessagePublished",
",",
"c",
",",
"nil",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n",
"}",
"\n\n",
"// handle qos 2 flow",
"if",
"publish",
".",
"Message",
".",
"QOS",
"==",
"2",
"{",
"// store received publish packet in session",
"err",
":=",
"c",
".",
"session",
".",
"SavePacket",
"(",
"session",
".",
"Incoming",
",",
"publish",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"SessionError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// prepare pubrec packet",
"pubrec",
":=",
"packet",
".",
"NewPubrec",
"(",
")",
"\n",
"pubrec",
".",
"ID",
"=",
"publish",
".",
"ID",
"\n\n",
"// signal qos 2 pubrec",
"err",
"=",
"c",
".",
"send",
"(",
"pubrec",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"TransportError",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming publish packet | [
"handle",
"an",
"incoming",
"publish",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L750-L816 |
10,039 | 256dpi/gomqtt | broker/client.go | processPubackAndPubcomp | func (c *Client) processPubackAndPubcomp(id packet.ID) error {
// remove packet from store
err := c.session.DeletePacket(session.Outgoing, id)
if err != nil {
return c.die(SessionError, err)
}
// put back dequeue token
select {
case c.dequeueTokens <- struct{}{}:
default:
// continue if full for some reason
}
return nil
} | go | func (c *Client) processPubackAndPubcomp(id packet.ID) error {
// remove packet from store
err := c.session.DeletePacket(session.Outgoing, id)
if err != nil {
return c.die(SessionError, err)
}
// put back dequeue token
select {
case c.dequeueTokens <- struct{}{}:
default:
// continue if full for some reason
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPubackAndPubcomp",
"(",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"// remove packet from store",
"err",
":=",
"c",
".",
"session",
".",
"DeletePacket",
"(",
"session",
".",
"Outgoing",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"SessionError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// put back dequeue token",
"select",
"{",
"case",
"c",
".",
"dequeueTokens",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"default",
":",
"// continue if full for some reason",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming p or pubcomp packet | [
"handle",
"an",
"incoming",
"p",
"or",
"pubcomp",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L819-L834 |
10,040 | 256dpi/gomqtt | broker/client.go | processPubrel | func (c *Client) processPubrel(id packet.ID) error {
// get stored publish packet from session
pkt, err := c.session.LookupPacket(session.Incoming, id)
if err != nil {
return c.die(SessionError, err)
}
// prepare pubcomp packet
pubcomp := packet.NewPubcomp()
pubcomp.ID = id
// get packet from store
publish, ok := pkt.(*packet.Publish)
if !ok {
// immediately send pubcomp for missing packets
err = c.send(pubcomp, true)
if err != nil {
return c.die(TransportError, err)
}
return nil
}
// publish message and queue pubcomp if ack is called
err = c.backend.Publish(c, &publish.Message, func() {
c.backend.Log(MessageAcknowledged, c, nil, &publish.Message, nil)
select {
case c.ackQueue <- pubcomp:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
return nil
} | go | func (c *Client) processPubrel(id packet.ID) error {
// get stored publish packet from session
pkt, err := c.session.LookupPacket(session.Incoming, id)
if err != nil {
return c.die(SessionError, err)
}
// prepare pubcomp packet
pubcomp := packet.NewPubcomp()
pubcomp.ID = id
// get packet from store
publish, ok := pkt.(*packet.Publish)
if !ok {
// immediately send pubcomp for missing packets
err = c.send(pubcomp, true)
if err != nil {
return c.die(TransportError, err)
}
return nil
}
// publish message and queue pubcomp if ack is called
err = c.backend.Publish(c, &publish.Message, func() {
c.backend.Log(MessageAcknowledged, c, nil, &publish.Message, nil)
select {
case c.ackQueue <- pubcomp:
case <-c.tomb.Dying():
}
})
if err != nil {
return c.die(BackendError, err)
}
c.backend.Log(MessagePublished, c, nil, &publish.Message, nil)
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processPubrel",
"(",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"// get stored publish packet from session",
"pkt",
",",
"err",
":=",
"c",
".",
"session",
".",
"LookupPacket",
"(",
"session",
".",
"Incoming",
",",
"id",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"SessionError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// prepare pubcomp packet",
"pubcomp",
":=",
"packet",
".",
"NewPubcomp",
"(",
")",
"\n",
"pubcomp",
".",
"ID",
"=",
"id",
"\n\n",
"// get packet from store",
"publish",
",",
"ok",
":=",
"pkt",
".",
"(",
"*",
"packet",
".",
"Publish",
")",
"\n",
"if",
"!",
"ok",
"{",
"// immediately send pubcomp for missing packets",
"err",
"=",
"c",
".",
"send",
"(",
"pubcomp",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"TransportError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// publish message and queue pubcomp if ack is called",
"err",
"=",
"c",
".",
"backend",
".",
"Publish",
"(",
"c",
",",
"&",
"publish",
".",
"Message",
",",
"func",
"(",
")",
"{",
"c",
".",
"backend",
".",
"Log",
"(",
"MessageAcknowledged",
",",
"c",
",",
"nil",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n\n",
"select",
"{",
"case",
"c",
".",
"ackQueue",
"<-",
"pubcomp",
":",
"case",
"<-",
"c",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"}",
"\n",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"BackendError",
",",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"backend",
".",
"Log",
"(",
"MessagePublished",
",",
"c",
",",
"nil",
",",
"&",
"publish",
".",
"Message",
",",
"nil",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle an incoming pubrel packet | [
"handle",
"an",
"incoming",
"pubrel",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L858-L897 |
10,041 | 256dpi/gomqtt | broker/client.go | processDisconnect | func (c *Client) processDisconnect() error {
// clear will
c.will = nil
// mark client as cleanly disconnected
atomic.StoreUint32(&c.state, clientDisconnected)
// close underlying connection (triggers cleanup)
_ = c.conn.Close()
// ensure tomb is killed
c.tomb.Kill(ErrClientDisconnected)
c.backend.Log(ClientDisconnected, c, nil, nil, nil)
return ErrClientDisconnected
} | go | func (c *Client) processDisconnect() error {
// clear will
c.will = nil
// mark client as cleanly disconnected
atomic.StoreUint32(&c.state, clientDisconnected)
// close underlying connection (triggers cleanup)
_ = c.conn.Close()
// ensure tomb is killed
c.tomb.Kill(ErrClientDisconnected)
c.backend.Log(ClientDisconnected, c, nil, nil, nil)
return ErrClientDisconnected
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processDisconnect",
"(",
")",
"error",
"{",
"// clear will",
"c",
".",
"will",
"=",
"nil",
"\n\n",
"// mark client as cleanly disconnected",
"atomic",
".",
"StoreUint32",
"(",
"&",
"c",
".",
"state",
",",
"clientDisconnected",
")",
"\n\n",
"// close underlying connection (triggers cleanup)",
"_",
"=",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"// ensure tomb is killed",
"c",
".",
"tomb",
".",
"Kill",
"(",
"ErrClientDisconnected",
")",
"\n\n",
"c",
".",
"backend",
".",
"Log",
"(",
"ClientDisconnected",
",",
"c",
",",
"nil",
",",
"nil",
",",
"nil",
")",
"\n\n",
"return",
"ErrClientDisconnected",
"\n",
"}"
] | // handle an incoming disconnect packet | [
"handle",
"an",
"incoming",
"disconnect",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/broker/client.go#L900-L916 |
10,042 | 256dpi/gomqtt | transport/net_server.go | CreateNetServer | func CreateNetServer(address string) (*NetServer, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, err
}
return NewNetServer(listener), nil
} | go | func CreateNetServer(address string) (*NetServer, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, err
}
return NewNetServer(listener), nil
} | [
"func",
"CreateNetServer",
"(",
"address",
"string",
")",
"(",
"*",
"NetServer",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewNetServer",
"(",
"listener",
")",
",",
"nil",
"\n",
"}"
] | // CreateNetServer creates a new TCP server that listens on the provided address. | [
"CreateNetServer",
"creates",
"a",
"new",
"TCP",
"server",
"that",
"listens",
"on",
"the",
"provided",
"address",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/net_server.go#L24-L31 |
10,043 | 256dpi/gomqtt | transport/net_server.go | CreateSecureNetServer | func CreateSecureNetServer(address string, config *tls.Config) (*NetServer, error) {
listener, err := tls.Listen("tcp", address, config)
if err != nil {
return nil, err
}
return NewNetServer(listener), nil
} | go | func CreateSecureNetServer(address string, config *tls.Config) (*NetServer, error) {
listener, err := tls.Listen("tcp", address, config)
if err != nil {
return nil, err
}
return NewNetServer(listener), nil
} | [
"func",
"CreateSecureNetServer",
"(",
"address",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"*",
"NetServer",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"tls",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewNetServer",
"(",
"listener",
")",
",",
"nil",
"\n",
"}"
] | // CreateSecureNetServer creates a new TLS server that listens on the provided address. | [
"CreateSecureNetServer",
"creates",
"a",
"new",
"TLS",
"server",
"that",
"listens",
"on",
"the",
"provided",
"address",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/net_server.go#L34-L41 |
10,044 | 256dpi/gomqtt | client/future/future.go | New | func New() *Future {
return &Future{
Data: new(sync.Map),
completeChannel: make(chan struct{}),
cancelChannel: make(chan struct{}),
}
} | go | func New() *Future {
return &Future{
Data: new(sync.Map),
completeChannel: make(chan struct{}),
cancelChannel: make(chan struct{}),
}
} | [
"func",
"New",
"(",
")",
"*",
"Future",
"{",
"return",
"&",
"Future",
"{",
"Data",
":",
"new",
"(",
"sync",
".",
"Map",
")",
",",
"completeChannel",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"cancelChannel",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // New will return a new Future. | [
"New",
"will",
"return",
"a",
"new",
"Future",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/future.go#L26-L32 |
10,045 | 256dpi/gomqtt | client/future/future.go | Bind | func (f *Future) Bind(f2 *Future) {
select {
case <-f2.completeChannel:
f.Data = f2.Data
close(f.completeChannel)
case <-f2.cancelChannel:
f.Data = f2.Data
close(f.cancelChannel)
}
} | go | func (f *Future) Bind(f2 *Future) {
select {
case <-f2.completeChannel:
f.Data = f2.Data
close(f.completeChannel)
case <-f2.cancelChannel:
f.Data = f2.Data
close(f.cancelChannel)
}
} | [
"func",
"(",
"f",
"*",
"Future",
")",
"Bind",
"(",
"f2",
"*",
"Future",
")",
"{",
"select",
"{",
"case",
"<-",
"f2",
".",
"completeChannel",
":",
"f",
".",
"Data",
"=",
"f2",
".",
"Data",
"\n",
"close",
"(",
"f",
".",
"completeChannel",
")",
"\n",
"case",
"<-",
"f2",
".",
"cancelChannel",
":",
"f",
".",
"Data",
"=",
"f2",
".",
"Data",
"\n",
"close",
"(",
"f",
".",
"cancelChannel",
")",
"\n",
"}",
"\n",
"}"
] | // Bind will tie the current future to the specified future. If the bound to
// future is completed or canceled the current will as well. Data saved in the
// bound future is copied to the current on complete and cancel. | [
"Bind",
"will",
"tie",
"the",
"current",
"future",
"to",
"the",
"specified",
"future",
".",
"If",
"the",
"bound",
"to",
"future",
"is",
"completed",
"or",
"canceled",
"the",
"current",
"will",
"as",
"well",
".",
"Data",
"saved",
"in",
"the",
"bound",
"future",
"is",
"copied",
"to",
"the",
"current",
"on",
"complete",
"and",
"cancel",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/future.go#L37-L46 |
10,046 | 256dpi/gomqtt | client/future/future.go | Wait | func (f *Future) Wait(timeout time.Duration) error {
select {
case <-f.completeChannel:
return nil
case <-f.cancelChannel:
return ErrCanceled
case <-time.After(timeout):
return ErrTimeout
}
} | go | func (f *Future) Wait(timeout time.Duration) error {
select {
case <-f.completeChannel:
return nil
case <-f.cancelChannel:
return ErrCanceled
case <-time.After(timeout):
return ErrTimeout
}
} | [
"func",
"(",
"f",
"*",
"Future",
")",
"Wait",
"(",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"select",
"{",
"case",
"<-",
"f",
".",
"completeChannel",
":",
"return",
"nil",
"\n",
"case",
"<-",
"f",
".",
"cancelChannel",
":",
"return",
"ErrCanceled",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"timeout",
")",
":",
"return",
"ErrTimeout",
"\n",
"}",
"\n",
"}"
] | // Wait will wait the given amount of time and return whether the future has been
// completed, canceled or the request timed out. | [
"Wait",
"will",
"wait",
"the",
"given",
"amount",
"of",
"time",
"and",
"return",
"whether",
"the",
"future",
"has",
"been",
"completed",
"canceled",
"or",
"the",
"request",
"timed",
"out",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/future.go#L50-L59 |
10,047 | 256dpi/gomqtt | topic/tree.go | Add | func (t *Tree) Add(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.add(value, 0, strings.Split(topic, t.Separator), t.root)
} | go | func (t *Tree) Add(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.add(value, 0, strings.Split(topic, t.Separator), t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Add",
"(",
"topic",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"add",
"(",
"value",
",",
"0",
",",
"strings",
".",
"Split",
"(",
"topic",
",",
"t",
".",
"Separator",
")",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Add registers the value for the supplied topic. This function will
// automatically grow the tree. If value already exists for the given topic it
// will not be added again. | [
"Add",
"registers",
"the",
"value",
"for",
"the",
"supplied",
"topic",
".",
"This",
"function",
"will",
"automatically",
"grow",
"the",
"tree",
".",
"If",
"value",
"already",
"exists",
"for",
"the",
"given",
"topic",
"it",
"will",
"not",
"be",
"added",
"again",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L78-L83 |
10,048 | 256dpi/gomqtt | topic/tree.go | Set | func (t *Tree) Set(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.set(value, 0, strings.Split(topic, t.Separator), t.root)
} | go | func (t *Tree) Set(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.set(value, 0, strings.Split(topic, t.Separator), t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Set",
"(",
"topic",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"set",
"(",
"value",
",",
"0",
",",
"strings",
".",
"Split",
"(",
"topic",
",",
"t",
".",
"Separator",
")",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Set sets the supplied value as the only value for the supplied topic. This
// function will automatically grow the tree. | [
"Set",
"sets",
"the",
"supplied",
"value",
"as",
"the",
"only",
"value",
"for",
"the",
"supplied",
"topic",
".",
"This",
"function",
"will",
"automatically",
"grow",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L112-L117 |
10,049 | 256dpi/gomqtt | topic/tree.go | Get | func (t *Tree) Get(topic string) []interface{} {
t.mutex.Lock()
defer t.mutex.Unlock()
return t.get(0, strings.Split(topic, t.Separator), t.root)
} | go | func (t *Tree) Get(topic string) []interface{} {
t.mutex.Lock()
defer t.mutex.Unlock()
return t.get(0, strings.Split(topic, t.Separator), t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Get",
"(",
"topic",
"string",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"t",
".",
"get",
"(",
"0",
",",
"strings",
".",
"Split",
"(",
"topic",
",",
"t",
".",
"Separator",
")",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Get gets the values from the topic that exactly matches the supplied topics. | [
"Get",
"gets",
"the",
"values",
"from",
"the",
"topic",
"that",
"exactly",
"matches",
"the",
"supplied",
"topics",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L139-L144 |
10,050 | 256dpi/gomqtt | topic/tree.go | Remove | func (t *Tree) Remove(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.remove(value, 0, strings.Split(topic, t.Separator), t.root)
} | go | func (t *Tree) Remove(topic string, value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.remove(value, 0, strings.Split(topic, t.Separator), t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Remove",
"(",
"topic",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"remove",
"(",
"value",
",",
"0",
",",
"strings",
".",
"Split",
"(",
"topic",
",",
"t",
".",
"Separator",
")",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Remove un-registers the value from the supplied topic. This function will
// automatically shrink the tree. | [
"Remove",
"un",
"-",
"registers",
"the",
"value",
"from",
"the",
"supplied",
"topic",
".",
"This",
"function",
"will",
"automatically",
"shrink",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L164-L169 |
10,051 | 256dpi/gomqtt | topic/tree.go | Empty | func (t *Tree) Empty(topic string) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.remove(nil, 0, strings.Split(topic, t.Separator), t.root)
} | go | func (t *Tree) Empty(topic string) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.remove(nil, 0, strings.Split(topic, t.Separator), t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Empty",
"(",
"topic",
"string",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"remove",
"(",
"nil",
",",
"0",
",",
"strings",
".",
"Split",
"(",
"topic",
",",
"t",
".",
"Separator",
")",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Empty will unregister all values from the supplied topic. This function will
// automatically shrink the tree. | [
"Empty",
"will",
"unregister",
"all",
"values",
"from",
"the",
"supplied",
"topic",
".",
"This",
"function",
"will",
"automatically",
"shrink",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L173-L178 |
10,052 | 256dpi/gomqtt | topic/tree.go | Clear | func (t *Tree) Clear(value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.clear(value, t.root)
} | go | func (t *Tree) Clear(value interface{}) {
t.mutex.Lock()
defer t.mutex.Unlock()
t.clear(value, t.root)
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Clear",
"(",
"value",
"interface",
"{",
"}",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"clear",
"(",
"value",
",",
"t",
".",
"root",
")",
"\n",
"}"
] | // Clear will unregister the supplied value from all topics. This function will
// automatically shrink the tree. | [
"Clear",
"will",
"unregister",
"the",
"supplied",
"value",
"from",
"all",
"topics",
".",
"This",
"function",
"will",
"automatically",
"shrink",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L209-L214 |
10,053 | 256dpi/gomqtt | topic/tree.go | MatchFirst | func (t *Tree) MatchFirst(topic string) interface{} {
values := t.Match(topic)
if len(values) > 0 {
return values[0]
}
return nil
} | go | func (t *Tree) MatchFirst(topic string) interface{} {
values := t.Match(topic)
if len(values) > 0 {
return values[0]
}
return nil
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"MatchFirst",
"(",
"topic",
"string",
")",
"interface",
"{",
"}",
"{",
"values",
":=",
"t",
".",
"Match",
"(",
"topic",
")",
"\n\n",
"if",
"len",
"(",
"values",
")",
">",
"0",
"{",
"return",
"values",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // MatchFirst will run Match and return the first value or nil. | [
"MatchFirst",
"will",
"run",
"Match",
"and",
"return",
"the",
"first",
"value",
"or",
"nil",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L273-L281 |
10,054 | 256dpi/gomqtt | topic/tree.go | SearchFirst | func (t *Tree) SearchFirst(topic string) interface{} {
values := t.Search(topic)
if len(values) > 0 {
return values[0]
}
return nil
} | go | func (t *Tree) SearchFirst(topic string) interface{} {
values := t.Search(topic)
if len(values) > 0 {
return values[0]
}
return nil
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"SearchFirst",
"(",
"topic",
"string",
")",
"interface",
"{",
"}",
"{",
"values",
":=",
"t",
".",
"Search",
"(",
"topic",
")",
"\n\n",
"if",
"len",
"(",
"values",
")",
">",
"0",
"{",
"return",
"values",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SearchFirst will run Search and return the first value or nil. | [
"SearchFirst",
"will",
"run",
"Search",
"and",
"return",
"the",
"first",
"value",
"or",
"nil",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L336-L344 |
10,055 | 256dpi/gomqtt | topic/tree.go | clean | func (t *Tree) clean(values []interface{}) []interface{} {
result := values[:0]
for _, v := range values {
if contains(result, v) {
continue
}
result = append(result, v)
}
return result
} | go | func (t *Tree) clean(values []interface{}) []interface{} {
result := values[:0]
for _, v := range values {
if contains(result, v) {
continue
}
result = append(result, v)
}
return result
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"clean",
"(",
"values",
"[",
"]",
"interface",
"{",
"}",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"result",
":=",
"values",
"[",
":",
"0",
"]",
"\n\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"if",
"contains",
"(",
"result",
",",
"v",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"result",
"=",
"append",
"(",
"result",
",",
"v",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] | // clean will remove duplicates | [
"clean",
"will",
"remove",
"duplicates"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L347-L359 |
10,056 | 256dpi/gomqtt | topic/tree.go | All | func (t *Tree) All() []interface{} {
t.mutex.RLock()
defer t.mutex.RUnlock()
return t.clean(t.all([]interface{}{}, t.root))
} | go | func (t *Tree) All() []interface{} {
t.mutex.RLock()
defer t.mutex.RUnlock()
return t.clean(t.all([]interface{}{}, t.root))
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"All",
"(",
")",
"[",
"]",
"interface",
"{",
"}",
"{",
"t",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"t",
".",
"clean",
"(",
"t",
".",
"all",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"}",
",",
"t",
".",
"root",
")",
")",
"\n",
"}"
] | // All will return all stored values in the tree. | [
"All",
"will",
"return",
"all",
"stored",
"values",
"in",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L384-L389 |
10,057 | 256dpi/gomqtt | topic/tree.go | Reset | func (t *Tree) Reset() {
t.mutex.Lock()
defer t.mutex.Unlock()
t.root = newNode()
} | go | func (t *Tree) Reset() {
t.mutex.Lock()
defer t.mutex.Unlock()
t.root = newNode()
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"Reset",
"(",
")",
"{",
"t",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"root",
"=",
"newNode",
"(",
")",
"\n",
"}"
] | // Reset will completely clear the tree. | [
"Reset",
"will",
"completely",
"clear",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L402-L407 |
10,058 | 256dpi/gomqtt | topic/tree.go | String | func (t *Tree) String() string {
t.mutex.RLock()
defer t.mutex.RUnlock()
return fmt.Sprintf("topic.Tree:%s", t.root.string(0))
} | go | func (t *Tree) String() string {
t.mutex.RLock()
defer t.mutex.RUnlock()
return fmt.Sprintf("topic.Tree:%s", t.root.string(0))
} | [
"func",
"(",
"t",
"*",
"Tree",
")",
"String",
"(",
")",
"string",
"{",
"t",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"t",
".",
"root",
".",
"string",
"(",
"0",
")",
")",
"\n",
"}"
] | // String will return a string representation of the tree. | [
"String",
"will",
"return",
"a",
"string",
"representation",
"of",
"the",
"tree",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/tree.go#L410-L415 |
10,059 | 256dpi/gomqtt | spec/spec.go | AllFeatures | func AllFeatures() *Config {
return &Config{
RetainedMessages: true,
StoredPackets: true,
StoredSubscriptions: true,
OfflineSubscriptions: true,
Authentication: true,
UniqueClientIDs: true,
RootSlashDistinction: true,
}
} | go | func AllFeatures() *Config {
return &Config{
RetainedMessages: true,
StoredPackets: true,
StoredSubscriptions: true,
OfflineSubscriptions: true,
Authentication: true,
UniqueClientIDs: true,
RootSlashDistinction: true,
}
} | [
"func",
"AllFeatures",
"(",
")",
"*",
"Config",
"{",
"return",
"&",
"Config",
"{",
"RetainedMessages",
":",
"true",
",",
"StoredPackets",
":",
"true",
",",
"StoredSubscriptions",
":",
"true",
",",
"OfflineSubscriptions",
":",
"true",
",",
"Authentication",
":",
"true",
",",
"UniqueClientIDs",
":",
"true",
",",
"RootSlashDistinction",
":",
"true",
",",
"}",
"\n",
"}"
] | // AllFeatures returns a config that enables all features. | [
"AllFeatures",
"returns",
"a",
"config",
"that",
"enables",
"all",
"features",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/spec/spec.go#L43-L53 |
10,060 | 256dpi/gomqtt | packet/type.go | String | func (t Type) String() string {
switch t {
case CONNECT:
return "Connect"
case CONNACK:
return "Connack"
case PUBLISH:
return "Publish"
case PUBACK:
return "Puback"
case PUBREC:
return "Pubrec"
case PUBREL:
return "Pubrel"
case PUBCOMP:
return "Pubcomp"
case SUBSCRIBE:
return "Subscribe"
case SUBACK:
return "Suback"
case UNSUBSCRIBE:
return "Unsubscribe"
case UNSUBACK:
return "Unsuback"
case PINGREQ:
return "Pingreq"
case PINGRESP:
return "Pingresp"
case DISCONNECT:
return "Disconnect"
}
return "Unknown"
} | go | func (t Type) String() string {
switch t {
case CONNECT:
return "Connect"
case CONNACK:
return "Connack"
case PUBLISH:
return "Publish"
case PUBACK:
return "Puback"
case PUBREC:
return "Pubrec"
case PUBREL:
return "Pubrel"
case PUBCOMP:
return "Pubcomp"
case SUBSCRIBE:
return "Subscribe"
case SUBACK:
return "Suback"
case UNSUBSCRIBE:
return "Unsubscribe"
case UNSUBACK:
return "Unsuback"
case PINGREQ:
return "Pingreq"
case PINGRESP:
return "Pingresp"
case DISCONNECT:
return "Disconnect"
}
return "Unknown"
} | [
"func",
"(",
"t",
"Type",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"t",
"{",
"case",
"CONNECT",
":",
"return",
"\"",
"\"",
"\n",
"case",
"CONNACK",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PUBLISH",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PUBACK",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PUBREC",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PUBREL",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PUBCOMP",
":",
"return",
"\"",
"\"",
"\n",
"case",
"SUBSCRIBE",
":",
"return",
"\"",
"\"",
"\n",
"case",
"SUBACK",
":",
"return",
"\"",
"\"",
"\n",
"case",
"UNSUBSCRIBE",
":",
"return",
"\"",
"\"",
"\n",
"case",
"UNSUBACK",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PINGREQ",
":",
"return",
"\"",
"\"",
"\n",
"case",
"PINGRESP",
":",
"return",
"\"",
"\"",
"\n",
"case",
"DISCONNECT",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // String returns the type as a string. | [
"String",
"returns",
"the",
"type",
"as",
"a",
"string",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/type.go#L31-L64 |
10,061 | 256dpi/gomqtt | packet/type.go | defaultFlags | func (t Type) defaultFlags() byte {
switch t {
case CONNECT:
return 0
case CONNACK:
return 0
case PUBACK:
return 0
case PUBREC:
return 0
case PUBREL:
return 2 // 00000010
case PUBCOMP:
return 0
case SUBSCRIBE:
return 2 // 00000010
case SUBACK:
return 0
case UNSUBSCRIBE:
return 2 // 00000010
case UNSUBACK:
return 0
case PINGREQ:
return 0
case PINGRESP:
return 0
case DISCONNECT:
return 0
}
return 0
} | go | func (t Type) defaultFlags() byte {
switch t {
case CONNECT:
return 0
case CONNACK:
return 0
case PUBACK:
return 0
case PUBREC:
return 0
case PUBREL:
return 2 // 00000010
case PUBCOMP:
return 0
case SUBSCRIBE:
return 2 // 00000010
case SUBACK:
return 0
case UNSUBSCRIBE:
return 2 // 00000010
case UNSUBACK:
return 0
case PINGREQ:
return 0
case PINGRESP:
return 0
case DISCONNECT:
return 0
}
return 0
} | [
"func",
"(",
"t",
"Type",
")",
"defaultFlags",
"(",
")",
"byte",
"{",
"switch",
"t",
"{",
"case",
"CONNECT",
":",
"return",
"0",
"\n",
"case",
"CONNACK",
":",
"return",
"0",
"\n",
"case",
"PUBACK",
":",
"return",
"0",
"\n",
"case",
"PUBREC",
":",
"return",
"0",
"\n",
"case",
"PUBREL",
":",
"return",
"2",
"// 00000010",
"\n",
"case",
"PUBCOMP",
":",
"return",
"0",
"\n",
"case",
"SUBSCRIBE",
":",
"return",
"2",
"// 00000010",
"\n",
"case",
"SUBACK",
":",
"return",
"0",
"\n",
"case",
"UNSUBSCRIBE",
":",
"return",
"2",
"// 00000010",
"\n",
"case",
"UNSUBACK",
":",
"return",
"0",
"\n",
"case",
"PINGREQ",
":",
"return",
"0",
"\n",
"case",
"PINGRESP",
":",
"return",
"0",
"\n",
"case",
"DISCONNECT",
":",
"return",
"0",
"\n",
"}",
"\n\n",
"return",
"0",
"\n",
"}"
] | // DefaultFlags returns the default flag values for the packet type, as defined
// by the MQTT spec, except for PUBLISH. | [
"DefaultFlags",
"returns",
"the",
"default",
"flag",
"values",
"for",
"the",
"packet",
"type",
"as",
"defined",
"by",
"the",
"MQTT",
"spec",
"except",
"for",
"PUBLISH",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/type.go#L68-L99 |
10,062 | 256dpi/gomqtt | transport/websocket_server.go | NewWebSocketServer | func NewWebSocketServer(listener net.Listener) *WebSocketServer {
// create server
ws := &WebSocketServer{
listener: listener,
upgrader: &websocket.Upgrader{
HandshakeTimeout: 60 * time.Second,
Subprotocols: []string{"mqtt", "mqttv3.1"},
},
incoming: make(chan *WebSocketConn),
}
// add check origin method that uses the optional check origin function
ws.upgrader.CheckOrigin = func(r *http.Request) bool {
if ws.originChecker != nil {
return ws.originChecker(r)
}
return true
}
// create http server
h := &http.Server{
Handler: http.HandlerFunc(ws.requestHandler),
}
// serve http traffic in background
ws.tomb.Go(func() error {
return h.Serve(ws.listener)
})
return ws
} | go | func NewWebSocketServer(listener net.Listener) *WebSocketServer {
// create server
ws := &WebSocketServer{
listener: listener,
upgrader: &websocket.Upgrader{
HandshakeTimeout: 60 * time.Second,
Subprotocols: []string{"mqtt", "mqttv3.1"},
},
incoming: make(chan *WebSocketConn),
}
// add check origin method that uses the optional check origin function
ws.upgrader.CheckOrigin = func(r *http.Request) bool {
if ws.originChecker != nil {
return ws.originChecker(r)
}
return true
}
// create http server
h := &http.Server{
Handler: http.HandlerFunc(ws.requestHandler),
}
// serve http traffic in background
ws.tomb.Go(func() error {
return h.Serve(ws.listener)
})
return ws
} | [
"func",
"NewWebSocketServer",
"(",
"listener",
"net",
".",
"Listener",
")",
"*",
"WebSocketServer",
"{",
"// create server",
"ws",
":=",
"&",
"WebSocketServer",
"{",
"listener",
":",
"listener",
",",
"upgrader",
":",
"&",
"websocket",
".",
"Upgrader",
"{",
"HandshakeTimeout",
":",
"60",
"*",
"time",
".",
"Second",
",",
"Subprotocols",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"}",
",",
"incoming",
":",
"make",
"(",
"chan",
"*",
"WebSocketConn",
")",
",",
"}",
"\n\n",
"// add check origin method that uses the optional check origin function",
"ws",
".",
"upgrader",
".",
"CheckOrigin",
"=",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
"{",
"if",
"ws",
".",
"originChecker",
"!=",
"nil",
"{",
"return",
"ws",
".",
"originChecker",
"(",
"r",
")",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}",
"\n\n",
"// create http server",
"h",
":=",
"&",
"http",
".",
"Server",
"{",
"Handler",
":",
"http",
".",
"HandlerFunc",
"(",
"ws",
".",
"requestHandler",
")",
",",
"}",
"\n\n",
"// serve http traffic in background",
"ws",
".",
"tomb",
".",
"Go",
"(",
"func",
"(",
")",
"error",
"{",
"return",
"h",
".",
"Serve",
"(",
"ws",
".",
"listener",
")",
"\n",
"}",
")",
"\n\n",
"return",
"ws",
"\n",
"}"
] | // NewWebSocketServer wraps the provided listener. | [
"NewWebSocketServer",
"wraps",
"the",
"provided",
"listener",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/websocket_server.go#L31-L62 |
10,063 | 256dpi/gomqtt | transport/websocket_server.go | CreateWebSocketServer | func CreateWebSocketServer(address string) (*WebSocketServer, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, err
}
return NewWebSocketServer(listener), nil
} | go | func CreateWebSocketServer(address string) (*WebSocketServer, error) {
listener, err := net.Listen("tcp", address)
if err != nil {
return nil, err
}
return NewWebSocketServer(listener), nil
} | [
"func",
"CreateWebSocketServer",
"(",
"address",
"string",
")",
"(",
"*",
"WebSocketServer",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"net",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewWebSocketServer",
"(",
"listener",
")",
",",
"nil",
"\n",
"}"
] | // CreateWebSocketServer creates a new WS server that listens on the provided address. | [
"CreateWebSocketServer",
"creates",
"a",
"new",
"WS",
"server",
"that",
"listens",
"on",
"the",
"provided",
"address",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/websocket_server.go#L65-L72 |
10,064 | 256dpi/gomqtt | transport/websocket_server.go | CreateSecureWebSocketServer | func CreateSecureWebSocketServer(address string, config *tls.Config) (*WebSocketServer, error) {
listener, err := tls.Listen("tcp", address, config)
if err != nil {
return nil, err
}
return NewWebSocketServer(listener), nil
} | go | func CreateSecureWebSocketServer(address string, config *tls.Config) (*WebSocketServer, error) {
listener, err := tls.Listen("tcp", address, config)
if err != nil {
return nil, err
}
return NewWebSocketServer(listener), nil
} | [
"func",
"CreateSecureWebSocketServer",
"(",
"address",
"string",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"(",
"*",
"WebSocketServer",
",",
"error",
")",
"{",
"listener",
",",
"err",
":=",
"tls",
".",
"Listen",
"(",
"\"",
"\"",
",",
"address",
",",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"NewWebSocketServer",
"(",
"listener",
")",
",",
"nil",
"\n",
"}"
] | // CreateSecureWebSocketServer creates a new WSS server that listens on the
// provided address. | [
"CreateSecureWebSocketServer",
"creates",
"a",
"new",
"WSS",
"server",
"that",
"listens",
"on",
"the",
"provided",
"address",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/websocket_server.go#L76-L83 |
10,065 | 256dpi/gomqtt | transport/websocket_server.go | SetOriginChecker | func (s *WebSocketServer) SetOriginChecker(fn func(r *http.Request) bool) {
s.originChecker = fn
} | go | func (s *WebSocketServer) SetOriginChecker(fn func(r *http.Request) bool) {
s.originChecker = fn
} | [
"func",
"(",
"s",
"*",
"WebSocketServer",
")",
"SetOriginChecker",
"(",
"fn",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"bool",
")",
"{",
"s",
".",
"originChecker",
"=",
"fn",
"\n",
"}"
] | // SetOriginChecker sets an optional function that allows check the request origin
// before accepting the connection. | [
"SetOriginChecker",
"sets",
"an",
"optional",
"function",
"that",
"allows",
"check",
"the",
"request",
"origin",
"before",
"accepting",
"the",
"connection",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/websocket_server.go#L93-L95 |
10,066 | 256dpi/gomqtt | client/service.go | NewService | func NewService(queueSize ...int) *Service {
var qs = 100
if len(queueSize) > 0 {
qs = queueSize[0]
}
return &Service{
state: serviceStopped,
Session: session.NewMemorySession(),
MinReconnectDelay: 50 * time.Millisecond,
MaxReconnectDelay: 10 * time.Second,
ConnectTimeout: 5 * time.Second,
DisconnectTimeout: 10 * time.Second,
ResubscribeTimeout: 5 * time.Second,
ResubscribeAllSubscriptions: true,
subscriptions: topic.NewTree(),
commandQueue: make(chan *command, qs),
futureStore: future.NewStore(),
}
} | go | func NewService(queueSize ...int) *Service {
var qs = 100
if len(queueSize) > 0 {
qs = queueSize[0]
}
return &Service{
state: serviceStopped,
Session: session.NewMemorySession(),
MinReconnectDelay: 50 * time.Millisecond,
MaxReconnectDelay: 10 * time.Second,
ConnectTimeout: 5 * time.Second,
DisconnectTimeout: 10 * time.Second,
ResubscribeTimeout: 5 * time.Second,
ResubscribeAllSubscriptions: true,
subscriptions: topic.NewTree(),
commandQueue: make(chan *command, qs),
futureStore: future.NewStore(),
}
} | [
"func",
"NewService",
"(",
"queueSize",
"...",
"int",
")",
"*",
"Service",
"{",
"var",
"qs",
"=",
"100",
"\n",
"if",
"len",
"(",
"queueSize",
")",
">",
"0",
"{",
"qs",
"=",
"queueSize",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"&",
"Service",
"{",
"state",
":",
"serviceStopped",
",",
"Session",
":",
"session",
".",
"NewMemorySession",
"(",
")",
",",
"MinReconnectDelay",
":",
"50",
"*",
"time",
".",
"Millisecond",
",",
"MaxReconnectDelay",
":",
"10",
"*",
"time",
".",
"Second",
",",
"ConnectTimeout",
":",
"5",
"*",
"time",
".",
"Second",
",",
"DisconnectTimeout",
":",
"10",
"*",
"time",
".",
"Second",
",",
"ResubscribeTimeout",
":",
"5",
"*",
"time",
".",
"Second",
",",
"ResubscribeAllSubscriptions",
":",
"true",
",",
"subscriptions",
":",
"topic",
".",
"NewTree",
"(",
")",
",",
"commandQueue",
":",
"make",
"(",
"chan",
"*",
"command",
",",
"qs",
")",
",",
"futureStore",
":",
"future",
".",
"NewStore",
"(",
")",
",",
"}",
"\n",
"}"
] | // NewService allocates and returns a new service. The optional parameter queueSize
// specifies how many Subscribe, Unsubscribe and Publish commands can be queued
// up before actually sending them on the wire. The default queueSize is 100. | [
"NewService",
"allocates",
"and",
"returns",
"a",
"new",
"service",
".",
"The",
"optional",
"parameter",
"queueSize",
"specifies",
"how",
"many",
"Subscribe",
"Unsubscribe",
"and",
"Publish",
"commands",
"can",
"be",
"queued",
"up",
"before",
"actually",
"sending",
"them",
"on",
"the",
"wire",
".",
"The",
"default",
"queueSize",
"is",
"100",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L131-L150 |
10,067 | 256dpi/gomqtt | client/service.go | Start | func (s *Service) Start(config *Config) {
if config == nil {
panic("no config specified")
}
s.mutex.Lock()
defer s.mutex.Unlock()
// return if already started
if atomic.LoadUint32(&s.state) == serviceStarted {
return
}
// set state
atomic.StoreUint32(&s.state, serviceStarted)
// save config
s.config = config
// initialize backoff
s.backoff = &backoff.Backoff{
Min: s.MinReconnectDelay,
Max: s.MaxReconnectDelay,
Factor: 2,
}
// mark future store as protected
s.futureStore.Protect(true)
// create new tomb
s.tomb = new(tomb.Tomb)
// start supervisor
s.tomb.Go(s.supervisor)
} | go | func (s *Service) Start(config *Config) {
if config == nil {
panic("no config specified")
}
s.mutex.Lock()
defer s.mutex.Unlock()
// return if already started
if atomic.LoadUint32(&s.state) == serviceStarted {
return
}
// set state
atomic.StoreUint32(&s.state, serviceStarted)
// save config
s.config = config
// initialize backoff
s.backoff = &backoff.Backoff{
Min: s.MinReconnectDelay,
Max: s.MaxReconnectDelay,
Factor: 2,
}
// mark future store as protected
s.futureStore.Protect(true)
// create new tomb
s.tomb = new(tomb.Tomb)
// start supervisor
s.tomb.Go(s.supervisor)
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Start",
"(",
"config",
"*",
"Config",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// return if already started",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"s",
".",
"state",
")",
"==",
"serviceStarted",
"{",
"return",
"\n",
"}",
"\n\n",
"// set state",
"atomic",
".",
"StoreUint32",
"(",
"&",
"s",
".",
"state",
",",
"serviceStarted",
")",
"\n\n",
"// save config",
"s",
".",
"config",
"=",
"config",
"\n\n",
"// initialize backoff",
"s",
".",
"backoff",
"=",
"&",
"backoff",
".",
"Backoff",
"{",
"Min",
":",
"s",
".",
"MinReconnectDelay",
",",
"Max",
":",
"s",
".",
"MaxReconnectDelay",
",",
"Factor",
":",
"2",
",",
"}",
"\n\n",
"// mark future store as protected",
"s",
".",
"futureStore",
".",
"Protect",
"(",
"true",
")",
"\n\n",
"// create new tomb",
"s",
".",
"tomb",
"=",
"new",
"(",
"tomb",
".",
"Tomb",
")",
"\n\n",
"// start supervisor",
"s",
".",
"tomb",
".",
"Go",
"(",
"s",
".",
"supervisor",
")",
"\n",
"}"
] | // Start will start the service with the specified configuration. From now on
// the service will automatically reconnect on any error until Stop is called. | [
"Start",
"will",
"start",
"the",
"service",
"with",
"the",
"specified",
"configuration",
".",
"From",
"now",
"on",
"the",
"service",
"will",
"automatically",
"reconnect",
"on",
"any",
"error",
"until",
"Stop",
"is",
"called",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L154-L188 |
10,068 | 256dpi/gomqtt | client/service.go | PublishMessage | func (s *Service) PublishMessage(msg *packet.Message) GenericFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// allocate future
f := future.New()
// queue publish
s.commandQueue <- &command{
publish: true,
future: f,
message: msg,
}
return f
} | go | func (s *Service) PublishMessage(msg *packet.Message) GenericFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// allocate future
f := future.New()
// queue publish
s.commandQueue <- &command{
publish: true,
future: f,
message: msg,
}
return f
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"PublishMessage",
"(",
"msg",
"*",
"packet",
".",
"Message",
")",
"GenericFuture",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// allocate future",
"f",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// queue publish",
"s",
".",
"commandQueue",
"<-",
"&",
"command",
"{",
"publish",
":",
"true",
",",
"future",
":",
"f",
",",
"message",
":",
"msg",
",",
"}",
"\n\n",
"return",
"f",
"\n",
"}"
] | // PublishMessage will send a Publish packet containing the passed message. It will
// return a PublishFuture that gets completed once the quality of service flow
// has been completed. | [
"PublishMessage",
"will",
"send",
"a",
"Publish",
"packet",
"containing",
"the",
"passed",
"message",
".",
"It",
"will",
"return",
"a",
"PublishFuture",
"that",
"gets",
"completed",
"once",
"the",
"quality",
"of",
"service",
"flow",
"has",
"been",
"completed",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L207-L222 |
10,069 | 256dpi/gomqtt | client/service.go | Subscribe | func (s *Service) Subscribe(topic string, qos packet.QOS) SubscribeFuture {
return s.SubscribeMultiple([]packet.Subscription{
{Topic: topic, QOS: qos},
})
} | go | func (s *Service) Subscribe(topic string, qos packet.QOS) SubscribeFuture {
return s.SubscribeMultiple([]packet.Subscription{
{Topic: topic, QOS: qos},
})
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Subscribe",
"(",
"topic",
"string",
",",
"qos",
"packet",
".",
"QOS",
")",
"SubscribeFuture",
"{",
"return",
"s",
".",
"SubscribeMultiple",
"(",
"[",
"]",
"packet",
".",
"Subscription",
"{",
"{",
"Topic",
":",
"topic",
",",
"QOS",
":",
"qos",
"}",
",",
"}",
")",
"\n",
"}"
] | // Subscribe will send a Subscribe packet containing one topic to subscribe. It
// will return a SubscribeFuture that gets completed once the acknowledgements
// have been received. | [
"Subscribe",
"will",
"send",
"a",
"Subscribe",
"packet",
"containing",
"one",
"topic",
"to",
"subscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"the",
"acknowledgements",
"have",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L227-L231 |
10,070 | 256dpi/gomqtt | client/service.go | SubscribeMultiple | func (s *Service) SubscribeMultiple(subscriptions []packet.Subscription) SubscribeFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// save subscription
for _, v := range subscriptions {
s.subscriptions.Set(v.Topic, v)
}
// allocate future
f := future.New()
// queue subscribe
s.commandQueue <- &command{
subscribe: true,
future: f,
subscriptions: subscriptions,
}
return &subscribeFuture{f}
} | go | func (s *Service) SubscribeMultiple(subscriptions []packet.Subscription) SubscribeFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// save subscription
for _, v := range subscriptions {
s.subscriptions.Set(v.Topic, v)
}
// allocate future
f := future.New()
// queue subscribe
s.commandQueue <- &command{
subscribe: true,
future: f,
subscriptions: subscriptions,
}
return &subscribeFuture{f}
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"SubscribeMultiple",
"(",
"subscriptions",
"[",
"]",
"packet",
".",
"Subscription",
")",
"SubscribeFuture",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// save subscription",
"for",
"_",
",",
"v",
":=",
"range",
"subscriptions",
"{",
"s",
".",
"subscriptions",
".",
"Set",
"(",
"v",
".",
"Topic",
",",
"v",
")",
"\n",
"}",
"\n\n",
"// allocate future",
"f",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// queue subscribe",
"s",
".",
"commandQueue",
"<-",
"&",
"command",
"{",
"subscribe",
":",
"true",
",",
"future",
":",
"f",
",",
"subscriptions",
":",
"subscriptions",
",",
"}",
"\n\n",
"return",
"&",
"subscribeFuture",
"{",
"f",
"}",
"\n",
"}"
] | // SubscribeMultiple will send a Subscribe packet containing multiple topics to
// subscribe. It will return a SubscribeFuture that gets completed once the
// acknowledgements have been received. | [
"SubscribeMultiple",
"will",
"send",
"a",
"Subscribe",
"packet",
"containing",
"multiple",
"topics",
"to",
"subscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"the",
"acknowledgements",
"have",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L236-L256 |
10,071 | 256dpi/gomqtt | client/service.go | Unsubscribe | func (s *Service) Unsubscribe(topic string) GenericFuture {
return s.UnsubscribeMultiple([]string{topic})
} | go | func (s *Service) Unsubscribe(topic string) GenericFuture {
return s.UnsubscribeMultiple([]string{topic})
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"Unsubscribe",
"(",
"topic",
"string",
")",
"GenericFuture",
"{",
"return",
"s",
".",
"UnsubscribeMultiple",
"(",
"[",
"]",
"string",
"{",
"topic",
"}",
")",
"\n",
"}"
] | // Unsubscribe will send a Unsubscribe packet containing one topic to unsubscribe.
// It will return a SubscribeFuture that gets completed once the acknowledgements
// have been received. | [
"Unsubscribe",
"will",
"send",
"a",
"Unsubscribe",
"packet",
"containing",
"one",
"topic",
"to",
"unsubscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"the",
"acknowledgements",
"have",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L261-L263 |
10,072 | 256dpi/gomqtt | client/service.go | UnsubscribeMultiple | func (s *Service) UnsubscribeMultiple(topics []string) GenericFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// remove subscription
for _, v := range topics {
s.subscriptions.Empty(v)
}
// allocate future
f := future.New()
// queue unsubscribe
s.commandQueue <- &command{
unsubscribe: true,
future: f,
topics: topics,
}
return f
} | go | func (s *Service) UnsubscribeMultiple(topics []string) GenericFuture {
s.mutex.Lock()
defer s.mutex.Unlock()
// remove subscription
for _, v := range topics {
s.subscriptions.Empty(v)
}
// allocate future
f := future.New()
// queue unsubscribe
s.commandQueue <- &command{
unsubscribe: true,
future: f,
topics: topics,
}
return f
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"UnsubscribeMultiple",
"(",
"topics",
"[",
"]",
"string",
")",
"GenericFuture",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// remove subscription",
"for",
"_",
",",
"v",
":=",
"range",
"topics",
"{",
"s",
".",
"subscriptions",
".",
"Empty",
"(",
"v",
")",
"\n",
"}",
"\n\n",
"// allocate future",
"f",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// queue unsubscribe",
"s",
".",
"commandQueue",
"<-",
"&",
"command",
"{",
"unsubscribe",
":",
"true",
",",
"future",
":",
"f",
",",
"topics",
":",
"topics",
",",
"}",
"\n\n",
"return",
"f",
"\n",
"}"
] | // UnsubscribeMultiple will send a Unsubscribe packet containing multiple
// topics to unsubscribe. It will return a SubscribeFuture that gets completed
// once the acknowledgements have been received. | [
"UnsubscribeMultiple",
"will",
"send",
"a",
"Unsubscribe",
"packet",
"containing",
"multiple",
"topics",
"to",
"unsubscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"the",
"acknowledgements",
"have",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L268-L288 |
10,073 | 256dpi/gomqtt | client/service.go | supervisor | func (s *Service) supervisor() error {
first := true
for {
if first {
// no delay on first attempt
first = false
} else {
// get backoff duration
d := s.backoff.Duration()
s.log(fmt.Sprintf("Delay Reconnect: %v", d))
// sleep but return on Stop
select {
case <-time.After(d):
case <-s.tomb.Dying():
return tomb.ErrDying
}
}
s.log("Next Reconnect")
// prepare the stop channel
fail := make(chan struct{})
// try once to get a client
client, resumed := s.connect(fail)
if client == nil {
continue
}
// resubscribe
if s.ResubscribeAllSubscriptions {
if !s.resubscribe(client) {
continue
}
}
// run callback
if s.OnlineCallback != nil {
s.OnlineCallback(resumed)
}
// run dispatcher on client
dying := s.dispatcher(client, fail)
// run callback
if s.OfflineCallback != nil {
s.OfflineCallback()
}
// return goroutine if dying
if dying {
return tomb.ErrDying
}
}
} | go | func (s *Service) supervisor() error {
first := true
for {
if first {
// no delay on first attempt
first = false
} else {
// get backoff duration
d := s.backoff.Duration()
s.log(fmt.Sprintf("Delay Reconnect: %v", d))
// sleep but return on Stop
select {
case <-time.After(d):
case <-s.tomb.Dying():
return tomb.ErrDying
}
}
s.log("Next Reconnect")
// prepare the stop channel
fail := make(chan struct{})
// try once to get a client
client, resumed := s.connect(fail)
if client == nil {
continue
}
// resubscribe
if s.ResubscribeAllSubscriptions {
if !s.resubscribe(client) {
continue
}
}
// run callback
if s.OnlineCallback != nil {
s.OnlineCallback(resumed)
}
// run dispatcher on client
dying := s.dispatcher(client, fail)
// run callback
if s.OfflineCallback != nil {
s.OfflineCallback()
}
// return goroutine if dying
if dying {
return tomb.ErrDying
}
}
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"supervisor",
"(",
")",
"error",
"{",
"first",
":=",
"true",
"\n\n",
"for",
"{",
"if",
"first",
"{",
"// no delay on first attempt",
"first",
"=",
"false",
"\n",
"}",
"else",
"{",
"// get backoff duration",
"d",
":=",
"s",
".",
"backoff",
".",
"Duration",
"(",
")",
"\n",
"s",
".",
"log",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"d",
")",
")",
"\n\n",
"// sleep but return on Stop",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"d",
")",
":",
"case",
"<-",
"s",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"log",
"(",
"\"",
"\"",
")",
"\n\n",
"// prepare the stop channel",
"fail",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n\n",
"// try once to get a client",
"client",
",",
"resumed",
":=",
"s",
".",
"connect",
"(",
"fail",
")",
"\n",
"if",
"client",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"// resubscribe",
"if",
"s",
".",
"ResubscribeAllSubscriptions",
"{",
"if",
"!",
"s",
".",
"resubscribe",
"(",
"client",
")",
"{",
"continue",
"\n",
"}",
"\n",
"}",
"\n\n",
"// run callback",
"if",
"s",
".",
"OnlineCallback",
"!=",
"nil",
"{",
"s",
".",
"OnlineCallback",
"(",
"resumed",
")",
"\n",
"}",
"\n\n",
"// run dispatcher on client",
"dying",
":=",
"s",
".",
"dispatcher",
"(",
"client",
",",
"fail",
")",
"\n\n",
"// run callback",
"if",
"s",
".",
"OfflineCallback",
"!=",
"nil",
"{",
"s",
".",
"OfflineCallback",
"(",
")",
"\n",
"}",
"\n\n",
"// return goroutine if dying",
"if",
"dying",
"{",
"return",
"tomb",
".",
"ErrDying",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // the supervised reconnect loop | [
"the",
"supervised",
"reconnect",
"loop"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L319-L375 |
10,074 | 256dpi/gomqtt | client/service.go | connect | func (s *Service) connect(fail chan struct{}) (*Client, bool) {
// prepare new client
client := New()
client.Session = s.Session
client.Logger = s.Logger
client.futureStore = s.futureStore
// set callback
client.Callback = func(msg *packet.Message, err error) error {
if err != nil {
s.err("Client", err)
close(fail)
return nil
}
// call the handler
if s.MessageCallback != nil {
return s.MessageCallback(msg)
}
return nil
}
// attempt to connect
connectFuture, err := client.Connect(s.config)
if err != nil {
s.err("Connect", err)
return nil, false
}
// wait for connack
err = connectFuture.Wait(s.ConnectTimeout)
// check if future has been canceled
if err == future.ErrCanceled {
s.err("Connect", err)
return nil, false
}
// check if future has timed out
if err == future.ErrTimeout {
client.Close()
s.err("Connect", err)
return nil, false
}
return client, connectFuture.SessionPresent()
} | go | func (s *Service) connect(fail chan struct{}) (*Client, bool) {
// prepare new client
client := New()
client.Session = s.Session
client.Logger = s.Logger
client.futureStore = s.futureStore
// set callback
client.Callback = func(msg *packet.Message, err error) error {
if err != nil {
s.err("Client", err)
close(fail)
return nil
}
// call the handler
if s.MessageCallback != nil {
return s.MessageCallback(msg)
}
return nil
}
// attempt to connect
connectFuture, err := client.Connect(s.config)
if err != nil {
s.err("Connect", err)
return nil, false
}
// wait for connack
err = connectFuture.Wait(s.ConnectTimeout)
// check if future has been canceled
if err == future.ErrCanceled {
s.err("Connect", err)
return nil, false
}
// check if future has timed out
if err == future.ErrTimeout {
client.Close()
s.err("Connect", err)
return nil, false
}
return client, connectFuture.SessionPresent()
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"connect",
"(",
"fail",
"chan",
"struct",
"{",
"}",
")",
"(",
"*",
"Client",
",",
"bool",
")",
"{",
"// prepare new client",
"client",
":=",
"New",
"(",
")",
"\n",
"client",
".",
"Session",
"=",
"s",
".",
"Session",
"\n",
"client",
".",
"Logger",
"=",
"s",
".",
"Logger",
"\n",
"client",
".",
"futureStore",
"=",
"s",
".",
"futureStore",
"\n\n",
"// set callback",
"client",
".",
"Callback",
"=",
"func",
"(",
"msg",
"*",
"packet",
".",
"Message",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"close",
"(",
"fail",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// call the handler",
"if",
"s",
".",
"MessageCallback",
"!=",
"nil",
"{",
"return",
"s",
".",
"MessageCallback",
"(",
"msg",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// attempt to connect",
"connectFuture",
",",
"err",
":=",
"client",
".",
"Connect",
"(",
"s",
".",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n\n",
"// wait for connack",
"err",
"=",
"connectFuture",
".",
"Wait",
"(",
"s",
".",
"ConnectTimeout",
")",
"\n\n",
"// check if future has been canceled",
"if",
"err",
"==",
"future",
".",
"ErrCanceled",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n\n",
"// check if future has timed out",
"if",
"err",
"==",
"future",
".",
"ErrTimeout",
"{",
"client",
".",
"Close",
"(",
")",
"\n\n",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"false",
"\n",
"}",
"\n\n",
"return",
"client",
",",
"connectFuture",
".",
"SessionPresent",
"(",
")",
"\n",
"}"
] | // will try to connect one client to the broker | [
"will",
"try",
"to",
"connect",
"one",
"client",
"to",
"the",
"broker"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L378-L426 |
10,075 | 256dpi/gomqtt | client/service.go | dispatcher | func (s *Service) dispatcher(client *Client, fail chan struct{}) bool {
for {
select {
case cmd := <-s.commandQueue:
// handle subscribe command
if cmd.subscribe {
f2, err := client.SubscribeMultiple(cmd.subscriptions)
if err != nil {
s.err("Subscribe", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*subscribeFuture).Future)
}
// handle unsubscribe command
if cmd.unsubscribe {
f2, err := client.UnsubscribeMultiple(cmd.topics)
if err != nil {
s.err("Unsubscribe", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*future.Future))
}
// handle publish command
if cmd.publish {
f2, err := client.PublishMessage(cmd.message)
if err != nil {
s.err("Publish", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*future.Future))
}
case <-s.tomb.Dying():
// disconnect client on Stop
err := client.Disconnect(s.DisconnectTimeout)
if err != nil {
s.err("Disconnect", err)
}
return true
case <-fail:
return false
}
}
} | go | func (s *Service) dispatcher(client *Client, fail chan struct{}) bool {
for {
select {
case cmd := <-s.commandQueue:
// handle subscribe command
if cmd.subscribe {
f2, err := client.SubscribeMultiple(cmd.subscriptions)
if err != nil {
s.err("Subscribe", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*subscribeFuture).Future)
}
// handle unsubscribe command
if cmd.unsubscribe {
f2, err := client.UnsubscribeMultiple(cmd.topics)
if err != nil {
s.err("Unsubscribe", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*future.Future))
}
// handle publish command
if cmd.publish {
f2, err := client.PublishMessage(cmd.message)
if err != nil {
s.err("Publish", err)
// cancel future
cmd.future.Cancel()
return false
}
// bind future in a own goroutine. the goroutine will be
// ultimately collected when the service is stopped
go cmd.future.Bind(f2.(*future.Future))
}
case <-s.tomb.Dying():
// disconnect client on Stop
err := client.Disconnect(s.DisconnectTimeout)
if err != nil {
s.err("Disconnect", err)
}
return true
case <-fail:
return false
}
}
} | [
"func",
"(",
"s",
"*",
"Service",
")",
"dispatcher",
"(",
"client",
"*",
"Client",
",",
"fail",
"chan",
"struct",
"{",
"}",
")",
"bool",
"{",
"for",
"{",
"select",
"{",
"case",
"cmd",
":=",
"<-",
"s",
".",
"commandQueue",
":",
"// handle subscribe command",
"if",
"cmd",
".",
"subscribe",
"{",
"f2",
",",
"err",
":=",
"client",
".",
"SubscribeMultiple",
"(",
"cmd",
".",
"subscriptions",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n\n",
"// cancel future",
"cmd",
".",
"future",
".",
"Cancel",
"(",
")",
"\n\n",
"return",
"false",
"\n",
"}",
"\n\n",
"// bind future in a own goroutine. the goroutine will be",
"// ultimately collected when the service is stopped",
"go",
"cmd",
".",
"future",
".",
"Bind",
"(",
"f2",
".",
"(",
"*",
"subscribeFuture",
")",
".",
"Future",
")",
"\n",
"}",
"\n\n",
"// handle unsubscribe command",
"if",
"cmd",
".",
"unsubscribe",
"{",
"f2",
",",
"err",
":=",
"client",
".",
"UnsubscribeMultiple",
"(",
"cmd",
".",
"topics",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n\n",
"// cancel future",
"cmd",
".",
"future",
".",
"Cancel",
"(",
")",
"\n\n",
"return",
"false",
"\n",
"}",
"\n\n",
"// bind future in a own goroutine. the goroutine will be",
"// ultimately collected when the service is stopped",
"go",
"cmd",
".",
"future",
".",
"Bind",
"(",
"f2",
".",
"(",
"*",
"future",
".",
"Future",
")",
")",
"\n",
"}",
"\n\n",
"// handle publish command",
"if",
"cmd",
".",
"publish",
"{",
"f2",
",",
"err",
":=",
"client",
".",
"PublishMessage",
"(",
"cmd",
".",
"message",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n\n",
"// cancel future",
"cmd",
".",
"future",
".",
"Cancel",
"(",
")",
"\n\n",
"return",
"false",
"\n",
"}",
"\n\n",
"// bind future in a own goroutine. the goroutine will be",
"// ultimately collected when the service is stopped",
"go",
"cmd",
".",
"future",
".",
"Bind",
"(",
"f2",
".",
"(",
"*",
"future",
".",
"Future",
")",
")",
"\n",
"}",
"\n",
"case",
"<-",
"s",
".",
"tomb",
".",
"Dying",
"(",
")",
":",
"// disconnect client on Stop",
"err",
":=",
"client",
".",
"Disconnect",
"(",
"s",
".",
"DisconnectTimeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"err",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"case",
"<-",
"fail",
":",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // reads from the queues and calls the current client | [
"reads",
"from",
"the",
"queues",
"and",
"calls",
"the",
"current",
"client"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/service.go#L474-L541 |
10,076 | 256dpi/gomqtt | packet/connack.go | String | func (cc ConnackCode) String() string {
switch cc {
case ConnectionAccepted:
return "connection accepted"
case InvalidProtocolVersion:
return "connection refused: unacceptable protocol version"
case IdentifierRejected:
return "connection refused: identifier rejected"
case ServerUnavailable:
return "connection refused: server unavailable"
case BadUsernameOrPassword:
return "connection refused: bad user name or password"
case NotAuthorized:
return "connection refused: not authorized"
}
return "invalid connack code"
} | go | func (cc ConnackCode) String() string {
switch cc {
case ConnectionAccepted:
return "connection accepted"
case InvalidProtocolVersion:
return "connection refused: unacceptable protocol version"
case IdentifierRejected:
return "connection refused: identifier rejected"
case ServerUnavailable:
return "connection refused: server unavailable"
case BadUsernameOrPassword:
return "connection refused: bad user name or password"
case NotAuthorized:
return "connection refused: not authorized"
}
return "invalid connack code"
} | [
"func",
"(",
"cc",
"ConnackCode",
")",
"String",
"(",
")",
"string",
"{",
"switch",
"cc",
"{",
"case",
"ConnectionAccepted",
":",
"return",
"\"",
"\"",
"\n",
"case",
"InvalidProtocolVersion",
":",
"return",
"\"",
"\"",
"\n",
"case",
"IdentifierRejected",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ServerUnavailable",
":",
"return",
"\"",
"\"",
"\n",
"case",
"BadUsernameOrPassword",
":",
"return",
"\"",
"\"",
"\n",
"case",
"NotAuthorized",
":",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // String returns the corresponding error string for the ConnackCode. | [
"String",
"returns",
"the",
"corresponding",
"error",
"string",
"for",
"the",
"ConnackCode",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/connack.go#L24-L41 |
10,077 | 256dpi/gomqtt | client/tools.go | ClearSession | func ClearSession(config *Config, timeout time.Duration) error {
// copy config
newConfig := *config
newConfig.CleanSession = true
// create client
client := New()
// connect to broker
future, err := client.Connect(&newConfig)
if err != nil {
return err
}
// wait for future
err = future.Wait(timeout)
if err != nil {
return err
}
// disconnect
err = client.Disconnect()
if err != nil {
return err
}
return nil
} | go | func ClearSession(config *Config, timeout time.Duration) error {
// copy config
newConfig := *config
newConfig.CleanSession = true
// create client
client := New()
// connect to broker
future, err := client.Connect(&newConfig)
if err != nil {
return err
}
// wait for future
err = future.Wait(timeout)
if err != nil {
return err
}
// disconnect
err = client.Disconnect()
if err != nil {
return err
}
return nil
} | [
"func",
"ClearSession",
"(",
"config",
"*",
"Config",
",",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"// copy config",
"newConfig",
":=",
"*",
"config",
"\n",
"newConfig",
".",
"CleanSession",
"=",
"true",
"\n\n",
"// create client",
"client",
":=",
"New",
"(",
")",
"\n\n",
"// connect to broker",
"future",
",",
"err",
":=",
"client",
".",
"Connect",
"(",
"&",
"newConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// wait for future",
"err",
"=",
"future",
".",
"Wait",
"(",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// disconnect",
"err",
"=",
"client",
".",
"Disconnect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // ClearSession will connect to the specified broker and request a clean session. | [
"ClearSession",
"will",
"connect",
"to",
"the",
"specified",
"broker",
"and",
"request",
"a",
"clean",
"session",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tools.go#L10-L37 |
10,078 | 256dpi/gomqtt | client/tools.go | PublishMessage | func PublishMessage(config *Config, msg *packet.Message, timeout time.Duration) error {
// create client
client := New()
// connect to broker
future, err := client.Connect(config)
if err != nil {
return err
}
// wait on future
err = future.Wait(timeout)
if err != nil {
return err
}
// publish message
publishFuture, err := client.PublishMessage(msg)
if err != nil {
return err
}
// wait on future
err = publishFuture.Wait(timeout)
if err != nil {
return err
}
// disconnect
err = client.Disconnect()
if err != nil {
return err
}
return nil
} | go | func PublishMessage(config *Config, msg *packet.Message, timeout time.Duration) error {
// create client
client := New()
// connect to broker
future, err := client.Connect(config)
if err != nil {
return err
}
// wait on future
err = future.Wait(timeout)
if err != nil {
return err
}
// publish message
publishFuture, err := client.PublishMessage(msg)
if err != nil {
return err
}
// wait on future
err = publishFuture.Wait(timeout)
if err != nil {
return err
}
// disconnect
err = client.Disconnect()
if err != nil {
return err
}
return nil
} | [
"func",
"PublishMessage",
"(",
"config",
"*",
"Config",
",",
"msg",
"*",
"packet",
".",
"Message",
",",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"// create client",
"client",
":=",
"New",
"(",
")",
"\n\n",
"// connect to broker",
"future",
",",
"err",
":=",
"client",
".",
"Connect",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// wait on future",
"err",
"=",
"future",
".",
"Wait",
"(",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// publish message",
"publishFuture",
",",
"err",
":=",
"client",
".",
"PublishMessage",
"(",
"msg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// wait on future",
"err",
"=",
"publishFuture",
".",
"Wait",
"(",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// disconnect",
"err",
"=",
"client",
".",
"Disconnect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // PublishMessage will connect to the specified broker to publish the passed message. | [
"PublishMessage",
"will",
"connect",
"to",
"the",
"specified",
"broker",
"to",
"publish",
"the",
"passed",
"message",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tools.go#L40-L75 |
10,079 | 256dpi/gomqtt | client/tools.go | ClearRetainedMessage | func ClearRetainedMessage(config *Config, topic string, timeout time.Duration) error {
return PublishMessage(config, &packet.Message{
Topic: topic,
Payload: nil,
QOS: 0,
Retain: true,
}, timeout)
} | go | func ClearRetainedMessage(config *Config, topic string, timeout time.Duration) error {
return PublishMessage(config, &packet.Message{
Topic: topic,
Payload: nil,
QOS: 0,
Retain: true,
}, timeout)
} | [
"func",
"ClearRetainedMessage",
"(",
"config",
"*",
"Config",
",",
"topic",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"return",
"PublishMessage",
"(",
"config",
",",
"&",
"packet",
".",
"Message",
"{",
"Topic",
":",
"topic",
",",
"Payload",
":",
"nil",
",",
"QOS",
":",
"0",
",",
"Retain",
":",
"true",
",",
"}",
",",
"timeout",
")",
"\n",
"}"
] | // ClearRetainedMessage will connect to the specified broker and send an empty
// retained message to force any already retained message to be cleared. | [
"ClearRetainedMessage",
"will",
"connect",
"to",
"the",
"specified",
"broker",
"and",
"send",
"an",
"empty",
"retained",
"message",
"to",
"force",
"any",
"already",
"retained",
"message",
"to",
"be",
"cleared",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tools.go#L79-L86 |
10,080 | 256dpi/gomqtt | client/tools.go | ReceiveMessage | func ReceiveMessage(config *Config, topic string, qos packet.QOS, timeout time.Duration) (*packet.Message, error) {
// create client
client := New()
// connect to broker
future, err := client.Connect(config)
if err != nil {
return nil, err
}
// wait for future
err = future.Wait(timeout)
if err != nil {
return nil, err
}
// create channel
msgCh := make(chan *packet.Message)
errCh := make(chan error)
// set callback
client.Callback = func(msg *packet.Message, err error) error {
if err != nil {
errCh <- err
return nil
}
msgCh <- msg
return nil
}
// make subscription
subscribeFuture, err := client.Subscribe(topic, qos)
if err != nil {
return nil, err
}
// wait for future
err = subscribeFuture.Wait(timeout)
if err != nil {
return nil, err
}
// prepare message
var msg *packet.Message
// wait for error, message or timeout
select {
case err = <-errCh:
return nil, err
case msg = <-msgCh:
case <-time.After(timeout):
}
// disconnect
err = client.Disconnect()
if err != nil {
return nil, err
}
return msg, nil
} | go | func ReceiveMessage(config *Config, topic string, qos packet.QOS, timeout time.Duration) (*packet.Message, error) {
// create client
client := New()
// connect to broker
future, err := client.Connect(config)
if err != nil {
return nil, err
}
// wait for future
err = future.Wait(timeout)
if err != nil {
return nil, err
}
// create channel
msgCh := make(chan *packet.Message)
errCh := make(chan error)
// set callback
client.Callback = func(msg *packet.Message, err error) error {
if err != nil {
errCh <- err
return nil
}
msgCh <- msg
return nil
}
// make subscription
subscribeFuture, err := client.Subscribe(topic, qos)
if err != nil {
return nil, err
}
// wait for future
err = subscribeFuture.Wait(timeout)
if err != nil {
return nil, err
}
// prepare message
var msg *packet.Message
// wait for error, message or timeout
select {
case err = <-errCh:
return nil, err
case msg = <-msgCh:
case <-time.After(timeout):
}
// disconnect
err = client.Disconnect()
if err != nil {
return nil, err
}
return msg, nil
} | [
"func",
"ReceiveMessage",
"(",
"config",
"*",
"Config",
",",
"topic",
"string",
",",
"qos",
"packet",
".",
"QOS",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"*",
"packet",
".",
"Message",
",",
"error",
")",
"{",
"// create client",
"client",
":=",
"New",
"(",
")",
"\n\n",
"// connect to broker",
"future",
",",
"err",
":=",
"client",
".",
"Connect",
"(",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// wait for future",
"err",
"=",
"future",
".",
"Wait",
"(",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// create channel",
"msgCh",
":=",
"make",
"(",
"chan",
"*",
"packet",
".",
"Message",
")",
"\n",
"errCh",
":=",
"make",
"(",
"chan",
"error",
")",
"\n\n",
"// set callback",
"client",
".",
"Callback",
"=",
"func",
"(",
"msg",
"*",
"packet",
".",
"Message",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"errCh",
"<-",
"err",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"msgCh",
"<-",
"msg",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// make subscription",
"subscribeFuture",
",",
"err",
":=",
"client",
".",
"Subscribe",
"(",
"topic",
",",
"qos",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// wait for future",
"err",
"=",
"subscribeFuture",
".",
"Wait",
"(",
"timeout",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// prepare message",
"var",
"msg",
"*",
"packet",
".",
"Message",
"\n\n",
"// wait for error, message or timeout",
"select",
"{",
"case",
"err",
"=",
"<-",
"errCh",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"msg",
"=",
"<-",
"msgCh",
":",
"case",
"<-",
"time",
".",
"After",
"(",
"timeout",
")",
":",
"}",
"\n\n",
"// disconnect",
"err",
"=",
"client",
".",
"Disconnect",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"msg",
",",
"nil",
"\n",
"}"
] | // ReceiveMessage will connect to the specified broker and issue a subscription
// for the specified topic and return the first message received. | [
"ReceiveMessage",
"will",
"connect",
"to",
"the",
"specified",
"broker",
"and",
"issue",
"a",
"subscription",
"for",
"the",
"specified",
"topic",
"and",
"return",
"the",
"first",
"message",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tools.go#L90-L151 |
10,081 | honeycombio/honeytail | httime/httime.go | GetTimestamp | func GetTimestamp(m map[string]interface{}, timeFieldName, timeFieldFormat string) time.Time {
var (
ts time.Time
foundFieldName string
timeFoundImproperTypeMsg = "Found time field but type is not string or int"
timeFoundInvalidFormatMsg = "found time field but failed to parse using specified format"
timeFieldNotFoundMsg = "Couldn't find specified time field"
)
if timeFieldName != "" {
if t, found := m[timeFieldName]; found {
timeStr := ""
switch v := t.(type) {
case string:
timeStr = v
case int:
timeStr = strconv.Itoa(v)
case float64:
timeStr = strconv.FormatFloat(v, 'f', -1, 64)
case time.Time:
// it's a time.Time struct - we can just return it
return v
default:
warnAboutTime(timeFieldName, t, timeFoundImproperTypeMsg)
ts = Now()
}
if timeStr != "" {
ts = tryTimeFormats(timeStr, timeFieldFormat)
if ts.IsZero() {
warnAboutTime(timeFieldName, t, timeFoundInvalidFormatMsg)
ts = Now()
}
}
} else {
warnAboutTime(timeFieldName, nil, timeFieldNotFoundMsg)
ts = Now()
}
// we were told to look for a specific field;
// let's return what we found instead of continuing to look.
delete(m, timeFieldName)
return ts
}
// go through all the possible fields that might have a timestamp
// for the first one we find, if it's a string field, try and parse it
// if we succeed, stop looking. Otherwise keep trying
for _, timeField := range possibleTimeFieldNames {
if t, found := m[timeField]; found {
timeStr, found := t.(string)
if found {
foundFieldName = timeField
ts = tryTimeFormats(timeStr, timeFieldFormat)
if !ts.IsZero() {
break
}
warnAboutTime(timeField, t, timeFoundInvalidFormatMsg)
}
}
}
if ts.IsZero() {
ts = Now()
}
delete(m, foundFieldName)
return ts
} | go | func GetTimestamp(m map[string]interface{}, timeFieldName, timeFieldFormat string) time.Time {
var (
ts time.Time
foundFieldName string
timeFoundImproperTypeMsg = "Found time field but type is not string or int"
timeFoundInvalidFormatMsg = "found time field but failed to parse using specified format"
timeFieldNotFoundMsg = "Couldn't find specified time field"
)
if timeFieldName != "" {
if t, found := m[timeFieldName]; found {
timeStr := ""
switch v := t.(type) {
case string:
timeStr = v
case int:
timeStr = strconv.Itoa(v)
case float64:
timeStr = strconv.FormatFloat(v, 'f', -1, 64)
case time.Time:
// it's a time.Time struct - we can just return it
return v
default:
warnAboutTime(timeFieldName, t, timeFoundImproperTypeMsg)
ts = Now()
}
if timeStr != "" {
ts = tryTimeFormats(timeStr, timeFieldFormat)
if ts.IsZero() {
warnAboutTime(timeFieldName, t, timeFoundInvalidFormatMsg)
ts = Now()
}
}
} else {
warnAboutTime(timeFieldName, nil, timeFieldNotFoundMsg)
ts = Now()
}
// we were told to look for a specific field;
// let's return what we found instead of continuing to look.
delete(m, timeFieldName)
return ts
}
// go through all the possible fields that might have a timestamp
// for the first one we find, if it's a string field, try and parse it
// if we succeed, stop looking. Otherwise keep trying
for _, timeField := range possibleTimeFieldNames {
if t, found := m[timeField]; found {
timeStr, found := t.(string)
if found {
foundFieldName = timeField
ts = tryTimeFormats(timeStr, timeFieldFormat)
if !ts.IsZero() {
break
}
warnAboutTime(timeField, t, timeFoundInvalidFormatMsg)
}
}
}
if ts.IsZero() {
ts = Now()
}
delete(m, foundFieldName)
return ts
} | [
"func",
"GetTimestamp",
"(",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"timeFieldName",
",",
"timeFieldFormat",
"string",
")",
"time",
".",
"Time",
"{",
"var",
"(",
"ts",
"time",
".",
"Time",
"\n",
"foundFieldName",
"string",
"\n",
"timeFoundImproperTypeMsg",
"=",
"\"",
"\"",
"\n",
"timeFoundInvalidFormatMsg",
"=",
"\"",
"\"",
"\n",
"timeFieldNotFoundMsg",
"=",
"\"",
"\"",
"\n",
")",
"\n",
"if",
"timeFieldName",
"!=",
"\"",
"\"",
"{",
"if",
"t",
",",
"found",
":=",
"m",
"[",
"timeFieldName",
"]",
";",
"found",
"{",
"timeStr",
":=",
"\"",
"\"",
"\n",
"switch",
"v",
":=",
"t",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"timeStr",
"=",
"v",
"\n",
"case",
"int",
":",
"timeStr",
"=",
"strconv",
".",
"Itoa",
"(",
"v",
")",
"\n",
"case",
"float64",
":",
"timeStr",
"=",
"strconv",
".",
"FormatFloat",
"(",
"v",
",",
"'f'",
",",
"-",
"1",
",",
"64",
")",
"\n",
"case",
"time",
".",
"Time",
":",
"// it's a time.Time struct - we can just return it",
"return",
"v",
"\n",
"default",
":",
"warnAboutTime",
"(",
"timeFieldName",
",",
"t",
",",
"timeFoundImproperTypeMsg",
")",
"\n",
"ts",
"=",
"Now",
"(",
")",
"\n",
"}",
"\n",
"if",
"timeStr",
"!=",
"\"",
"\"",
"{",
"ts",
"=",
"tryTimeFormats",
"(",
"timeStr",
",",
"timeFieldFormat",
")",
"\n",
"if",
"ts",
".",
"IsZero",
"(",
")",
"{",
"warnAboutTime",
"(",
"timeFieldName",
",",
"t",
",",
"timeFoundInvalidFormatMsg",
")",
"\n",
"ts",
"=",
"Now",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"warnAboutTime",
"(",
"timeFieldName",
",",
"nil",
",",
"timeFieldNotFoundMsg",
")",
"\n",
"ts",
"=",
"Now",
"(",
")",
"\n",
"}",
"\n",
"// we were told to look for a specific field;",
"// let's return what we found instead of continuing to look.",
"delete",
"(",
"m",
",",
"timeFieldName",
")",
"\n",
"return",
"ts",
"\n",
"}",
"\n",
"// go through all the possible fields that might have a timestamp",
"// for the first one we find, if it's a string field, try and parse it",
"// if we succeed, stop looking. Otherwise keep trying",
"for",
"_",
",",
"timeField",
":=",
"range",
"possibleTimeFieldNames",
"{",
"if",
"t",
",",
"found",
":=",
"m",
"[",
"timeField",
"]",
";",
"found",
"{",
"timeStr",
",",
"found",
":=",
"t",
".",
"(",
"string",
")",
"\n",
"if",
"found",
"{",
"foundFieldName",
"=",
"timeField",
"\n",
"ts",
"=",
"tryTimeFormats",
"(",
"timeStr",
",",
"timeFieldFormat",
")",
"\n",
"if",
"!",
"ts",
".",
"IsZero",
"(",
")",
"{",
"break",
"\n",
"}",
"\n",
"warnAboutTime",
"(",
"timeField",
",",
"t",
",",
"timeFoundInvalidFormatMsg",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"ts",
".",
"IsZero",
"(",
")",
"{",
"ts",
"=",
"Now",
"(",
")",
"\n",
"}",
"\n",
"delete",
"(",
"m",
",",
"foundFieldName",
")",
"\n",
"return",
"ts",
"\n",
"}"
] | // GetTimestamp looks through the event map for something that looks like a
// timestamp.
//
// It will guess at the key name or use the specified one if it is not an empty
// string. If unable to parse the timestamp, it will return the current time.
// The time field will be deleted from the map if found. | [
"GetTimestamp",
"looks",
"through",
"the",
"event",
"map",
"for",
"something",
"that",
"looks",
"like",
"a",
"timestamp",
".",
"It",
"will",
"guess",
"at",
"the",
"key",
"name",
"or",
"use",
"the",
"specified",
"one",
"if",
"it",
"is",
"not",
"an",
"empty",
"string",
".",
"If",
"unable",
"to",
"parse",
"the",
"timestamp",
"it",
"will",
"return",
"the",
"current",
"time",
".",
"The",
"time",
"field",
"will",
"be",
"deleted",
"from",
"the",
"map",
"if",
"found",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/httime/httime.go#L114-L176 |
10,082 | honeycombio/honeytail | httime/httime.go | Parse | func Parse(format, timespec string) (time.Time, error) {
return time.ParseInLocation(format, timespec, Location)
} | go | func Parse(format, timespec string) (time.Time, error) {
return time.ParseInLocation(format, timespec, Location)
} | [
"func",
"Parse",
"(",
"format",
",",
"timespec",
"string",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"return",
"time",
".",
"ParseInLocation",
"(",
"format",
",",
"timespec",
",",
"Location",
")",
"\n",
"}"
] | // Parse wraps time.ParseInLocation to use httime's Location from parsers | [
"Parse",
"wraps",
"time",
".",
"ParseInLocation",
"to",
"use",
"httime",
"s",
"Location",
"from",
"parsers"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/httime/httime.go#L179-L181 |
10,083 | honeycombio/honeytail | httime/httime.go | convertTimeFormat | func convertTimeFormat(layout string) string {
for format, conv := range convertMapping {
layout = strings.Replace(layout, format, conv, -1)
}
return layout
} | go | func convertTimeFormat(layout string) string {
for format, conv := range convertMapping {
layout = strings.Replace(layout, format, conv, -1)
}
return layout
} | [
"func",
"convertTimeFormat",
"(",
"layout",
"string",
")",
"string",
"{",
"for",
"format",
",",
"conv",
":=",
"range",
"convertMapping",
"{",
"layout",
"=",
"strings",
".",
"Replace",
"(",
"layout",
",",
"format",
",",
"conv",
",",
"-",
"1",
")",
"\n",
"}",
"\n",
"return",
"layout",
"\n",
"}"
] | // convertTimeFormat tries to handle C-style time formats alongside Go's
// existing time.Parse behavior. | [
"convertTimeFormat",
"tries",
"to",
"handle",
"C",
"-",
"style",
"time",
"formats",
"alongside",
"Go",
"s",
"existing",
"time",
".",
"Parse",
"behavior",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/httime/httime.go#L185-L190 |
10,084 | honeycombio/honeytail | parsers/postgresql/postgresql.go | handleEvents | func (p *Parser) handleEvents(rawEvents <-chan []string, send chan<- event.Event, wg *sync.WaitGroup) {
defer wg.Done()
// TODO: spin up a group of goroutines to do this
for rawEvent := range rawEvents {
ev := p.handleEvent(rawEvent)
if ev != nil {
send <- *ev
}
}
} | go | func (p *Parser) handleEvents(rawEvents <-chan []string, send chan<- event.Event, wg *sync.WaitGroup) {
defer wg.Done()
// TODO: spin up a group of goroutines to do this
for rawEvent := range rawEvents {
ev := p.handleEvent(rawEvent)
if ev != nil {
send <- *ev
}
}
} | [
"func",
"(",
"p",
"*",
"Parser",
")",
"handleEvents",
"(",
"rawEvents",
"<-",
"chan",
"[",
"]",
"string",
",",
"send",
"chan",
"<-",
"event",
".",
"Event",
",",
"wg",
"*",
"sync",
".",
"WaitGroup",
")",
"{",
"defer",
"wg",
".",
"Done",
"(",
")",
"\n",
"// TODO: spin up a group of goroutines to do this",
"for",
"rawEvent",
":=",
"range",
"rawEvents",
"{",
"ev",
":=",
"p",
".",
"handleEvent",
"(",
"rawEvent",
")",
"\n",
"if",
"ev",
"!=",
"nil",
"{",
"send",
"<-",
"*",
"ev",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // handleEvents receives sets of grouped log lines, each representing a single
// log statement. It attempts to parse them, and sends the events it constructs
// down the send channel. | [
"handleEvents",
"receives",
"sets",
"of",
"grouped",
"log",
"lines",
"each",
"representing",
"a",
"single",
"log",
"statement",
".",
"It",
"attempts",
"to",
"parse",
"them",
"and",
"sends",
"the",
"events",
"it",
"constructs",
"down",
"the",
"send",
"channel",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/parsers/postgresql/postgresql.go#L162-L171 |
10,085 | honeycombio/honeytail | parsers/postgresql/postgresql.go | addFieldsToEvent | func addFieldsToEvent(fields map[string]string, ev *event.Event) {
for k, v := range fields {
// Try to convert values to integer types where sensible, and extract
// timestamp for event
switch k {
case "session_id", "pid", "session_line_number":
if typed, err := strconv.Atoi(v); err == nil {
ev.Data[k] = typed
} else {
ev.Data[k] = v
}
case "timestamp", "timestamp_millis":
if timestamp, err := time.Parse("2006-01-02 15:04:05.999 MST", v); err == nil {
ev.Timestamp = timestamp
} else {
logrus.WithField("timestamp", v).WithError(err).Debug("Error parsing query timestamp")
}
case "timestamp_unix":
if typed, err := strconv.Atoi(v); err == nil {
// Convert millisecond-resolution Unix timestamp to time.Time
// object
timestamp := time.Unix(int64(typed/1000), int64((1000*1000)*(typed%1000))).UTC()
ev.Timestamp = timestamp
} else {
logrus.WithField("timestamp", v).WithError(err).Debug("Error parsing query timestamp")
}
default:
ev.Data[k] = v
}
}
} | go | func addFieldsToEvent(fields map[string]string, ev *event.Event) {
for k, v := range fields {
// Try to convert values to integer types where sensible, and extract
// timestamp for event
switch k {
case "session_id", "pid", "session_line_number":
if typed, err := strconv.Atoi(v); err == nil {
ev.Data[k] = typed
} else {
ev.Data[k] = v
}
case "timestamp", "timestamp_millis":
if timestamp, err := time.Parse("2006-01-02 15:04:05.999 MST", v); err == nil {
ev.Timestamp = timestamp
} else {
logrus.WithField("timestamp", v).WithError(err).Debug("Error parsing query timestamp")
}
case "timestamp_unix":
if typed, err := strconv.Atoi(v); err == nil {
// Convert millisecond-resolution Unix timestamp to time.Time
// object
timestamp := time.Unix(int64(typed/1000), int64((1000*1000)*(typed%1000))).UTC()
ev.Timestamp = timestamp
} else {
logrus.WithField("timestamp", v).WithError(err).Debug("Error parsing query timestamp")
}
default:
ev.Data[k] = v
}
}
} | [
"func",
"addFieldsToEvent",
"(",
"fields",
"map",
"[",
"string",
"]",
"string",
",",
"ev",
"*",
"event",
".",
"Event",
")",
"{",
"for",
"k",
",",
"v",
":=",
"range",
"fields",
"{",
"// Try to convert values to integer types where sensible, and extract",
"// timestamp for event",
"switch",
"k",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"typed",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"v",
")",
";",
"err",
"==",
"nil",
"{",
"ev",
".",
"Data",
"[",
"k",
"]",
"=",
"typed",
"\n",
"}",
"else",
"{",
"ev",
".",
"Data",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"if",
"timestamp",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"\"",
"\"",
",",
"v",
")",
";",
"err",
"==",
"nil",
"{",
"ev",
".",
"Timestamp",
"=",
"timestamp",
"\n",
"}",
"else",
"{",
"logrus",
".",
"WithField",
"(",
"\"",
"\"",
",",
"v",
")",
".",
"WithError",
"(",
"err",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"if",
"typed",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"v",
")",
";",
"err",
"==",
"nil",
"{",
"// Convert millisecond-resolution Unix timestamp to time.Time",
"// object",
"timestamp",
":=",
"time",
".",
"Unix",
"(",
"int64",
"(",
"typed",
"/",
"1000",
")",
",",
"int64",
"(",
"(",
"1000",
"*",
"1000",
")",
"*",
"(",
"typed",
"%",
"1000",
")",
")",
")",
".",
"UTC",
"(",
")",
"\n",
"ev",
".",
"Timestamp",
"=",
"timestamp",
"\n",
"}",
"else",
"{",
"logrus",
".",
"WithField",
"(",
"\"",
"\"",
",",
"v",
")",
".",
"WithError",
"(",
"err",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"default",
":",
"ev",
".",
"Data",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // addFieldsToEvent takes a map of key-value metadata extracted from a log
// line, and adds them to the given event. It'll convert values to integer
// types where possible, and try to populate the event's timestamp. | [
"addFieldsToEvent",
"takes",
"a",
"map",
"of",
"key",
"-",
"value",
"metadata",
"extracted",
"from",
"a",
"log",
"line",
"and",
"adds",
"them",
"to",
"the",
"given",
"event",
".",
"It",
"ll",
"convert",
"values",
"to",
"integer",
"types",
"where",
"possible",
"and",
"try",
"to",
"populate",
"the",
"event",
"s",
"timestamp",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/parsers/postgresql/postgresql.go#L238-L268 |
10,086 | honeycombio/honeytail | parsers/extregexp.go | FindStringSubmatchMap | func (r *ExtRegexp) FindStringSubmatchMap(s string) (string, map[string]string) {
match := r.FindStringSubmatch(s)
if match == nil {
return "", nil
}
captures := make(map[string]string)
for i, name := range r.SubexpNames() {
if i == 0 {
continue
}
if name != "" {
// ignore unnamed matches
captures[name] = match[i]
}
}
return match[0], captures
} | go | func (r *ExtRegexp) FindStringSubmatchMap(s string) (string, map[string]string) {
match := r.FindStringSubmatch(s)
if match == nil {
return "", nil
}
captures := make(map[string]string)
for i, name := range r.SubexpNames() {
if i == 0 {
continue
}
if name != "" {
// ignore unnamed matches
captures[name] = match[i]
}
}
return match[0], captures
} | [
"func",
"(",
"r",
"*",
"ExtRegexp",
")",
"FindStringSubmatchMap",
"(",
"s",
"string",
")",
"(",
"string",
",",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"match",
":=",
"r",
".",
"FindStringSubmatch",
"(",
"s",
")",
"\n",
"if",
"match",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"}",
"\n\n",
"captures",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n",
"for",
"i",
",",
"name",
":=",
"range",
"r",
".",
"SubexpNames",
"(",
")",
"{",
"if",
"i",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"// ignore unnamed matches",
"captures",
"[",
"name",
"]",
"=",
"match",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"match",
"[",
"0",
"]",
",",
"captures",
"\n",
"}"
] | // FindStringSubmatchMap behaves the same as FindStringSubmatch except instead
// of a list of matches with the names separate, it returns the full match and a
// map of named submatches | [
"FindStringSubmatchMap",
"behaves",
"the",
"same",
"as",
"FindStringSubmatch",
"except",
"instead",
"of",
"a",
"list",
"of",
"matches",
"with",
"the",
"names",
"separate",
"it",
"returns",
"the",
"full",
"match",
"and",
"a",
"map",
"of",
"named",
"submatches"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/parsers/extregexp.go#L14-L31 |
10,087 | honeycombio/honeytail | leash.go | getParserAndOptions | func getParserAndOptions(options GlobalOptions) (parsers.Parser, interface{}) {
var parser parsers.Parser
var opts interface{}
switch options.Reqs.ParserName {
case "regex":
parser = ®ex.Parser{}
opts = &options.Regex
opts.(*regex.Options).NumParsers = int(options.NumSenders)
case "nginx":
parser = &nginx.Parser{}
opts = &options.Nginx
opts.(*nginx.Options).NumParsers = int(options.NumSenders)
case "json":
parser = &htjson.Parser{}
opts = &options.JSON
opts.(*htjson.Options).NumParsers = int(options.NumSenders)
case "keyval":
parser = &keyval.Parser{}
opts = &options.KeyVal
opts.(*keyval.Options).NumParsers = int(options.NumSenders)
case "mongo", "mongodb":
parser = &mongodb.Parser{}
opts = &options.Mongo
opts.(*mongodb.Options).NumParsers = int(options.NumSenders)
case "mysql":
parser = &mysql.Parser{
SampleRate: int(options.SampleRate),
}
opts = &options.MySQL
opts.(*mysql.Options).NumParsers = int(options.NumSenders)
case "postgresql":
opts = &options.PostgreSQL
parser = &postgresql.Parser{}
case "arangodb":
parser = &arangodb.Parser{}
opts = &options.ArangoDB
case "csv":
parser = &csv.Parser{}
opts = &options.CSV
opts.(*csv.Options).NumParsers = int(options.NumSenders)
case "syslog":
parser = &syslog.Parser{}
opts = &options.Syslog
opts.(*syslog.Options).NumParsers = int(options.NumSenders)
}
parser, _ = parser.(parsers.Parser)
return parser, opts
} | go | func getParserAndOptions(options GlobalOptions) (parsers.Parser, interface{}) {
var parser parsers.Parser
var opts interface{}
switch options.Reqs.ParserName {
case "regex":
parser = ®ex.Parser{}
opts = &options.Regex
opts.(*regex.Options).NumParsers = int(options.NumSenders)
case "nginx":
parser = &nginx.Parser{}
opts = &options.Nginx
opts.(*nginx.Options).NumParsers = int(options.NumSenders)
case "json":
parser = &htjson.Parser{}
opts = &options.JSON
opts.(*htjson.Options).NumParsers = int(options.NumSenders)
case "keyval":
parser = &keyval.Parser{}
opts = &options.KeyVal
opts.(*keyval.Options).NumParsers = int(options.NumSenders)
case "mongo", "mongodb":
parser = &mongodb.Parser{}
opts = &options.Mongo
opts.(*mongodb.Options).NumParsers = int(options.NumSenders)
case "mysql":
parser = &mysql.Parser{
SampleRate: int(options.SampleRate),
}
opts = &options.MySQL
opts.(*mysql.Options).NumParsers = int(options.NumSenders)
case "postgresql":
opts = &options.PostgreSQL
parser = &postgresql.Parser{}
case "arangodb":
parser = &arangodb.Parser{}
opts = &options.ArangoDB
case "csv":
parser = &csv.Parser{}
opts = &options.CSV
opts.(*csv.Options).NumParsers = int(options.NumSenders)
case "syslog":
parser = &syslog.Parser{}
opts = &options.Syslog
opts.(*syslog.Options).NumParsers = int(options.NumSenders)
}
parser, _ = parser.(parsers.Parser)
return parser, opts
} | [
"func",
"getParserAndOptions",
"(",
"options",
"GlobalOptions",
")",
"(",
"parsers",
".",
"Parser",
",",
"interface",
"{",
"}",
")",
"{",
"var",
"parser",
"parsers",
".",
"Parser",
"\n",
"var",
"opts",
"interface",
"{",
"}",
"\n",
"switch",
"options",
".",
"Reqs",
".",
"ParserName",
"{",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"regex",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"Regex",
"\n",
"opts",
".",
"(",
"*",
"regex",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"nginx",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"Nginx",
"\n",
"opts",
".",
"(",
"*",
"nginx",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"htjson",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"JSON",
"\n",
"opts",
".",
"(",
"*",
"htjson",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"keyval",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"KeyVal",
"\n",
"opts",
".",
"(",
"*",
"keyval",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"parser",
"=",
"&",
"mongodb",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"Mongo",
"\n",
"opts",
".",
"(",
"*",
"mongodb",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"mysql",
".",
"Parser",
"{",
"SampleRate",
":",
"int",
"(",
"options",
".",
"SampleRate",
")",
",",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"MySQL",
"\n",
"opts",
".",
"(",
"*",
"mysql",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"opts",
"=",
"&",
"options",
".",
"PostgreSQL",
"\n",
"parser",
"=",
"&",
"postgresql",
".",
"Parser",
"{",
"}",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"arangodb",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"ArangoDB",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"csv",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"CSV",
"\n",
"opts",
".",
"(",
"*",
"csv",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"case",
"\"",
"\"",
":",
"parser",
"=",
"&",
"syslog",
".",
"Parser",
"{",
"}",
"\n",
"opts",
"=",
"&",
"options",
".",
"Syslog",
"\n",
"opts",
".",
"(",
"*",
"syslog",
".",
"Options",
")",
".",
"NumParsers",
"=",
"int",
"(",
"options",
".",
"NumSenders",
")",
"\n",
"}",
"\n",
"parser",
",",
"_",
"=",
"parser",
".",
"(",
"parsers",
".",
"Parser",
")",
"\n",
"return",
"parser",
",",
"opts",
"\n",
"}"
] | // getParserOptions takes a parser name and the global options struct
// it returns the options group for the specified parser | [
"getParserOptions",
"takes",
"a",
"parser",
"name",
"and",
"the",
"global",
"options",
"struct",
"it",
"returns",
"the",
"options",
"group",
"for",
"the",
"specified",
"parser"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L208-L255 |
10,088 | honeycombio/honeytail | leash.go | makeDynsampleKey | func makeDynsampleKey(ev *event.Event, options GlobalOptions) string {
key := make([]string, len(options.DynSample))
for i, field := range options.DynSample {
if val, ok := ev.Data[field]; ok {
switch val := val.(type) {
case bool:
key[i] = strconv.FormatBool(val)
case int64:
key[i] = strconv.FormatInt(val, 10)
case float64:
key[i] = strconv.FormatFloat(val, 'E', -1, 64)
case string:
key[i] = val
default:
key[i] = "" // skip it
}
}
}
return strings.Join(key, "_")
} | go | func makeDynsampleKey(ev *event.Event, options GlobalOptions) string {
key := make([]string, len(options.DynSample))
for i, field := range options.DynSample {
if val, ok := ev.Data[field]; ok {
switch val := val.(type) {
case bool:
key[i] = strconv.FormatBool(val)
case int64:
key[i] = strconv.FormatInt(val, 10)
case float64:
key[i] = strconv.FormatFloat(val, 'E', -1, 64)
case string:
key[i] = val
default:
key[i] = "" // skip it
}
}
}
return strings.Join(key, "_")
} | [
"func",
"makeDynsampleKey",
"(",
"ev",
"*",
"event",
".",
"Event",
",",
"options",
"GlobalOptions",
")",
"string",
"{",
"key",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"options",
".",
"DynSample",
")",
")",
"\n",
"for",
"i",
",",
"field",
":=",
"range",
"options",
".",
"DynSample",
"{",
"if",
"val",
",",
"ok",
":=",
"ev",
".",
"Data",
"[",
"field",
"]",
";",
"ok",
"{",
"switch",
"val",
":=",
"val",
".",
"(",
"type",
")",
"{",
"case",
"bool",
":",
"key",
"[",
"i",
"]",
"=",
"strconv",
".",
"FormatBool",
"(",
"val",
")",
"\n",
"case",
"int64",
":",
"key",
"[",
"i",
"]",
"=",
"strconv",
".",
"FormatInt",
"(",
"val",
",",
"10",
")",
"\n",
"case",
"float64",
":",
"key",
"[",
"i",
"]",
"=",
"strconv",
".",
"FormatFloat",
"(",
"val",
",",
"'E'",
",",
"-",
"1",
",",
"64",
")",
"\n",
"case",
"string",
":",
"key",
"[",
"i",
"]",
"=",
"val",
"\n",
"default",
":",
"key",
"[",
"i",
"]",
"=",
"\"",
"\"",
"// skip it",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"key",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // makeDynsampleKey pulls in all the values necessary from the event to create a
// key for dynamic sampling | [
"makeDynsampleKey",
"pulls",
"in",
"all",
"the",
"values",
"necessary",
"from",
"the",
"event",
"to",
"create",
"a",
"key",
"for",
"dynamic",
"sampling"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L457-L477 |
10,089 | honeycombio/honeytail | leash.go | whitelistKey | func whitelistKey(whiteKeys []string, key string) bool {
for _, whiteKey := range whiteKeys {
if key == whiteKey {
return true
}
}
return false
} | go | func whitelistKey(whiteKeys []string, key string) bool {
for _, whiteKey := range whiteKeys {
if key == whiteKey {
return true
}
}
return false
} | [
"func",
"whitelistKey",
"(",
"whiteKeys",
"[",
"]",
"string",
",",
"key",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"whiteKey",
":=",
"range",
"whiteKeys",
"{",
"if",
"key",
"==",
"whiteKey",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // return true if the key is in the whitelist | [
"return",
"true",
"if",
"the",
"key",
"is",
"in",
"the",
"whitelist"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L547-L554 |
10,090 | honeycombio/honeytail | leash.go | sendToLibhoney | func sendToLibhoney(ctx context.Context, toBeSent chan event.Event, toBeResent chan event.Event,
delaySending chan int, doneSending chan bool) {
for {
// check and see if we need to back off the API because of rate limiting
select {
case delay := <-delaySending:
time.Sleep(time.Duration(delay) * time.Millisecond)
default:
}
// if we have events to retransmit, send those first
select {
case ev := <-toBeResent:
// retransmitted events have already been sampled; always use
// SendPresampled() for these
sendEvent(ev)
continue
default:
}
// otherwise pick something up off the regular queue and send it
select {
case ev, ok := <-toBeSent:
if !ok {
// channel is closed
// NOTE: any unrtransmitted retransmittable events will be dropped
doneSending <- true
return
}
sendEvent(ev)
continue
default:
}
// no events at all? chill for a sec until we get the next one
time.Sleep(100 * time.Millisecond)
}
} | go | func sendToLibhoney(ctx context.Context, toBeSent chan event.Event, toBeResent chan event.Event,
delaySending chan int, doneSending chan bool) {
for {
// check and see if we need to back off the API because of rate limiting
select {
case delay := <-delaySending:
time.Sleep(time.Duration(delay) * time.Millisecond)
default:
}
// if we have events to retransmit, send those first
select {
case ev := <-toBeResent:
// retransmitted events have already been sampled; always use
// SendPresampled() for these
sendEvent(ev)
continue
default:
}
// otherwise pick something up off the regular queue and send it
select {
case ev, ok := <-toBeSent:
if !ok {
// channel is closed
// NOTE: any unrtransmitted retransmittable events will be dropped
doneSending <- true
return
}
sendEvent(ev)
continue
default:
}
// no events at all? chill for a sec until we get the next one
time.Sleep(100 * time.Millisecond)
}
} | [
"func",
"sendToLibhoney",
"(",
"ctx",
"context",
".",
"Context",
",",
"toBeSent",
"chan",
"event",
".",
"Event",
",",
"toBeResent",
"chan",
"event",
".",
"Event",
",",
"delaySending",
"chan",
"int",
",",
"doneSending",
"chan",
"bool",
")",
"{",
"for",
"{",
"// check and see if we need to back off the API because of rate limiting",
"select",
"{",
"case",
"delay",
":=",
"<-",
"delaySending",
":",
"time",
".",
"Sleep",
"(",
"time",
".",
"Duration",
"(",
"delay",
")",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"default",
":",
"}",
"\n",
"// if we have events to retransmit, send those first",
"select",
"{",
"case",
"ev",
":=",
"<-",
"toBeResent",
":",
"// retransmitted events have already been sampled; always use",
"// SendPresampled() for these",
"sendEvent",
"(",
"ev",
")",
"\n",
"continue",
"\n",
"default",
":",
"}",
"\n",
"// otherwise pick something up off the regular queue and send it",
"select",
"{",
"case",
"ev",
",",
"ok",
":=",
"<-",
"toBeSent",
":",
"if",
"!",
"ok",
"{",
"// channel is closed",
"// NOTE: any unrtransmitted retransmittable events will be dropped",
"doneSending",
"<-",
"true",
"\n",
"return",
"\n",
"}",
"\n",
"sendEvent",
"(",
"ev",
")",
"\n",
"continue",
"\n",
"default",
":",
"}",
"\n",
"// no events at all? chill for a sec until we get the next one",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}",
"\n",
"}"
] | // sendToLibhoney reads from the toBeSent channel and shoves the events into
// libhoney events, sending them on their way. | [
"sendToLibhoney",
"reads",
"from",
"the",
"toBeSent",
"channel",
"and",
"shoves",
"the",
"events",
"into",
"libhoney",
"events",
"sending",
"them",
"on",
"their",
"way",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L558-L592 |
10,091 | honeycombio/honeytail | leash.go | sendEvent | func sendEvent(ev event.Event) {
if ev.SampleRate == -1 {
// drop the event!
logrus.WithFields(logrus.Fields{
"event": ev,
}).Debug("droppped event due to sampling")
return
}
libhEv := libhoney.NewEvent()
libhEv.Metadata = ev
libhEv.Timestamp = ev.Timestamp
libhEv.SampleRate = uint(ev.SampleRate)
if err := libhEv.Add(ev.Data); err != nil {
logrus.WithFields(logrus.Fields{
"event": ev,
"error": err,
}).Error("Unexpected error adding data to libhoney event")
}
if err := libhEv.SendPresampled(); err != nil {
logrus.WithFields(logrus.Fields{
"event": ev,
"error": err,
}).Error("Unexpected error event to libhoney send")
}
} | go | func sendEvent(ev event.Event) {
if ev.SampleRate == -1 {
// drop the event!
logrus.WithFields(logrus.Fields{
"event": ev,
}).Debug("droppped event due to sampling")
return
}
libhEv := libhoney.NewEvent()
libhEv.Metadata = ev
libhEv.Timestamp = ev.Timestamp
libhEv.SampleRate = uint(ev.SampleRate)
if err := libhEv.Add(ev.Data); err != nil {
logrus.WithFields(logrus.Fields{
"event": ev,
"error": err,
}).Error("Unexpected error adding data to libhoney event")
}
if err := libhEv.SendPresampled(); err != nil {
logrus.WithFields(logrus.Fields{
"event": ev,
"error": err,
}).Error("Unexpected error event to libhoney send")
}
} | [
"func",
"sendEvent",
"(",
"ev",
"event",
".",
"Event",
")",
"{",
"if",
"ev",
".",
"SampleRate",
"==",
"-",
"1",
"{",
"// drop the event!",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"ev",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"libhEv",
":=",
"libhoney",
".",
"NewEvent",
"(",
")",
"\n",
"libhEv",
".",
"Metadata",
"=",
"ev",
"\n",
"libhEv",
".",
"Timestamp",
"=",
"ev",
".",
"Timestamp",
"\n",
"libhEv",
".",
"SampleRate",
"=",
"uint",
"(",
"ev",
".",
"SampleRate",
")",
"\n",
"if",
"err",
":=",
"libhEv",
".",
"Add",
"(",
"ev",
".",
"Data",
")",
";",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"ev",
",",
"\"",
"\"",
":",
"err",
",",
"}",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"libhEv",
".",
"SendPresampled",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"ev",
",",
"\"",
"\"",
":",
"err",
",",
"}",
")",
".",
"Error",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // sendEvent does the actual handoff to libhoney | [
"sendEvent",
"does",
"the",
"actual",
"handoff",
"to",
"libhoney"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L595-L619 |
10,092 | honeycombio/honeytail | leash.go | handleResponses | func handleResponses(responses chan libhoney.Response, stats *responseStats,
toBeResent chan event.Event, delaySending chan int,
options GlobalOptions) {
go logStats(stats, options.StatusInterval)
for rsp := range responses {
stats.update(rsp)
logfields := logrus.Fields{
"status_code": rsp.StatusCode,
"body": strings.TrimSpace(string(rsp.Body)),
"duration": rsp.Duration,
"error": rsp.Err,
"timestamp": rsp.Metadata.(event.Event).Timestamp,
}
// if this is an error we should retry sending, re-enqueue the event
if options.BackOff && (rsp.StatusCode == 429 || rsp.StatusCode == 500) {
logfields["retry_send"] = true
delaySending <- 1000 / int(options.NumSenders) // back off for a little bit
toBeResent <- rsp.Metadata.(event.Event) // then retry sending the event
} else {
logfields["retry_send"] = false
}
logrus.WithFields(logfields).Debug("event send record received")
}
} | go | func handleResponses(responses chan libhoney.Response, stats *responseStats,
toBeResent chan event.Event, delaySending chan int,
options GlobalOptions) {
go logStats(stats, options.StatusInterval)
for rsp := range responses {
stats.update(rsp)
logfields := logrus.Fields{
"status_code": rsp.StatusCode,
"body": strings.TrimSpace(string(rsp.Body)),
"duration": rsp.Duration,
"error": rsp.Err,
"timestamp": rsp.Metadata.(event.Event).Timestamp,
}
// if this is an error we should retry sending, re-enqueue the event
if options.BackOff && (rsp.StatusCode == 429 || rsp.StatusCode == 500) {
logfields["retry_send"] = true
delaySending <- 1000 / int(options.NumSenders) // back off for a little bit
toBeResent <- rsp.Metadata.(event.Event) // then retry sending the event
} else {
logfields["retry_send"] = false
}
logrus.WithFields(logfields).Debug("event send record received")
}
} | [
"func",
"handleResponses",
"(",
"responses",
"chan",
"libhoney",
".",
"Response",
",",
"stats",
"*",
"responseStats",
",",
"toBeResent",
"chan",
"event",
".",
"Event",
",",
"delaySending",
"chan",
"int",
",",
"options",
"GlobalOptions",
")",
"{",
"go",
"logStats",
"(",
"stats",
",",
"options",
".",
"StatusInterval",
")",
"\n\n",
"for",
"rsp",
":=",
"range",
"responses",
"{",
"stats",
".",
"update",
"(",
"rsp",
")",
"\n",
"logfields",
":=",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"rsp",
".",
"StatusCode",
",",
"\"",
"\"",
":",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"rsp",
".",
"Body",
")",
")",
",",
"\"",
"\"",
":",
"rsp",
".",
"Duration",
",",
"\"",
"\"",
":",
"rsp",
".",
"Err",
",",
"\"",
"\"",
":",
"rsp",
".",
"Metadata",
".",
"(",
"event",
".",
"Event",
")",
".",
"Timestamp",
",",
"}",
"\n",
"// if this is an error we should retry sending, re-enqueue the event",
"if",
"options",
".",
"BackOff",
"&&",
"(",
"rsp",
".",
"StatusCode",
"==",
"429",
"||",
"rsp",
".",
"StatusCode",
"==",
"500",
")",
"{",
"logfields",
"[",
"\"",
"\"",
"]",
"=",
"true",
"\n",
"delaySending",
"<-",
"1000",
"/",
"int",
"(",
"options",
".",
"NumSenders",
")",
"// back off for a little bit",
"\n",
"toBeResent",
"<-",
"rsp",
".",
"Metadata",
".",
"(",
"event",
".",
"Event",
")",
"// then retry sending the event",
"\n",
"}",
"else",
"{",
"logfields",
"[",
"\"",
"\"",
"]",
"=",
"false",
"\n",
"}",
"\n",
"logrus",
".",
"WithFields",
"(",
"logfields",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // handleResponses reads from the response queue, logging a summary and debug
// re-enqueues any events that failed to send in a retryable way | [
"handleResponses",
"reads",
"from",
"the",
"response",
"queue",
"logging",
"a",
"summary",
"and",
"debug",
"re",
"-",
"enqueues",
"any",
"events",
"that",
"failed",
"to",
"send",
"in",
"a",
"retryable",
"way"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L623-L647 |
10,093 | honeycombio/honeytail | leash.go | logStats | func logStats(stats *responseStats, interval uint) {
logrus.Debugf("Initializing stats reporting. Will print stats once/%d seconds", interval)
if interval == 0 {
// interval of 0 means don't print summary status
return
}
ticker := time.NewTicker(time.Second * time.Duration(interval))
for range ticker.C {
stats.logAndReset()
}
} | go | func logStats(stats *responseStats, interval uint) {
logrus.Debugf("Initializing stats reporting. Will print stats once/%d seconds", interval)
if interval == 0 {
// interval of 0 means don't print summary status
return
}
ticker := time.NewTicker(time.Second * time.Duration(interval))
for range ticker.C {
stats.logAndReset()
}
} | [
"func",
"logStats",
"(",
"stats",
"*",
"responseStats",
",",
"interval",
"uint",
")",
"{",
"logrus",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"interval",
")",
"\n",
"if",
"interval",
"==",
"0",
"{",
"// interval of 0 means don't print summary status",
"return",
"\n",
"}",
"\n",
"ticker",
":=",
"time",
".",
"NewTicker",
"(",
"time",
".",
"Second",
"*",
"time",
".",
"Duration",
"(",
"interval",
")",
")",
"\n",
"for",
"range",
"ticker",
".",
"C",
"{",
"stats",
".",
"logAndReset",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // logStats dumps and resets the stats once every minute | [
"logStats",
"dumps",
"and",
"resets",
"the",
"stats",
"once",
"every",
"minute"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/leash.go#L650-L660 |
10,094 | honeycombio/honeytail | parsers/nginx/nginx.go | typeifyParsedLine | func typeifyParsedLine(pl map[string]string) map[string]interface{} {
// try to convert numbers, if possible
msi := make(map[string]interface{}, len(pl))
for k, v := range pl {
switch {
case strings.Contains(v, "."):
f, err := strconv.ParseFloat(v, 64)
if err == nil {
msi[k] = f
continue
}
case v == "-":
// no value, don't set a "-" string
continue
default:
i, err := strconv.ParseInt(v, 10, 64)
if err == nil {
msi[k] = i
continue
}
}
msi[k] = v
}
return msi
} | go | func typeifyParsedLine(pl map[string]string) map[string]interface{} {
// try to convert numbers, if possible
msi := make(map[string]interface{}, len(pl))
for k, v := range pl {
switch {
case strings.Contains(v, "."):
f, err := strconv.ParseFloat(v, 64)
if err == nil {
msi[k] = f
continue
}
case v == "-":
// no value, don't set a "-" string
continue
default:
i, err := strconv.ParseInt(v, 10, 64)
if err == nil {
msi[k] = i
continue
}
}
msi[k] = v
}
return msi
} | [
"func",
"typeifyParsedLine",
"(",
"pl",
"map",
"[",
"string",
"]",
"string",
")",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"// try to convert numbers, if possible",
"msi",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"pl",
")",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"pl",
"{",
"switch",
"{",
"case",
"strings",
".",
"Contains",
"(",
"v",
",",
"\"",
"\"",
")",
":",
"f",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"v",
",",
"64",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"msi",
"[",
"k",
"]",
"=",
"f",
"\n",
"continue",
"\n",
"}",
"\n",
"case",
"v",
"==",
"\"",
"\"",
":",
"// no value, don't set a \"-\" string",
"continue",
"\n",
"default",
":",
"i",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"v",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"msi",
"[",
"k",
"]",
"=",
"i",
"\n",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"msi",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"return",
"msi",
"\n",
"}"
] | // typeifyParsedLine attempts to cast numbers in the event to floats or ints | [
"typeifyParsedLine",
"attempts",
"to",
"cast",
"numbers",
"in",
"the",
"event",
"to",
"floats",
"or",
"ints"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/parsers/nginx/nginx.go#L127-L151 |
10,095 | honeycombio/honeytail | parsers/nginx/nginx.go | getTimestamp | func (n *Parser) getTimestamp(evMap map[string]interface{}) time.Time {
var (
setBothFieldsMsg = "Timestamp format and field must both be set to be used, one was not. Using current time instead."
)
// Custom (user-defined) timestamp field/format takes priority over the
// default parsing behavior. Try that first.
if n.conf.TimeFieldFormat != "" || n.conf.TimeFieldName != "" {
if n.conf.TimeFieldFormat == "" || n.conf.TimeFieldName == "" {
logrus.Debug(setBothFieldsMsg)
return httime.Now()
}
return httime.GetTimestamp(evMap, n.conf.TimeFieldName, n.conf.TimeFieldFormat)
}
if _, ok := evMap["time_local"]; ok {
return httime.GetTimestamp(evMap, "time_local", commonLogFormatTimeLayout)
}
if _, ok := evMap["time_iso8601"]; ok {
return httime.GetTimestamp(evMap, "time_iso8601", iso8601TimeLayout)
}
if _, ok := evMap["msec"]; ok {
return httime.GetTimestamp(evMap, "msec", "")
}
return httime.GetTimestamp(evMap, "", "")
} | go | func (n *Parser) getTimestamp(evMap map[string]interface{}) time.Time {
var (
setBothFieldsMsg = "Timestamp format and field must both be set to be used, one was not. Using current time instead."
)
// Custom (user-defined) timestamp field/format takes priority over the
// default parsing behavior. Try that first.
if n.conf.TimeFieldFormat != "" || n.conf.TimeFieldName != "" {
if n.conf.TimeFieldFormat == "" || n.conf.TimeFieldName == "" {
logrus.Debug(setBothFieldsMsg)
return httime.Now()
}
return httime.GetTimestamp(evMap, n.conf.TimeFieldName, n.conf.TimeFieldFormat)
}
if _, ok := evMap["time_local"]; ok {
return httime.GetTimestamp(evMap, "time_local", commonLogFormatTimeLayout)
}
if _, ok := evMap["time_iso8601"]; ok {
return httime.GetTimestamp(evMap, "time_iso8601", iso8601TimeLayout)
}
if _, ok := evMap["msec"]; ok {
return httime.GetTimestamp(evMap, "msec", "")
}
return httime.GetTimestamp(evMap, "", "")
} | [
"func",
"(",
"n",
"*",
"Parser",
")",
"getTimestamp",
"(",
"evMap",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"time",
".",
"Time",
"{",
"var",
"(",
"setBothFieldsMsg",
"=",
"\"",
"\"",
"\n",
")",
"\n\n",
"// Custom (user-defined) timestamp field/format takes priority over the",
"// default parsing behavior. Try that first.",
"if",
"n",
".",
"conf",
".",
"TimeFieldFormat",
"!=",
"\"",
"\"",
"||",
"n",
".",
"conf",
".",
"TimeFieldName",
"!=",
"\"",
"\"",
"{",
"if",
"n",
".",
"conf",
".",
"TimeFieldFormat",
"==",
"\"",
"\"",
"||",
"n",
".",
"conf",
".",
"TimeFieldName",
"==",
"\"",
"\"",
"{",
"logrus",
".",
"Debug",
"(",
"setBothFieldsMsg",
")",
"\n",
"return",
"httime",
".",
"Now",
"(",
")",
"\n",
"}",
"\n",
"return",
"httime",
".",
"GetTimestamp",
"(",
"evMap",
",",
"n",
".",
"conf",
".",
"TimeFieldName",
",",
"n",
".",
"conf",
".",
"TimeFieldFormat",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"evMap",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"httime",
".",
"GetTimestamp",
"(",
"evMap",
",",
"\"",
"\"",
",",
"commonLogFormatTimeLayout",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"evMap",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"httime",
".",
"GetTimestamp",
"(",
"evMap",
",",
"\"",
"\"",
",",
"iso8601TimeLayout",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"evMap",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"return",
"httime",
".",
"GetTimestamp",
"(",
"evMap",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"httime",
".",
"GetTimestamp",
"(",
"evMap",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // tries to extract a timestamp from the log line | [
"tries",
"to",
"extract",
"a",
"timestamp",
"from",
"the",
"log",
"line"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/parsers/nginx/nginx.go#L154-L182 |
10,096 | honeycombio/honeytail | tail/tail.go | GetSampledEntries | func GetSampledEntries(ctx context.Context, conf Config, sampleRate uint) ([]chan string, error) {
unsampledLinesChans, err := GetEntries(ctx, conf)
if err != nil {
return nil, err
}
if sampleRate == 1 {
return unsampledLinesChans, nil
}
sampledLinesChans := make([]chan string, 0, len(unsampledLinesChans))
for _, lines := range unsampledLinesChans {
sampledLines := make(chan string)
go func(pLines chan string) {
defer close(sampledLines)
for line := range pLines {
if shouldDrop(sampleRate) {
logrus.WithFields(logrus.Fields{
"line": line,
"samplerate": sampleRate,
}).Debug("Sampler says skip this line")
} else {
sampledLines <- line
}
}
}(lines)
sampledLinesChans = append(sampledLinesChans, sampledLines)
}
return sampledLinesChans, nil
} | go | func GetSampledEntries(ctx context.Context, conf Config, sampleRate uint) ([]chan string, error) {
unsampledLinesChans, err := GetEntries(ctx, conf)
if err != nil {
return nil, err
}
if sampleRate == 1 {
return unsampledLinesChans, nil
}
sampledLinesChans := make([]chan string, 0, len(unsampledLinesChans))
for _, lines := range unsampledLinesChans {
sampledLines := make(chan string)
go func(pLines chan string) {
defer close(sampledLines)
for line := range pLines {
if shouldDrop(sampleRate) {
logrus.WithFields(logrus.Fields{
"line": line,
"samplerate": sampleRate,
}).Debug("Sampler says skip this line")
} else {
sampledLines <- line
}
}
}(lines)
sampledLinesChans = append(sampledLinesChans, sampledLines)
}
return sampledLinesChans, nil
} | [
"func",
"GetSampledEntries",
"(",
"ctx",
"context",
".",
"Context",
",",
"conf",
"Config",
",",
"sampleRate",
"uint",
")",
"(",
"[",
"]",
"chan",
"string",
",",
"error",
")",
"{",
"unsampledLinesChans",
",",
"err",
":=",
"GetEntries",
"(",
"ctx",
",",
"conf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"sampleRate",
"==",
"1",
"{",
"return",
"unsampledLinesChans",
",",
"nil",
"\n",
"}",
"\n\n",
"sampledLinesChans",
":=",
"make",
"(",
"[",
"]",
"chan",
"string",
",",
"0",
",",
"len",
"(",
"unsampledLinesChans",
")",
")",
"\n\n",
"for",
"_",
",",
"lines",
":=",
"range",
"unsampledLinesChans",
"{",
"sampledLines",
":=",
"make",
"(",
"chan",
"string",
")",
"\n",
"go",
"func",
"(",
"pLines",
"chan",
"string",
")",
"{",
"defer",
"close",
"(",
"sampledLines",
")",
"\n",
"for",
"line",
":=",
"range",
"pLines",
"{",
"if",
"shouldDrop",
"(",
"sampleRate",
")",
"{",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"line",
",",
"\"",
"\"",
":",
"sampleRate",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"sampledLines",
"<-",
"line",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
"lines",
")",
"\n",
"sampledLinesChans",
"=",
"append",
"(",
"sampledLinesChans",
",",
"sampledLines",
")",
"\n",
"}",
"\n",
"return",
"sampledLinesChans",
",",
"nil",
"\n",
"}"
] | // GetSampledEntries wraps GetEntries and returns a list of channels that
// provide sampled entries | [
"GetSampledEntries",
"wraps",
"GetEntries",
"and",
"returns",
"a",
"list",
"of",
"channels",
"that",
"provide",
"sampled",
"entries"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/tail/tail.go#L68-L97 |
10,097 | honeycombio/honeytail | tail/tail.go | GetEntries | func GetEntries(ctx context.Context, conf Config) ([]chan string, error) {
if conf.Type != RotateStyleSyslog {
return nil, errors.New("Only Syslog style rotation currently supported")
}
// expand any globs in the list of files so our list all represents real files
var filenames []string
for _, filePath := range conf.Paths {
if filePath == "-" {
filenames = append(filenames, filePath)
} else {
files, err := filepath.Glob(filePath)
if err != nil {
return nil, err
}
files = removeStateFiles(files, conf)
files = removeFilteredPaths(files, conf.FilterPaths)
filenames = append(filenames, files...)
}
}
if len(filenames) == 0 {
return nil, errors.New("After removing missing files and state files from the list, there are no files left to tail")
}
// make our lines channel list; we'll get one channel for each file
linesChans := make([]chan string, 0, len(filenames))
numFiles := len(filenames)
for _, file := range filenames {
var lines chan string
if file == "-" {
lines = tailStdIn(ctx)
} else {
stateFile := getStateFile(conf, file, numFiles)
tailer, err := getTailer(conf, file, stateFile)
if err != nil {
return nil, err
}
lines = tailSingleFile(ctx, tailer, file, stateFile)
}
linesChans = append(linesChans, lines)
}
return linesChans, nil
} | go | func GetEntries(ctx context.Context, conf Config) ([]chan string, error) {
if conf.Type != RotateStyleSyslog {
return nil, errors.New("Only Syslog style rotation currently supported")
}
// expand any globs in the list of files so our list all represents real files
var filenames []string
for _, filePath := range conf.Paths {
if filePath == "-" {
filenames = append(filenames, filePath)
} else {
files, err := filepath.Glob(filePath)
if err != nil {
return nil, err
}
files = removeStateFiles(files, conf)
files = removeFilteredPaths(files, conf.FilterPaths)
filenames = append(filenames, files...)
}
}
if len(filenames) == 0 {
return nil, errors.New("After removing missing files and state files from the list, there are no files left to tail")
}
// make our lines channel list; we'll get one channel for each file
linesChans := make([]chan string, 0, len(filenames))
numFiles := len(filenames)
for _, file := range filenames {
var lines chan string
if file == "-" {
lines = tailStdIn(ctx)
} else {
stateFile := getStateFile(conf, file, numFiles)
tailer, err := getTailer(conf, file, stateFile)
if err != nil {
return nil, err
}
lines = tailSingleFile(ctx, tailer, file, stateFile)
}
linesChans = append(linesChans, lines)
}
return linesChans, nil
} | [
"func",
"GetEntries",
"(",
"ctx",
"context",
".",
"Context",
",",
"conf",
"Config",
")",
"(",
"[",
"]",
"chan",
"string",
",",
"error",
")",
"{",
"if",
"conf",
".",
"Type",
"!=",
"RotateStyleSyslog",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// expand any globs in the list of files so our list all represents real files",
"var",
"filenames",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"filePath",
":=",
"range",
"conf",
".",
"Paths",
"{",
"if",
"filePath",
"==",
"\"",
"\"",
"{",
"filenames",
"=",
"append",
"(",
"filenames",
",",
"filePath",
")",
"\n",
"}",
"else",
"{",
"files",
",",
"err",
":=",
"filepath",
".",
"Glob",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"files",
"=",
"removeStateFiles",
"(",
"files",
",",
"conf",
")",
"\n",
"files",
"=",
"removeFilteredPaths",
"(",
"files",
",",
"conf",
".",
"FilterPaths",
")",
"\n",
"filenames",
"=",
"append",
"(",
"filenames",
",",
"files",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"filenames",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// make our lines channel list; we'll get one channel for each file",
"linesChans",
":=",
"make",
"(",
"[",
"]",
"chan",
"string",
",",
"0",
",",
"len",
"(",
"filenames",
")",
")",
"\n",
"numFiles",
":=",
"len",
"(",
"filenames",
")",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"filenames",
"{",
"var",
"lines",
"chan",
"string",
"\n",
"if",
"file",
"==",
"\"",
"\"",
"{",
"lines",
"=",
"tailStdIn",
"(",
"ctx",
")",
"\n",
"}",
"else",
"{",
"stateFile",
":=",
"getStateFile",
"(",
"conf",
",",
"file",
",",
"numFiles",
")",
"\n",
"tailer",
",",
"err",
":=",
"getTailer",
"(",
"conf",
",",
"file",
",",
"stateFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"lines",
"=",
"tailSingleFile",
"(",
"ctx",
",",
"tailer",
",",
"file",
",",
"stateFile",
")",
"\n",
"}",
"\n",
"linesChans",
"=",
"append",
"(",
"linesChans",
",",
"lines",
")",
"\n",
"}",
"\n\n",
"return",
"linesChans",
",",
"nil",
"\n",
"}"
] | // GetEntries sets up a list of channels that get one line at a time from each
// file down each channel. | [
"GetEntries",
"sets",
"up",
"a",
"list",
"of",
"channels",
"that",
"get",
"one",
"line",
"at",
"a",
"time",
"from",
"each",
"file",
"down",
"each",
"channel",
"."
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/tail/tail.go#L109-L151 |
10,098 | honeycombio/honeytail | tail/tail.go | removeStateFiles | func removeStateFiles(files []string, conf Config) []string {
newFiles := []string{}
for _, file := range files {
if file == conf.Options.StateFile {
logrus.WithFields(logrus.Fields{
"file": file,
}).Debug("skipping tailing file because it is named the same as the statefile flag")
continue
}
if strings.HasSuffix(file, ".leash.state") {
logrus.WithFields(logrus.Fields{
"file": file,
}).Debug("skipping tailing file because the filename ends with .leash.state")
continue
}
// great! it's not a state file. let's use it.
newFiles = append(newFiles, file)
}
return newFiles
} | go | func removeStateFiles(files []string, conf Config) []string {
newFiles := []string{}
for _, file := range files {
if file == conf.Options.StateFile {
logrus.WithFields(logrus.Fields{
"file": file,
}).Debug("skipping tailing file because it is named the same as the statefile flag")
continue
}
if strings.HasSuffix(file, ".leash.state") {
logrus.WithFields(logrus.Fields{
"file": file,
}).Debug("skipping tailing file because the filename ends with .leash.state")
continue
}
// great! it's not a state file. let's use it.
newFiles = append(newFiles, file)
}
return newFiles
} | [
"func",
"removeStateFiles",
"(",
"files",
"[",
"]",
"string",
",",
"conf",
"Config",
")",
"[",
"]",
"string",
"{",
"newFiles",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"file",
":=",
"range",
"files",
"{",
"if",
"file",
"==",
"conf",
".",
"Options",
".",
"StateFile",
"{",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"file",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"strings",
".",
"HasSuffix",
"(",
"file",
",",
"\"",
"\"",
")",
"{",
"logrus",
".",
"WithFields",
"(",
"logrus",
".",
"Fields",
"{",
"\"",
"\"",
":",
"file",
",",
"}",
")",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"// great! it's not a state file. let's use it.",
"newFiles",
"=",
"append",
"(",
"newFiles",
",",
"file",
")",
"\n",
"}",
"\n",
"return",
"newFiles",
"\n",
"}"
] | // removeStateFiles goes through the list of files and removes any that appear
// to be statefiles to avoid .leash.state.leash.state.leash.state from appearing
// when you use an overly permissive glob | [
"removeStateFiles",
"goes",
"through",
"the",
"list",
"of",
"files",
"and",
"removes",
"any",
"that",
"appear",
"to",
"be",
"statefiles",
"to",
"avoid",
".",
"leash",
".",
"state",
".",
"leash",
".",
"state",
".",
"leash",
".",
"state",
"from",
"appearing",
"when",
"you",
"use",
"an",
"overly",
"permissive",
"glob"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/tail/tail.go#L156-L175 |
10,099 | honeycombio/honeytail | tail/tail.go | tailStdIn | func tailStdIn(ctx context.Context) chan string {
lines := make(chan string)
input := bufio.NewReader(os.Stdin)
go func() {
defer close(lines)
for {
// check for signal triggered exit
select {
case <-ctx.Done():
return
default:
}
line, partialLine, err := input.ReadLine()
if err != nil {
logrus.Debug("stdin is closed")
// bail when STDIN closes
return
}
var parts []string
parts = append(parts, string(line))
for partialLine {
line, partialLine, _ = input.ReadLine()
parts = append(parts, string(line))
}
lines <- strings.Join(parts, "")
}
}()
return lines
} | go | func tailStdIn(ctx context.Context) chan string {
lines := make(chan string)
input := bufio.NewReader(os.Stdin)
go func() {
defer close(lines)
for {
// check for signal triggered exit
select {
case <-ctx.Done():
return
default:
}
line, partialLine, err := input.ReadLine()
if err != nil {
logrus.Debug("stdin is closed")
// bail when STDIN closes
return
}
var parts []string
parts = append(parts, string(line))
for partialLine {
line, partialLine, _ = input.ReadLine()
parts = append(parts, string(line))
}
lines <- strings.Join(parts, "")
}
}()
return lines
} | [
"func",
"tailStdIn",
"(",
"ctx",
"context",
".",
"Context",
")",
"chan",
"string",
"{",
"lines",
":=",
"make",
"(",
"chan",
"string",
")",
"\n",
"input",
":=",
"bufio",
".",
"NewReader",
"(",
"os",
".",
"Stdin",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"lines",
")",
"\n",
"for",
"{",
"// check for signal triggered exit",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"\n",
"default",
":",
"}",
"\n",
"line",
",",
"partialLine",
",",
"err",
":=",
"input",
".",
"ReadLine",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logrus",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"// bail when STDIN closes",
"return",
"\n",
"}",
"\n",
"var",
"parts",
"[",
"]",
"string",
"\n",
"parts",
"=",
"append",
"(",
"parts",
",",
"string",
"(",
"line",
")",
")",
"\n",
"for",
"partialLine",
"{",
"line",
",",
"partialLine",
",",
"_",
"=",
"input",
".",
"ReadLine",
"(",
")",
"\n",
"parts",
"=",
"append",
"(",
"parts",
",",
"string",
"(",
"line",
")",
")",
"\n",
"}",
"\n",
"lines",
"<-",
"strings",
".",
"Join",
"(",
"parts",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"lines",
"\n",
"}"
] | // tailStdIn is a special case to tail STDIN without any of the
// fancy stuff that the tail module provides | [
"tailStdIn",
"is",
"a",
"special",
"case",
"to",
"tail",
"STDIN",
"without",
"any",
"of",
"the",
"fancy",
"stuff",
"that",
"the",
"tail",
"module",
"provides"
] | a4d169e4b0f5204538da680d276e09be979ee26c | https://github.com/honeycombio/honeytail/blob/a4d169e4b0f5204538da680d276e09be979ee26c/tail/tail.go#L257-L285 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.