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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
143,300 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewRSAPKCS15KeyDecrypt
|
func NewRSAPKCS15KeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey, keysize int) *RSAPKCS15KeyDecrypt {
generator := NewRandomKeyGenerate(keysize * 2)
return &RSAPKCS15KeyDecrypt{
alg: alg,
privkey: privkey,
generator: generator,
}
}
|
go
|
func NewRSAPKCS15KeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey, keysize int) *RSAPKCS15KeyDecrypt {
generator := NewRandomKeyGenerate(keysize * 2)
return &RSAPKCS15KeyDecrypt{
alg: alg,
privkey: privkey,
generator: generator,
}
}
|
[
"func",
"NewRSAPKCS15KeyDecrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"privkey",
"*",
"rsa",
".",
"PrivateKey",
",",
"keysize",
"int",
")",
"*",
"RSAPKCS15KeyDecrypt",
"{",
"generator",
":=",
"NewRandomKeyGenerate",
"(",
"keysize",
"*",
"2",
")",
"\n",
"return",
"&",
"RSAPKCS15KeyDecrypt",
"{",
"alg",
":",
"alg",
",",
"privkey",
":",
"privkey",
",",
"generator",
":",
"generator",
",",
"}",
"\n",
"}"
] |
// NewRSAPKCS15KeyDecrypt creates a new decrypter using RSA PKCS1v15
|
[
"NewRSAPKCS15KeyDecrypt",
"creates",
"a",
"new",
"decrypter",
"using",
"RSA",
"PKCS1v15"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L245-L252
|
143,301 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyDecrypt
|
func (d RSAPKCS15KeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
if debug.Enabled {
debug.Printf("START PKCS.KeyDecrypt")
}
// Hey, these notes and workarounds were stolen from go-jose
defer func() {
// DecryptPKCS1v15SessionKey sometimes panics on an invalid payload
// because of an index out of bounds error, which we want to ignore.
// This has been fixed in Go 1.3.1 (released 2014/08/13), the recover()
// only exists for preventing crashes with unpatched versions.
// See: https://groups.google.com/forum/#!topic/golang-dev/7ihX6Y6kx9k
// See: https://code.google.com/p/go/source/detail?r=58ee390ff31602edb66af41ed10901ec95904d33
_ = recover()
}()
// Perform some input validation.
expectedlen := d.privkey.PublicKey.N.BitLen() / 8
if expectedlen != len(enckey) {
// Input size is incorrect, the encrypted payload should always match
// the size of the public modulus (e.g. using a 2048 bit key will
// produce 256 bytes of output). Reject this since it's invalid input.
return nil, fmt.Errorf(
"input size for key decrypt is incorrect (expected %d, got %d)",
expectedlen,
len(enckey),
)
}
var err error
bk, err := d.generator.KeyGenerate()
if err != nil {
return nil, errors.New("failed to generate key")
}
cek := bk.Bytes()
// When decrypting an RSA-PKCS1v1.5 payload, we must take precautions to
// prevent chosen-ciphertext attacks as described in RFC 3218, "Preventing
// the Million Message Attack on Cryptographic Message Syntax". We are
// therefore deliberatly ignoring errors here.
err = rsa.DecryptPKCS1v15SessionKey(rand.Reader, d.privkey, enckey, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to decrypt via PKCS1v15")
}
return cek, nil
}
|
go
|
func (d RSAPKCS15KeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
if debug.Enabled {
debug.Printf("START PKCS.KeyDecrypt")
}
// Hey, these notes and workarounds were stolen from go-jose
defer func() {
// DecryptPKCS1v15SessionKey sometimes panics on an invalid payload
// because of an index out of bounds error, which we want to ignore.
// This has been fixed in Go 1.3.1 (released 2014/08/13), the recover()
// only exists for preventing crashes with unpatched versions.
// See: https://groups.google.com/forum/#!topic/golang-dev/7ihX6Y6kx9k
// See: https://code.google.com/p/go/source/detail?r=58ee390ff31602edb66af41ed10901ec95904d33
_ = recover()
}()
// Perform some input validation.
expectedlen := d.privkey.PublicKey.N.BitLen() / 8
if expectedlen != len(enckey) {
// Input size is incorrect, the encrypted payload should always match
// the size of the public modulus (e.g. using a 2048 bit key will
// produce 256 bytes of output). Reject this since it's invalid input.
return nil, fmt.Errorf(
"input size for key decrypt is incorrect (expected %d, got %d)",
expectedlen,
len(enckey),
)
}
var err error
bk, err := d.generator.KeyGenerate()
if err != nil {
return nil, errors.New("failed to generate key")
}
cek := bk.Bytes()
// When decrypting an RSA-PKCS1v1.5 payload, we must take precautions to
// prevent chosen-ciphertext attacks as described in RFC 3218, "Preventing
// the Million Message Attack on Cryptographic Message Syntax". We are
// therefore deliberatly ignoring errors here.
err = rsa.DecryptPKCS1v15SessionKey(rand.Reader, d.privkey, enckey, cek)
if err != nil {
return nil, errors.Wrap(err, "failed to decrypt via PKCS1v15")
}
return cek, nil
}
|
[
"func",
"(",
"d",
"RSAPKCS15KeyDecrypt",
")",
"KeyDecrypt",
"(",
"enckey",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"debug",
".",
"Enabled",
"{",
"debug",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// Hey, these notes and workarounds were stolen from go-jose",
"defer",
"func",
"(",
")",
"{",
"// DecryptPKCS1v15SessionKey sometimes panics on an invalid payload",
"// because of an index out of bounds error, which we want to ignore.",
"// This has been fixed in Go 1.3.1 (released 2014/08/13), the recover()",
"// only exists for preventing crashes with unpatched versions.",
"// See: https://groups.google.com/forum/#!topic/golang-dev/7ihX6Y6kx9k",
"// See: https://code.google.com/p/go/source/detail?r=58ee390ff31602edb66af41ed10901ec95904d33",
"_",
"=",
"recover",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"// Perform some input validation.",
"expectedlen",
":=",
"d",
".",
"privkey",
".",
"PublicKey",
".",
"N",
".",
"BitLen",
"(",
")",
"/",
"8",
"\n",
"if",
"expectedlen",
"!=",
"len",
"(",
"enckey",
")",
"{",
"// Input size is incorrect, the encrypted payload should always match",
"// the size of the public modulus (e.g. using a 2048 bit key will",
"// produce 256 bytes of output). Reject this since it's invalid input.",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"expectedlen",
",",
"len",
"(",
"enckey",
")",
",",
")",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n\n",
"bk",
",",
"err",
":=",
"d",
".",
"generator",
".",
"KeyGenerate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"cek",
":=",
"bk",
".",
"Bytes",
"(",
")",
"\n\n",
"// When decrypting an RSA-PKCS1v1.5 payload, we must take precautions to",
"// prevent chosen-ciphertext attacks as described in RFC 3218, \"Preventing",
"// the Million Message Attack on Cryptographic Message Syntax\". We are",
"// therefore deliberatly ignoring errors here.",
"err",
"=",
"rsa",
".",
"DecryptPKCS1v15SessionKey",
"(",
"rand",
".",
"Reader",
",",
"d",
".",
"privkey",
",",
"enckey",
",",
"cek",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"cek",
",",
"nil",
"\n",
"}"
] |
// KeyDecrypt decryptes the encrypted key using RSA PKCS1v1.5
|
[
"KeyDecrypt",
"decryptes",
"the",
"encrypted",
"key",
"using",
"RSA",
"PKCS1v1",
".",
"5"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L260-L306
|
143,302 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
NewRSAOAEPKeyDecrypt
|
func NewRSAOAEPKeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey) (*RSAOAEPKeyDecrypt, error) {
switch alg {
case jwa.RSA_OAEP, jwa.RSA_OAEP_256:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA OAEP decrypt algorithm")
}
return &RSAOAEPKeyDecrypt{
alg: alg,
privkey: privkey,
}, nil
}
|
go
|
func NewRSAOAEPKeyDecrypt(alg jwa.KeyEncryptionAlgorithm, privkey *rsa.PrivateKey) (*RSAOAEPKeyDecrypt, error) {
switch alg {
case jwa.RSA_OAEP, jwa.RSA_OAEP_256:
default:
return nil, errors.Wrap(ErrUnsupportedAlgorithm, "invalid RSA OAEP decrypt algorithm")
}
return &RSAOAEPKeyDecrypt{
alg: alg,
privkey: privkey,
}, nil
}
|
[
"func",
"NewRSAOAEPKeyDecrypt",
"(",
"alg",
"jwa",
".",
"KeyEncryptionAlgorithm",
",",
"privkey",
"*",
"rsa",
".",
"PrivateKey",
")",
"(",
"*",
"RSAOAEPKeyDecrypt",
",",
"error",
")",
"{",
"switch",
"alg",
"{",
"case",
"jwa",
".",
"RSA_OAEP",
",",
"jwa",
".",
"RSA_OAEP_256",
":",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"ErrUnsupportedAlgorithm",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"RSAOAEPKeyDecrypt",
"{",
"alg",
":",
"alg",
",",
"privkey",
":",
"privkey",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewRSAOAEPKeyDecrypt creates a new key decrypter using RSA OAEP
|
[
"NewRSAOAEPKeyDecrypt",
"creates",
"a",
"new",
"key",
"decrypter",
"using",
"RSA",
"OAEP"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L309-L320
|
143,303 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
KeyDecrypt
|
func (d RSAOAEPKeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
if debug.Enabled {
debug.Printf("START OAEP.KeyDecrypt")
}
var hash hash.Hash
switch d.alg {
case jwa.RSA_OAEP:
hash = sha1.New()
case jwa.RSA_OAEP_256:
hash = sha256.New()
default:
return nil, errors.New("failed to generate key encrypter for RSA-OAEP: RSA_OAEP/RSA_OAEP_256 required")
}
return rsa.DecryptOAEP(hash, rand.Reader, d.privkey, enckey, []byte{})
}
|
go
|
func (d RSAOAEPKeyDecrypt) KeyDecrypt(enckey []byte) ([]byte, error) {
if debug.Enabled {
debug.Printf("START OAEP.KeyDecrypt")
}
var hash hash.Hash
switch d.alg {
case jwa.RSA_OAEP:
hash = sha1.New()
case jwa.RSA_OAEP_256:
hash = sha256.New()
default:
return nil, errors.New("failed to generate key encrypter for RSA-OAEP: RSA_OAEP/RSA_OAEP_256 required")
}
return rsa.DecryptOAEP(hash, rand.Reader, d.privkey, enckey, []byte{})
}
|
[
"func",
"(",
"d",
"RSAOAEPKeyDecrypt",
")",
"KeyDecrypt",
"(",
"enckey",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"debug",
".",
"Enabled",
"{",
"debug",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"hash",
"hash",
".",
"Hash",
"\n",
"switch",
"d",
".",
"alg",
"{",
"case",
"jwa",
".",
"RSA_OAEP",
":",
"hash",
"=",
"sha1",
".",
"New",
"(",
")",
"\n",
"case",
"jwa",
".",
"RSA_OAEP_256",
":",
"hash",
"=",
"sha256",
".",
"New",
"(",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"rsa",
".",
"DecryptOAEP",
"(",
"hash",
",",
"rand",
".",
"Reader",
",",
"d",
".",
"privkey",
",",
"enckey",
",",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"}"
] |
// KeyDecrypt decryptes the encrypted key using RSA OAEP
|
[
"KeyDecrypt",
"decryptes",
"the",
"encrypted",
"key",
"using",
"RSA",
"OAEP"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L328-L342
|
143,304 |
lestrrat-go/jwx
|
jwe/key_encrypt.go
|
Decrypt
|
func (d DirectDecrypt) Decrypt() ([]byte, error) {
cek := make([]byte, len(d.Key))
copy(cek, d.Key)
return cek, nil
}
|
go
|
func (d DirectDecrypt) Decrypt() ([]byte, error) {
cek := make([]byte, len(d.Key))
copy(cek, d.Key)
return cek, nil
}
|
[
"func",
"(",
"d",
"DirectDecrypt",
")",
"Decrypt",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cek",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"d",
".",
"Key",
")",
")",
"\n",
"copy",
"(",
"cek",
",",
"d",
".",
"Key",
")",
"\n",
"return",
"cek",
",",
"nil",
"\n",
"}"
] |
// Decrypt for DirectDecrypt does not do anything other than
// return a copy of the embedded key
|
[
"Decrypt",
"for",
"DirectDecrypt",
"does",
"not",
"do",
"anything",
"other",
"than",
"return",
"a",
"copy",
"of",
"the",
"embedded",
"key"
] |
0251e8147021ce27b0d3b1812b7c07265fe7a538
|
https://github.com/lestrrat-go/jwx/blob/0251e8147021ce27b0d3b1812b7c07265fe7a538/jwe/key_encrypt.go#L346-L350
|
143,305 |
jrallison/go-workers
|
hooks.go
|
DuringDrain
|
func DuringDrain(f func()) {
access.Lock()
defer access.Unlock()
duringDrain = append(duringDrain, f)
}
|
go
|
func DuringDrain(f func()) {
access.Lock()
defer access.Unlock()
duringDrain = append(duringDrain, f)
}
|
[
"func",
"DuringDrain",
"(",
"f",
"func",
"(",
")",
")",
"{",
"access",
".",
"Lock",
"(",
")",
"\n",
"defer",
"access",
".",
"Unlock",
"(",
")",
"\n",
"duringDrain",
"=",
"append",
"(",
"duringDrain",
",",
"f",
")",
"\n",
"}"
] |
// func AfterStart
// func BeforeQuit
// func AfterQuit
|
[
"func",
"AfterStart",
"func",
"BeforeQuit",
"func",
"AfterQuit"
] |
dbf81d0b75bbe2fd90ef66a07643dd70cb42a88a
|
https://github.com/jrallison/go-workers/blob/dbf81d0b75bbe2fd90ef66a07643dd70cb42a88a/hooks.go#L16-L20
|
143,306 |
eapache/go-resiliency
|
semaphore/semaphore.go
|
New
|
func New(tickets int, timeout time.Duration) *Semaphore {
return &Semaphore{
sem: make(chan struct{}, tickets),
timeout: timeout,
}
}
|
go
|
func New(tickets int, timeout time.Duration) *Semaphore {
return &Semaphore{
sem: make(chan struct{}, tickets),
timeout: timeout,
}
}
|
[
"func",
"New",
"(",
"tickets",
"int",
",",
"timeout",
"time",
".",
"Duration",
")",
"*",
"Semaphore",
"{",
"return",
"&",
"Semaphore",
"{",
"sem",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"tickets",
")",
",",
"timeout",
":",
"timeout",
",",
"}",
"\n",
"}"
] |
// New constructs a new Semaphore with the given ticket-count
// and timeout.
|
[
"New",
"constructs",
"a",
"new",
"Semaphore",
"with",
"the",
"given",
"ticket",
"-",
"count",
"and",
"timeout",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/semaphore/semaphore.go#L21-L26
|
143,307 |
eapache/go-resiliency
|
semaphore/semaphore.go
|
Acquire
|
func (s *Semaphore) Acquire() error {
select {
case s.sem <- struct{}{}:
return nil
case <-time.After(s.timeout):
return ErrNoTickets
}
}
|
go
|
func (s *Semaphore) Acquire() error {
select {
case s.sem <- struct{}{}:
return nil
case <-time.After(s.timeout):
return ErrNoTickets
}
}
|
[
"func",
"(",
"s",
"*",
"Semaphore",
")",
"Acquire",
"(",
")",
"error",
"{",
"select",
"{",
"case",
"s",
".",
"sem",
"<-",
"struct",
"{",
"}",
"{",
"}",
":",
"return",
"nil",
"\n",
"case",
"<-",
"time",
".",
"After",
"(",
"s",
".",
"timeout",
")",
":",
"return",
"ErrNoTickets",
"\n",
"}",
"\n",
"}"
] |
// Acquire tries to acquire a ticket from the semaphore. If it can, it returns nil.
// If it cannot after "timeout" amount of time, it returns ErrNoTickets. It is
// safe to call Acquire concurrently on a single Semaphore.
|
[
"Acquire",
"tries",
"to",
"acquire",
"a",
"ticket",
"from",
"the",
"semaphore",
".",
"If",
"it",
"can",
"it",
"returns",
"nil",
".",
"If",
"it",
"cannot",
"after",
"timeout",
"amount",
"of",
"time",
"it",
"returns",
"ErrNoTickets",
".",
"It",
"is",
"safe",
"to",
"call",
"Acquire",
"concurrently",
"on",
"a",
"single",
"Semaphore",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/semaphore/semaphore.go#L31-L38
|
143,308 |
eapache/go-resiliency
|
breaker/breaker.go
|
New
|
func New(errorThreshold, successThreshold int, timeout time.Duration) *Breaker {
return &Breaker{
errorThreshold: errorThreshold,
successThreshold: successThreshold,
timeout: timeout,
}
}
|
go
|
func New(errorThreshold, successThreshold int, timeout time.Duration) *Breaker {
return &Breaker{
errorThreshold: errorThreshold,
successThreshold: successThreshold,
timeout: timeout,
}
}
|
[
"func",
"New",
"(",
"errorThreshold",
",",
"successThreshold",
"int",
",",
"timeout",
"time",
".",
"Duration",
")",
"*",
"Breaker",
"{",
"return",
"&",
"Breaker",
"{",
"errorThreshold",
":",
"errorThreshold",
",",
"successThreshold",
":",
"successThreshold",
",",
"timeout",
":",
"timeout",
",",
"}",
"\n",
"}"
] |
// New constructs a new circuit-breaker that starts closed.
// From closed, the breaker opens if "errorThreshold" errors are seen
// without an error-free period of at least "timeout". From open, the
// breaker half-closes after "timeout". From half-open, the breaker closes
// after "successThreshold" consecutive successes, or opens on a single error.
|
[
"New",
"constructs",
"a",
"new",
"circuit",
"-",
"breaker",
"that",
"starts",
"closed",
".",
"From",
"closed",
"the",
"breaker",
"opens",
"if",
"errorThreshold",
"errors",
"are",
"seen",
"without",
"an",
"error",
"-",
"free",
"period",
"of",
"at",
"least",
"timeout",
".",
"From",
"open",
"the",
"breaker",
"half",
"-",
"closes",
"after",
"timeout",
".",
"From",
"half",
"-",
"open",
"the",
"breaker",
"closes",
"after",
"successThreshold",
"consecutive",
"successes",
"or",
"opens",
"on",
"a",
"single",
"error",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/breaker/breaker.go#L37-L43
|
143,309 |
eapache/go-resiliency
|
breaker/breaker.go
|
Run
|
func (b *Breaker) Run(work func() error) error {
state := atomic.LoadUint32(&b.state)
if state == open {
return ErrBreakerOpen
}
return b.doWork(state, work)
}
|
go
|
func (b *Breaker) Run(work func() error) error {
state := atomic.LoadUint32(&b.state)
if state == open {
return ErrBreakerOpen
}
return b.doWork(state, work)
}
|
[
"func",
"(",
"b",
"*",
"Breaker",
")",
"Run",
"(",
"work",
"func",
"(",
")",
"error",
")",
"error",
"{",
"state",
":=",
"atomic",
".",
"LoadUint32",
"(",
"&",
"b",
".",
"state",
")",
"\n\n",
"if",
"state",
"==",
"open",
"{",
"return",
"ErrBreakerOpen",
"\n",
"}",
"\n\n",
"return",
"b",
".",
"doWork",
"(",
"state",
",",
"work",
")",
"\n",
"}"
] |
// Run will either return ErrBreakerOpen immediately if the circuit-breaker is
// already open, or it will run the given function and pass along its return
// value. It is safe to call Run concurrently on the same Breaker.
|
[
"Run",
"will",
"either",
"return",
"ErrBreakerOpen",
"immediately",
"if",
"the",
"circuit",
"-",
"breaker",
"is",
"already",
"open",
"or",
"it",
"will",
"run",
"the",
"given",
"function",
"and",
"pass",
"along",
"its",
"return",
"value",
".",
"It",
"is",
"safe",
"to",
"call",
"Run",
"concurrently",
"on",
"the",
"same",
"Breaker",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/breaker/breaker.go#L48-L56
|
143,310 |
eapache/go-resiliency
|
retrier/backoffs.go
|
ConstantBackoff
|
func ConstantBackoff(n int, amount time.Duration) []time.Duration {
ret := make([]time.Duration, n)
for i := range ret {
ret[i] = amount
}
return ret
}
|
go
|
func ConstantBackoff(n int, amount time.Duration) []time.Duration {
ret := make([]time.Duration, n)
for i := range ret {
ret[i] = amount
}
return ret
}
|
[
"func",
"ConstantBackoff",
"(",
"n",
"int",
",",
"amount",
"time",
".",
"Duration",
")",
"[",
"]",
"time",
".",
"Duration",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"time",
".",
"Duration",
",",
"n",
")",
"\n",
"for",
"i",
":=",
"range",
"ret",
"{",
"ret",
"[",
"i",
"]",
"=",
"amount",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
// ConstantBackoff generates a simple back-off strategy of retrying 'n' times, and waiting 'amount' time after each one.
|
[
"ConstantBackoff",
"generates",
"a",
"simple",
"back",
"-",
"off",
"strategy",
"of",
"retrying",
"n",
"times",
"and",
"waiting",
"amount",
"time",
"after",
"each",
"one",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/retrier/backoffs.go#L6-L12
|
143,311 |
eapache/go-resiliency
|
retrier/backoffs.go
|
ExponentialBackoff
|
func ExponentialBackoff(n int, initialAmount time.Duration) []time.Duration {
ret := make([]time.Duration, n)
next := initialAmount
for i := range ret {
ret[i] = next
next *= 2
}
return ret
}
|
go
|
func ExponentialBackoff(n int, initialAmount time.Duration) []time.Duration {
ret := make([]time.Duration, n)
next := initialAmount
for i := range ret {
ret[i] = next
next *= 2
}
return ret
}
|
[
"func",
"ExponentialBackoff",
"(",
"n",
"int",
",",
"initialAmount",
"time",
".",
"Duration",
")",
"[",
"]",
"time",
".",
"Duration",
"{",
"ret",
":=",
"make",
"(",
"[",
"]",
"time",
".",
"Duration",
",",
"n",
")",
"\n",
"next",
":=",
"initialAmount",
"\n",
"for",
"i",
":=",
"range",
"ret",
"{",
"ret",
"[",
"i",
"]",
"=",
"next",
"\n",
"next",
"*=",
"2",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] |
// ExponentialBackoff generates a simple back-off strategy of retrying 'n' times, and doubling the amount of
// time waited after each one.
|
[
"ExponentialBackoff",
"generates",
"a",
"simple",
"back",
"-",
"off",
"strategy",
"of",
"retrying",
"n",
"times",
"and",
"doubling",
"the",
"amount",
"of",
"time",
"waited",
"after",
"each",
"one",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/retrier/backoffs.go#L16-L24
|
143,312 |
eapache/go-resiliency
|
retrier/retrier.go
|
New
|
func New(backoff []time.Duration, class Classifier) *Retrier {
if class == nil {
class = DefaultClassifier{}
}
return &Retrier{
backoff: backoff,
class: class,
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
}
}
|
go
|
func New(backoff []time.Duration, class Classifier) *Retrier {
if class == nil {
class = DefaultClassifier{}
}
return &Retrier{
backoff: backoff,
class: class,
rand: rand.New(rand.NewSource(time.Now().UnixNano())),
}
}
|
[
"func",
"New",
"(",
"backoff",
"[",
"]",
"time",
".",
"Duration",
",",
"class",
"Classifier",
")",
"*",
"Retrier",
"{",
"if",
"class",
"==",
"nil",
"{",
"class",
"=",
"DefaultClassifier",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"Retrier",
"{",
"backoff",
":",
"backoff",
",",
"class",
":",
"class",
",",
"rand",
":",
"rand",
".",
"New",
"(",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
")",
",",
"}",
"\n",
"}"
] |
// New constructs a Retrier with the given backoff pattern and classifier. The length of the backoff pattern
// indicates how many times an action will be retried, and the value at each index indicates the amount of time
// waited before each subsequent retry. The classifier is used to determine which errors should be retried and
// which should cause the retrier to fail fast. The DefaultClassifier is used if nil is passed.
|
[
"New",
"constructs",
"a",
"Retrier",
"with",
"the",
"given",
"backoff",
"pattern",
"and",
"classifier",
".",
"The",
"length",
"of",
"the",
"backoff",
"pattern",
"indicates",
"how",
"many",
"times",
"an",
"action",
"will",
"be",
"retried",
"and",
"the",
"value",
"at",
"each",
"index",
"indicates",
"the",
"amount",
"of",
"time",
"waited",
"before",
"each",
"subsequent",
"retry",
".",
"The",
"classifier",
"is",
"used",
"to",
"determine",
"which",
"errors",
"should",
"be",
"retried",
"and",
"which",
"should",
"cause",
"the",
"retrier",
"to",
"fail",
"fast",
".",
"The",
"DefaultClassifier",
"is",
"used",
"if",
"nil",
"is",
"passed",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/retrier/retrier.go#L25-L35
|
143,313 |
eapache/go-resiliency
|
retrier/retrier.go
|
Run
|
func (r *Retrier) Run(work func() error) error {
return r.RunCtx(context.Background(), func(ctx context.Context) error {
// never use ctx
return work()
})
}
|
go
|
func (r *Retrier) Run(work func() error) error {
return r.RunCtx(context.Background(), func(ctx context.Context) error {
// never use ctx
return work()
})
}
|
[
"func",
"(",
"r",
"*",
"Retrier",
")",
"Run",
"(",
"work",
"func",
"(",
")",
"error",
")",
"error",
"{",
"return",
"r",
".",
"RunCtx",
"(",
"context",
".",
"Background",
"(",
")",
",",
"func",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"// never use ctx",
"return",
"work",
"(",
")",
"\n",
"}",
")",
"\n",
"}"
] |
// Run executes the given work function by executing RunCtx without context.Context.
|
[
"Run",
"executes",
"the",
"given",
"work",
"function",
"by",
"executing",
"RunCtx",
"without",
"context",
".",
"Context",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/retrier/retrier.go#L38-L43
|
143,314 |
eapache/go-resiliency
|
retrier/retrier.go
|
RunCtx
|
func (r *Retrier) RunCtx(ctx context.Context, work func(ctx context.Context) error) error {
retries := 0
for {
ret := work(ctx)
switch r.class.Classify(ret) {
case Succeed, Fail:
return ret
case Retry:
if retries >= len(r.backoff) {
return ret
}
timeout := time.After(r.calcSleep(retries))
if err := r.sleep(ctx, timeout); err != nil {
return err
}
retries++
}
}
}
|
go
|
func (r *Retrier) RunCtx(ctx context.Context, work func(ctx context.Context) error) error {
retries := 0
for {
ret := work(ctx)
switch r.class.Classify(ret) {
case Succeed, Fail:
return ret
case Retry:
if retries >= len(r.backoff) {
return ret
}
timeout := time.After(r.calcSleep(retries))
if err := r.sleep(ctx, timeout); err != nil {
return err
}
retries++
}
}
}
|
[
"func",
"(",
"r",
"*",
"Retrier",
")",
"RunCtx",
"(",
"ctx",
"context",
".",
"Context",
",",
"work",
"func",
"(",
"ctx",
"context",
".",
"Context",
")",
"error",
")",
"error",
"{",
"retries",
":=",
"0",
"\n",
"for",
"{",
"ret",
":=",
"work",
"(",
"ctx",
")",
"\n\n",
"switch",
"r",
".",
"class",
".",
"Classify",
"(",
"ret",
")",
"{",
"case",
"Succeed",
",",
"Fail",
":",
"return",
"ret",
"\n",
"case",
"Retry",
":",
"if",
"retries",
">=",
"len",
"(",
"r",
".",
"backoff",
")",
"{",
"return",
"ret",
"\n",
"}",
"\n\n",
"timeout",
":=",
"time",
".",
"After",
"(",
"r",
".",
"calcSleep",
"(",
"retries",
")",
")",
"\n",
"if",
"err",
":=",
"r",
".",
"sleep",
"(",
"ctx",
",",
"timeout",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"retries",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// RunCtx executes the given work function, then classifies its return value based on the classifier used
// to construct the Retrier. If the result is Succeed or Fail, the return value of the work function is
// returned to the caller. If the result is Retry, then Run sleeps according to the its backoff policy
// before retrying. If the total number of retries is exceeded then the return value of the work function
// is returned to the caller regardless.
|
[
"RunCtx",
"executes",
"the",
"given",
"work",
"function",
"then",
"classifies",
"its",
"return",
"value",
"based",
"on",
"the",
"classifier",
"used",
"to",
"construct",
"the",
"Retrier",
".",
"If",
"the",
"result",
"is",
"Succeed",
"or",
"Fail",
"the",
"return",
"value",
"of",
"the",
"work",
"function",
"is",
"returned",
"to",
"the",
"caller",
".",
"If",
"the",
"result",
"is",
"Retry",
"then",
"Run",
"sleeps",
"according",
"to",
"the",
"its",
"backoff",
"policy",
"before",
"retrying",
".",
"If",
"the",
"total",
"number",
"of",
"retries",
"is",
"exceeded",
"then",
"the",
"return",
"value",
"of",
"the",
"work",
"function",
"is",
"returned",
"to",
"the",
"caller",
"regardless",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/retrier/retrier.go#L50-L71
|
143,315 |
eapache/go-resiliency
|
batcher/batcher.go
|
New
|
func New(timeout time.Duration, doWork func([]interface{}) error) *Batcher {
return &Batcher{
timeout: timeout,
doWork: doWork,
}
}
|
go
|
func New(timeout time.Duration, doWork func([]interface{}) error) *Batcher {
return &Batcher{
timeout: timeout,
doWork: doWork,
}
}
|
[
"func",
"New",
"(",
"timeout",
"time",
".",
"Duration",
",",
"doWork",
"func",
"(",
"[",
"]",
"interface",
"{",
"}",
")",
"error",
")",
"*",
"Batcher",
"{",
"return",
"&",
"Batcher",
"{",
"timeout",
":",
"timeout",
",",
"doWork",
":",
"doWork",
",",
"}",
"\n",
"}"
] |
// New constructs a new batcher that will batch all calls to Run that occur within
// `timeout` time before calling doWork just once for the entire batch. The doWork
// function must be safe to run concurrently with itself as this may occur, especially
// when the timeout is small.
|
[
"New",
"constructs",
"a",
"new",
"batcher",
"that",
"will",
"batch",
"all",
"calls",
"to",
"Run",
"that",
"occur",
"within",
"timeout",
"time",
"before",
"calling",
"doWork",
"just",
"once",
"for",
"the",
"entire",
"batch",
".",
"The",
"doWork",
"function",
"must",
"be",
"safe",
"to",
"run",
"concurrently",
"with",
"itself",
"as",
"this",
"may",
"occur",
"especially",
"when",
"the",
"timeout",
"is",
"small",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/batcher/batcher.go#L28-L33
|
143,316 |
eapache/go-resiliency
|
batcher/batcher.go
|
Run
|
func (b *Batcher) Run(param interface{}) error {
if b.prefilter != nil {
if err := b.prefilter(param); err != nil {
return err
}
}
if b.timeout == 0 {
return b.doWork([]interface{}{param})
}
w := &work{
param: param,
future: make(chan error, 1),
}
b.submitWork(w)
return <-w.future
}
|
go
|
func (b *Batcher) Run(param interface{}) error {
if b.prefilter != nil {
if err := b.prefilter(param); err != nil {
return err
}
}
if b.timeout == 0 {
return b.doWork([]interface{}{param})
}
w := &work{
param: param,
future: make(chan error, 1),
}
b.submitWork(w)
return <-w.future
}
|
[
"func",
"(",
"b",
"*",
"Batcher",
")",
"Run",
"(",
"param",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"b",
".",
"prefilter",
"!=",
"nil",
"{",
"if",
"err",
":=",
"b",
".",
"prefilter",
"(",
"param",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"b",
".",
"timeout",
"==",
"0",
"{",
"return",
"b",
".",
"doWork",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"param",
"}",
")",
"\n",
"}",
"\n\n",
"w",
":=",
"&",
"work",
"{",
"param",
":",
"param",
",",
"future",
":",
"make",
"(",
"chan",
"error",
",",
"1",
")",
",",
"}",
"\n\n",
"b",
".",
"submitWork",
"(",
"w",
")",
"\n\n",
"return",
"<-",
"w",
".",
"future",
"\n",
"}"
] |
// Run runs the work function with the given parameter, possibly
// including it in a batch with other calls to Run that occur within the
// specified timeout. It is safe to call Run concurrently on the same batcher.
|
[
"Run",
"runs",
"the",
"work",
"function",
"with",
"the",
"given",
"parameter",
"possibly",
"including",
"it",
"in",
"a",
"batch",
"with",
"other",
"calls",
"to",
"Run",
"that",
"occur",
"within",
"the",
"specified",
"timeout",
".",
"It",
"is",
"safe",
"to",
"call",
"Run",
"concurrently",
"on",
"the",
"same",
"batcher",
"."
] |
842e16ec2c98ef0c59eebfe60d2d3500a793ba19
|
https://github.com/eapache/go-resiliency/blob/842e16ec2c98ef0c59eebfe60d2d3500a793ba19/batcher/batcher.go#L38-L57
|
143,317 |
pebbe/zmq4
|
examples/kvsimple/kvsimple.go
|
NewKvmsg
|
func NewKvmsg(sequence int64) (kvmsg *Kvmsg) {
kvmsg = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
}
kvmsg.SetSequence(sequence)
return
}
|
go
|
func NewKvmsg(sequence int64) (kvmsg *Kvmsg) {
kvmsg = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
}
kvmsg.SetSequence(sequence)
return
}
|
[
"func",
"NewKvmsg",
"(",
"sequence",
"int64",
")",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"{",
"kvmsg",
"=",
"&",
"Kvmsg",
"{",
"present",
":",
"make",
"(",
"[",
"]",
"bool",
",",
"kvmsg_FRAMES",
")",
",",
"frame",
":",
"make",
"(",
"[",
"]",
"string",
",",
"kvmsg_FRAMES",
")",
",",
"}",
"\n",
"kvmsg",
".",
"SetSequence",
"(",
"sequence",
")",
"\n",
"return",
"\n",
"}"
] |
// Constructor, takes a sequence number for the new Kvmsg instance.
|
[
"Constructor",
"takes",
"a",
"sequence",
"number",
"for",
"the",
"new",
"Kvmsg",
"instance",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvsimple/kvsimple.go#L31-L38
|
143,318 |
pebbe/zmq4
|
examples/kvsimple/kvsimple.go
|
Size
|
func (kvmsg *Kvmsg) Size() int {
if kvmsg.present[frame_BODY] {
return len(kvmsg.frame[frame_BODY])
}
return 0
}
|
go
|
func (kvmsg *Kvmsg) Size() int {
if kvmsg.present[frame_BODY] {
return len(kvmsg.frame[frame_BODY])
}
return 0
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"Size",
"(",
")",
"int",
"{",
"if",
"kvmsg",
".",
"present",
"[",
"frame_BODY",
"]",
"{",
"return",
"len",
"(",
"kvmsg",
".",
"frame",
"[",
"frame_BODY",
"]",
")",
"\n",
"}",
"\n",
"return",
"0",
"\n",
"}"
] |
// The size method returns the body size of the last-read message, if any.
|
[
"The",
"size",
"method",
"returns",
"the",
"body",
"size",
"of",
"the",
"last",
"-",
"read",
"message",
"if",
"any",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvsimple/kvsimple.go#L128-L133
|
143,319 |
pebbe/zmq4
|
examples/kvsimple/kvsimple.go
|
Dump
|
func (kvmsg *Kvmsg) Dump() {
size := kvmsg.Size()
body, _ := kvmsg.GetBody()
seq, _ := kvmsg.GetSequence()
key, _ := kvmsg.GetKey()
fmt.Fprintf(os.Stderr, "[seq:%v][key:%v][size:%v]", seq, key, size)
for char_nbr := 0; char_nbr < size; char_nbr++ {
fmt.Fprintf(os.Stderr, "%02X", body[char_nbr])
}
fmt.Fprintln(os.Stderr)
}
|
go
|
func (kvmsg *Kvmsg) Dump() {
size := kvmsg.Size()
body, _ := kvmsg.GetBody()
seq, _ := kvmsg.GetSequence()
key, _ := kvmsg.GetKey()
fmt.Fprintf(os.Stderr, "[seq:%v][key:%v][size:%v]", seq, key, size)
for char_nbr := 0; char_nbr < size; char_nbr++ {
fmt.Fprintf(os.Stderr, "%02X", body[char_nbr])
}
fmt.Fprintln(os.Stderr)
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"Dump",
"(",
")",
"{",
"size",
":=",
"kvmsg",
".",
"Size",
"(",
")",
"\n",
"body",
",",
"_",
":=",
"kvmsg",
".",
"GetBody",
"(",
")",
"\n",
"seq",
",",
"_",
":=",
"kvmsg",
".",
"GetSequence",
"(",
")",
"\n",
"key",
",",
"_",
":=",
"kvmsg",
".",
"GetKey",
"(",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"seq",
",",
"key",
",",
"size",
")",
"\n",
"for",
"char_nbr",
":=",
"0",
";",
"char_nbr",
"<",
"size",
";",
"char_nbr",
"++",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"body",
"[",
"char_nbr",
"]",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
")",
"\n",
"}"
] |
// The dump method prints the key-value message to stderr,
// for debugging and tracing.
|
[
"The",
"dump",
"method",
"prints",
"the",
"key",
"-",
"value",
"message",
"to",
"stderr",
"for",
"debugging",
"and",
"tracing",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvsimple/kvsimple.go#L145-L155
|
143,320 |
pebbe/zmq4
|
examples/ppqueue.go
|
s_worker_new
|
func s_worker_new(identity string) worker_t {
return worker_t{
identity: identity,
id_string: identity,
expire: time.Now().Add(HEARTBEAT_INTERVAL * HEARTBEAT_LIVENESS),
}
}
|
go
|
func s_worker_new(identity string) worker_t {
return worker_t{
identity: identity,
id_string: identity,
expire: time.Now().Add(HEARTBEAT_INTERVAL * HEARTBEAT_LIVENESS),
}
}
|
[
"func",
"s_worker_new",
"(",
"identity",
"string",
")",
"worker_t",
"{",
"return",
"worker_t",
"{",
"identity",
":",
"identity",
",",
"id_string",
":",
"identity",
",",
"expire",
":",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"HEARTBEAT_INTERVAL",
"*",
"HEARTBEAT_LIVENESS",
")",
",",
"}",
"\n",
"}"
] |
// Construct new worker
|
[
"Construct",
"new",
"worker"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/ppqueue.go#L32-L38
|
143,321 |
pebbe/zmq4
|
examples/ppqueue.go
|
unwrap
|
func unwrap(msg []string) (head string, tail []string) {
head = msg[0]
if len(msg) > 1 && msg[1] == "" {
tail = msg[2:]
} else {
tail = msg[1:]
}
return
}
|
go
|
func unwrap(msg []string) (head string, tail []string) {
head = msg[0]
if len(msg) > 1 && msg[1] == "" {
tail = msg[2:]
} else {
tail = msg[1:]
}
return
}
|
[
"func",
"unwrap",
"(",
"msg",
"[",
"]",
"string",
")",
"(",
"head",
"string",
",",
"tail",
"[",
"]",
"string",
")",
"{",
"head",
"=",
"msg",
"[",
"0",
"]",
"\n",
"if",
"len",
"(",
"msg",
")",
">",
"1",
"&&",
"msg",
"[",
"1",
"]",
"==",
"\"",
"\"",
"{",
"tail",
"=",
"msg",
"[",
"2",
":",
"]",
"\n",
"}",
"else",
"{",
"tail",
"=",
"msg",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Pops frame off front of message and returns it as 'head'
// If next frame is empty, pops that empty frame.
// Return remaining frames of message as 'tail'
|
[
"Pops",
"frame",
"off",
"front",
"of",
"message",
"and",
"returns",
"it",
"as",
"head",
"If",
"next",
"frame",
"is",
"empty",
"pops",
"that",
"empty",
"frame",
".",
"Return",
"remaining",
"frames",
"of",
"message",
"as",
"tail"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/ppqueue.go#L158-L166
|
143,322 |
pebbe/zmq4
|
draft/zmq4.go
|
Version
|
func Version() (major, minor, patch int) {
if initVersionError != nil {
return 0, 0, 0
}
var maj, min, pat C.int
C.zmq_version(&maj, &min, &pat)
return int(maj), int(min), int(pat)
}
|
go
|
func Version() (major, minor, patch int) {
if initVersionError != nil {
return 0, 0, 0
}
var maj, min, pat C.int
C.zmq_version(&maj, &min, &pat)
return int(maj), int(min), int(pat)
}
|
[
"func",
"Version",
"(",
")",
"(",
"major",
",",
"minor",
",",
"patch",
"int",
")",
"{",
"if",
"initVersionError",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"0",
"\n",
"}",
"\n",
"var",
"maj",
",",
"min",
",",
"pat",
"C",
".",
"int",
"\n",
"C",
".",
"zmq_version",
"(",
"&",
"maj",
",",
"&",
"min",
",",
"&",
"pat",
")",
"\n",
"return",
"int",
"(",
"maj",
")",
",",
"int",
"(",
"min",
")",
",",
"int",
"(",
"pat",
")",
"\n",
"}"
] |
//. Util
// Report 0MQ library version.
|
[
".",
"Util",
"Report",
"0MQ",
"library",
"version",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L159-L166
|
143,323 |
pebbe/zmq4
|
draft/zmq4.go
|
Error
|
func Error(e int) string {
return C.GoString(C.zmq_strerror(C.int(e)))
}
|
go
|
func Error(e int) string {
return C.GoString(C.zmq_strerror(C.int(e)))
}
|
[
"func",
"Error",
"(",
"e",
"int",
")",
"string",
"{",
"return",
"C",
".",
"GoString",
"(",
"C",
".",
"zmq_strerror",
"(",
"C",
".",
"int",
"(",
"e",
")",
")",
")",
"\n",
"}"
] |
// Get 0MQ error message string.
|
[
"Get",
"0MQ",
"error",
"message",
"string",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L169-L171
|
143,324 |
pebbe/zmq4
|
draft/zmq4.go
|
GetIoThreads
|
func GetIoThreads() (int, error) {
if initVersionError != nil {
return 0, initVersionError
}
if initContextError != nil {
return 0, initContextError
}
return defaultCtx.GetIoThreads()
}
|
go
|
func GetIoThreads() (int, error) {
if initVersionError != nil {
return 0, initVersionError
}
if initContextError != nil {
return 0, initContextError
}
return defaultCtx.GetIoThreads()
}
|
[
"func",
"GetIoThreads",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"initVersionError",
"!=",
"nil",
"{",
"return",
"0",
",",
"initVersionError",
"\n",
"}",
"\n",
"if",
"initContextError",
"!=",
"nil",
"{",
"return",
"0",
",",
"initContextError",
"\n",
"}",
"\n",
"return",
"defaultCtx",
".",
"GetIoThreads",
"(",
")",
"\n",
"}"
] |
// Returns the size of the 0MQ thread pool in the default context.
|
[
"Returns",
"the",
"size",
"of",
"the",
"0MQ",
"thread",
"pool",
"in",
"the",
"default",
"context",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L251-L259
|
143,325 |
pebbe/zmq4
|
draft/zmq4.go
|
GetMaxSockets
|
func GetMaxSockets() (int, error) {
if initVersionError != nil {
return 0, initVersionError
}
if initContextError != nil {
return 0, initContextError
}
return defaultCtx.GetMaxSockets()
}
|
go
|
func GetMaxSockets() (int, error) {
if initVersionError != nil {
return 0, initVersionError
}
if initContextError != nil {
return 0, initContextError
}
return defaultCtx.GetMaxSockets()
}
|
[
"func",
"GetMaxSockets",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"initVersionError",
"!=",
"nil",
"{",
"return",
"0",
",",
"initVersionError",
"\n",
"}",
"\n",
"if",
"initContextError",
"!=",
"nil",
"{",
"return",
"0",
",",
"initContextError",
"\n",
"}",
"\n",
"return",
"defaultCtx",
".",
"GetMaxSockets",
"(",
")",
"\n",
"}"
] |
// Returns the maximum number of sockets allowed in the default context.
|
[
"Returns",
"the",
"maximum",
"number",
"of",
"sockets",
"allowed",
"in",
"the",
"default",
"context",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L267-L275
|
143,326 |
pebbe/zmq4
|
draft/zmq4.go
|
GetIpv6
|
func GetIpv6() (bool, error) {
if initVersionError != nil {
return false, initVersionError
}
if initContextError != nil {
return false, initContextError
}
return defaultCtx.GetIpv6()
}
|
go
|
func GetIpv6() (bool, error) {
if initVersionError != nil {
return false, initVersionError
}
if initContextError != nil {
return false, initContextError
}
return defaultCtx.GetIpv6()
}
|
[
"func",
"GetIpv6",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"initVersionError",
"!=",
"nil",
"{",
"return",
"false",
",",
"initVersionError",
"\n",
"}",
"\n",
"if",
"initContextError",
"!=",
"nil",
"{",
"return",
"false",
",",
"initContextError",
"\n",
"}",
"\n",
"return",
"defaultCtx",
".",
"GetIpv6",
"(",
")",
"\n",
"}"
] |
// Returns the IPv6 option in the default context.
|
[
"Returns",
"the",
"IPv6",
"option",
"in",
"the",
"default",
"context",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L310-L318
|
143,327 |
pebbe/zmq4
|
draft/zmq4.go
|
GetIpv6
|
func (ctx *Context) GetIpv6() (bool, error) {
i, e := getOption(ctx, C.ZMQ_IPV6)
if i == 0 {
return false, e
}
return true, e
}
|
go
|
func (ctx *Context) GetIpv6() (bool, error) {
i, e := getOption(ctx, C.ZMQ_IPV6)
if i == 0 {
return false, e
}
return true, e
}
|
[
"func",
"(",
"ctx",
"*",
"Context",
")",
"GetIpv6",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"i",
",",
"e",
":=",
"getOption",
"(",
"ctx",
",",
"C",
".",
"ZMQ_IPV6",
")",
"\n",
"if",
"i",
"==",
"0",
"{",
"return",
"false",
",",
"e",
"\n",
"}",
"\n",
"return",
"true",
",",
"e",
"\n",
"}"
] |
// Returns the IPv6 option.
|
[
"Returns",
"the",
"IPv6",
"option",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L321-L327
|
143,328 |
pebbe/zmq4
|
draft/zmq4.go
|
Close
|
func (soc *Socket) Close() error {
if soc.opened {
soc.opened = false
if i, err := C.zmq_close(soc.soc); int(i) != 0 {
soc.err = errget(err)
}
soc.soc = unsafe.Pointer(nil)
soc.ctx = nil
}
return soc.err
}
|
go
|
func (soc *Socket) Close() error {
if soc.opened {
soc.opened = false
if i, err := C.zmq_close(soc.soc); int(i) != 0 {
soc.err = errget(err)
}
soc.soc = unsafe.Pointer(nil)
soc.ctx = nil
}
return soc.err
}
|
[
"func",
"(",
"soc",
"*",
"Socket",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"soc",
".",
"opened",
"{",
"soc",
".",
"opened",
"=",
"false",
"\n",
"if",
"i",
",",
"err",
":=",
"C",
".",
"zmq_close",
"(",
"soc",
".",
"soc",
")",
";",
"int",
"(",
"i",
")",
"!=",
"0",
"{",
"soc",
".",
"err",
"=",
"errget",
"(",
"err",
")",
"\n",
"}",
"\n",
"soc",
".",
"soc",
"=",
"unsafe",
".",
"Pointer",
"(",
"nil",
")",
"\n",
"soc",
".",
"ctx",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"soc",
".",
"err",
"\n",
"}"
] |
// If not called explicitly, the socket will be closed on garbage collection
|
[
"If",
"not",
"called",
"explicitly",
"the",
"socket",
"will",
"be",
"closed",
"on",
"garbage",
"collection"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L881-L891
|
143,329 |
pebbe/zmq4
|
draft/zmq4.go
|
Context
|
func (soc *Socket) Context() (*Context, error) {
if !soc.opened {
return nil, ErrorSocketClosed
}
return soc.ctx, nil
}
|
go
|
func (soc *Socket) Context() (*Context, error) {
if !soc.opened {
return nil, ErrorSocketClosed
}
return soc.ctx, nil
}
|
[
"func",
"(",
"soc",
"*",
"Socket",
")",
"Context",
"(",
")",
"(",
"*",
"Context",
",",
"error",
")",
"{",
"if",
"!",
"soc",
".",
"opened",
"{",
"return",
"nil",
",",
"ErrorSocketClosed",
"\n",
"}",
"\n",
"return",
"soc",
".",
"ctx",
",",
"nil",
"\n",
"}"
] |
// Return the context associated with a socket
|
[
"Return",
"the",
"context",
"associated",
"with",
"a",
"socket"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/draft/zmq4.go#L894-L899
|
143,330 |
pebbe/zmq4
|
examples/clonesrv4.go
|
main
|
func main() {
snapshot, _ := zmq.NewSocket(zmq.ROUTER)
snapshot.Bind("tcp://*:5556")
publisher, _ := zmq.NewSocket(zmq.PUB)
publisher.Bind("tcp://*:5557")
collector, _ := zmq.NewSocket(zmq.PULL)
collector.Bind("tcp://*:5558")
// The body of the main task collects updates from clients and
// publishes them back out to clients:
sequence := int64(0)
kvmap := make(map[string]*kvsimple.Kvmsg)
poller := zmq.NewPoller()
poller.Add(collector, zmq.POLLIN)
poller.Add(snapshot, zmq.POLLIN)
LOOP:
for {
polled, err := poller.Poll(1000 * time.Millisecond)
if err != nil {
break
}
for _, item := range polled {
switch socket := item.Socket; socket {
case collector:
// Apply state update sent from client
kvmsg, err := kvsimple.RecvKvmsg(collector)
if err != nil {
break LOOP // Interrupted
}
sequence++
kvmsg.SetSequence(sequence)
kvmsg.Send(publisher)
kvmsg.Store(kvmap)
fmt.Println("I: publishing update", sequence)
case snapshot:
// Execute state snapshot request
msg, err := snapshot.RecvMessage(0)
if err != nil {
break LOOP
}
identity := msg[0]
// Request is in second frame of message
request := msg[1]
if request != "ICANHAZ?" {
fmt.Println("E: bad request, aborting")
break LOOP
}
subtree := msg[2]
// Send state snapshot to client
// For each entry in kvmap, send kvmsg to client
for _, kvmsg := range kvmap {
if key, _ := kvmsg.GetKey(); strings.HasPrefix(key, subtree) {
snapshot.Send(identity, zmq.SNDMORE)
kvmsg.Send(snapshot)
}
}
// Now send END message with sequence number
fmt.Println("I: sending shapshot =", sequence)
snapshot.Send(identity, zmq.SNDMORE)
kvmsg := kvsimple.NewKvmsg(sequence)
kvmsg.SetKey("KTHXBAI")
kvmsg.SetBody(subtree)
kvmsg.Send(snapshot)
}
}
}
fmt.Printf("Interrupted\n%d messages handled\n", sequence)
}
|
go
|
func main() {
snapshot, _ := zmq.NewSocket(zmq.ROUTER)
snapshot.Bind("tcp://*:5556")
publisher, _ := zmq.NewSocket(zmq.PUB)
publisher.Bind("tcp://*:5557")
collector, _ := zmq.NewSocket(zmq.PULL)
collector.Bind("tcp://*:5558")
// The body of the main task collects updates from clients and
// publishes them back out to clients:
sequence := int64(0)
kvmap := make(map[string]*kvsimple.Kvmsg)
poller := zmq.NewPoller()
poller.Add(collector, zmq.POLLIN)
poller.Add(snapshot, zmq.POLLIN)
LOOP:
for {
polled, err := poller.Poll(1000 * time.Millisecond)
if err != nil {
break
}
for _, item := range polled {
switch socket := item.Socket; socket {
case collector:
// Apply state update sent from client
kvmsg, err := kvsimple.RecvKvmsg(collector)
if err != nil {
break LOOP // Interrupted
}
sequence++
kvmsg.SetSequence(sequence)
kvmsg.Send(publisher)
kvmsg.Store(kvmap)
fmt.Println("I: publishing update", sequence)
case snapshot:
// Execute state snapshot request
msg, err := snapshot.RecvMessage(0)
if err != nil {
break LOOP
}
identity := msg[0]
// Request is in second frame of message
request := msg[1]
if request != "ICANHAZ?" {
fmt.Println("E: bad request, aborting")
break LOOP
}
subtree := msg[2]
// Send state snapshot to client
// For each entry in kvmap, send kvmsg to client
for _, kvmsg := range kvmap {
if key, _ := kvmsg.GetKey(); strings.HasPrefix(key, subtree) {
snapshot.Send(identity, zmq.SNDMORE)
kvmsg.Send(snapshot)
}
}
// Now send END message with sequence number
fmt.Println("I: sending shapshot =", sequence)
snapshot.Send(identity, zmq.SNDMORE)
kvmsg := kvsimple.NewKvmsg(sequence)
kvmsg.SetKey("KTHXBAI")
kvmsg.SetBody(subtree)
kvmsg.Send(snapshot)
}
}
}
fmt.Printf("Interrupted\n%d messages handled\n", sequence)
}
|
[
"func",
"main",
"(",
")",
"{",
"snapshot",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"ROUTER",
")",
"\n",
"snapshot",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n",
"publisher",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"PUB",
")",
"\n",
"publisher",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n",
"collector",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"PULL",
")",
"\n",
"collector",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n\n",
"// The body of the main task collects updates from clients and",
"// publishes them back out to clients:",
"sequence",
":=",
"int64",
"(",
"0",
")",
"\n",
"kvmap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"kvsimple",
".",
"Kvmsg",
")",
"\n\n",
"poller",
":=",
"zmq",
".",
"NewPoller",
"(",
")",
"\n",
"poller",
".",
"Add",
"(",
"collector",
",",
"zmq",
".",
"POLLIN",
")",
"\n",
"poller",
".",
"Add",
"(",
"snapshot",
",",
"zmq",
".",
"POLLIN",
")",
"\n",
"LOOP",
":",
"for",
"{",
"polled",
",",
"err",
":=",
"poller",
".",
"Poll",
"(",
"1000",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"for",
"_",
",",
"item",
":=",
"range",
"polled",
"{",
"switch",
"socket",
":=",
"item",
".",
"Socket",
";",
"socket",
"{",
"case",
"collector",
":",
"// Apply state update sent from client",
"kvmsg",
",",
"err",
":=",
"kvsimple",
".",
"RecvKvmsg",
"(",
"collector",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"LOOP",
"// Interrupted",
"\n",
"}",
"\n",
"sequence",
"++",
"\n",
"kvmsg",
".",
"SetSequence",
"(",
"sequence",
")",
"\n",
"kvmsg",
".",
"Send",
"(",
"publisher",
")",
"\n",
"kvmsg",
".",
"Store",
"(",
"kvmap",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"sequence",
")",
"\n",
"case",
"snapshot",
":",
"// Execute state snapshot request",
"msg",
",",
"err",
":=",
"snapshot",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"LOOP",
"\n",
"}",
"\n",
"identity",
":=",
"msg",
"[",
"0",
"]",
"\n\n",
"// Request is in second frame of message",
"request",
":=",
"msg",
"[",
"1",
"]",
"\n",
"if",
"request",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"break",
"LOOP",
"\n",
"}",
"\n",
"subtree",
":=",
"msg",
"[",
"2",
"]",
"\n",
"// Send state snapshot to client",
"// For each entry in kvmap, send kvmsg to client",
"for",
"_",
",",
"kvmsg",
":=",
"range",
"kvmap",
"{",
"if",
"key",
",",
"_",
":=",
"kvmsg",
".",
"GetKey",
"(",
")",
";",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"subtree",
")",
"{",
"snapshot",
".",
"Send",
"(",
"identity",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"kvmsg",
".",
"Send",
"(",
"snapshot",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Now send END message with sequence number",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"sequence",
")",
"\n",
"snapshot",
".",
"Send",
"(",
"identity",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"kvmsg",
":=",
"kvsimple",
".",
"NewKvmsg",
"(",
"sequence",
")",
"\n",
"kvmsg",
".",
"SetKey",
"(",
"\"",
"\"",
")",
"\n",
"kvmsg",
".",
"SetBody",
"(",
"subtree",
")",
"\n",
"kvmsg",
".",
"Send",
"(",
"snapshot",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"sequence",
")",
"\n",
"}"
] |
// The main task is identical to clonesrv3 except for where it
// handles subtrees.
|
[
"The",
"main",
"task",
"is",
"identical",
"to",
"clonesrv3",
"except",
"for",
"where",
"it",
"handles",
"subtrees",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/clonesrv4.go#L19-L91
|
143,331 |
pebbe/zmq4
|
examples/intface/intface.go
|
control_message
|
func (agent *agent_t) control_message() (err error) {
// Get the whole message off the pipe in one go
msg, e := agent.pipe.RecvMessage(0)
if e != nil {
return e
}
command := msg[0]
// We don't actually implement any control commands yet
// but if we did, this would be where we did it..
switch command {
case "EXAMPLE":
default:
}
return
}
|
go
|
func (agent *agent_t) control_message() (err error) {
// Get the whole message off the pipe in one go
msg, e := agent.pipe.RecvMessage(0)
if e != nil {
return e
}
command := msg[0]
// We don't actually implement any control commands yet
// but if we did, this would be where we did it..
switch command {
case "EXAMPLE":
default:
}
return
}
|
[
"func",
"(",
"agent",
"*",
"agent_t",
")",
"control_message",
"(",
")",
"(",
"err",
"error",
")",
"{",
"// Get the whole message off the pipe in one go",
"msg",
",",
"e",
":=",
"agent",
".",
"pipe",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"return",
"e",
"\n",
"}",
"\n",
"command",
":=",
"msg",
"[",
"0",
"]",
"\n\n",
"// We don't actually implement any control commands yet",
"// but if we did, this would be where we did it..",
"switch",
"command",
"{",
"case",
"\"",
"\"",
":",
"default",
":",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Here we handle the different control messages from the front-end.
|
[
"Here",
"we",
"handle",
"the",
"different",
"control",
"messages",
"from",
"the",
"front",
"-",
"end",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/intface/intface.go#L145-L161
|
143,332 |
pebbe/zmq4
|
examples/ppworker.go
|
s_worker_socket
|
func s_worker_socket() (*zmq.Socket, *zmq.Poller) {
worker, _ := zmq.NewSocket(zmq.DEALER)
worker.Connect("tcp://localhost:5556")
// Tell queue we're ready for work
fmt.Println("I: worker ready")
worker.Send(PPP_READY, 0)
poller := zmq.NewPoller()
poller.Add(worker, zmq.POLLIN)
return worker, poller
}
|
go
|
func s_worker_socket() (*zmq.Socket, *zmq.Poller) {
worker, _ := zmq.NewSocket(zmq.DEALER)
worker.Connect("tcp://localhost:5556")
// Tell queue we're ready for work
fmt.Println("I: worker ready")
worker.Send(PPP_READY, 0)
poller := zmq.NewPoller()
poller.Add(worker, zmq.POLLIN)
return worker, poller
}
|
[
"func",
"s_worker_socket",
"(",
")",
"(",
"*",
"zmq",
".",
"Socket",
",",
"*",
"zmq",
".",
"Poller",
")",
"{",
"worker",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"DEALER",
")",
"\n",
"worker",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n\n",
"// Tell queue we're ready for work",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"worker",
".",
"Send",
"(",
"PPP_READY",
",",
"0",
")",
"\n\n",
"poller",
":=",
"zmq",
".",
"NewPoller",
"(",
")",
"\n",
"poller",
".",
"Add",
"(",
"worker",
",",
"zmq",
".",
"POLLIN",
")",
"\n\n",
"return",
"worker",
",",
"poller",
"\n",
"}"
] |
// Helper function that returns a new configured socket
// connected to the Paranoid Pirate queue
|
[
"Helper",
"function",
"that",
"returns",
"a",
"new",
"configured",
"socket",
"connected",
"to",
"the",
"Paranoid",
"Pirate",
"queue"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/ppworker.go#L29-L41
|
143,333 |
pebbe/zmq4
|
auth.go
|
AuthStop
|
func AuthStop() {
if !auth_init {
if auth_verbose {
log.Println("AUTH: Not running, can't stop")
}
return
}
if auth_verbose {
log.Println("AUTH: Stopping")
}
_, err := auth_quit.SendMessageDontwait("QUIT")
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: SendMessageDontwait(\"QUIT\"):", err)
}
_, err = auth_quit.RecvMessage(0)
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: RecvMessage:", err)
}
err = auth_quit.Close()
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: Close:", err)
}
if auth_verbose {
log.Println("AUTH: Stopped")
}
auth_init = false
}
|
go
|
func AuthStop() {
if !auth_init {
if auth_verbose {
log.Println("AUTH: Not running, can't stop")
}
return
}
if auth_verbose {
log.Println("AUTH: Stopping")
}
_, err := auth_quit.SendMessageDontwait("QUIT")
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: SendMessageDontwait(\"QUIT\"):", err)
}
_, err = auth_quit.RecvMessage(0)
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: RecvMessage:", err)
}
err = auth_quit.Close()
if err != nil && auth_verbose {
log.Println("AUTH: Stopping: Close:", err)
}
if auth_verbose {
log.Println("AUTH: Stopped")
}
auth_init = false
}
|
[
"func",
"AuthStop",
"(",
")",
"{",
"if",
"!",
"auth_init",
"{",
"if",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
":=",
"auth_quit",
".",
"SendMessageDontwait",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"auth_quit",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"err",
"=",
"auth_quit",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"auth_verbose",
"{",
"log",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"auth_init",
"=",
"false",
"\n\n",
"}"
] |
// Stop authentication.
|
[
"Stop",
"authentication",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L351-L379
|
143,334 |
pebbe/zmq4
|
auth.go
|
AuthPlainRemove
|
func AuthPlainRemove(domain string, usernames ...string) {
if u, ok := auth_users[domain]; ok {
for _, username := range usernames {
delete(u, username)
}
}
}
|
go
|
func AuthPlainRemove(domain string, usernames ...string) {
if u, ok := auth_users[domain]; ok {
for _, username := range usernames {
delete(u, username)
}
}
}
|
[
"func",
"AuthPlainRemove",
"(",
"domain",
"string",
",",
"usernames",
"...",
"string",
")",
"{",
"if",
"u",
",",
"ok",
":=",
"auth_users",
"[",
"domain",
"]",
";",
"ok",
"{",
"for",
"_",
",",
"username",
":=",
"range",
"usernames",
"{",
"delete",
"(",
"u",
",",
"username",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Remove users from PLAIN authentication for a given domain.
|
[
"Remove",
"users",
"from",
"PLAIN",
"authentication",
"for",
"a",
"given",
"domain",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L478-L484
|
143,335 |
pebbe/zmq4
|
auth.go
|
AuthCurveRemove
|
func AuthCurveRemove(domain string, pubkeys ...string) {
if p, ok := auth_pubkeys[domain]; ok {
for _, pubkey := range pubkeys {
delete(p, pubkey)
}
}
}
|
go
|
func AuthCurveRemove(domain string, pubkeys ...string) {
if p, ok := auth_pubkeys[domain]; ok {
for _, pubkey := range pubkeys {
delete(p, pubkey)
}
}
}
|
[
"func",
"AuthCurveRemove",
"(",
"domain",
"string",
",",
"pubkeys",
"...",
"string",
")",
"{",
"if",
"p",
",",
"ok",
":=",
"auth_pubkeys",
"[",
"domain",
"]",
";",
"ok",
"{",
"for",
"_",
",",
"pubkey",
":=",
"range",
"pubkeys",
"{",
"delete",
"(",
"p",
",",
"pubkey",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Remove user keys from CURVE authentication for a given domain.
|
[
"Remove",
"user",
"keys",
"from",
"CURVE",
"authentication",
"for",
"a",
"given",
"domain",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L508-L514
|
143,336 |
pebbe/zmq4
|
auth.go
|
ServerAuthNull
|
func (server *Socket) ServerAuthNull(domain string) error {
err := server.SetPlainServer(0)
if err == nil {
err = server.SetZapDomain(domain)
}
return err
}
|
go
|
func (server *Socket) ServerAuthNull(domain string) error {
err := server.SetPlainServer(0)
if err == nil {
err = server.SetZapDomain(domain)
}
return err
}
|
[
"func",
"(",
"server",
"*",
"Socket",
")",
"ServerAuthNull",
"(",
"domain",
"string",
")",
"error",
"{",
"err",
":=",
"server",
".",
"SetPlainServer",
"(",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"server",
".",
"SetZapDomain",
"(",
"domain",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
//. Additional functions for configuring server or client socket with a single command
// Set NULL server role.
|
[
".",
"Additional",
"functions",
"for",
"configuring",
"server",
"or",
"client",
"socket",
"with",
"a",
"single",
"command",
"Set",
"NULL",
"server",
"role",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L579-L585
|
143,337 |
pebbe/zmq4
|
auth.go
|
ServerAuthCurve
|
func (server *Socket) ServerAuthCurve(domain, secret_key string) error {
err := server.SetCurveServer(1)
if err == nil {
err = server.SetCurveSecretkey(secret_key)
}
if err == nil {
err = server.SetZapDomain(domain)
}
return err
}
|
go
|
func (server *Socket) ServerAuthCurve(domain, secret_key string) error {
err := server.SetCurveServer(1)
if err == nil {
err = server.SetCurveSecretkey(secret_key)
}
if err == nil {
err = server.SetZapDomain(domain)
}
return err
}
|
[
"func",
"(",
"server",
"*",
"Socket",
")",
"ServerAuthCurve",
"(",
"domain",
",",
"secret_key",
"string",
")",
"error",
"{",
"err",
":=",
"server",
".",
"SetCurveServer",
"(",
"1",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"server",
".",
"SetCurveSecretkey",
"(",
"secret_key",
")",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"server",
".",
"SetZapDomain",
"(",
"domain",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Set CURVE server role.
|
[
"Set",
"CURVE",
"server",
"role",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L597-L606
|
143,338 |
pebbe/zmq4
|
auth.go
|
ClientAuthPlain
|
func (client *Socket) ClientAuthPlain(username, password string) error {
err := client.SetPlainUsername(username)
if err == nil {
err = client.SetPlainPassword(password)
}
return err
}
|
go
|
func (client *Socket) ClientAuthPlain(username, password string) error {
err := client.SetPlainUsername(username)
if err == nil {
err = client.SetPlainPassword(password)
}
return err
}
|
[
"func",
"(",
"client",
"*",
"Socket",
")",
"ClientAuthPlain",
"(",
"username",
",",
"password",
"string",
")",
"error",
"{",
"err",
":=",
"client",
".",
"SetPlainUsername",
"(",
"username",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"client",
".",
"SetPlainPassword",
"(",
"password",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Set PLAIN client role.
|
[
"Set",
"PLAIN",
"client",
"role",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L609-L615
|
143,339 |
pebbe/zmq4
|
auth.go
|
ClientAuthCurve
|
func (client *Socket) ClientAuthCurve(server_public_key, client_public_key, client_secret_key string) error {
err := client.SetCurveServerkey(server_public_key)
if err == nil {
err = client.SetCurvePublickey(client_public_key)
}
if err == nil {
client.SetCurveSecretkey(client_secret_key)
}
return err
}
|
go
|
func (client *Socket) ClientAuthCurve(server_public_key, client_public_key, client_secret_key string) error {
err := client.SetCurveServerkey(server_public_key)
if err == nil {
err = client.SetCurvePublickey(client_public_key)
}
if err == nil {
client.SetCurveSecretkey(client_secret_key)
}
return err
}
|
[
"func",
"(",
"client",
"*",
"Socket",
")",
"ClientAuthCurve",
"(",
"server_public_key",
",",
"client_public_key",
",",
"client_secret_key",
"string",
")",
"error",
"{",
"err",
":=",
"client",
".",
"SetCurveServerkey",
"(",
"server_public_key",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"client",
".",
"SetCurvePublickey",
"(",
"client_public_key",
")",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"client",
".",
"SetCurveSecretkey",
"(",
"client_secret_key",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// Set CURVE client role.
|
[
"Set",
"CURVE",
"client",
"role",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L618-L627
|
143,340 |
pebbe/zmq4
|
auth.go
|
AuthCurvePublic
|
func AuthCurvePublic(z85SecretKey string) (z85PublicKey string, err error) {
if minor < 2 {
return "", ErrorNotImplemented42
}
secret := C.CString(z85SecretKey)
defer C.free(unsafe.Pointer(secret))
public := C.CString(strings.Repeat(" ", 41))
defer C.free(unsafe.Pointer(public))
if i, err := C.zmq_curve_public(public, secret); int(i) != 0 {
return "", errget(err)
}
z85PublicKey = C.GoString(public)
return z85PublicKey, nil
}
|
go
|
func AuthCurvePublic(z85SecretKey string) (z85PublicKey string, err error) {
if minor < 2 {
return "", ErrorNotImplemented42
}
secret := C.CString(z85SecretKey)
defer C.free(unsafe.Pointer(secret))
public := C.CString(strings.Repeat(" ", 41))
defer C.free(unsafe.Pointer(public))
if i, err := C.zmq_curve_public(public, secret); int(i) != 0 {
return "", errget(err)
}
z85PublicKey = C.GoString(public)
return z85PublicKey, nil
}
|
[
"func",
"AuthCurvePublic",
"(",
"z85SecretKey",
"string",
")",
"(",
"z85PublicKey",
"string",
",",
"err",
"error",
")",
"{",
"if",
"minor",
"<",
"2",
"{",
"return",
"\"",
"\"",
",",
"ErrorNotImplemented42",
"\n",
"}",
"\n",
"secret",
":=",
"C",
".",
"CString",
"(",
"z85SecretKey",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"secret",
")",
")",
"\n",
"public",
":=",
"C",
".",
"CString",
"(",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"41",
")",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"public",
")",
")",
"\n",
"if",
"i",
",",
"err",
":=",
"C",
".",
"zmq_curve_public",
"(",
"public",
",",
"secret",
")",
";",
"int",
"(",
"i",
")",
"!=",
"0",
"{",
"return",
"\"",
"\"",
",",
"errget",
"(",
"err",
")",
"\n",
"}",
"\n",
"z85PublicKey",
"=",
"C",
".",
"GoString",
"(",
"public",
")",
"\n",
"return",
"z85PublicKey",
",",
"nil",
"\n",
"}"
] |
// Helper function to derive z85 public key from secret key
//
// Returns ErrorNotImplemented42 with ZeroMQ version < 4.2
|
[
"Helper",
"function",
"to",
"derive",
"z85",
"public",
"key",
"from",
"secret",
"key",
"Returns",
"ErrorNotImplemented42",
"with",
"ZeroMQ",
"version",
"<",
"4",
".",
"2"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/auth.go#L632-L645
|
143,341 |
pebbe/zmq4
|
examples/espresso.go
|
subscriber_thread
|
func subscriber_thread() {
// Subscribe to "A" and "B"
subscriber, _ := zmq.NewSocket(zmq.SUB)
subscriber.Connect("tcp://localhost:6001")
subscriber.SetSubscribe("A")
subscriber.SetSubscribe("B")
defer subscriber.Close() // cancel subscribe
for count := 0; count < 5; count++ {
_, err := subscriber.RecvMessage(0)
if err != nil {
break // Interrupted
}
}
}
|
go
|
func subscriber_thread() {
// Subscribe to "A" and "B"
subscriber, _ := zmq.NewSocket(zmq.SUB)
subscriber.Connect("tcp://localhost:6001")
subscriber.SetSubscribe("A")
subscriber.SetSubscribe("B")
defer subscriber.Close() // cancel subscribe
for count := 0; count < 5; count++ {
_, err := subscriber.RecvMessage(0)
if err != nil {
break // Interrupted
}
}
}
|
[
"func",
"subscriber_thread",
"(",
")",
"{",
"// Subscribe to \"A\" and \"B\"",
"subscriber",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"SUB",
")",
"\n",
"subscriber",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n",
"subscriber",
".",
"SetSubscribe",
"(",
"\"",
"\"",
")",
"\n",
"subscriber",
".",
"SetSubscribe",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"subscriber",
".",
"Close",
"(",
")",
"// cancel subscribe",
"\n\n",
"for",
"count",
":=",
"0",
";",
"count",
"<",
"5",
";",
"count",
"++",
"{",
"_",
",",
"err",
":=",
"subscriber",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"// Interrupted",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// The subscriber thread requests messages starting with
// A and B, then reads and counts incoming messages.
|
[
"The",
"subscriber",
"thread",
"requests",
"messages",
"starting",
"with",
"A",
"and",
"B",
"then",
"reads",
"and",
"counts",
"incoming",
"messages",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/espresso.go#L19-L33
|
143,342 |
pebbe/zmq4
|
examples/asyncsrv.go
|
server_task
|
func server_task() {
// Frontend socket talks to clients over TCP
frontend, _ := zmq.NewSocket(zmq.ROUTER)
defer frontend.Close()
frontend.Bind("tcp://*:5570")
// Backend socket talks to workers over inproc
backend, _ := zmq.NewSocket(zmq.DEALER)
defer backend.Close()
backend.Bind("inproc://backend")
// Launch pool of worker threads, precise number is not critical
for i := 0; i < 5; i++ {
go server_worker()
}
// Connect backend to frontend via a proxy
err := zmq.Proxy(frontend, backend, nil)
log.Fatalln("Proxy interrupted:", err)
}
|
go
|
func server_task() {
// Frontend socket talks to clients over TCP
frontend, _ := zmq.NewSocket(zmq.ROUTER)
defer frontend.Close()
frontend.Bind("tcp://*:5570")
// Backend socket talks to workers over inproc
backend, _ := zmq.NewSocket(zmq.DEALER)
defer backend.Close()
backend.Bind("inproc://backend")
// Launch pool of worker threads, precise number is not critical
for i := 0; i < 5; i++ {
go server_worker()
}
// Connect backend to frontend via a proxy
err := zmq.Proxy(frontend, backend, nil)
log.Fatalln("Proxy interrupted:", err)
}
|
[
"func",
"server_task",
"(",
")",
"{",
"// Frontend socket talks to clients over TCP",
"frontend",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"ROUTER",
")",
"\n",
"defer",
"frontend",
".",
"Close",
"(",
")",
"\n",
"frontend",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n\n",
"// Backend socket talks to workers over inproc",
"backend",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"DEALER",
")",
"\n",
"defer",
"backend",
".",
"Close",
"(",
")",
"\n",
"backend",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n\n",
"// Launch pool of worker threads, precise number is not critical",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"5",
";",
"i",
"++",
"{",
"go",
"server_worker",
"(",
")",
"\n",
"}",
"\n\n",
"// Connect backend to frontend via a proxy",
"err",
":=",
"zmq",
".",
"Proxy",
"(",
"frontend",
",",
"backend",
",",
"nil",
")",
"\n",
"log",
".",
"Fatalln",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}"
] |
// This is our server task.
// It uses the multithreaded server model to deal requests out to a pool
// of workers and route replies back to clients. One worker can handle
// one request at a time but one client can talk to multiple workers at
// once.
|
[
"This",
"is",
"our",
"server",
"task",
".",
"It",
"uses",
"the",
"multithreaded",
"server",
"model",
"to",
"deal",
"requests",
"out",
"to",
"a",
"pool",
"of",
"workers",
"and",
"route",
"replies",
"back",
"to",
"clients",
".",
"One",
"worker",
"can",
"handle",
"one",
"request",
"at",
"a",
"time",
"but",
"one",
"client",
"can",
"talk",
"to",
"multiple",
"workers",
"at",
"once",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/asyncsrv.go#L63-L83
|
143,343 |
pebbe/zmq4
|
examples/asyncsrv.go
|
main
|
func main() {
rand.Seed(time.Now().UnixNano())
go client_task()
go client_task()
go client_task()
go server_task()
// Run for 5 seconds then quit
time.Sleep(5 * time.Second)
}
|
go
|
func main() {
rand.Seed(time.Now().UnixNano())
go client_task()
go client_task()
go client_task()
go server_task()
// Run for 5 seconds then quit
time.Sleep(5 * time.Second)
}
|
[
"func",
"main",
"(",
")",
"{",
"rand",
".",
"Seed",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
"\n\n",
"go",
"client_task",
"(",
")",
"\n",
"go",
"client_task",
"(",
")",
"\n",
"go",
"client_task",
"(",
")",
"\n",
"go",
"server_task",
"(",
")",
"\n\n",
"// Run for 5 seconds then quit",
"time",
".",
"Sleep",
"(",
"5",
"*",
"time",
".",
"Second",
")",
"\n",
"}"
] |
// The main thread simply starts several clients, and a server, and then
// waits for the server to finish.
|
[
"The",
"main",
"thread",
"simply",
"starts",
"several",
"clients",
"and",
"a",
"server",
"and",
"then",
"waits",
"for",
"the",
"server",
"to",
"finish",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/asyncsrv.go#L112-L122
|
143,344 |
pebbe/zmq4
|
examples/lbbroker2.go
|
client_task
|
func client_task() {
client, _ := zmq.NewSocket(zmq.REQ)
defer client.Close()
client.Connect("ipc://frontend.ipc")
// Send request, get reply
for {
client.SendMessage("HELLO")
reply, _ := client.RecvMessage(0)
if len(reply) == 0 {
break
}
fmt.Println("Client:", strings.Join(reply, "\n\t"))
time.Sleep(time.Second)
}
}
|
go
|
func client_task() {
client, _ := zmq.NewSocket(zmq.REQ)
defer client.Close()
client.Connect("ipc://frontend.ipc")
// Send request, get reply
for {
client.SendMessage("HELLO")
reply, _ := client.RecvMessage(0)
if len(reply) == 0 {
break
}
fmt.Println("Client:", strings.Join(reply, "\n\t"))
time.Sleep(time.Second)
}
}
|
[
"func",
"client_task",
"(",
")",
"{",
"client",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"REQ",
")",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"client",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n\n",
"// Send request, get reply",
"for",
"{",
"client",
".",
"SendMessage",
"(",
"\"",
"\"",
")",
"\n",
"reply",
",",
"_",
":=",
"client",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"len",
"(",
"reply",
")",
"==",
"0",
"{",
"break",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"reply",
",",
"\"",
"\\n",
"\\t",
"\"",
")",
")",
"\n",
"time",
".",
"Sleep",
"(",
"time",
".",
"Second",
")",
"\n",
"}",
"\n",
"}"
] |
// Basic request-reply client using REQ socket
//
|
[
"Basic",
"request",
"-",
"reply",
"client",
"using",
"REQ",
"socket"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker2.go#L24-L39
|
143,345 |
pebbe/zmq4
|
polling.go
|
NewPoller
|
func NewPoller() *Poller {
return &Poller{
items: make([]C.zmq_pollitem_t, 0),
socks: make([]*Socket, 0),
}
}
|
go
|
func NewPoller() *Poller {
return &Poller{
items: make([]C.zmq_pollitem_t, 0),
socks: make([]*Socket, 0),
}
}
|
[
"func",
"NewPoller",
"(",
")",
"*",
"Poller",
"{",
"return",
"&",
"Poller",
"{",
"items",
":",
"make",
"(",
"[",
"]",
"C",
".",
"zmq_pollitem_t",
",",
"0",
")",
",",
"socks",
":",
"make",
"(",
"[",
"]",
"*",
"Socket",
",",
"0",
")",
",",
"}",
"\n",
"}"
] |
// Create a new Poller
|
[
"Create",
"a",
"new",
"Poller"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L25-L30
|
143,346 |
pebbe/zmq4
|
polling.go
|
Update
|
func (p *Poller) Update(id int, events State) (previous State, err error) {
if id >= 0 && id < len(p.items) {
previous = State(p.items[id].events)
p.items[id].events = C.short(events)
return previous, nil
}
return 0, ErrorNoSocket
}
|
go
|
func (p *Poller) Update(id int, events State) (previous State, err error) {
if id >= 0 && id < len(p.items) {
previous = State(p.items[id].events)
p.items[id].events = C.short(events)
return previous, nil
}
return 0, ErrorNoSocket
}
|
[
"func",
"(",
"p",
"*",
"Poller",
")",
"Update",
"(",
"id",
"int",
",",
"events",
"State",
")",
"(",
"previous",
"State",
",",
"err",
"error",
")",
"{",
"if",
"id",
">=",
"0",
"&&",
"id",
"<",
"len",
"(",
"p",
".",
"items",
")",
"{",
"previous",
"=",
"State",
"(",
"p",
".",
"items",
"[",
"id",
"]",
".",
"events",
")",
"\n",
"p",
".",
"items",
"[",
"id",
"]",
".",
"events",
"=",
"C",
".",
"short",
"(",
"events",
")",
"\n",
"return",
"previous",
",",
"nil",
"\n",
"}",
"\n",
"return",
"0",
",",
"ErrorNoSocket",
"\n",
"}"
] |
// Update the events mask of a socket in the poller
//
// Replaces the Poller's bitmask for the specified id with the events parameter passed
//
// Returns the previous value, or ErrorNoSocket if the id was out of range
|
[
"Update",
"the",
"events",
"mask",
"of",
"a",
"socket",
"in",
"the",
"poller",
"Replaces",
"the",
"Poller",
"s",
"bitmask",
"for",
"the",
"specified",
"id",
"with",
"the",
"events",
"parameter",
"passed",
"Returns",
"the",
"previous",
"value",
"or",
"ErrorNoSocket",
"if",
"the",
"id",
"was",
"out",
"of",
"range"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L53-L60
|
143,347 |
pebbe/zmq4
|
polling.go
|
UpdateBySocket
|
func (p *Poller) UpdateBySocket(soc *Socket, events State) (previous State, err error) {
for id, s := range p.socks {
if s == soc {
previous = State(p.items[id].events)
p.items[id].events = C.short(events)
return previous, nil
}
}
return 0, ErrorNoSocket
}
|
go
|
func (p *Poller) UpdateBySocket(soc *Socket, events State) (previous State, err error) {
for id, s := range p.socks {
if s == soc {
previous = State(p.items[id].events)
p.items[id].events = C.short(events)
return previous, nil
}
}
return 0, ErrorNoSocket
}
|
[
"func",
"(",
"p",
"*",
"Poller",
")",
"UpdateBySocket",
"(",
"soc",
"*",
"Socket",
",",
"events",
"State",
")",
"(",
"previous",
"State",
",",
"err",
"error",
")",
"{",
"for",
"id",
",",
"s",
":=",
"range",
"p",
".",
"socks",
"{",
"if",
"s",
"==",
"soc",
"{",
"previous",
"=",
"State",
"(",
"p",
".",
"items",
"[",
"id",
"]",
".",
"events",
")",
"\n",
"p",
".",
"items",
"[",
"id",
"]",
".",
"events",
"=",
"C",
".",
"short",
"(",
"events",
")",
"\n",
"return",
"previous",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"0",
",",
"ErrorNoSocket",
"\n",
"}"
] |
// Update the events mask of a socket in the poller
//
// Replaces the Poller's bitmask for the specified socket with the events parameter passed
//
// Returns the previous value, or ErrorNoSocket if the socket didn't match
|
[
"Update",
"the",
"events",
"mask",
"of",
"a",
"socket",
"in",
"the",
"poller",
"Replaces",
"the",
"Poller",
"s",
"bitmask",
"for",
"the",
"specified",
"socket",
"with",
"the",
"events",
"parameter",
"passed",
"Returns",
"the",
"previous",
"value",
"or",
"ErrorNoSocket",
"if",
"the",
"socket",
"didn",
"t",
"match"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L67-L76
|
143,348 |
pebbe/zmq4
|
polling.go
|
Remove
|
func (p *Poller) Remove(id int) error {
if id >= 0 && id < len(p.items) {
if id == len(p.items)-1 {
p.items = p.items[:id]
p.socks = p.socks[:id]
} else {
p.items = append(p.items[:id], p.items[id+1:]...)
p.socks = append(p.socks[:id], p.socks[id+1:]...)
}
return nil
}
return ErrorNoSocket
}
|
go
|
func (p *Poller) Remove(id int) error {
if id >= 0 && id < len(p.items) {
if id == len(p.items)-1 {
p.items = p.items[:id]
p.socks = p.socks[:id]
} else {
p.items = append(p.items[:id], p.items[id+1:]...)
p.socks = append(p.socks[:id], p.socks[id+1:]...)
}
return nil
}
return ErrorNoSocket
}
|
[
"func",
"(",
"p",
"*",
"Poller",
")",
"Remove",
"(",
"id",
"int",
")",
"error",
"{",
"if",
"id",
">=",
"0",
"&&",
"id",
"<",
"len",
"(",
"p",
".",
"items",
")",
"{",
"if",
"id",
"==",
"len",
"(",
"p",
".",
"items",
")",
"-",
"1",
"{",
"p",
".",
"items",
"=",
"p",
".",
"items",
"[",
":",
"id",
"]",
"\n",
"p",
".",
"socks",
"=",
"p",
".",
"socks",
"[",
":",
"id",
"]",
"\n",
"}",
"else",
"{",
"p",
".",
"items",
"=",
"append",
"(",
"p",
".",
"items",
"[",
":",
"id",
"]",
",",
"p",
".",
"items",
"[",
"id",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"p",
".",
"socks",
"=",
"append",
"(",
"p",
".",
"socks",
"[",
":",
"id",
"]",
",",
"p",
".",
"socks",
"[",
"id",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"ErrorNoSocket",
"\n",
"}"
] |
// Remove a socket from the poller
//
// Returns ErrorNoSocket if the id was out of range
|
[
"Remove",
"a",
"socket",
"from",
"the",
"poller",
"Returns",
"ErrorNoSocket",
"if",
"the",
"id",
"was",
"out",
"of",
"range"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L81-L93
|
143,349 |
pebbe/zmq4
|
polling.go
|
RemoveBySocket
|
func (p *Poller) RemoveBySocket(soc *Socket) error {
for id, s := range p.socks {
if s == soc {
return p.Remove(id)
}
}
return ErrorNoSocket
}
|
go
|
func (p *Poller) RemoveBySocket(soc *Socket) error {
for id, s := range p.socks {
if s == soc {
return p.Remove(id)
}
}
return ErrorNoSocket
}
|
[
"func",
"(",
"p",
"*",
"Poller",
")",
"RemoveBySocket",
"(",
"soc",
"*",
"Socket",
")",
"error",
"{",
"for",
"id",
",",
"s",
":=",
"range",
"p",
".",
"socks",
"{",
"if",
"s",
"==",
"soc",
"{",
"return",
"p",
".",
"Remove",
"(",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ErrorNoSocket",
"\n",
"}"
] |
// Remove a socket from the poller
//
// Returns ErrorNoSocket if the socket didn't match
|
[
"Remove",
"a",
"socket",
"from",
"the",
"poller",
"Returns",
"ErrorNoSocket",
"if",
"the",
"socket",
"didn",
"t",
"match"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L98-L105
|
143,350 |
pebbe/zmq4
|
polling.go
|
String
|
func (p *Poller) String() string {
str := make([]string, 0)
for i, poll := range p.items {
str = append(str, fmt.Sprintf("%v%v", p.socks[i], State(poll.events)))
}
return fmt.Sprint("Poller", str)
}
|
go
|
func (p *Poller) String() string {
str := make([]string, 0)
for i, poll := range p.items {
str = append(str, fmt.Sprintf("%v%v", p.socks[i], State(poll.events)))
}
return fmt.Sprint("Poller", str)
}
|
[
"func",
"(",
"p",
"*",
"Poller",
")",
"String",
"(",
")",
"string",
"{",
"str",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"i",
",",
"poll",
":=",
"range",
"p",
".",
"items",
"{",
"str",
"=",
"append",
"(",
"str",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"socks",
"[",
"i",
"]",
",",
"State",
"(",
"poll",
".",
"events",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprint",
"(",
"\"",
"\"",
",",
"str",
")",
"\n",
"}"
] |
// Poller as string.
|
[
"Poller",
"as",
"string",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/polling.go#L181-L187
|
143,351 |
pebbe/zmq4
|
errors.go
|
Error
|
func (errno Errno) Error() string {
if errno >= C.ZMQ_HAUSNUMERO {
return C.GoString(C.zmq_strerror(C.int(errno)))
}
return syscall.Errno(errno).Error()
}
|
go
|
func (errno Errno) Error() string {
if errno >= C.ZMQ_HAUSNUMERO {
return C.GoString(C.zmq_strerror(C.int(errno)))
}
return syscall.Errno(errno).Error()
}
|
[
"func",
"(",
"errno",
"Errno",
")",
"Error",
"(",
")",
"string",
"{",
"if",
"errno",
">=",
"C",
".",
"ZMQ_HAUSNUMERO",
"{",
"return",
"C",
".",
"GoString",
"(",
"C",
".",
"zmq_strerror",
"(",
"C",
".",
"int",
"(",
"errno",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"syscall",
".",
"Errno",
"(",
"errno",
")",
".",
"Error",
"(",
")",
"\n",
"}"
] |
// Return Errno as string.
|
[
"Return",
"Errno",
"as",
"string",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/errors.go#L56-L61
|
143,352 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
RecvKvmsg
|
func RecvKvmsg(socket *zmq.Socket) (kvmsg *Kvmsg, err error) {
kvmsg = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
}
msg, err := socket.RecvMessage(0)
if err != nil {
return
}
//fmt.Printf("Recv from %s: %q\n", socket, msg)
for i := 0; i < kvmsg_FRAMES && i < len(msg); i++ {
kvmsg.frame[i] = msg[i]
kvmsg.present[i] = true
}
kvmsg.decode_props()
return
}
|
go
|
func RecvKvmsg(socket *zmq.Socket) (kvmsg *Kvmsg, err error) {
kvmsg = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
}
msg, err := socket.RecvMessage(0)
if err != nil {
return
}
//fmt.Printf("Recv from %s: %q\n", socket, msg)
for i := 0; i < kvmsg_FRAMES && i < len(msg); i++ {
kvmsg.frame[i] = msg[i]
kvmsg.present[i] = true
}
kvmsg.decode_props()
return
}
|
[
"func",
"RecvKvmsg",
"(",
"socket",
"*",
"zmq",
".",
"Socket",
")",
"(",
"kvmsg",
"*",
"Kvmsg",
",",
"err",
"error",
")",
"{",
"kvmsg",
"=",
"&",
"Kvmsg",
"{",
"present",
":",
"make",
"(",
"[",
"]",
"bool",
",",
"kvmsg_FRAMES",
")",
",",
"frame",
":",
"make",
"(",
"[",
"]",
"string",
",",
"kvmsg_FRAMES",
")",
",",
"}",
"\n",
"msg",
",",
"err",
":=",
"socket",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"//fmt.Printf(\"Recv from %s: %q\\n\", socket, msg)",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"kvmsg_FRAMES",
"&&",
"i",
"<",
"len",
"(",
"msg",
")",
";",
"i",
"++",
"{",
"kvmsg",
".",
"frame",
"[",
"i",
"]",
"=",
"msg",
"[",
"i",
"]",
"\n",
"kvmsg",
".",
"present",
"[",
"i",
"]",
"=",
"true",
"\n",
"}",
"\n",
"kvmsg",
".",
"decode_props",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// The RecvKvmsg function reads a key-value message from socket, and returns a new
// Kvmsg instance.
|
[
"The",
"RecvKvmsg",
"function",
"reads",
"a",
"key",
"-",
"value",
"message",
"from",
"socket",
"and",
"returns",
"a",
"new",
"Kvmsg",
"instance",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L68-L84
|
143,353 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
Send
|
func (kvmsg *Kvmsg) Send(socket *zmq.Socket) (err error) {
//fmt.Printf("Send to %s: %q\n", socket, kvmsg.frame)
kvmsg.encode_props()
_, err = socket.SendMessage(kvmsg.frame)
return
}
|
go
|
func (kvmsg *Kvmsg) Send(socket *zmq.Socket) (err error) {
//fmt.Printf("Send to %s: %q\n", socket, kvmsg.frame)
kvmsg.encode_props()
_, err = socket.SendMessage(kvmsg.frame)
return
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"Send",
"(",
"socket",
"*",
"zmq",
".",
"Socket",
")",
"(",
"err",
"error",
")",
"{",
"//fmt.Printf(\"Send to %s: %q\\n\", socket, kvmsg.frame)",
"kvmsg",
".",
"encode_props",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"socket",
".",
"SendMessage",
"(",
"kvmsg",
".",
"frame",
")",
"\n",
"return",
"\n",
"}"
] |
// Send key-value message to socket; any empty frames are sent as such.
|
[
"Send",
"key",
"-",
"value",
"message",
"to",
"socket",
";",
"any",
"empty",
"frames",
"are",
"sent",
"as",
"such",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L87-L92
|
143,354 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
Dup
|
func (kvmsg *Kvmsg) Dup() (dup *Kvmsg) {
dup = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
props: make([]string, len(kvmsg.props)),
}
copy(dup.present, kvmsg.present)
copy(dup.frame, kvmsg.frame)
copy(dup.props, kvmsg.props)
return
}
|
go
|
func (kvmsg *Kvmsg) Dup() (dup *Kvmsg) {
dup = &Kvmsg{
present: make([]bool, kvmsg_FRAMES),
frame: make([]string, kvmsg_FRAMES),
props: make([]string, len(kvmsg.props)),
}
copy(dup.present, kvmsg.present)
copy(dup.frame, kvmsg.frame)
copy(dup.props, kvmsg.props)
return
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"Dup",
"(",
")",
"(",
"dup",
"*",
"Kvmsg",
")",
"{",
"dup",
"=",
"&",
"Kvmsg",
"{",
"present",
":",
"make",
"(",
"[",
"]",
"bool",
",",
"kvmsg_FRAMES",
")",
",",
"frame",
":",
"make",
"(",
"[",
"]",
"string",
",",
"kvmsg_FRAMES",
")",
",",
"props",
":",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"kvmsg",
".",
"props",
")",
")",
",",
"}",
"\n",
"copy",
"(",
"dup",
".",
"present",
",",
"kvmsg",
".",
"present",
")",
"\n",
"copy",
"(",
"dup",
".",
"frame",
",",
"kvmsg",
".",
"frame",
")",
"\n",
"copy",
"(",
"dup",
".",
"props",
",",
"kvmsg",
".",
"props",
")",
"\n",
"return",
"\n",
"}"
] |
// The Dup method duplicates a kvmsg instance, returns the new instance.
|
[
"The",
"Dup",
"method",
"duplicates",
"a",
"kvmsg",
"instance",
"returns",
"the",
"new",
"instance",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L95-L105
|
143,355 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
SetUuid
|
func (kvmsg *Kvmsg) SetUuid() {
kvmsg.frame[frame_UUID] = string(uuid.NewRandom()) // raw 16 bytes
kvmsg.present[frame_UUID] = true
}
|
go
|
func (kvmsg *Kvmsg) SetUuid() {
kvmsg.frame[frame_UUID] = string(uuid.NewRandom()) // raw 16 bytes
kvmsg.present[frame_UUID] = true
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"SetUuid",
"(",
")",
"{",
"kvmsg",
".",
"frame",
"[",
"frame_UUID",
"]",
"=",
"string",
"(",
"uuid",
".",
"NewRandom",
"(",
")",
")",
"// raw 16 bytes",
"\n",
"kvmsg",
".",
"present",
"[",
"frame_UUID",
"]",
"=",
"true",
"\n\n",
"}"
] |
// Sets the UUID to a random generated value
|
[
"Sets",
"the",
"UUID",
"to",
"a",
"random",
"generated",
"value"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L187-L191
|
143,356 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
GetProp
|
func (kvmsg *Kvmsg) GetProp(name string) (value string, err error) {
if !kvmsg.present[frame_PROPS] {
err = errors.New("No properties set")
return
}
f := name + "="
for _, prop := range kvmsg.props {
if strings.HasPrefix(prop, f) {
value = prop[len(f):]
return
}
}
err = errors.New("Property not set")
return
}
|
go
|
func (kvmsg *Kvmsg) GetProp(name string) (value string, err error) {
if !kvmsg.present[frame_PROPS] {
err = errors.New("No properties set")
return
}
f := name + "="
for _, prop := range kvmsg.props {
if strings.HasPrefix(prop, f) {
value = prop[len(f):]
return
}
}
err = errors.New("Property not set")
return
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"GetProp",
"(",
"name",
"string",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"if",
"!",
"kvmsg",
".",
"present",
"[",
"frame_PROPS",
"]",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"f",
":=",
"name",
"+",
"\"",
"\"",
"\n",
"for",
"_",
",",
"prop",
":=",
"range",
"kvmsg",
".",
"props",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"prop",
",",
"f",
")",
"{",
"value",
"=",
"prop",
"[",
"len",
"(",
"f",
")",
":",
"]",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}"
] |
// Get message property, return error if no such property is defined.
|
[
"Get",
"message",
"property",
"return",
"error",
"if",
"no",
"such",
"property",
"is",
"defined",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L194-L208
|
143,357 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
SetProp
|
func (kvmsg *Kvmsg) SetProp(name, value string) (err error) {
if strings.Index(name, "=") >= 0 {
err = errors.New("No '=' allowed in property name")
return
}
p := name + "="
for i, prop := range kvmsg.props {
if strings.HasPrefix(prop, p) {
kvmsg.props = append(kvmsg.props[:i], kvmsg.props[i+1:]...)
break
}
}
kvmsg.props = append(kvmsg.props, name+"="+value)
kvmsg.present[frame_PROPS] = true
return
}
|
go
|
func (kvmsg *Kvmsg) SetProp(name, value string) (err error) {
if strings.Index(name, "=") >= 0 {
err = errors.New("No '=' allowed in property name")
return
}
p := name + "="
for i, prop := range kvmsg.props {
if strings.HasPrefix(prop, p) {
kvmsg.props = append(kvmsg.props[:i], kvmsg.props[i+1:]...)
break
}
}
kvmsg.props = append(kvmsg.props, name+"="+value)
kvmsg.present[frame_PROPS] = true
return
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"SetProp",
"(",
"name",
",",
"value",
"string",
")",
"(",
"err",
"error",
")",
"{",
"if",
"strings",
".",
"Index",
"(",
"name",
",",
"\"",
"\"",
")",
">=",
"0",
"{",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"p",
":=",
"name",
"+",
"\"",
"\"",
"\n",
"for",
"i",
",",
"prop",
":=",
"range",
"kvmsg",
".",
"props",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"prop",
",",
"p",
")",
"{",
"kvmsg",
".",
"props",
"=",
"append",
"(",
"kvmsg",
".",
"props",
"[",
":",
"i",
"]",
",",
"kvmsg",
".",
"props",
"[",
"i",
"+",
"1",
":",
"]",
"...",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"kvmsg",
".",
"props",
"=",
"append",
"(",
"kvmsg",
".",
"props",
",",
"name",
"+",
"\"",
"\"",
"+",
"value",
")",
"\n",
"kvmsg",
".",
"present",
"[",
"frame_PROPS",
"]",
"=",
"true",
"\n",
"return",
"\n",
"}"
] |
// Set message property. Property name cannot contain '='.
|
[
"Set",
"message",
"property",
".",
"Property",
"name",
"cannot",
"contain",
"=",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L211-L226
|
143,358 |
pebbe/zmq4
|
examples/kvmsg/kvmsg.go
|
Dump
|
func (kvmsg *Kvmsg) Dump() {
size := kvmsg.Size()
body, _ := kvmsg.GetBody()
seq, _ := kvmsg.GetSequence()
key, _ := kvmsg.GetKey()
fmt.Fprintf(os.Stderr, "[seq:%v][key:%v][size:%v] ", seq, key, size)
p := "["
for _, prop := range kvmsg.props {
fmt.Fprint(os.Stderr, p, prop)
p = ";"
}
if p == ";" {
fmt.Fprint(os.Stderr, "]")
}
for char_nbr := 0; char_nbr < size; char_nbr++ {
fmt.Fprintf(os.Stderr, "%02X", body[char_nbr])
}
fmt.Fprintln(os.Stderr)
}
|
go
|
func (kvmsg *Kvmsg) Dump() {
size := kvmsg.Size()
body, _ := kvmsg.GetBody()
seq, _ := kvmsg.GetSequence()
key, _ := kvmsg.GetKey()
fmt.Fprintf(os.Stderr, "[seq:%v][key:%v][size:%v] ", seq, key, size)
p := "["
for _, prop := range kvmsg.props {
fmt.Fprint(os.Stderr, p, prop)
p = ";"
}
if p == ";" {
fmt.Fprint(os.Stderr, "]")
}
for char_nbr := 0; char_nbr < size; char_nbr++ {
fmt.Fprintf(os.Stderr, "%02X", body[char_nbr])
}
fmt.Fprintln(os.Stderr)
}
|
[
"func",
"(",
"kvmsg",
"*",
"Kvmsg",
")",
"Dump",
"(",
")",
"{",
"size",
":=",
"kvmsg",
".",
"Size",
"(",
")",
"\n",
"body",
",",
"_",
":=",
"kvmsg",
".",
"GetBody",
"(",
")",
"\n",
"seq",
",",
"_",
":=",
"kvmsg",
".",
"GetSequence",
"(",
")",
"\n",
"key",
",",
"_",
":=",
"kvmsg",
".",
"GetKey",
"(",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"seq",
",",
"key",
",",
"size",
")",
"\n",
"p",
":=",
"\"",
"\"",
"\n",
"for",
"_",
",",
"prop",
":=",
"range",
"kvmsg",
".",
"props",
"{",
"fmt",
".",
"Fprint",
"(",
"os",
".",
"Stderr",
",",
"p",
",",
"prop",
")",
"\n",
"p",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"if",
"p",
"==",
"\"",
"\"",
"{",
"fmt",
".",
"Fprint",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"char_nbr",
":=",
"0",
";",
"char_nbr",
"<",
"size",
";",
"char_nbr",
"++",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"body",
"[",
"char_nbr",
"]",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"os",
".",
"Stderr",
")",
"\n",
"}"
] |
// The dump method extends the kvsimple implementation with support for
// message properties.
|
[
"The",
"dump",
"method",
"extends",
"the",
"kvsimple",
"implementation",
"with",
"support",
"for",
"message",
"properties",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/kvmsg/kvmsg.go#L242-L260
|
143,359 |
pebbe/zmq4
|
examples/lbbroker3.go
|
worker_task
|
func worker_task() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
worker.Connect("ipc://backend.ipc")
// Tell broker we're ready for work
worker.SendMessage(WORKER_READY)
// Process messages as they arrive
for {
msg, e := worker.RecvMessage(0)
if e != nil {
break // Interrupted
}
msg[len(msg)-1] = "OK"
worker.SendMessage(msg)
}
}
|
go
|
func worker_task() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
worker.Connect("ipc://backend.ipc")
// Tell broker we're ready for work
worker.SendMessage(WORKER_READY)
// Process messages as they arrive
for {
msg, e := worker.RecvMessage(0)
if e != nil {
break // Interrupted
}
msg[len(msg)-1] = "OK"
worker.SendMessage(msg)
}
}
|
[
"func",
"worker_task",
"(",
")",
"{",
"worker",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"REQ",
")",
"\n",
"defer",
"worker",
".",
"Close",
"(",
")",
"\n",
"worker",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n\n",
"// Tell broker we're ready for work",
"worker",
".",
"SendMessage",
"(",
"WORKER_READY",
")",
"\n\n",
"// Process messages as they arrive",
"for",
"{",
"msg",
",",
"e",
":=",
"worker",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"break",
"// Interrupted",
"\n",
"}",
"\n",
"msg",
"[",
"len",
"(",
"msg",
")",
"-",
"1",
"]",
"=",
"\"",
"\"",
"\n",
"worker",
".",
"SendMessage",
"(",
"msg",
")",
"\n",
"}",
"\n",
"}"
] |
// Worker using REQ socket to do load-balancing
//
|
[
"Worker",
"using",
"REQ",
"socket",
"to",
"do",
"load",
"-",
"balancing"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker3.go#L43-L60
|
143,360 |
pebbe/zmq4
|
examples/lbbroker3.go
|
handle_backend
|
func handle_backend(lbbroker *lbbroker_t) error {
// Use worker identity for load-balancing
msg, err := lbbroker.backend.RecvMessage(0)
if err != nil {
return err
}
identity, msg := unwrap(msg)
lbbroker.workers = append(lbbroker.workers, identity)
// Enable reader on frontend if we went from 0 to 1 workers
if len(lbbroker.workers) == 1 {
lbbroker.reactor.AddSocket(lbbroker.frontend, zmq.POLLIN,
func(e zmq.State) error { return handle_frontend(lbbroker) })
}
// Forward message to client if it's not a READY
if msg[0] != WORKER_READY {
lbbroker.frontend.SendMessage(msg)
}
return nil
}
|
go
|
func handle_backend(lbbroker *lbbroker_t) error {
// Use worker identity for load-balancing
msg, err := lbbroker.backend.RecvMessage(0)
if err != nil {
return err
}
identity, msg := unwrap(msg)
lbbroker.workers = append(lbbroker.workers, identity)
// Enable reader on frontend if we went from 0 to 1 workers
if len(lbbroker.workers) == 1 {
lbbroker.reactor.AddSocket(lbbroker.frontend, zmq.POLLIN,
func(e zmq.State) error { return handle_frontend(lbbroker) })
}
// Forward message to client if it's not a READY
if msg[0] != WORKER_READY {
lbbroker.frontend.SendMessage(msg)
}
return nil
}
|
[
"func",
"handle_backend",
"(",
"lbbroker",
"*",
"lbbroker_t",
")",
"error",
"{",
"// Use worker identity for load-balancing",
"msg",
",",
"err",
":=",
"lbbroker",
".",
"backend",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"identity",
",",
"msg",
":=",
"unwrap",
"(",
"msg",
")",
"\n",
"lbbroker",
".",
"workers",
"=",
"append",
"(",
"lbbroker",
".",
"workers",
",",
"identity",
")",
"\n\n",
"// Enable reader on frontend if we went from 0 to 1 workers",
"if",
"len",
"(",
"lbbroker",
".",
"workers",
")",
"==",
"1",
"{",
"lbbroker",
".",
"reactor",
".",
"AddSocket",
"(",
"lbbroker",
".",
"frontend",
",",
"zmq",
".",
"POLLIN",
",",
"func",
"(",
"e",
"zmq",
".",
"State",
")",
"error",
"{",
"return",
"handle_frontend",
"(",
"lbbroker",
")",
"}",
")",
"\n",
"}",
"\n\n",
"// Forward message to client if it's not a READY",
"if",
"msg",
"[",
"0",
"]",
"!=",
"WORKER_READY",
"{",
"lbbroker",
".",
"frontend",
".",
"SendMessage",
"(",
"msg",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Handle input from worker, on backend
|
[
"Handle",
"input",
"from",
"worker",
"on",
"backend"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker3.go#L93-L114
|
143,361 |
pebbe/zmq4
|
examples/mdbroker.go
|
Delete
|
func (worker *Worker) Delete(disconnect bool) {
if disconnect {
worker.Send(mdapi.MDPW_DISCONNECT, "", []string{})
}
if worker.service != nil {
worker.service.waiting = delWorker(worker.service.waiting, worker)
}
worker.broker.waiting = delWorker(worker.broker.waiting, worker)
delete(worker.broker.workers, worker.id_string)
}
|
go
|
func (worker *Worker) Delete(disconnect bool) {
if disconnect {
worker.Send(mdapi.MDPW_DISCONNECT, "", []string{})
}
if worker.service != nil {
worker.service.waiting = delWorker(worker.service.waiting, worker)
}
worker.broker.waiting = delWorker(worker.broker.waiting, worker)
delete(worker.broker.workers, worker.id_string)
}
|
[
"func",
"(",
"worker",
"*",
"Worker",
")",
"Delete",
"(",
"disconnect",
"bool",
")",
"{",
"if",
"disconnect",
"{",
"worker",
".",
"Send",
"(",
"mdapi",
".",
"MDPW_DISCONNECT",
",",
"\"",
"\"",
",",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"worker",
".",
"service",
"!=",
"nil",
"{",
"worker",
".",
"service",
".",
"waiting",
"=",
"delWorker",
"(",
"worker",
".",
"service",
".",
"waiting",
",",
"worker",
")",
"\n",
"}",
"\n",
"worker",
".",
"broker",
".",
"waiting",
"=",
"delWorker",
"(",
"worker",
".",
"broker",
".",
"waiting",
",",
"worker",
")",
"\n",
"delete",
"(",
"worker",
".",
"broker",
".",
"workers",
",",
"worker",
".",
"id_string",
")",
"\n",
"}"
] |
// The delete method deletes the current worker.
|
[
"The",
"delete",
"method",
"deletes",
"the",
"current",
"worker",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/mdbroker.go#L279-L289
|
143,362 |
pebbe/zmq4
|
examples/mdbroker.go
|
Waiting
|
func (worker *Worker) Waiting() {
// Queue to broker and service waiting lists
worker.broker.waiting = append(worker.broker.waiting, worker)
worker.service.waiting = append(worker.service.waiting, worker)
worker.expiry = time.Now().Add(HEARTBEAT_EXPIRY)
worker.service.Dispatch([]string{})
}
|
go
|
func (worker *Worker) Waiting() {
// Queue to broker and service waiting lists
worker.broker.waiting = append(worker.broker.waiting, worker)
worker.service.waiting = append(worker.service.waiting, worker)
worker.expiry = time.Now().Add(HEARTBEAT_EXPIRY)
worker.service.Dispatch([]string{})
}
|
[
"func",
"(",
"worker",
"*",
"Worker",
")",
"Waiting",
"(",
")",
"{",
"// Queue to broker and service waiting lists",
"worker",
".",
"broker",
".",
"waiting",
"=",
"append",
"(",
"worker",
".",
"broker",
".",
"waiting",
",",
"worker",
")",
"\n",
"worker",
".",
"service",
".",
"waiting",
"=",
"append",
"(",
"worker",
".",
"service",
".",
"waiting",
",",
"worker",
")",
"\n",
"worker",
".",
"expiry",
"=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"HEARTBEAT_EXPIRY",
")",
"\n",
"worker",
".",
"service",
".",
"Dispatch",
"(",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"}"
] |
// This worker is now waiting for work
|
[
"This",
"worker",
"is",
"now",
"waiting",
"for",
"work"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/mdbroker.go#L322-L328
|
143,363 |
pebbe/zmq4
|
examples/lbbroker.go
|
client_task
|
func client_task() {
client, _ := zmq.NewSocket(zmq.REQ)
defer client.Close()
// set_id(client) // Set a printable identity
client.Connect("ipc://frontend.ipc")
// Send request, get reply
client.Send("HELLO", 0)
reply, _ := client.Recv(0)
fmt.Println("Client:", reply)
}
|
go
|
func client_task() {
client, _ := zmq.NewSocket(zmq.REQ)
defer client.Close()
// set_id(client) // Set a printable identity
client.Connect("ipc://frontend.ipc")
// Send request, get reply
client.Send("HELLO", 0)
reply, _ := client.Recv(0)
fmt.Println("Client:", reply)
}
|
[
"func",
"client_task",
"(",
")",
"{",
"client",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"REQ",
")",
"\n",
"defer",
"client",
".",
"Close",
"(",
")",
"\n",
"// set_id(client) // Set a printable identity",
"client",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n\n",
"// Send request, get reply",
"client",
".",
"Send",
"(",
"\"",
"\"",
",",
"0",
")",
"\n",
"reply",
",",
"_",
":=",
"client",
".",
"Recv",
"(",
"0",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"reply",
")",
"\n",
"}"
] |
// Basic request-reply client using REQ socket
// Since Go Send and Recv can handle 0MQ binary identities we
// don't need printable text identity to allow routing.
|
[
"Basic",
"request",
"-",
"reply",
"client",
"using",
"REQ",
"socket",
"Since",
"Go",
"Send",
"and",
"Recv",
"can",
"handle",
"0MQ",
"binary",
"identities",
"we",
"don",
"t",
"need",
"printable",
"text",
"identity",
"to",
"allow",
"routing",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker.go#L25-L35
|
143,364 |
pebbe/zmq4
|
examples/lbbroker.go
|
worker_task
|
func worker_task() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
// set_id(worker)
worker.Connect("ipc://backend.ipc")
// Tell broker we're ready for work
worker.Send("READY", 0)
for {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
identity, _ := worker.Recv(0)
empty, _ := worker.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
// Get request, send reply
request, _ := worker.Recv(0)
fmt.Println("Worker:", request)
worker.Send(identity, zmq.SNDMORE)
worker.Send("", zmq.SNDMORE)
worker.Send("OK", 0)
}
}
|
go
|
func worker_task() {
worker, _ := zmq.NewSocket(zmq.REQ)
defer worker.Close()
// set_id(worker)
worker.Connect("ipc://backend.ipc")
// Tell broker we're ready for work
worker.Send("READY", 0)
for {
// Read and save all frames until we get an empty frame
// In this example there is only 1 but it could be more
identity, _ := worker.Recv(0)
empty, _ := worker.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
// Get request, send reply
request, _ := worker.Recv(0)
fmt.Println("Worker:", request)
worker.Send(identity, zmq.SNDMORE)
worker.Send("", zmq.SNDMORE)
worker.Send("OK", 0)
}
}
|
[
"func",
"worker_task",
"(",
")",
"{",
"worker",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"REQ",
")",
"\n",
"defer",
"worker",
".",
"Close",
"(",
")",
"\n",
"// set_id(worker)",
"worker",
".",
"Connect",
"(",
"\"",
"\"",
")",
"\n\n",
"// Tell broker we're ready for work",
"worker",
".",
"Send",
"(",
"\"",
"\"",
",",
"0",
")",
"\n\n",
"for",
"{",
"// Read and save all frames until we get an empty frame",
"// In this example there is only 1 but it could be more",
"identity",
",",
"_",
":=",
"worker",
".",
"Recv",
"(",
"0",
")",
"\n",
"empty",
",",
"_",
":=",
"worker",
".",
"Recv",
"(",
"0",
")",
"\n",
"if",
"empty",
"!=",
"\"",
"\"",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"empty",
")",
")",
"\n",
"}",
"\n\n",
"// Get request, send reply",
"request",
",",
"_",
":=",
"worker",
".",
"Recv",
"(",
"0",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"request",
")",
"\n\n",
"worker",
".",
"Send",
"(",
"identity",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"worker",
".",
"Send",
"(",
"\"",
"\"",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"worker",
".",
"Send",
"(",
"\"",
"\"",
",",
"0",
")",
"\n",
"}",
"\n",
"}"
] |
// While this example runs in a single process, that is just to make
// it easier to start and stop the example.
// This is the worker task, using a REQ socket to do load-balancing.
// Since Go Send and Recv can handle 0MQ binary identities we
// don't need printable text identity to allow routing.
|
[
"While",
"this",
"example",
"runs",
"in",
"a",
"single",
"process",
"that",
"is",
"just",
"to",
"make",
"it",
"easier",
"to",
"start",
"and",
"stop",
"the",
"example",
".",
"This",
"is",
"the",
"worker",
"task",
"using",
"a",
"REQ",
"socket",
"to",
"do",
"load",
"-",
"balancing",
".",
"Since",
"Go",
"Send",
"and",
"Recv",
"can",
"handle",
"0MQ",
"binary",
"identities",
"we",
"don",
"t",
"need",
"printable",
"text",
"identity",
"to",
"allow",
"routing",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker.go#L43-L69
|
143,365 |
pebbe/zmq4
|
examples/lbbroker.go
|
main
|
func main() {
// Prepare our sockets
frontend, _ := zmq.NewSocket(zmq.ROUTER)
backend, _ := zmq.NewSocket(zmq.ROUTER)
defer frontend.Close()
defer backend.Close()
frontend.Bind("ipc://frontend.ipc")
backend.Bind("ipc://backend.ipc")
client_nbr := 0
for ; client_nbr < NBR_CLIENTS; client_nbr++ {
go client_task()
}
for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
go worker_task()
}
// Here is the main loop for the least-recently-used queue. It has two
// sockets; a frontend for clients and a backend for workers. It polls
// the backend in all cases, and polls the frontend only when there are
// one or more workers ready. This is a neat way to use 0MQ's own queues
// to hold messages we're not ready to process yet. When we get a client
// reply, we pop the next available worker, and send the request to it,
// including the originating client identity. When a worker replies, we
// re-queue that worker, and we forward the reply to the original client,
// using the reply envelope.
// Queue of available workers
worker_queue := make([]string, 0, 10)
poller1 := zmq.NewPoller()
poller1.Add(backend, zmq.POLLIN)
poller2 := zmq.NewPoller()
poller2.Add(backend, zmq.POLLIN)
poller2.Add(frontend, zmq.POLLIN)
for client_nbr > 0 {
// Poll frontend only if we have available workers
var sockets []zmq.Polled
if len(worker_queue) > 0 {
sockets, _ = poller2.Poll(-1)
} else {
sockets, _ = poller1.Poll(-1)
}
for _, socket := range sockets {
switch socket.Socket {
case backend:
// Handle worker activity on backend
// Queue worker identity for load-balancing
worker_id, _ := backend.Recv(0)
if !(len(worker_queue) < NBR_WORKERS) {
panic("!(len(worker_queue) < NBR_WORKERS)")
}
worker_queue = append(worker_queue, worker_id)
// Second frame is empty
empty, _ := backend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
// Third frame is READY or else a client reply identity
client_id, _ := backend.Recv(0)
// If client reply, send rest back to frontend
if client_id != "READY" {
empty, _ := backend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
reply, _ := backend.Recv(0)
frontend.Send(client_id, zmq.SNDMORE)
frontend.Send("", zmq.SNDMORE)
frontend.Send(reply, 0)
client_nbr--
}
case frontend:
// Here is how we handle a client request:
// Now get next client request, route to last-used worker
// Client request is [identity][empty][request]
client_id, _ := frontend.Recv(0)
empty, _ := frontend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
request, _ := frontend.Recv(0)
backend.Send(worker_queue[0], zmq.SNDMORE)
backend.Send("", zmq.SNDMORE)
backend.Send(client_id, zmq.SNDMORE)
backend.Send("", zmq.SNDMORE)
backend.Send(request, 0)
// Dequeue and drop the next worker identity
worker_queue = worker_queue[1:]
}
}
}
time.Sleep(100 * time.Millisecond)
}
|
go
|
func main() {
// Prepare our sockets
frontend, _ := zmq.NewSocket(zmq.ROUTER)
backend, _ := zmq.NewSocket(zmq.ROUTER)
defer frontend.Close()
defer backend.Close()
frontend.Bind("ipc://frontend.ipc")
backend.Bind("ipc://backend.ipc")
client_nbr := 0
for ; client_nbr < NBR_CLIENTS; client_nbr++ {
go client_task()
}
for worker_nbr := 0; worker_nbr < NBR_WORKERS; worker_nbr++ {
go worker_task()
}
// Here is the main loop for the least-recently-used queue. It has two
// sockets; a frontend for clients and a backend for workers. It polls
// the backend in all cases, and polls the frontend only when there are
// one or more workers ready. This is a neat way to use 0MQ's own queues
// to hold messages we're not ready to process yet. When we get a client
// reply, we pop the next available worker, and send the request to it,
// including the originating client identity. When a worker replies, we
// re-queue that worker, and we forward the reply to the original client,
// using the reply envelope.
// Queue of available workers
worker_queue := make([]string, 0, 10)
poller1 := zmq.NewPoller()
poller1.Add(backend, zmq.POLLIN)
poller2 := zmq.NewPoller()
poller2.Add(backend, zmq.POLLIN)
poller2.Add(frontend, zmq.POLLIN)
for client_nbr > 0 {
// Poll frontend only if we have available workers
var sockets []zmq.Polled
if len(worker_queue) > 0 {
sockets, _ = poller2.Poll(-1)
} else {
sockets, _ = poller1.Poll(-1)
}
for _, socket := range sockets {
switch socket.Socket {
case backend:
// Handle worker activity on backend
// Queue worker identity for load-balancing
worker_id, _ := backend.Recv(0)
if !(len(worker_queue) < NBR_WORKERS) {
panic("!(len(worker_queue) < NBR_WORKERS)")
}
worker_queue = append(worker_queue, worker_id)
// Second frame is empty
empty, _ := backend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
// Third frame is READY or else a client reply identity
client_id, _ := backend.Recv(0)
// If client reply, send rest back to frontend
if client_id != "READY" {
empty, _ := backend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
reply, _ := backend.Recv(0)
frontend.Send(client_id, zmq.SNDMORE)
frontend.Send("", zmq.SNDMORE)
frontend.Send(reply, 0)
client_nbr--
}
case frontend:
// Here is how we handle a client request:
// Now get next client request, route to last-used worker
// Client request is [identity][empty][request]
client_id, _ := frontend.Recv(0)
empty, _ := frontend.Recv(0)
if empty != "" {
panic(fmt.Sprintf("empty is not \"\": %q", empty))
}
request, _ := frontend.Recv(0)
backend.Send(worker_queue[0], zmq.SNDMORE)
backend.Send("", zmq.SNDMORE)
backend.Send(client_id, zmq.SNDMORE)
backend.Send("", zmq.SNDMORE)
backend.Send(request, 0)
// Dequeue and drop the next worker identity
worker_queue = worker_queue[1:]
}
}
}
time.Sleep(100 * time.Millisecond)
}
|
[
"func",
"main",
"(",
")",
"{",
"// Prepare our sockets",
"frontend",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"ROUTER",
")",
"\n",
"backend",
",",
"_",
":=",
"zmq",
".",
"NewSocket",
"(",
"zmq",
".",
"ROUTER",
")",
"\n",
"defer",
"frontend",
".",
"Close",
"(",
")",
"\n",
"defer",
"backend",
".",
"Close",
"(",
")",
"\n",
"frontend",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n",
"backend",
".",
"Bind",
"(",
"\"",
"\"",
")",
"\n\n",
"client_nbr",
":=",
"0",
"\n",
"for",
";",
"client_nbr",
"<",
"NBR_CLIENTS",
";",
"client_nbr",
"++",
"{",
"go",
"client_task",
"(",
")",
"\n",
"}",
"\n",
"for",
"worker_nbr",
":=",
"0",
";",
"worker_nbr",
"<",
"NBR_WORKERS",
";",
"worker_nbr",
"++",
"{",
"go",
"worker_task",
"(",
")",
"\n",
"}",
"\n\n",
"// Here is the main loop for the least-recently-used queue. It has two",
"// sockets; a frontend for clients and a backend for workers. It polls",
"// the backend in all cases, and polls the frontend only when there are",
"// one or more workers ready. This is a neat way to use 0MQ's own queues",
"// to hold messages we're not ready to process yet. When we get a client",
"// reply, we pop the next available worker, and send the request to it,",
"// including the originating client identity. When a worker replies, we",
"// re-queue that worker, and we forward the reply to the original client,",
"// using the reply envelope.",
"// Queue of available workers",
"worker_queue",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"10",
")",
"\n\n",
"poller1",
":=",
"zmq",
".",
"NewPoller",
"(",
")",
"\n",
"poller1",
".",
"Add",
"(",
"backend",
",",
"zmq",
".",
"POLLIN",
")",
"\n",
"poller2",
":=",
"zmq",
".",
"NewPoller",
"(",
")",
"\n",
"poller2",
".",
"Add",
"(",
"backend",
",",
"zmq",
".",
"POLLIN",
")",
"\n",
"poller2",
".",
"Add",
"(",
"frontend",
",",
"zmq",
".",
"POLLIN",
")",
"\n\n",
"for",
"client_nbr",
">",
"0",
"{",
"// Poll frontend only if we have available workers",
"var",
"sockets",
"[",
"]",
"zmq",
".",
"Polled",
"\n",
"if",
"len",
"(",
"worker_queue",
")",
">",
"0",
"{",
"sockets",
",",
"_",
"=",
"poller2",
".",
"Poll",
"(",
"-",
"1",
")",
"\n",
"}",
"else",
"{",
"sockets",
",",
"_",
"=",
"poller1",
".",
"Poll",
"(",
"-",
"1",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"socket",
":=",
"range",
"sockets",
"{",
"switch",
"socket",
".",
"Socket",
"{",
"case",
"backend",
":",
"// Handle worker activity on backend",
"// Queue worker identity for load-balancing",
"worker_id",
",",
"_",
":=",
"backend",
".",
"Recv",
"(",
"0",
")",
"\n",
"if",
"!",
"(",
"len",
"(",
"worker_queue",
")",
"<",
"NBR_WORKERS",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"worker_queue",
"=",
"append",
"(",
"worker_queue",
",",
"worker_id",
")",
"\n\n",
"// Second frame is empty",
"empty",
",",
"_",
":=",
"backend",
".",
"Recv",
"(",
"0",
")",
"\n",
"if",
"empty",
"!=",
"\"",
"\"",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"empty",
")",
")",
"\n",
"}",
"\n\n",
"// Third frame is READY or else a client reply identity",
"client_id",
",",
"_",
":=",
"backend",
".",
"Recv",
"(",
"0",
")",
"\n\n",
"// If client reply, send rest back to frontend",
"if",
"client_id",
"!=",
"\"",
"\"",
"{",
"empty",
",",
"_",
":=",
"backend",
".",
"Recv",
"(",
"0",
")",
"\n",
"if",
"empty",
"!=",
"\"",
"\"",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"empty",
")",
")",
"\n",
"}",
"\n",
"reply",
",",
"_",
":=",
"backend",
".",
"Recv",
"(",
"0",
")",
"\n",
"frontend",
".",
"Send",
"(",
"client_id",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"frontend",
".",
"Send",
"(",
"\"",
"\"",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"frontend",
".",
"Send",
"(",
"reply",
",",
"0",
")",
"\n",
"client_nbr",
"--",
"\n",
"}",
"\n\n",
"case",
"frontend",
":",
"// Here is how we handle a client request:",
"// Now get next client request, route to last-used worker",
"// Client request is [identity][empty][request]",
"client_id",
",",
"_",
":=",
"frontend",
".",
"Recv",
"(",
"0",
")",
"\n",
"empty",
",",
"_",
":=",
"frontend",
".",
"Recv",
"(",
"0",
")",
"\n",
"if",
"empty",
"!=",
"\"",
"\"",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"empty",
")",
")",
"\n",
"}",
"\n",
"request",
",",
"_",
":=",
"frontend",
".",
"Recv",
"(",
"0",
")",
"\n\n",
"backend",
".",
"Send",
"(",
"worker_queue",
"[",
"0",
"]",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"backend",
".",
"Send",
"(",
"\"",
"\"",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"backend",
".",
"Send",
"(",
"client_id",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"backend",
".",
"Send",
"(",
"\"",
"\"",
",",
"zmq",
".",
"SNDMORE",
")",
"\n",
"backend",
".",
"Send",
"(",
"request",
",",
"0",
")",
"\n\n",
"// Dequeue and drop the next worker identity",
"worker_queue",
"=",
"worker_queue",
"[",
"1",
":",
"]",
"\n\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"time",
".",
"Sleep",
"(",
"100",
"*",
"time",
".",
"Millisecond",
")",
"\n",
"}"
] |
// This is the main task. It starts the clients and workers, and then
// routes requests between the two layers. Workers signal READY when
// they start; after that we treat them as ready when they reply with
// a response back to a client. The load-balancing data structure is
// just a queue of next available workers.
|
[
"This",
"is",
"the",
"main",
"task",
".",
"It",
"starts",
"the",
"clients",
"and",
"workers",
"and",
"then",
"routes",
"requests",
"between",
"the",
"two",
"layers",
".",
"Workers",
"signal",
"READY",
"when",
"they",
"start",
";",
"after",
"that",
"we",
"treat",
"them",
"as",
"ready",
"when",
"they",
"reply",
"with",
"a",
"response",
"back",
"to",
"a",
"client",
".",
"The",
"load",
"-",
"balancing",
"data",
"structure",
"is",
"just",
"a",
"queue",
"of",
"next",
"available",
"workers",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/lbbroker.go#L77-L181
|
143,366 |
pebbe/zmq4
|
examples/bstar/bstar.go
|
recv_state
|
func (bstar *Bstar) recv_state() (err error) {
msg, err := bstar.statesub.RecvMessage(0)
if err == nil {
e, _ := strconv.Atoi(msg[0])
bstar.event = event_t(e)
}
return bstar.execute_fsm()
}
|
go
|
func (bstar *Bstar) recv_state() (err error) {
msg, err := bstar.statesub.RecvMessage(0)
if err == nil {
e, _ := strconv.Atoi(msg[0])
bstar.event = event_t(e)
}
return bstar.execute_fsm()
}
|
[
"func",
"(",
"bstar",
"*",
"Bstar",
")",
"recv_state",
"(",
")",
"(",
"err",
"error",
")",
"{",
"msg",
",",
"err",
":=",
"bstar",
".",
"statesub",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"e",
",",
"_",
":=",
"strconv",
".",
"Atoi",
"(",
"msg",
"[",
"0",
"]",
")",
"\n",
"bstar",
".",
"event",
"=",
"event_t",
"(",
"e",
")",
"\n",
"}",
"\n",
"return",
"bstar",
".",
"execute_fsm",
"(",
")",
"\n",
"}"
] |
// Receive state from peer, execute finite state machine
|
[
"Receive",
"state",
"from",
"peer",
"execute",
"finite",
"state",
"machine"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/bstar/bstar.go#L170-L177
|
143,367 |
pebbe/zmq4
|
examples/bstar/bstar.go
|
voter_ready
|
func (bstar *Bstar) voter_ready(socket *zmq.Socket) error {
// If server can accept input now, call appl handler
bstar.event = client_REQUEST
err := bstar.execute_fsm()
if err == nil {
bstar.voter_fn(socket)
} else {
// Destroy waiting message, no-one to read it
socket.RecvMessage(0)
}
return nil
}
|
go
|
func (bstar *Bstar) voter_ready(socket *zmq.Socket) error {
// If server can accept input now, call appl handler
bstar.event = client_REQUEST
err := bstar.execute_fsm()
if err == nil {
bstar.voter_fn(socket)
} else {
// Destroy waiting message, no-one to read it
socket.RecvMessage(0)
}
return nil
}
|
[
"func",
"(",
"bstar",
"*",
"Bstar",
")",
"voter_ready",
"(",
"socket",
"*",
"zmq",
".",
"Socket",
")",
"error",
"{",
"// If server can accept input now, call appl handler",
"bstar",
".",
"event",
"=",
"client_REQUEST",
"\n",
"err",
":=",
"bstar",
".",
"execute_fsm",
"(",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"bstar",
".",
"voter_fn",
"(",
"socket",
")",
"\n",
"}",
"else",
"{",
"// Destroy waiting message, no-one to read it",
"socket",
".",
"RecvMessage",
"(",
"0",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Application wants to speak to us, see if it's possible
|
[
"Application",
"wants",
"to",
"speak",
"to",
"us",
"see",
"if",
"it",
"s",
"possible"
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/examples/bstar/bstar.go#L180-L191
|
143,368 |
pebbe/zmq4
|
reactor.go
|
RemoveSocket
|
func (r *Reactor) RemoveSocket(soc *Socket) {
if _, ok := r.sockets[soc]; ok {
delete(r.sockets, soc)
// rebuild poller
r.p = NewPoller()
for s, props := range r.sockets {
r.p.Add(s, props.e)
}
}
}
|
go
|
func (r *Reactor) RemoveSocket(soc *Socket) {
if _, ok := r.sockets[soc]; ok {
delete(r.sockets, soc)
// rebuild poller
r.p = NewPoller()
for s, props := range r.sockets {
r.p.Add(s, props.e)
}
}
}
|
[
"func",
"(",
"r",
"*",
"Reactor",
")",
"RemoveSocket",
"(",
"soc",
"*",
"Socket",
")",
"{",
"if",
"_",
",",
"ok",
":=",
"r",
".",
"sockets",
"[",
"soc",
"]",
";",
"ok",
"{",
"delete",
"(",
"r",
".",
"sockets",
",",
"soc",
")",
"\n",
"// rebuild poller",
"r",
".",
"p",
"=",
"NewPoller",
"(",
")",
"\n",
"for",
"s",
",",
"props",
":=",
"range",
"r",
".",
"sockets",
"{",
"r",
".",
"p",
".",
"Add",
"(",
"s",
",",
"props",
".",
"e",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Remove a socket handler from the reactor.
|
[
"Remove",
"a",
"socket",
"handler",
"from",
"the",
"reactor",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/reactor.go#L62-L71
|
143,369 |
pebbe/zmq4
|
reactor.go
|
AddChannel
|
func (r *Reactor) AddChannel(ch <-chan interface{}, limit int, handler func(interface{}) error) (id uint64) {
r.idx++
id = r.idx
r.channels[id] = &reactor_channel{ch: ch, f: handler, limit: limit}
return
}
|
go
|
func (r *Reactor) AddChannel(ch <-chan interface{}, limit int, handler func(interface{}) error) (id uint64) {
r.idx++
id = r.idx
r.channels[id] = &reactor_channel{ch: ch, f: handler, limit: limit}
return
}
|
[
"func",
"(",
"r",
"*",
"Reactor",
")",
"AddChannel",
"(",
"ch",
"<-",
"chan",
"interface",
"{",
"}",
",",
"limit",
"int",
",",
"handler",
"func",
"(",
"interface",
"{",
"}",
")",
"error",
")",
"(",
"id",
"uint64",
")",
"{",
"r",
".",
"idx",
"++",
"\n",
"id",
"=",
"r",
".",
"idx",
"\n",
"r",
".",
"channels",
"[",
"id",
"]",
"=",
"&",
"reactor_channel",
"{",
"ch",
":",
"ch",
",",
"f",
":",
"handler",
",",
"limit",
":",
"limit",
"}",
"\n",
"return",
"\n",
"}"
] |
// Add channel handler to the reactor.
//
// Returns id of added handler, that can be used later to remove it.
//
// If limit is positive, at most this many items will be handled in each run through the main loop,
// otherwise it will process as many items as possible.
//
// The handler function receives the value received from the channel.
|
[
"Add",
"channel",
"handler",
"to",
"the",
"reactor",
".",
"Returns",
"id",
"of",
"added",
"handler",
"that",
"can",
"be",
"used",
"later",
"to",
"remove",
"it",
".",
"If",
"limit",
"is",
"positive",
"at",
"most",
"this",
"many",
"items",
"will",
"be",
"handled",
"in",
"each",
"run",
"through",
"the",
"main",
"loop",
"otherwise",
"it",
"will",
"process",
"as",
"many",
"items",
"as",
"possible",
".",
"The",
"handler",
"function",
"receives",
"the",
"value",
"received",
"from",
"the",
"channel",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/reactor.go#L81-L86
|
143,370 |
pebbe/zmq4
|
reactor.go
|
RemoveChannel
|
func (r *Reactor) RemoveChannel(id uint64) {
r.remove = append(r.remove, id)
}
|
go
|
func (r *Reactor) RemoveChannel(id uint64) {
r.remove = append(r.remove, id)
}
|
[
"func",
"(",
"r",
"*",
"Reactor",
")",
"RemoveChannel",
"(",
"id",
"uint64",
")",
"{",
"r",
".",
"remove",
"=",
"append",
"(",
"r",
".",
"remove",
",",
"id",
")",
"\n",
"}"
] |
// Remove a channel from the reactor.
//
// Closed channels are removed automatically.
|
[
"Remove",
"a",
"channel",
"from",
"the",
"reactor",
".",
"Closed",
"channels",
"are",
"removed",
"automatically",
"."
] |
7a493a642e7acbd03045d4f5fe9516908a62f86f
|
https://github.com/pebbe/zmq4/blob/7a493a642e7acbd03045d4f5fe9516908a62f86f/reactor.go#L107-L109
|
143,371 |
kardianos/osext
|
osext.go
|
ExecutableFolder
|
func ExecutableFolder() (string, error) {
p, err := Executable()
if err != nil {
return "", err
}
return filepath.Dir(p), nil
}
|
go
|
func ExecutableFolder() (string, error) {
p, err := Executable()
if err != nil {
return "", err
}
return filepath.Dir(p), nil
}
|
[
"func",
"ExecutableFolder",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"Executable",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"filepath",
".",
"Dir",
"(",
"p",
")",
",",
"nil",
"\n",
"}"
] |
// Returns same path as Executable, returns just the folder
// path. Excludes the executable name and any trailing slash.
|
[
"Returns",
"same",
"path",
"as",
"Executable",
"returns",
"just",
"the",
"folder",
"path",
".",
"Excludes",
"the",
"executable",
"name",
"and",
"any",
"trailing",
"slash",
"."
] |
2bc1f35cddc0cc527b4bc3dce8578fc2a6c11384
|
https://github.com/kardianos/osext/blob/2bc1f35cddc0cc527b4bc3dce8578fc2a6c11384/osext.go#L26-L33
|
143,372 |
cloudfoundry/bosh-cli
|
stemcell/mocks/mocks.go
|
NewMockCloudStemcell
|
func NewMockCloudStemcell(ctrl *gomock.Controller) *MockCloudStemcell {
mock := &MockCloudStemcell{ctrl: ctrl}
mock.recorder = &MockCloudStemcellMockRecorder{mock}
return mock
}
|
go
|
func NewMockCloudStemcell(ctrl *gomock.Controller) *MockCloudStemcell {
mock := &MockCloudStemcell{ctrl: ctrl}
mock.recorder = &MockCloudStemcellMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockCloudStemcell",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCloudStemcell",
"{",
"mock",
":=",
"&",
"MockCloudStemcell",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCloudStemcellMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockCloudStemcell creates a new mock instance
|
[
"NewMockCloudStemcell",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/stemcell/mocks/mocks.go#L26-L30
|
143,373 |
cloudfoundry/bosh-cli
|
stemcell/mocks/mocks.go
|
CID
|
func (mr *MockCloudStemcellMockRecorder) CID() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CID", reflect.TypeOf((*MockCloudStemcell)(nil).CID))
}
|
go
|
func (mr *MockCloudStemcellMockRecorder) CID() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CID", reflect.TypeOf((*MockCloudStemcell)(nil).CID))
}
|
[
"func",
"(",
"mr",
"*",
"MockCloudStemcellMockRecorder",
")",
"CID",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCloudStemcell",
")",
"(",
"nil",
")",
".",
"CID",
")",
")",
"\n",
"}"
] |
// CID indicates an expected call of CID
|
[
"CID",
"indicates",
"an",
"expected",
"call",
"of",
"CID"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/stemcell/mocks/mocks.go#L45-L47
|
143,374 |
cloudfoundry/bosh-cli
|
stemcell/mocks/mocks.go
|
DeleteUnused
|
func (m *MockManager) DeleteUnused(arg0 ui.Stage) error {
ret := m.ctrl.Call(m, "DeleteUnused", arg0)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockManager) DeleteUnused(arg0 ui.Stage) error {
ret := m.ctrl.Call(m, "DeleteUnused", arg0)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockManager",
")",
"DeleteUnused",
"(",
"arg0",
"ui",
".",
"Stage",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// DeleteUnused mocks base method
|
[
"DeleteUnused",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/stemcell/mocks/mocks.go#L121-L125
|
143,375 |
cloudfoundry/bosh-cli
|
stemcell/mocks/mocks.go
|
Upload
|
func (m *MockManager) Upload(arg0 stemcell.ExtractedStemcell, arg1 ui.Stage) (stemcell.CloudStemcell, error) {
ret := m.ctrl.Call(m, "Upload", arg0, arg1)
ret0, _ := ret[0].(stemcell.CloudStemcell)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockManager) Upload(arg0 stemcell.ExtractedStemcell, arg1 ui.Stage) (stemcell.CloudStemcell, error) {
ret := m.ctrl.Call(m, "Upload", arg0, arg1)
ret0, _ := ret[0].(stemcell.CloudStemcell)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockManager",
")",
"Upload",
"(",
"arg0",
"stemcell",
".",
"ExtractedStemcell",
",",
"arg1",
"ui",
".",
"Stage",
")",
"(",
"stemcell",
".",
"CloudStemcell",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"stemcell",
".",
"CloudStemcell",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// Upload mocks base method
|
[
"Upload",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/stemcell/mocks/mocks.go#L159-L164
|
143,376 |
cloudfoundry/bosh-cli
|
deployment/release/mocks/mocks.go
|
NewMockJobResolver
|
func NewMockJobResolver(ctrl *gomock.Controller) *MockJobResolver {
mock := &MockJobResolver{ctrl: ctrl}
mock.recorder = &MockJobResolverMockRecorder{mock}
return mock
}
|
go
|
func NewMockJobResolver(ctrl *gomock.Controller) *MockJobResolver {
mock := &MockJobResolver{ctrl: ctrl}
mock.recorder = &MockJobResolverMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockJobResolver",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockJobResolver",
"{",
"mock",
":=",
"&",
"MockJobResolver",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockJobResolverMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockJobResolver creates a new mock instance
|
[
"NewMockJobResolver",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/deployment/release/mocks/mocks.go#L25-L29
|
143,377 |
cloudfoundry/bosh-cli
|
state/job/mocks/mocks.go
|
NewMockDependencyCompiler
|
func NewMockDependencyCompiler(ctrl *gomock.Controller) *MockDependencyCompiler {
mock := &MockDependencyCompiler{ctrl: ctrl}
mock.recorder = &MockDependencyCompilerMockRecorder{mock}
return mock
}
|
go
|
func NewMockDependencyCompiler(ctrl *gomock.Controller) *MockDependencyCompiler {
mock := &MockDependencyCompiler{ctrl: ctrl}
mock.recorder = &MockDependencyCompilerMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockDependencyCompiler",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockDependencyCompiler",
"{",
"mock",
":=",
"&",
"MockDependencyCompiler",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockDependencyCompilerMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockDependencyCompiler creates a new mock instance
|
[
"NewMockDependencyCompiler",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/state/job/mocks/mocks.go#L27-L31
|
143,378 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockJobRenderer
|
func NewMockJobRenderer(ctrl *gomock.Controller) *MockJobRenderer {
mock := &MockJobRenderer{ctrl: ctrl}
mock.recorder = &MockJobRendererMockRecorder{mock}
return mock
}
|
go
|
func NewMockJobRenderer(ctrl *gomock.Controller) *MockJobRenderer {
mock := &MockJobRenderer{ctrl: ctrl}
mock.recorder = &MockJobRendererMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockJobRenderer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockJobRenderer",
"{",
"mock",
":=",
"&",
"MockJobRenderer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockJobRendererMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockJobRenderer creates a new mock instance
|
[
"NewMockJobRenderer",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L27-L31
|
143,379 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Render
|
func (m *MockJobRenderer) Render(arg0 job.Job, arg1 *property.Map, arg2, arg3 property.Map, arg4, arg5 string) (templatescompiler.RenderedJob, error) {
ret := m.ctrl.Call(m, "Render", arg0, arg1, arg2, arg3, arg4, arg5)
ret0, _ := ret[0].(templatescompiler.RenderedJob)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockJobRenderer) Render(arg0 job.Job, arg1 *property.Map, arg2, arg3 property.Map, arg4, arg5 string) (templatescompiler.RenderedJob, error) {
ret := m.ctrl.Call(m, "Render", arg0, arg1, arg2, arg3, arg4, arg5)
ret0, _ := ret[0].(templatescompiler.RenderedJob)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockJobRenderer",
")",
"Render",
"(",
"arg0",
"job",
".",
"Job",
",",
"arg1",
"*",
"property",
".",
"Map",
",",
"arg2",
",",
"arg3",
"property",
".",
"Map",
",",
"arg4",
",",
"arg5",
"string",
")",
"(",
"templatescompiler",
".",
"RenderedJob",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
",",
"arg5",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"templatescompiler",
".",
"RenderedJob",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// Render mocks base method
|
[
"Render",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L39-L44
|
143,380 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Render
|
func (mr *MockJobRendererMockRecorder) Render(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Render", reflect.TypeOf((*MockJobRenderer)(nil).Render), arg0, arg1, arg2, arg3, arg4, arg5)
}
|
go
|
func (mr *MockJobRendererMockRecorder) Render(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Render", reflect.TypeOf((*MockJobRenderer)(nil).Render), arg0, arg1, arg2, arg3, arg4, arg5)
}
|
[
"func",
"(",
"mr",
"*",
"MockJobRendererMockRecorder",
")",
"Render",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
",",
"arg5",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockJobRenderer",
")",
"(",
"nil",
")",
".",
"Render",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
",",
"arg5",
")",
"\n",
"}"
] |
// Render indicates an expected call of Render
|
[
"Render",
"indicates",
"an",
"expected",
"call",
"of",
"Render"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L47-L49
|
143,381 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockJobListRenderer
|
func NewMockJobListRenderer(ctrl *gomock.Controller) *MockJobListRenderer {
mock := &MockJobListRenderer{ctrl: ctrl}
mock.recorder = &MockJobListRendererMockRecorder{mock}
return mock
}
|
go
|
func NewMockJobListRenderer(ctrl *gomock.Controller) *MockJobListRenderer {
mock := &MockJobListRenderer{ctrl: ctrl}
mock.recorder = &MockJobListRendererMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockJobListRenderer",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockJobListRenderer",
"{",
"mock",
":=",
"&",
"MockJobListRenderer",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockJobListRendererMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockJobListRenderer creates a new mock instance
|
[
"NewMockJobListRenderer",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L63-L67
|
143,382 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockRenderedJob
|
func NewMockRenderedJob(ctrl *gomock.Controller) *MockRenderedJob {
mock := &MockRenderedJob{ctrl: ctrl}
mock.recorder = &MockRenderedJobMockRecorder{mock}
return mock
}
|
go
|
func NewMockRenderedJob(ctrl *gomock.Controller) *MockRenderedJob {
mock := &MockRenderedJob{ctrl: ctrl}
mock.recorder = &MockRenderedJobMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRenderedJob",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRenderedJob",
"{",
"mock",
":=",
"&",
"MockRenderedJob",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRenderedJobMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRenderedJob creates a new mock instance
|
[
"NewMockRenderedJob",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L99-L103
|
143,383 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Path
|
func (m *MockRenderedJob) Path() string {
ret := m.ctrl.Call(m, "Path")
ret0, _ := ret[0].(string)
return ret0
}
|
go
|
func (m *MockRenderedJob) Path() string {
ret := m.ctrl.Call(m, "Path")
ret0, _ := ret[0].(string)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockRenderedJob",
")",
"Path",
"(",
")",
"string",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// Path mocks base method
|
[
"Path",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L145-L149
|
143,384 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Path
|
func (mr *MockRenderedJobMockRecorder) Path() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockRenderedJob)(nil).Path))
}
|
go
|
func (mr *MockRenderedJobMockRecorder) Path() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Path", reflect.TypeOf((*MockRenderedJob)(nil).Path))
}
|
[
"func",
"(",
"mr",
"*",
"MockRenderedJobMockRecorder",
")",
"Path",
"(",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRenderedJob",
")",
"(",
"nil",
")",
".",
"Path",
")",
")",
"\n",
"}"
] |
// Path indicates an expected call of Path
|
[
"Path",
"indicates",
"an",
"expected",
"call",
"of",
"Path"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L152-L154
|
143,385 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockRenderedJobList
|
func NewMockRenderedJobList(ctrl *gomock.Controller) *MockRenderedJobList {
mock := &MockRenderedJobList{ctrl: ctrl}
mock.recorder = &MockRenderedJobListMockRecorder{mock}
return mock
}
|
go
|
func NewMockRenderedJobList(ctrl *gomock.Controller) *MockRenderedJobList {
mock := &MockRenderedJobList{ctrl: ctrl}
mock.recorder = &MockRenderedJobListMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRenderedJobList",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRenderedJobList",
"{",
"mock",
":=",
"&",
"MockRenderedJobList",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRenderedJobListMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRenderedJobList creates a new mock instance
|
[
"NewMockRenderedJobList",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L168-L172
|
143,386 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockRenderedJobListArchive
|
func NewMockRenderedJobListArchive(ctrl *gomock.Controller) *MockRenderedJobListArchive {
mock := &MockRenderedJobListArchive{ctrl: ctrl}
mock.recorder = &MockRenderedJobListArchiveMockRecorder{mock}
return mock
}
|
go
|
func NewMockRenderedJobListArchive(ctrl *gomock.Controller) *MockRenderedJobListArchive {
mock := &MockRenderedJobListArchive{ctrl: ctrl}
mock.recorder = &MockRenderedJobListArchiveMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRenderedJobListArchive",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRenderedJobListArchive",
"{",
"mock",
":=",
"&",
"MockRenderedJobListArchive",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRenderedJobListArchiveMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRenderedJobListArchive creates a new mock instance
|
[
"NewMockRenderedJobListArchive",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L235-L239
|
143,387 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
NewMockRenderedJobListCompressor
|
func NewMockRenderedJobListCompressor(ctrl *gomock.Controller) *MockRenderedJobListCompressor {
mock := &MockRenderedJobListCompressor{ctrl: ctrl}
mock.recorder = &MockRenderedJobListCompressorMockRecorder{mock}
return mock
}
|
go
|
func NewMockRenderedJobListCompressor(ctrl *gomock.Controller) *MockRenderedJobListCompressor {
mock := &MockRenderedJobListCompressor{ctrl: ctrl}
mock.recorder = &MockRenderedJobListCompressorMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockRenderedJobListCompressor",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockRenderedJobListCompressor",
"{",
"mock",
":=",
"&",
"MockRenderedJobListCompressor",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockRenderedJobListCompressorMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockRenderedJobListCompressor creates a new mock instance
|
[
"NewMockRenderedJobListCompressor",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L316-L320
|
143,388 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Compress
|
func (m *MockRenderedJobListCompressor) Compress(arg0 templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error) {
ret := m.ctrl.Call(m, "Compress", arg0)
ret0, _ := ret[0].(templatescompiler.RenderedJobListArchive)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockRenderedJobListCompressor) Compress(arg0 templatescompiler.RenderedJobList) (templatescompiler.RenderedJobListArchive, error) {
ret := m.ctrl.Call(m, "Compress", arg0)
ret0, _ := ret[0].(templatescompiler.RenderedJobListArchive)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockRenderedJobListCompressor",
")",
"Compress",
"(",
"arg0",
"templatescompiler",
".",
"RenderedJobList",
")",
"(",
"templatescompiler",
".",
"RenderedJobListArchive",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"templatescompiler",
".",
"RenderedJobListArchive",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// Compress mocks base method
|
[
"Compress",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L328-L333
|
143,389 |
cloudfoundry/bosh-cli
|
templatescompiler/mocks/mocks.go
|
Compress
|
func (mr *MockRenderedJobListCompressorMockRecorder) Compress(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compress", reflect.TypeOf((*MockRenderedJobListCompressor)(nil).Compress), arg0)
}
|
go
|
func (mr *MockRenderedJobListCompressorMockRecorder) Compress(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Compress", reflect.TypeOf((*MockRenderedJobListCompressor)(nil).Compress), arg0)
}
|
[
"func",
"(",
"mr",
"*",
"MockRenderedJobListCompressorMockRecorder",
")",
"Compress",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockRenderedJobListCompressor",
")",
"(",
"nil",
")",
".",
"Compress",
")",
",",
"arg0",
")",
"\n",
"}"
] |
// Compress indicates an expected call of Compress
|
[
"Compress",
"indicates",
"an",
"expected",
"call",
"of",
"Compress"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/templatescompiler/mocks/mocks.go#L336-L338
|
143,390 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
NewMockCloud
|
func NewMockCloud(ctrl *gomock.Controller) *MockCloud {
mock := &MockCloud{ctrl: ctrl}
mock.recorder = &MockCloudMockRecorder{mock}
return mock
}
|
go
|
func NewMockCloud(ctrl *gomock.Controller) *MockCloud {
mock := &MockCloud{ctrl: ctrl}
mock.recorder = &MockCloudMockRecorder{mock}
return mock
}
|
[
"func",
"NewMockCloud",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockCloud",
"{",
"mock",
":=",
"&",
"MockCloud",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockCloudMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] |
// NewMockCloud creates a new mock instance
|
[
"NewMockCloud",
"creates",
"a",
"new",
"mock",
"instance"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L27-L31
|
143,391 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
AttachDisk
|
func (m *MockCloud) AttachDisk(arg0, arg1 string) (interface{}, error) {
ret := m.ctrl.Call(m, "AttachDisk", arg0, arg1)
ret0, _ := ret[0].(interface{})
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockCloud) AttachDisk(arg0, arg1 string) (interface{}, error) {
ret := m.ctrl.Call(m, "AttachDisk", arg0, arg1)
ret0, _ := ret[0].(interface{})
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"AttachDisk",
"(",
"arg0",
",",
"arg1",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"interface",
"{",
"}",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// AttachDisk mocks base method
|
[
"AttachDisk",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L39-L44
|
143,392 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
CreateDisk
|
func (m *MockCloud) CreateDisk(arg0 int, arg1 property.Map, arg2 string) (string, error) {
ret := m.ctrl.Call(m, "CreateDisk", arg0, arg1, arg2)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockCloud) CreateDisk(arg0 int, arg1 property.Map, arg2 string) (string, error) {
ret := m.ctrl.Call(m, "CreateDisk", arg0, arg1, arg2)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"CreateDisk",
"(",
"arg0",
"int",
",",
"arg1",
"property",
".",
"Map",
",",
"arg2",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// CreateDisk mocks base method
|
[
"CreateDisk",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L52-L57
|
143,393 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
CreateStemcell
|
func (m *MockCloud) CreateStemcell(arg0 string, arg1 property.Map) (string, error) {
ret := m.ctrl.Call(m, "CreateStemcell", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockCloud) CreateStemcell(arg0 string, arg1 property.Map) (string, error) {
ret := m.ctrl.Call(m, "CreateStemcell", arg0, arg1)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"CreateStemcell",
"(",
"arg0",
"string",
",",
"arg1",
"property",
".",
"Map",
")",
"(",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// CreateStemcell mocks base method
|
[
"CreateStemcell",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L65-L70
|
143,394 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
CreateVM
|
func (m *MockCloud) CreateVM(arg0, arg1 string, arg2 property.Map, arg3 map[string]property.Map, arg4 property.Map) (string, error) {
ret := m.ctrl.Call(m, "CreateVM", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockCloud) CreateVM(arg0, arg1 string, arg2 property.Map, arg3 map[string]property.Map, arg4 property.Map) (string, error) {
ret := m.ctrl.Call(m, "CreateVM", arg0, arg1, arg2, arg3, arg4)
ret0, _ := ret[0].(string)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"CreateVM",
"(",
"arg0",
",",
"arg1",
"string",
",",
"arg2",
"property",
".",
"Map",
",",
"arg3",
"map",
"[",
"string",
"]",
"property",
".",
"Map",
",",
"arg4",
"property",
".",
"Map",
")",
"(",
"string",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"string",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// CreateVM mocks base method
|
[
"CreateVM",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L78-L83
|
143,395 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
CreateVM
|
func (mr *MockCloudMockRecorder) CreateVM(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVM", reflect.TypeOf((*MockCloud)(nil).CreateVM), arg0, arg1, arg2, arg3, arg4)
}
|
go
|
func (mr *MockCloudMockRecorder) CreateVM(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVM", reflect.TypeOf((*MockCloud)(nil).CreateVM), arg0, arg1, arg2, arg3, arg4)
}
|
[
"func",
"(",
"mr",
"*",
"MockCloudMockRecorder",
")",
"CreateVM",
"(",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCloud",
")",
"(",
"nil",
")",
".",
"CreateVM",
")",
",",
"arg0",
",",
"arg1",
",",
"arg2",
",",
"arg3",
",",
"arg4",
")",
"\n",
"}"
] |
// CreateVM indicates an expected call of CreateVM
|
[
"CreateVM",
"indicates",
"an",
"expected",
"call",
"of",
"CreateVM"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L86-L88
|
143,396 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
DeleteDisk
|
func (m *MockCloud) DeleteDisk(arg0 string) error {
ret := m.ctrl.Call(m, "DeleteDisk", arg0)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockCloud) DeleteDisk(arg0 string) error {
ret := m.ctrl.Call(m, "DeleteDisk", arg0)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"DeleteDisk",
"(",
"arg0",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// DeleteDisk mocks base method
|
[
"DeleteDisk",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L91-L95
|
143,397 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
DetachDisk
|
func (m *MockCloud) DetachDisk(arg0, arg1 string) error {
ret := m.ctrl.Call(m, "DetachDisk", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
|
go
|
func (m *MockCloud) DetachDisk(arg0, arg1 string) error {
ret := m.ctrl.Call(m, "DetachDisk", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"DetachDisk",
"(",
"arg0",
",",
"arg1",
"string",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] |
// DetachDisk mocks base method
|
[
"DetachDisk",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L127-L131
|
143,398 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
DetachDisk
|
func (mr *MockCloudMockRecorder) DetachDisk(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockCloud)(nil).DetachDisk), arg0, arg1)
}
|
go
|
func (mr *MockCloudMockRecorder) DetachDisk(arg0, arg1 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachDisk", reflect.TypeOf((*MockCloud)(nil).DetachDisk), arg0, arg1)
}
|
[
"func",
"(",
"mr",
"*",
"MockCloudMockRecorder",
")",
"DetachDisk",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockCloud",
")",
"(",
"nil",
")",
".",
"DetachDisk",
")",
",",
"arg0",
",",
"arg1",
")",
"\n",
"}"
] |
// DetachDisk indicates an expected call of DetachDisk
|
[
"DetachDisk",
"indicates",
"an",
"expected",
"call",
"of",
"DetachDisk"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L134-L136
|
143,399 |
cloudfoundry/bosh-cli
|
cloud/mocks/mocks.go
|
HasVM
|
func (m *MockCloud) HasVM(arg0 string) (bool, error) {
ret := m.ctrl.Call(m, "HasVM", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
go
|
func (m *MockCloud) HasVM(arg0 string) (bool, error) {
ret := m.ctrl.Call(m, "HasVM", arg0)
ret0, _ := ret[0].(bool)
ret1, _ := ret[1].(error)
return ret0, ret1
}
|
[
"func",
"(",
"m",
"*",
"MockCloud",
")",
"HasVM",
"(",
"arg0",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"bool",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] |
// HasVM mocks base method
|
[
"HasVM",
"mocks",
"base",
"method"
] |
0ee5b2abedb27e521dc6e70719023e7b382cab79
|
https://github.com/cloudfoundry/bosh-cli/blob/0ee5b2abedb27e521dc6e70719023e7b382cab79/cloud/mocks/mocks.go#L139-L144
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.