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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
RoaringBitmap/roaring | roaring.go | Or | func (rb *Bitmap) Or(x2 *Bitmap) {
pos1 := 0
pos2 := 0
length1 := rb.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for (pos1 < length1) && (pos2 < length2) {
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
pos1++
if pos1 == length1 {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 > s2 {
rb.highlowcontainer.insertNewKeyValueAt(pos1, s2, x2.highlowcontainer.getContainerAtIndex(pos2).clone())
pos1++
length1++
pos2++
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else {
rb.highlowcontainer.replaceKeyAndContainerAtIndex(pos1, s1, rb.highlowcontainer.getWritableContainerAtIndex(pos1).ior(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
if pos1 == length1 {
rb.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
}
} | go | func (rb *Bitmap) Or(x2 *Bitmap) {
pos1 := 0
pos2 := 0
length1 := rb.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for (pos1 < length1) && (pos2 < length2) {
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
pos1++
if pos1 == length1 {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 > s2 {
rb.highlowcontainer.insertNewKeyValueAt(pos1, s2, x2.highlowcontainer.getContainerAtIndex(pos2).clone())
pos1++
length1++
pos2++
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else {
rb.highlowcontainer.replaceKeyAndContainerAtIndex(pos1, s1, rb.highlowcontainer.getWritableContainerAtIndex(pos1).ior(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
if pos1 == length1 {
rb.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
}
} | [
"func",
"(",
"rb",
"*",
"Bitmap",
")",
"Or",
"(",
"x2",
"*",
"Bitmap",
")",
"{",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"length1",
":=",
"rb",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"main",
":",
"for",
"(",
"pos1",
"<",
"length1",
")",
"&&",
"(",
"pos2",
"<",
"length2",
")",
"{",
"s1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n\n",
"for",
"{",
"if",
"s1",
"<",
"s2",
"{",
"pos1",
"++",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"}",
"else",
"if",
"s1",
">",
"s2",
"{",
"rb",
".",
"highlowcontainer",
".",
"insertNewKeyValueAt",
"(",
"pos1",
",",
"s2",
",",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
".",
"clone",
"(",
")",
")",
"\n",
"pos1",
"++",
"\n",
"length1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"else",
"{",
"rb",
".",
"highlowcontainer",
".",
"replaceKeyAndContainerAtIndex",
"(",
"pos1",
",",
"s1",
",",
"rb",
".",
"highlowcontainer",
".",
"getWritableContainerAtIndex",
"(",
"pos1",
")",
".",
"ior",
"(",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
")",
",",
"false",
")",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"(",
"pos1",
"==",
"length1",
")",
"||",
"(",
"pos2",
"==",
"length2",
")",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"rb",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x2",
".",
"highlowcontainer",
",",
"pos2",
",",
"length2",
")",
"\n",
"}",
"\n",
"}"
] | // Or computes the union between two bitmaps and stores the result in the current bitmap | [
"Or",
"computes",
"the",
"union",
"between",
"two",
"bitmaps",
"and",
"stores",
"the",
"result",
"in",
"the",
"current",
"bitmap"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L841-L882 | train |
RoaringBitmap/roaring | roaring.go | AndNot | func (rb *Bitmap) AndNot(x2 *Bitmap) {
pos1 := 0
pos2 := 0
intersectionsize := 0
length1 := rb.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for {
if pos1 < length1 && pos2 < length2 {
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 == s2 {
c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
diff := c1.iandNot(c2)
if diff.getCardinality() > 0 {
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
intersectionsize++
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else if s1 < s2 {
c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
intersectionsize++
pos1++
if pos1 == length1 {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
} else { //s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
} else {
break
}
}
// TODO:implement as a copy
for pos1 < length1 {
c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
intersectionsize++
pos1++
}
rb.highlowcontainer.resize(intersectionsize)
} | go | func (rb *Bitmap) AndNot(x2 *Bitmap) {
pos1 := 0
pos2 := 0
intersectionsize := 0
length1 := rb.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for {
if pos1 < length1 && pos2 < length2 {
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 == s2 {
c1 := rb.highlowcontainer.getWritableContainerAtIndex(pos1)
c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
diff := c1.iandNot(c2)
if diff.getCardinality() > 0 {
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, diff, false)
intersectionsize++
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else if s1 < s2 {
c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
intersectionsize++
pos1++
if pos1 == length1 {
break main
}
s1 = rb.highlowcontainer.getKeyAtIndex(pos1)
} else { //s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
} else {
break
}
}
// TODO:implement as a copy
for pos1 < length1 {
c1 := rb.highlowcontainer.getContainerAtIndex(pos1)
s1 := rb.highlowcontainer.getKeyAtIndex(pos1)
mustCopyOnWrite := rb.highlowcontainer.needsCopyOnWrite(pos1)
rb.highlowcontainer.replaceKeyAndContainerAtIndex(intersectionsize, s1, c1, mustCopyOnWrite)
intersectionsize++
pos1++
}
rb.highlowcontainer.resize(intersectionsize)
} | [
"func",
"(",
"rb",
"*",
"Bitmap",
")",
"AndNot",
"(",
"x2",
"*",
"Bitmap",
")",
"{",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"intersectionsize",
":=",
"0",
"\n",
"length1",
":=",
"rb",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n\n",
"main",
":",
"for",
"{",
"if",
"pos1",
"<",
"length1",
"&&",
"pos2",
"<",
"length2",
"{",
"s1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"for",
"{",
"if",
"s1",
"==",
"s2",
"{",
"c1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getWritableContainerAtIndex",
"(",
"pos1",
")",
"\n",
"c2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
"\n",
"diff",
":=",
"c1",
".",
"iandNot",
"(",
"c2",
")",
"\n",
"if",
"diff",
".",
"getCardinality",
"(",
")",
">",
"0",
"{",
"rb",
".",
"highlowcontainer",
".",
"replaceKeyAndContainerAtIndex",
"(",
"intersectionsize",
",",
"s1",
",",
"diff",
",",
"false",
")",
"\n",
"intersectionsize",
"++",
"\n",
"}",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"(",
"pos1",
"==",
"length1",
")",
"||",
"(",
"pos2",
"==",
"length2",
")",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"else",
"if",
"s1",
"<",
"s2",
"{",
"c1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
"\n",
"mustCopyOnWrite",
":=",
"rb",
".",
"highlowcontainer",
".",
"needsCopyOnWrite",
"(",
"pos1",
")",
"\n",
"rb",
".",
"highlowcontainer",
".",
"replaceKeyAndContainerAtIndex",
"(",
"intersectionsize",
",",
"s1",
",",
"c1",
",",
"mustCopyOnWrite",
")",
"\n",
"intersectionsize",
"++",
"\n",
"pos1",
"++",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"}",
"else",
"{",
"//s1 > s2",
"pos2",
"=",
"x2",
".",
"highlowcontainer",
".",
"advanceUntil",
"(",
"s1",
",",
"pos2",
")",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"// TODO:implement as a copy",
"for",
"pos1",
"<",
"length1",
"{",
"c1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
"\n",
"s1",
":=",
"rb",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"mustCopyOnWrite",
":=",
"rb",
".",
"highlowcontainer",
".",
"needsCopyOnWrite",
"(",
"pos1",
")",
"\n",
"rb",
".",
"highlowcontainer",
".",
"replaceKeyAndContainerAtIndex",
"(",
"intersectionsize",
",",
"s1",
",",
"c1",
",",
"mustCopyOnWrite",
")",
"\n",
"intersectionsize",
"++",
"\n",
"pos1",
"++",
"\n",
"}",
"\n",
"rb",
".",
"highlowcontainer",
".",
"resize",
"(",
"intersectionsize",
")",
"\n",
"}"
] | // AndNot computes the difference between two bitmaps and stores the result in the current bitmap | [
"AndNot",
"computes",
"the",
"difference",
"between",
"two",
"bitmaps",
"and",
"stores",
"the",
"result",
"in",
"the",
"current",
"bitmap"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L885-L945 | train |
RoaringBitmap/roaring | roaring.go | Or | func Or(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for (pos1 < length1) && (pos2 < length2) {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 > s2 {
answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
pos2++
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else {
answer.highlowcontainer.appendContainer(s1, x1.highlowcontainer.getContainerAtIndex(pos1).or(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
if pos1 == length1 {
answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
} else if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | go | func Or(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for (pos1 < length1) && (pos2 < length2) {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 > s2 {
answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
pos2++
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else {
answer.highlowcontainer.appendContainer(s1, x1.highlowcontainer.getContainerAtIndex(pos1).or(x2.highlowcontainer.getContainerAtIndex(pos2)), false)
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
if pos1 == length1 {
answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
} else if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | [
"func",
"Or",
"(",
"x1",
",",
"x2",
"*",
"Bitmap",
")",
"*",
"Bitmap",
"{",
"answer",
":=",
"NewBitmap",
"(",
")",
"\n",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"length1",
":=",
"x1",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"main",
":",
"for",
"(",
"pos1",
"<",
"length1",
")",
"&&",
"(",
"pos2",
"<",
"length2",
")",
"{",
"s1",
":=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n\n",
"for",
"{",
"if",
"s1",
"<",
"s2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopy",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
")",
"\n",
"pos1",
"++",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"}",
"else",
"if",
"s1",
">",
"s2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopy",
"(",
"x2",
".",
"highlowcontainer",
",",
"pos2",
")",
"\n",
"pos2",
"++",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"else",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendContainer",
"(",
"s1",
",",
"x1",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
".",
"or",
"(",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
")",
",",
"false",
")",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"(",
"pos1",
"==",
"length1",
")",
"||",
"(",
"pos2",
"==",
"length2",
")",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x2",
".",
"highlowcontainer",
",",
"pos2",
",",
"length2",
")",
"\n",
"}",
"else",
"if",
"pos2",
"==",
"length2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
",",
"length1",
")",
"\n",
"}",
"\n",
"return",
"answer",
"\n",
"}"
] | // Or computes the union between two bitmaps and returns the result | [
"Or",
"computes",
"the",
"union",
"between",
"two",
"bitmaps",
"and",
"returns",
"the",
"result"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L948-L993 | train |
RoaringBitmap/roaring | roaring.go | And | func And(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for pos1 < length1 && pos2 < length2 {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 == s2 {
C := x1.highlowcontainer.getContainerAtIndex(pos1)
C = C.and(x2.highlowcontainer.getContainerAtIndex(pos2))
if C.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, C, false)
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else if s1 < s2 {
pos1 = x1.highlowcontainer.advanceUntil(s2, pos1)
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else { // s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
return answer
} | go | func And(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for pos1 < length1 && pos2 < length2 {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 == s2 {
C := x1.highlowcontainer.getContainerAtIndex(pos1)
C = C.and(x2.highlowcontainer.getContainerAtIndex(pos2))
if C.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, C, false)
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else if s1 < s2 {
pos1 = x1.highlowcontainer.advanceUntil(s2, pos1)
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else { // s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
}
return answer
} | [
"func",
"And",
"(",
"x1",
",",
"x2",
"*",
"Bitmap",
")",
"*",
"Bitmap",
"{",
"answer",
":=",
"NewBitmap",
"(",
")",
"\n",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"length1",
":=",
"x1",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"main",
":",
"for",
"pos1",
"<",
"length1",
"&&",
"pos2",
"<",
"length2",
"{",
"s1",
":=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"for",
"{",
"if",
"s1",
"==",
"s2",
"{",
"C",
":=",
"x1",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
"\n",
"C",
"=",
"C",
".",
"and",
"(",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
")",
"\n\n",
"if",
"C",
".",
"getCardinality",
"(",
")",
">",
"0",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendContainer",
"(",
"s1",
",",
"C",
",",
"false",
")",
"\n",
"}",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"(",
"pos1",
"==",
"length1",
")",
"||",
"(",
"pos2",
"==",
"length2",
")",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"else",
"if",
"s1",
"<",
"s2",
"{",
"pos1",
"=",
"x1",
".",
"highlowcontainer",
".",
"advanceUntil",
"(",
"s2",
",",
"pos1",
")",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"}",
"else",
"{",
"// s1 > s2",
"pos2",
"=",
"x2",
".",
"highlowcontainer",
".",
"advanceUntil",
"(",
"s1",
",",
"pos2",
")",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"answer",
"\n",
"}"
] | // And computes the intersection between two bitmaps and returns the result | [
"And",
"computes",
"the",
"intersection",
"between",
"two",
"bitmaps",
"and",
"returns",
"the",
"result"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L996-L1037 | train |
RoaringBitmap/roaring | roaring.go | Xor | func Xor(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
for {
if (pos1 < length1) && (pos2 < length2) {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
} else if s1 > s2 {
answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
pos2++
} else {
c := x1.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
if c.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, c, false)
}
pos1++
pos2++
}
} else {
break
}
}
if pos1 == length1 {
answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
} else if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | go | func Xor(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
for {
if (pos1 < length1) && (pos2 < length2) {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
} else if s1 > s2 {
answer.highlowcontainer.appendCopy(x2.highlowcontainer, pos2)
pos2++
} else {
c := x1.highlowcontainer.getContainerAtIndex(pos1).xor(x2.highlowcontainer.getContainerAtIndex(pos2))
if c.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, c, false)
}
pos1++
pos2++
}
} else {
break
}
}
if pos1 == length1 {
answer.highlowcontainer.appendCopyMany(x2.highlowcontainer, pos2, length2)
} else if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | [
"func",
"Xor",
"(",
"x1",
",",
"x2",
"*",
"Bitmap",
")",
"*",
"Bitmap",
"{",
"answer",
":=",
"NewBitmap",
"(",
")",
"\n",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"length1",
":=",
"x1",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"for",
"{",
"if",
"(",
"pos1",
"<",
"length1",
")",
"&&",
"(",
"pos2",
"<",
"length2",
")",
"{",
"s1",
":=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"if",
"s1",
"<",
"s2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopy",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
")",
"\n",
"pos1",
"++",
"\n",
"}",
"else",
"if",
"s1",
">",
"s2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopy",
"(",
"x2",
".",
"highlowcontainer",
",",
"pos2",
")",
"\n",
"pos2",
"++",
"\n",
"}",
"else",
"{",
"c",
":=",
"x1",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
".",
"xor",
"(",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
")",
"\n",
"if",
"c",
".",
"getCardinality",
"(",
")",
">",
"0",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendContainer",
"(",
"s1",
",",
"c",
",",
"false",
")",
"\n",
"}",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"}",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x2",
".",
"highlowcontainer",
",",
"pos2",
",",
"length2",
")",
"\n",
"}",
"else",
"if",
"pos2",
"==",
"length2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
",",
"length1",
")",
"\n",
"}",
"\n",
"return",
"answer",
"\n",
"}"
] | // Xor computes the symmetric difference between two bitmaps and returns the result | [
"Xor",
"computes",
"the",
"symmetric",
"difference",
"between",
"two",
"bitmaps",
"and",
"returns",
"the",
"result"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L1040-L1074 | train |
RoaringBitmap/roaring | roaring.go | AndNot | func AndNot(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for {
if pos1 < length1 && pos2 < length2 {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 == s2 {
c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
diff := c1.andNot(c2)
if diff.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, diff, false)
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else { //s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
} else {
break
}
}
if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | go | func AndNot(x1, x2 *Bitmap) *Bitmap {
answer := NewBitmap()
pos1 := 0
pos2 := 0
length1 := x1.highlowcontainer.size()
length2 := x2.highlowcontainer.size()
main:
for {
if pos1 < length1 && pos2 < length2 {
s1 := x1.highlowcontainer.getKeyAtIndex(pos1)
s2 := x2.highlowcontainer.getKeyAtIndex(pos2)
for {
if s1 < s2 {
answer.highlowcontainer.appendCopy(x1.highlowcontainer, pos1)
pos1++
if pos1 == length1 {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
} else if s1 == s2 {
c1 := x1.highlowcontainer.getContainerAtIndex(pos1)
c2 := x2.highlowcontainer.getContainerAtIndex(pos2)
diff := c1.andNot(c2)
if diff.getCardinality() > 0 {
answer.highlowcontainer.appendContainer(s1, diff, false)
}
pos1++
pos2++
if (pos1 == length1) || (pos2 == length2) {
break main
}
s1 = x1.highlowcontainer.getKeyAtIndex(pos1)
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
} else { //s1 > s2
pos2 = x2.highlowcontainer.advanceUntil(s1, pos2)
if pos2 == length2 {
break main
}
s2 = x2.highlowcontainer.getKeyAtIndex(pos2)
}
}
} else {
break
}
}
if pos2 == length2 {
answer.highlowcontainer.appendCopyMany(x1.highlowcontainer, pos1, length1)
}
return answer
} | [
"func",
"AndNot",
"(",
"x1",
",",
"x2",
"*",
"Bitmap",
")",
"*",
"Bitmap",
"{",
"answer",
":=",
"NewBitmap",
"(",
")",
"\n",
"pos1",
":=",
"0",
"\n",
"pos2",
":=",
"0",
"\n",
"length1",
":=",
"x1",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n",
"length2",
":=",
"x2",
".",
"highlowcontainer",
".",
"size",
"(",
")",
"\n\n",
"main",
":",
"for",
"{",
"if",
"pos1",
"<",
"length1",
"&&",
"pos2",
"<",
"length2",
"{",
"s1",
":=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"for",
"{",
"if",
"s1",
"<",
"s2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopy",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
")",
"\n",
"pos1",
"++",
"\n",
"if",
"pos1",
"==",
"length1",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"}",
"else",
"if",
"s1",
"==",
"s2",
"{",
"c1",
":=",
"x1",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos1",
")",
"\n",
"c2",
":=",
"x2",
".",
"highlowcontainer",
".",
"getContainerAtIndex",
"(",
"pos2",
")",
"\n",
"diff",
":=",
"c1",
".",
"andNot",
"(",
"c2",
")",
"\n",
"if",
"diff",
".",
"getCardinality",
"(",
")",
">",
"0",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendContainer",
"(",
"s1",
",",
"diff",
",",
"false",
")",
"\n",
"}",
"\n",
"pos1",
"++",
"\n",
"pos2",
"++",
"\n",
"if",
"(",
"pos1",
"==",
"length1",
")",
"||",
"(",
"pos2",
"==",
"length2",
")",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s1",
"=",
"x1",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos1",
")",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"else",
"{",
"//s1 > s2",
"pos2",
"=",
"x2",
".",
"highlowcontainer",
".",
"advanceUntil",
"(",
"s1",
",",
"pos2",
")",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"break",
"main",
"\n",
"}",
"\n",
"s2",
"=",
"x2",
".",
"highlowcontainer",
".",
"getKeyAtIndex",
"(",
"pos2",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"else",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"pos2",
"==",
"length2",
"{",
"answer",
".",
"highlowcontainer",
".",
"appendCopyMany",
"(",
"x1",
".",
"highlowcontainer",
",",
"pos1",
",",
"length1",
")",
"\n",
"}",
"\n",
"return",
"answer",
"\n",
"}"
] | // AndNot computes the difference between two bitmaps and returns the result | [
"AndNot",
"computes",
"the",
"difference",
"between",
"two",
"bitmaps",
"and",
"returns",
"the",
"result"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L1077-L1127 | train |
RoaringBitmap/roaring | roaring.go | AddMany | func (rb *Bitmap) AddMany(dat []uint32) {
if len(dat) == 0 {
return
}
prev := dat[0]
idx, c := rb.addwithptr(prev)
for _, i := range dat[1:] {
if highbits(prev) == highbits(i) {
c = c.iaddReturnMinimized(lowbits(i))
rb.highlowcontainer.setContainerAtIndex(idx, c)
} else {
idx, c = rb.addwithptr(i)
}
prev = i
}
} | go | func (rb *Bitmap) AddMany(dat []uint32) {
if len(dat) == 0 {
return
}
prev := dat[0]
idx, c := rb.addwithptr(prev)
for _, i := range dat[1:] {
if highbits(prev) == highbits(i) {
c = c.iaddReturnMinimized(lowbits(i))
rb.highlowcontainer.setContainerAtIndex(idx, c)
} else {
idx, c = rb.addwithptr(i)
}
prev = i
}
} | [
"func",
"(",
"rb",
"*",
"Bitmap",
")",
"AddMany",
"(",
"dat",
"[",
"]",
"uint32",
")",
"{",
"if",
"len",
"(",
"dat",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"prev",
":=",
"dat",
"[",
"0",
"]",
"\n",
"idx",
",",
"c",
":=",
"rb",
".",
"addwithptr",
"(",
"prev",
")",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"dat",
"[",
"1",
":",
"]",
"{",
"if",
"highbits",
"(",
"prev",
")",
"==",
"highbits",
"(",
"i",
")",
"{",
"c",
"=",
"c",
".",
"iaddReturnMinimized",
"(",
"lowbits",
"(",
"i",
")",
")",
"\n",
"rb",
".",
"highlowcontainer",
".",
"setContainerAtIndex",
"(",
"idx",
",",
"c",
")",
"\n",
"}",
"else",
"{",
"idx",
",",
"c",
"=",
"rb",
".",
"addwithptr",
"(",
"i",
")",
"\n",
"}",
"\n",
"prev",
"=",
"i",
"\n",
"}",
"\n",
"}"
] | // AddMany add all of the values in dat | [
"AddMany",
"add",
"all",
"of",
"the",
"values",
"in",
"dat"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L1130-L1145 | train |
RoaringBitmap/roaring | roaring.go | BitmapOf | func BitmapOf(dat ...uint32) *Bitmap {
ans := NewBitmap()
ans.AddMany(dat)
return ans
} | go | func BitmapOf(dat ...uint32) *Bitmap {
ans := NewBitmap()
ans.AddMany(dat)
return ans
} | [
"func",
"BitmapOf",
"(",
"dat",
"...",
"uint32",
")",
"*",
"Bitmap",
"{",
"ans",
":=",
"NewBitmap",
"(",
")",
"\n",
"ans",
".",
"AddMany",
"(",
"dat",
")",
"\n",
"return",
"ans",
"\n",
"}"
] | // BitmapOf generates a new bitmap filled with the specified integers | [
"BitmapOf",
"generates",
"a",
"new",
"bitmap",
"filled",
"with",
"the",
"specified",
"integers"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L1148-L1152 | train |
RoaringBitmap/roaring | roaring.go | Stats | func (rb *Bitmap) Stats() Statistics {
stats := Statistics{}
stats.Containers = uint64(len(rb.highlowcontainer.containers))
for _, c := range rb.highlowcontainer.containers {
stats.Cardinality += uint64(c.getCardinality())
switch c.(type) {
case *arrayContainer:
stats.ArrayContainers++
stats.ArrayContainerBytes += uint64(c.getSizeInBytes())
stats.ArrayContainerValues += uint64(c.getCardinality())
case *bitmapContainer:
stats.BitmapContainers++
stats.BitmapContainerBytes += uint64(c.getSizeInBytes())
stats.BitmapContainerValues += uint64(c.getCardinality())
case *runContainer16:
stats.RunContainers++
stats.RunContainerBytes += uint64(c.getSizeInBytes())
stats.RunContainerValues += uint64(c.getCardinality())
}
}
return stats
} | go | func (rb *Bitmap) Stats() Statistics {
stats := Statistics{}
stats.Containers = uint64(len(rb.highlowcontainer.containers))
for _, c := range rb.highlowcontainer.containers {
stats.Cardinality += uint64(c.getCardinality())
switch c.(type) {
case *arrayContainer:
stats.ArrayContainers++
stats.ArrayContainerBytes += uint64(c.getSizeInBytes())
stats.ArrayContainerValues += uint64(c.getCardinality())
case *bitmapContainer:
stats.BitmapContainers++
stats.BitmapContainerBytes += uint64(c.getSizeInBytes())
stats.BitmapContainerValues += uint64(c.getCardinality())
case *runContainer16:
stats.RunContainers++
stats.RunContainerBytes += uint64(c.getSizeInBytes())
stats.RunContainerValues += uint64(c.getCardinality())
}
}
return stats
} | [
"func",
"(",
"rb",
"*",
"Bitmap",
")",
"Stats",
"(",
")",
"Statistics",
"{",
"stats",
":=",
"Statistics",
"{",
"}",
"\n",
"stats",
".",
"Containers",
"=",
"uint64",
"(",
"len",
"(",
"rb",
".",
"highlowcontainer",
".",
"containers",
")",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"rb",
".",
"highlowcontainer",
".",
"containers",
"{",
"stats",
".",
"Cardinality",
"+=",
"uint64",
"(",
"c",
".",
"getCardinality",
"(",
")",
")",
"\n\n",
"switch",
"c",
".",
"(",
"type",
")",
"{",
"case",
"*",
"arrayContainer",
":",
"stats",
".",
"ArrayContainers",
"++",
"\n",
"stats",
".",
"ArrayContainerBytes",
"+=",
"uint64",
"(",
"c",
".",
"getSizeInBytes",
"(",
")",
")",
"\n",
"stats",
".",
"ArrayContainerValues",
"+=",
"uint64",
"(",
"c",
".",
"getCardinality",
"(",
")",
")",
"\n",
"case",
"*",
"bitmapContainer",
":",
"stats",
".",
"BitmapContainers",
"++",
"\n",
"stats",
".",
"BitmapContainerBytes",
"+=",
"uint64",
"(",
"c",
".",
"getSizeInBytes",
"(",
")",
")",
"\n",
"stats",
".",
"BitmapContainerValues",
"+=",
"uint64",
"(",
"c",
".",
"getCardinality",
"(",
")",
")",
"\n",
"case",
"*",
"runContainer16",
":",
"stats",
".",
"RunContainers",
"++",
"\n",
"stats",
".",
"RunContainerBytes",
"+=",
"uint64",
"(",
"c",
".",
"getSizeInBytes",
"(",
")",
")",
"\n",
"stats",
".",
"RunContainerValues",
"+=",
"uint64",
"(",
"c",
".",
"getCardinality",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"stats",
"\n",
"}"
] | // Stats returns details on container type usage in a Statistics struct. | [
"Stats",
"returns",
"details",
"on",
"container",
"type",
"usage",
"in",
"a",
"Statistics",
"struct",
"."
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaring.go#L1405-L1427 | train |
RoaringBitmap/roaring | arraycontainer.go | iaddRange | func (ac *arrayContainer) iaddRange(firstOfRange, endx int) container {
if firstOfRange >= endx {
return ac
}
indexstart := binarySearch(ac.content, uint16(firstOfRange))
if indexstart < 0 {
indexstart = -indexstart - 1
}
indexend := binarySearch(ac.content, uint16(endx-1))
if indexend < 0 {
indexend = -indexend - 1
} else {
indexend++
}
rangelength := endx - firstOfRange
newcardinality := indexstart + (ac.getCardinality() - indexend) + rangelength
if newcardinality > arrayDefaultMaxSize {
a := ac.toBitmapContainer()
return a.iaddRange(firstOfRange, endx)
}
if cap(ac.content) < newcardinality {
tmp := make([]uint16, newcardinality, newcardinality)
copy(tmp[:indexstart], ac.content[:indexstart])
copy(tmp[indexstart+rangelength:], ac.content[indexend:])
ac.content = tmp
} else {
ac.content = ac.content[:newcardinality]
copy(ac.content[indexstart+rangelength:], ac.content[indexend:])
}
for k := 0; k < rangelength; k++ {
ac.content[k+indexstart] = uint16(firstOfRange + k)
}
return ac
} | go | func (ac *arrayContainer) iaddRange(firstOfRange, endx int) container {
if firstOfRange >= endx {
return ac
}
indexstart := binarySearch(ac.content, uint16(firstOfRange))
if indexstart < 0 {
indexstart = -indexstart - 1
}
indexend := binarySearch(ac.content, uint16(endx-1))
if indexend < 0 {
indexend = -indexend - 1
} else {
indexend++
}
rangelength := endx - firstOfRange
newcardinality := indexstart + (ac.getCardinality() - indexend) + rangelength
if newcardinality > arrayDefaultMaxSize {
a := ac.toBitmapContainer()
return a.iaddRange(firstOfRange, endx)
}
if cap(ac.content) < newcardinality {
tmp := make([]uint16, newcardinality, newcardinality)
copy(tmp[:indexstart], ac.content[:indexstart])
copy(tmp[indexstart+rangelength:], ac.content[indexend:])
ac.content = tmp
} else {
ac.content = ac.content[:newcardinality]
copy(ac.content[indexstart+rangelength:], ac.content[indexend:])
}
for k := 0; k < rangelength; k++ {
ac.content[k+indexstart] = uint16(firstOfRange + k)
}
return ac
} | [
"func",
"(",
"ac",
"*",
"arrayContainer",
")",
"iaddRange",
"(",
"firstOfRange",
",",
"endx",
"int",
")",
"container",
"{",
"if",
"firstOfRange",
">=",
"endx",
"{",
"return",
"ac",
"\n",
"}",
"\n",
"indexstart",
":=",
"binarySearch",
"(",
"ac",
".",
"content",
",",
"uint16",
"(",
"firstOfRange",
")",
")",
"\n",
"if",
"indexstart",
"<",
"0",
"{",
"indexstart",
"=",
"-",
"indexstart",
"-",
"1",
"\n",
"}",
"\n",
"indexend",
":=",
"binarySearch",
"(",
"ac",
".",
"content",
",",
"uint16",
"(",
"endx",
"-",
"1",
")",
")",
"\n",
"if",
"indexend",
"<",
"0",
"{",
"indexend",
"=",
"-",
"indexend",
"-",
"1",
"\n",
"}",
"else",
"{",
"indexend",
"++",
"\n",
"}",
"\n",
"rangelength",
":=",
"endx",
"-",
"firstOfRange",
"\n",
"newcardinality",
":=",
"indexstart",
"+",
"(",
"ac",
".",
"getCardinality",
"(",
")",
"-",
"indexend",
")",
"+",
"rangelength",
"\n",
"if",
"newcardinality",
">",
"arrayDefaultMaxSize",
"{",
"a",
":=",
"ac",
".",
"toBitmapContainer",
"(",
")",
"\n",
"return",
"a",
".",
"iaddRange",
"(",
"firstOfRange",
",",
"endx",
")",
"\n",
"}",
"\n",
"if",
"cap",
"(",
"ac",
".",
"content",
")",
"<",
"newcardinality",
"{",
"tmp",
":=",
"make",
"(",
"[",
"]",
"uint16",
",",
"newcardinality",
",",
"newcardinality",
")",
"\n",
"copy",
"(",
"tmp",
"[",
":",
"indexstart",
"]",
",",
"ac",
".",
"content",
"[",
":",
"indexstart",
"]",
")",
"\n",
"copy",
"(",
"tmp",
"[",
"indexstart",
"+",
"rangelength",
":",
"]",
",",
"ac",
".",
"content",
"[",
"indexend",
":",
"]",
")",
"\n\n",
"ac",
".",
"content",
"=",
"tmp",
"\n",
"}",
"else",
"{",
"ac",
".",
"content",
"=",
"ac",
".",
"content",
"[",
":",
"newcardinality",
"]",
"\n",
"copy",
"(",
"ac",
".",
"content",
"[",
"indexstart",
"+",
"rangelength",
":",
"]",
",",
"ac",
".",
"content",
"[",
"indexend",
":",
"]",
")",
"\n\n",
"}",
"\n",
"for",
"k",
":=",
"0",
";",
"k",
"<",
"rangelength",
";",
"k",
"++",
"{",
"ac",
".",
"content",
"[",
"k",
"+",
"indexstart",
"]",
"=",
"uint16",
"(",
"firstOfRange",
"+",
"k",
")",
"\n",
"}",
"\n",
"return",
"ac",
"\n",
"}"
] | // add the values in the range [firstOfRange,endx) | [
"add",
"the",
"values",
"in",
"the",
"range",
"[",
"firstOfRange",
"endx",
")"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/arraycontainer.go#L60-L95 | train |
RoaringBitmap/roaring | arraycontainer.go | iremoveReturnMinimized | func (ac *arrayContainer) iremoveReturnMinimized(x uint16) container {
ac.iremove(x)
return ac
} | go | func (ac *arrayContainer) iremoveReturnMinimized(x uint16) container {
ac.iremove(x)
return ac
} | [
"func",
"(",
"ac",
"*",
"arrayContainer",
")",
"iremoveReturnMinimized",
"(",
"x",
"uint16",
")",
"container",
"{",
"ac",
".",
"iremove",
"(",
"x",
")",
"\n",
"return",
"ac",
"\n",
"}"
] | // iremoveReturnMinimized is allowed to change the return type to minimize storage. | [
"iremoveReturnMinimized",
"is",
"allowed",
"to",
"change",
"the",
"return",
"type",
"to",
"minimize",
"storage",
"."
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/arraycontainer.go#L273-L276 | train |
RoaringBitmap/roaring | serialization_generic.go | byteSliceAsInterval16Slice | func byteSliceAsInterval16Slice(byteSlice []byte) []interval16 {
if len(byteSlice)%4 != 0 {
panic("Slice size should be divisible by 4")
}
intervalSlice := make([]interval16, len(byteSlice)/4)
for i := range intervalSlice {
intervalSlice[i] = interval16{
start: binary.LittleEndian.Uint16(byteSlice[i*4:]),
length: binary.LittleEndian.Uint16(byteSlice[i*4+2:]),
}
}
return intervalSlice
} | go | func byteSliceAsInterval16Slice(byteSlice []byte) []interval16 {
if len(byteSlice)%4 != 0 {
panic("Slice size should be divisible by 4")
}
intervalSlice := make([]interval16, len(byteSlice)/4)
for i := range intervalSlice {
intervalSlice[i] = interval16{
start: binary.LittleEndian.Uint16(byteSlice[i*4:]),
length: binary.LittleEndian.Uint16(byteSlice[i*4+2:]),
}
}
return intervalSlice
} | [
"func",
"byteSliceAsInterval16Slice",
"(",
"byteSlice",
"[",
"]",
"byte",
")",
"[",
"]",
"interval16",
"{",
"if",
"len",
"(",
"byteSlice",
")",
"%",
"4",
"!=",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"intervalSlice",
":=",
"make",
"(",
"[",
"]",
"interval16",
",",
"len",
"(",
"byteSlice",
")",
"/",
"4",
")",
"\n\n",
"for",
"i",
":=",
"range",
"intervalSlice",
"{",
"intervalSlice",
"[",
"i",
"]",
"=",
"interval16",
"{",
"start",
":",
"binary",
".",
"LittleEndian",
".",
"Uint16",
"(",
"byteSlice",
"[",
"i",
"*",
"4",
":",
"]",
")",
",",
"length",
":",
"binary",
".",
"LittleEndian",
".",
"Uint16",
"(",
"byteSlice",
"[",
"i",
"*",
"4",
"+",
"2",
":",
"]",
")",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"intervalSlice",
"\n",
"}"
] | // Converts a byte slice to a interval16 slice.
// The function assumes that the slice byte buffer is run container data
// encoded according to Roaring Format Spec | [
"Converts",
"a",
"byte",
"slice",
"to",
"a",
"interval16",
"slice",
".",
"The",
"function",
"assumes",
"that",
"the",
"slice",
"byte",
"buffer",
"is",
"run",
"container",
"data",
"encoded",
"according",
"to",
"Roaring",
"Format",
"Spec"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/serialization_generic.go#L108-L123 | train |
RoaringBitmap/roaring | clz_compat.go | countLeadingZeros | func countLeadingZeros(i uint64) int {
if i == 0 {
return 64
}
n := 1
x := uint32(i >> 32)
if x == 0 {
n += 32
x = uint32(i)
}
if (x >> 16) == 0 {
n += 16
x <<= 16
}
if (x >> 24) == 0 {
n += 8
x <<= 8
}
if x>>28 == 0 {
n += 4
x <<= 4
}
if x>>30 == 0 {
n += 2
x <<= 2
}
n -= int(x >> 31)
return n
} | go | func countLeadingZeros(i uint64) int {
if i == 0 {
return 64
}
n := 1
x := uint32(i >> 32)
if x == 0 {
n += 32
x = uint32(i)
}
if (x >> 16) == 0 {
n += 16
x <<= 16
}
if (x >> 24) == 0 {
n += 8
x <<= 8
}
if x>>28 == 0 {
n += 4
x <<= 4
}
if x>>30 == 0 {
n += 2
x <<= 2
}
n -= int(x >> 31)
return n
} | [
"func",
"countLeadingZeros",
"(",
"i",
"uint64",
")",
"int",
"{",
"if",
"i",
"==",
"0",
"{",
"return",
"64",
"\n",
"}",
"\n",
"n",
":=",
"1",
"\n",
"x",
":=",
"uint32",
"(",
"i",
">>",
"32",
")",
"\n",
"if",
"x",
"==",
"0",
"{",
"n",
"+=",
"32",
"\n",
"x",
"=",
"uint32",
"(",
"i",
")",
"\n",
"}",
"\n",
"if",
"(",
"x",
">>",
"16",
")",
"==",
"0",
"{",
"n",
"+=",
"16",
"\n",
"x",
"<<=",
"16",
"\n",
"}",
"\n",
"if",
"(",
"x",
">>",
"24",
")",
"==",
"0",
"{",
"n",
"+=",
"8",
"\n",
"x",
"<<=",
"8",
"\n",
"}",
"\n",
"if",
"x",
">>",
"28",
"==",
"0",
"{",
"n",
"+=",
"4",
"\n",
"x",
"<<=",
"4",
"\n",
"}",
"\n",
"if",
"x",
">>",
"30",
"==",
"0",
"{",
"n",
"+=",
"2",
"\n",
"x",
"<<=",
"2",
"\n\n",
"}",
"\n",
"n",
"-=",
"int",
"(",
"x",
">>",
"31",
")",
"\n",
"return",
"n",
"\n",
"}"
] | // LeadingZeroBits returns the number of consecutive most significant zero
// bits of x. | [
"LeadingZeroBits",
"returns",
"the",
"number",
"of",
"consecutive",
"most",
"significant",
"zero",
"bits",
"of",
"x",
"."
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/clz_compat.go#L7-L36 | train |
RoaringBitmap/roaring | roaringarray.go | serializedSizeInBytes | func (ra *roaringArray) serializedSizeInBytes() uint64 {
answer := ra.headerSize()
for _, c := range ra.containers {
answer += uint64(c.serializedSizeInBytes())
}
return answer
} | go | func (ra *roaringArray) serializedSizeInBytes() uint64 {
answer := ra.headerSize()
for _, c := range ra.containers {
answer += uint64(c.serializedSizeInBytes())
}
return answer
} | [
"func",
"(",
"ra",
"*",
"roaringArray",
")",
"serializedSizeInBytes",
"(",
")",
"uint64",
"{",
"answer",
":=",
"ra",
".",
"headerSize",
"(",
")",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"ra",
".",
"containers",
"{",
"answer",
"+=",
"uint64",
"(",
"c",
".",
"serializedSizeInBytes",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"answer",
"\n",
"}"
] | // should be dirt cheap | [
"should",
"be",
"dirt",
"cheap"
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/roaringarray.go#L451-L457 | train |
RoaringBitmap/roaring | smat.go | smatWrap | func smatWrap(cb func(c *smatContext)) func(smat.Context) (next smat.State, err error) {
return func(ctx smat.Context) (next smat.State, err error) {
c := ctx.(*smatContext)
cb(c)
return smatRunning, nil
}
} | go | func smatWrap(cb func(c *smatContext)) func(smat.Context) (next smat.State, err error) {
return func(ctx smat.Context) (next smat.State, err error) {
c := ctx.(*smatContext)
cb(c)
return smatRunning, nil
}
} | [
"func",
"smatWrap",
"(",
"cb",
"func",
"(",
"c",
"*",
"smatContext",
")",
")",
"func",
"(",
"smat",
".",
"Context",
")",
"(",
"next",
"smat",
".",
"State",
",",
"err",
"error",
")",
"{",
"return",
"func",
"(",
"ctx",
"smat",
".",
"Context",
")",
"(",
"next",
"smat",
".",
"State",
",",
"err",
"error",
")",
"{",
"c",
":=",
"ctx",
".",
"(",
"*",
"smatContext",
")",
"\n",
"cb",
"(",
"c",
")",
"\n",
"return",
"smatRunning",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Creates an smat action func based on a simple callback. | [
"Creates",
"an",
"smat",
"action",
"func",
"based",
"on",
"a",
"simple",
"callback",
"."
] | 8d778e47dd84f169ef4436abb474b0e0101a6dae | https://github.com/RoaringBitmap/roaring/blob/8d778e47dd84f169ef4436abb474b0e0101a6dae/smat.go#L173-L179 | train |
mesosphere/mesos-dns | records/state/client/cli.go | NewStateLoader | func NewStateLoader(doer httpcli.Doer, initialEndpoint urls.Builder, unmarshal Unmarshaler) StateLoader {
return func(masters []string) (state.State, error) {
return LoadMasterStateTryAll(masters, func(ip, port string) (state.State, error) {
return LoadMasterStateFailover(ip, func(tryIP string) (state.State, error) {
return LoadMasterState(doer, initialEndpoint, tryIP, port, unmarshal)
})
})
}
} | go | func NewStateLoader(doer httpcli.Doer, initialEndpoint urls.Builder, unmarshal Unmarshaler) StateLoader {
return func(masters []string) (state.State, error) {
return LoadMasterStateTryAll(masters, func(ip, port string) (state.State, error) {
return LoadMasterStateFailover(ip, func(tryIP string) (state.State, error) {
return LoadMasterState(doer, initialEndpoint, tryIP, port, unmarshal)
})
})
}
} | [
"func",
"NewStateLoader",
"(",
"doer",
"httpcli",
".",
"Doer",
",",
"initialEndpoint",
"urls",
".",
"Builder",
",",
"unmarshal",
"Unmarshaler",
")",
"StateLoader",
"{",
"return",
"func",
"(",
"masters",
"[",
"]",
"string",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
"{",
"return",
"LoadMasterStateTryAll",
"(",
"masters",
",",
"func",
"(",
"ip",
",",
"port",
"string",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
"{",
"return",
"LoadMasterStateFailover",
"(",
"ip",
",",
"func",
"(",
"tryIP",
"string",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
"{",
"return",
"LoadMasterState",
"(",
"doer",
",",
"initialEndpoint",
",",
"tryIP",
",",
"port",
",",
"unmarshal",
")",
"\n",
"}",
")",
"\n",
"}",
")",
"\n",
"}",
"\n\n",
"}"
] | // NewStateLoader generates a new Mesos master state loader using the given http client and initial endpoint. | [
"NewStateLoader",
"generates",
"a",
"new",
"Mesos",
"master",
"state",
"loader",
"using",
"the",
"given",
"http",
"client",
"and",
"initial",
"endpoint",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/client/cli.go#L27-L36 | train |
mesosphere/mesos-dns | records/state/client/cli.go | LoadMasterStateTryAll | func LoadMasterStateTryAll(masters []string, stateLoader func(ip, port string) (state.State, error)) (state.State, error) {
var sj state.State
var leader string
if len(masters) > 0 {
leader, masters = masters[0], masters[1:]
} else {
return sj, errors.New("no masters given to fetch state.json")
}
// Check if ZK leader is correct
if leader != "" {
logging.VeryVerbose.Println("Zookeeper says the leader is: ", leader)
ip, port, err := urls.SplitHostPort(leader)
if err != nil {
logging.Error.Println(err)
} else {
if sj, err = stateLoader(ip, port); err == nil {
return sj, nil
}
logging.Error.Println("Failed to fetch state from leader. Error: ", err)
if len(masters) == 0 {
logging.Error.Println("No more masters to try, returning last error")
return sj, err
}
logging.Error.Println("Falling back to remaining masters: ", masters)
}
}
// try each listed mesos master before dying
var (
ip, port string
err error
)
for _, master := range masters {
ip, port, err = urls.SplitHostPort(master)
if err != nil {
logging.Error.Println(err)
continue
}
if sj, err = stateLoader(ip, port); err != nil {
logging.Error.Println("Failed to fetch state - trying next one. Error: ", err)
continue
}
return sj, nil
}
logging.Error.Println("No more masters eligible for state query, returning last error")
return sj, err
} | go | func LoadMasterStateTryAll(masters []string, stateLoader func(ip, port string) (state.State, error)) (state.State, error) {
var sj state.State
var leader string
if len(masters) > 0 {
leader, masters = masters[0], masters[1:]
} else {
return sj, errors.New("no masters given to fetch state.json")
}
// Check if ZK leader is correct
if leader != "" {
logging.VeryVerbose.Println("Zookeeper says the leader is: ", leader)
ip, port, err := urls.SplitHostPort(leader)
if err != nil {
logging.Error.Println(err)
} else {
if sj, err = stateLoader(ip, port); err == nil {
return sj, nil
}
logging.Error.Println("Failed to fetch state from leader. Error: ", err)
if len(masters) == 0 {
logging.Error.Println("No more masters to try, returning last error")
return sj, err
}
logging.Error.Println("Falling back to remaining masters: ", masters)
}
}
// try each listed mesos master before dying
var (
ip, port string
err error
)
for _, master := range masters {
ip, port, err = urls.SplitHostPort(master)
if err != nil {
logging.Error.Println(err)
continue
}
if sj, err = stateLoader(ip, port); err != nil {
logging.Error.Println("Failed to fetch state - trying next one. Error: ", err)
continue
}
return sj, nil
}
logging.Error.Println("No more masters eligible for state query, returning last error")
return sj, err
} | [
"func",
"LoadMasterStateTryAll",
"(",
"masters",
"[",
"]",
"string",
",",
"stateLoader",
"func",
"(",
"ip",
",",
"port",
"string",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
"{",
"var",
"sj",
"state",
".",
"State",
"\n",
"var",
"leader",
"string",
"\n\n",
"if",
"len",
"(",
"masters",
")",
">",
"0",
"{",
"leader",
",",
"masters",
"=",
"masters",
"[",
"0",
"]",
",",
"masters",
"[",
"1",
":",
"]",
"\n",
"}",
"else",
"{",
"return",
"sj",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Check if ZK leader is correct",
"if",
"leader",
"!=",
"\"",
"\"",
"{",
"logging",
".",
"VeryVerbose",
".",
"Println",
"(",
"\"",
"\"",
",",
"leader",
")",
"\n",
"ip",
",",
"port",
",",
"err",
":=",
"urls",
".",
"SplitHostPort",
"(",
"leader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"else",
"{",
"if",
"sj",
",",
"err",
"=",
"stateLoader",
"(",
"ip",
",",
"port",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"sj",
",",
"nil",
"\n",
"}",
"\n",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"if",
"len",
"(",
"masters",
")",
"==",
"0",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}",
"\n",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
",",
"masters",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// try each listed mesos master before dying",
"var",
"(",
"ip",
",",
"port",
"string",
"\n",
"err",
"error",
"\n",
")",
"\n",
"for",
"_",
",",
"master",
":=",
"range",
"masters",
"{",
"ip",
",",
"port",
",",
"err",
"=",
"urls",
".",
"SplitHostPort",
"(",
"master",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"sj",
",",
"err",
"=",
"stateLoader",
"(",
"ip",
",",
"port",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"sj",
",",
"nil",
"\n",
"}",
"\n\n",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}"
] | // LoadMasterStateTryAll tries each master and looks for the leader; if no leader responds it errors.
// The first master in the list is assumed to be the leading mesos master. | [
"LoadMasterStateTryAll",
"tries",
"each",
"master",
"and",
"looks",
"for",
"the",
"leader",
";",
"if",
"no",
"leader",
"responds",
"it",
"errors",
".",
"The",
"first",
"master",
"in",
"the",
"list",
"is",
"assumed",
"to",
"be",
"the",
"leading",
"mesos",
"master",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/client/cli.go#L40-L90 | train |
mesosphere/mesos-dns | records/state/client/cli.go | LoadMasterStateFailover | func LoadMasterStateFailover(initialMasterIP string, stateLoader func(ip string) (state.State, error)) (state.State, error) {
var err error
var sj state.State
logging.VeryVerbose.Println("reloading from master " + initialMasterIP)
sj, err = stateLoader(initialMasterIP)
if err != nil {
return state.State{}, err
}
if sj.Leader != "" {
var stateLeaderIP string
stateLeaderIP, err = leaderIP(sj.Leader)
if err != nil {
return sj, err
}
if stateLeaderIP != initialMasterIP {
logging.VeryVerbose.Println("Warning: master changed to " + stateLeaderIP)
return stateLoader(stateLeaderIP)
}
return sj, nil
}
err = errors.New("fetched state does not contain leader information")
return sj, err
} | go | func LoadMasterStateFailover(initialMasterIP string, stateLoader func(ip string) (state.State, error)) (state.State, error) {
var err error
var sj state.State
logging.VeryVerbose.Println("reloading from master " + initialMasterIP)
sj, err = stateLoader(initialMasterIP)
if err != nil {
return state.State{}, err
}
if sj.Leader != "" {
var stateLeaderIP string
stateLeaderIP, err = leaderIP(sj.Leader)
if err != nil {
return sj, err
}
if stateLeaderIP != initialMasterIP {
logging.VeryVerbose.Println("Warning: master changed to " + stateLeaderIP)
return stateLoader(stateLeaderIP)
}
return sj, nil
}
err = errors.New("fetched state does not contain leader information")
return sj, err
} | [
"func",
"LoadMasterStateFailover",
"(",
"initialMasterIP",
"string",
",",
"stateLoader",
"func",
"(",
"ip",
"string",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
")",
"(",
"state",
".",
"State",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"var",
"sj",
"state",
".",
"State",
"\n\n",
"logging",
".",
"VeryVerbose",
".",
"Println",
"(",
"\"",
"\"",
"+",
"initialMasterIP",
")",
"\n",
"sj",
",",
"err",
"=",
"stateLoader",
"(",
"initialMasterIP",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"state",
".",
"State",
"{",
"}",
",",
"err",
"\n",
"}",
"\n",
"if",
"sj",
".",
"Leader",
"!=",
"\"",
"\"",
"{",
"var",
"stateLeaderIP",
"string",
"\n\n",
"stateLeaderIP",
",",
"err",
"=",
"leaderIP",
"(",
"sj",
".",
"Leader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"sj",
",",
"err",
"\n",
"}",
"\n",
"if",
"stateLeaderIP",
"!=",
"initialMasterIP",
"{",
"logging",
".",
"VeryVerbose",
".",
"Println",
"(",
"\"",
"\"",
"+",
"stateLeaderIP",
")",
"\n",
"return",
"stateLoader",
"(",
"stateLeaderIP",
")",
"\n",
"}",
"\n",
"return",
"sj",
",",
"nil",
"\n",
"}",
"\n",
"err",
"=",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}"
] | // LoadMasterStateFailover catches an attempt to load state from a mesos master.
// Attempts can fail from due to a down server or if contacting a mesos master secondary.
// It reloads from a different master if the contacted master is a secondary. | [
"LoadMasterStateFailover",
"catches",
"an",
"attempt",
"to",
"load",
"state",
"from",
"a",
"mesos",
"master",
".",
"Attempts",
"can",
"fail",
"from",
"due",
"to",
"a",
"down",
"server",
"or",
"if",
"contacting",
"a",
"mesos",
"master",
"secondary",
".",
"It",
"reloads",
"from",
"a",
"different",
"master",
"if",
"the",
"contacted",
"master",
"is",
"a",
"secondary",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/client/cli.go#L95-L119 | train |
mesosphere/mesos-dns | records/state/client/cli.go | LoadMasterState | func LoadMasterState(client httpcli.Doer, stateEndpoint urls.Builder, ip, port string, unmarshal Unmarshaler) (sj state.State, _ error) {
// REFACTOR: state security
u := url.URL(stateEndpoint.With(urls.Host(net.JoinHostPort(ip, port))))
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
req.Header.Set("Content-Type", "application/json") // TODO(jdef) unclear why Content-Type vs. Accept
req.Header.Set("User-Agent", "Mesos-DNS")
resp, err := client.Do(req)
if err != nil {
logging.Error.Println(err)
return sj, err
}
defer errorutil.Ignore(resp.Body.Close)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logging.Error.Println(err)
return sj, err
}
err = unmarshal(body, &sj)
if err != nil {
logging.Error.Println(err)
return sj, err
}
return
} | go | func LoadMasterState(client httpcli.Doer, stateEndpoint urls.Builder, ip, port string, unmarshal Unmarshaler) (sj state.State, _ error) {
// REFACTOR: state security
u := url.URL(stateEndpoint.With(urls.Host(net.JoinHostPort(ip, port))))
req, err := http.NewRequest("GET", u.String(), nil)
if err != nil {
logging.Error.Println(err)
return state.State{}, err
}
req.Header.Set("Content-Type", "application/json") // TODO(jdef) unclear why Content-Type vs. Accept
req.Header.Set("User-Agent", "Mesos-DNS")
resp, err := client.Do(req)
if err != nil {
logging.Error.Println(err)
return sj, err
}
defer errorutil.Ignore(resp.Body.Close)
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
logging.Error.Println(err)
return sj, err
}
err = unmarshal(body, &sj)
if err != nil {
logging.Error.Println(err)
return sj, err
}
return
} | [
"func",
"LoadMasterState",
"(",
"client",
"httpcli",
".",
"Doer",
",",
"stateEndpoint",
"urls",
".",
"Builder",
",",
"ip",
",",
"port",
"string",
",",
"unmarshal",
"Unmarshaler",
")",
"(",
"sj",
"state",
".",
"State",
",",
"_",
"error",
")",
"{",
"// REFACTOR: state security",
"u",
":=",
"url",
".",
"URL",
"(",
"stateEndpoint",
".",
"With",
"(",
"urls",
".",
"Host",
"(",
"net",
".",
"JoinHostPort",
"(",
"ip",
",",
"port",
")",
")",
")",
")",
"\n\n",
"req",
",",
"err",
":=",
"http",
".",
"NewRequest",
"(",
"\"",
"\"",
",",
"u",
".",
"String",
"(",
")",
",",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"return",
"state",
".",
"State",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"// TODO(jdef) unclear why Content-Type vs. Accept",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"resp",
",",
"err",
":=",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}",
"\n\n",
"defer",
"errorutil",
".",
"Ignore",
"(",
"resp",
".",
"Body",
".",
"Close",
")",
"\n",
"body",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"resp",
".",
"Body",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"unmarshal",
"(",
"body",
",",
"&",
"sj",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"return",
"sj",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // LoadMasterState loads state from mesos master | [
"LoadMasterState",
"loads",
"state",
"from",
"mesos",
"master"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/client/cli.go#L122-L156 | train |
mesosphere/mesos-dns | records/state/client/cli.go | leaderIP | func leaderIP(leader string) (string, error) {
// TODO(jdef) it's unclear why we drop the port here
nameAddressPair := strings.Split(leader, "@")
if len(nameAddressPair) != 2 {
return "", errors.New("Invalid leader address: " + leader)
}
hostPort := nameAddressPair[1]
host, _, err := net.SplitHostPort(hostPort)
if err != nil {
return "", err
}
return host, nil
} | go | func leaderIP(leader string) (string, error) {
// TODO(jdef) it's unclear why we drop the port here
nameAddressPair := strings.Split(leader, "@")
if len(nameAddressPair) != 2 {
return "", errors.New("Invalid leader address: " + leader)
}
hostPort := nameAddressPair[1]
host, _, err := net.SplitHostPort(hostPort)
if err != nil {
return "", err
}
return host, nil
} | [
"func",
"leaderIP",
"(",
"leader",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"// TODO(jdef) it's unclear why we drop the port here",
"nameAddressPair",
":=",
"strings",
".",
"Split",
"(",
"leader",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"nameAddressPair",
")",
"!=",
"2",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
"+",
"leader",
")",
"\n",
"}",
"\n",
"hostPort",
":=",
"nameAddressPair",
"[",
"1",
"]",
"\n",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"hostPort",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"host",
",",
"nil",
"\n",
"}"
] | // leaderIP returns the ip for the mesos master
// input format master@ip:port | [
"leaderIP",
"returns",
"the",
"ip",
"for",
"the",
"mesos",
"master",
"input",
"format",
"master"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/client/cli.go#L160-L172 | train |
mesosphere/mesos-dns | records/validation.go | validateUniqueStrings | func validateUniqueStrings(strings []string, normalize func(string) (string, error)) error {
valid := make(map[string]struct{}, len(strings))
for _, str := range strings {
normalized, err := normalize(str)
if err != nil {
return err
}
if _, found := valid[normalized]; found {
return fmt.Errorf("duplicate found: %v", str)
}
valid[normalized] = struct{}{}
}
return nil
} | go | func validateUniqueStrings(strings []string, normalize func(string) (string, error)) error {
valid := make(map[string]struct{}, len(strings))
for _, str := range strings {
normalized, err := normalize(str)
if err != nil {
return err
}
if _, found := valid[normalized]; found {
return fmt.Errorf("duplicate found: %v", str)
}
valid[normalized] = struct{}{}
}
return nil
} | [
"func",
"validateUniqueStrings",
"(",
"strings",
"[",
"]",
"string",
",",
"normalize",
"func",
"(",
"string",
")",
"(",
"string",
",",
"error",
")",
")",
"error",
"{",
"valid",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"struct",
"{",
"}",
",",
"len",
"(",
"strings",
")",
")",
"\n",
"for",
"_",
",",
"str",
":=",
"range",
"strings",
"{",
"normalized",
",",
"err",
":=",
"normalize",
"(",
"str",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"_",
",",
"found",
":=",
"valid",
"[",
"normalized",
"]",
";",
"found",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"str",
")",
"\n",
"}",
"\n",
"valid",
"[",
"normalized",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // validateUniqueStrings runs a normalize function on each string in a list and
// retuns an error if any duplicates are found. | [
"validateUniqueStrings",
"runs",
"a",
"normalize",
"function",
"on",
"each",
"string",
"in",
"a",
"list",
"and",
"retuns",
"an",
"error",
"if",
"any",
"duplicates",
"are",
"found",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/validation.go#L122-L135 | train |
mesosphere/mesos-dns | records/validation.go | validateIPSources | func validateIPSources(srcs []string) error {
if len(srcs) == 0 {
return fmt.Errorf("empty ip sources")
}
if len(srcs) != len(unique(srcs)) {
return fmt.Errorf("duplicate ip source specified")
}
for _, src := range srcs {
switch src {
case "host", "docker", "mesos", "netinfo":
default:
return fmt.Errorf("invalid ip source %q", src)
}
}
return nil
} | go | func validateIPSources(srcs []string) error {
if len(srcs) == 0 {
return fmt.Errorf("empty ip sources")
}
if len(srcs) != len(unique(srcs)) {
return fmt.Errorf("duplicate ip source specified")
}
for _, src := range srcs {
switch src {
case "host", "docker", "mesos", "netinfo":
default:
return fmt.Errorf("invalid ip source %q", src)
}
}
return nil
} | [
"func",
"validateIPSources",
"(",
"srcs",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"srcs",
")",
"==",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"srcs",
")",
"!=",
"len",
"(",
"unique",
"(",
"srcs",
")",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"src",
":=",
"range",
"srcs",
"{",
"switch",
"src",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"src",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // validateIPSources checks validity of ip sources | [
"validateIPSources",
"checks",
"validity",
"of",
"ip",
"sources"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/validation.go#L138-L154 | train |
mesosphere/mesos-dns | records/validation.go | validPortString | func validPortString(portString string) bool {
port, err := strconv.Atoi(portString)
return err == nil && port > 0 && port <= 65535
} | go | func validPortString(portString string) bool {
port, err := strconv.Atoi(portString)
return err == nil && port > 0 && port <= 65535
} | [
"func",
"validPortString",
"(",
"portString",
"string",
")",
"bool",
"{",
"port",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"portString",
")",
"\n",
"return",
"err",
"==",
"nil",
"&&",
"port",
">",
"0",
"&&",
"port",
"<=",
"65535",
"\n",
"}"
] | // validPortString retuns true if the given port string is
// an integer between 1 and 65535, false otherwise. | [
"validPortString",
"retuns",
"true",
"if",
"the",
"given",
"port",
"string",
"is",
"an",
"integer",
"between",
"1",
"and",
"65535",
"false",
"otherwise",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/validation.go#L158-L161 | train |
mesosphere/mesos-dns | records/generator.go | ToAXFRResourceRecordSet | func (r rrs) ToAXFRResourceRecordSet() models.AXFRResourceRecordSet {
ret := make(models.AXFRResourceRecordSet, len(r))
for host, values := range r {
ret[host] = make([]string, 0, len(values))
for record := range values {
ret[host] = append(ret[host], record)
}
}
return ret
} | go | func (r rrs) ToAXFRResourceRecordSet() models.AXFRResourceRecordSet {
ret := make(models.AXFRResourceRecordSet, len(r))
for host, values := range r {
ret[host] = make([]string, 0, len(values))
for record := range values {
ret[host] = append(ret[host], record)
}
}
return ret
} | [
"func",
"(",
"r",
"rrs",
")",
"ToAXFRResourceRecordSet",
"(",
")",
"models",
".",
"AXFRResourceRecordSet",
"{",
"ret",
":=",
"make",
"(",
"models",
".",
"AXFRResourceRecordSet",
",",
"len",
"(",
"r",
")",
")",
"\n",
"for",
"host",
",",
"values",
":=",
"range",
"r",
"{",
"ret",
"[",
"host",
"]",
"=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"values",
")",
")",
"\n",
"for",
"record",
":=",
"range",
"values",
"{",
"ret",
"[",
"host",
"]",
"=",
"append",
"(",
"ret",
"[",
"host",
"]",
",",
"record",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ret",
"\n",
"}"
] | // Transform the record set into something exportable via the REST API | [
"Transform",
"the",
"record",
"set",
"into",
"something",
"exportable",
"via",
"the",
"REST",
"API"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L59-L68 | train |
mesosphere/mesos-dns | records/generator.go | NewRecordGenerator | func NewRecordGenerator(options ...Option) *RecordGenerator {
rg := &RecordGenerator{}
rg.stateLoader = func(_ []string) (s state.State, err error) { return }
for i := range options {
if options[i] != nil {
options[i](rg)
}
}
return rg
} | go | func NewRecordGenerator(options ...Option) *RecordGenerator {
rg := &RecordGenerator{}
rg.stateLoader = func(_ []string) (s state.State, err error) { return }
for i := range options {
if options[i] != nil {
options[i](rg)
}
}
return rg
} | [
"func",
"NewRecordGenerator",
"(",
"options",
"...",
"Option",
")",
"*",
"RecordGenerator",
"{",
"rg",
":=",
"&",
"RecordGenerator",
"{",
"}",
"\n",
"rg",
".",
"stateLoader",
"=",
"func",
"(",
"_",
"[",
"]",
"string",
")",
"(",
"s",
"state",
".",
"State",
",",
"err",
"error",
")",
"{",
"return",
"}",
"\n",
"for",
"i",
":=",
"range",
"options",
"{",
"if",
"options",
"[",
"i",
"]",
"!=",
"nil",
"{",
"options",
"[",
"i",
"]",
"(",
"rg",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"rg",
"\n",
"}"
] | // NewRecordGenerator returns a RecordGenerator that's been configured with a timeout. | [
"NewRecordGenerator",
"returns",
"a",
"RecordGenerator",
"that",
"s",
"been",
"configured",
"with",
"a",
"timeout",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L160-L169 | train |
mesosphere/mesos-dns | records/generator.go | InsertState | func (rg *RecordGenerator) InsertState(sj state.State, domain, ns, listener string, masters, ipSources []string, spec labels.Func) error {
rg.SlaveIPs = map[string][]string{}
rg.SRVs = rrs{}
rg.As = rrs{}
rg.AAAAs = rrs{}
rg.frameworkRecords(sj, domain, spec)
rg.slaveRecords(sj, domain, spec)
rg.listenerRecord(listener, ns)
rg.masterRecord(domain, masters, sj.Leader)
rg.taskRecords(sj, domain, spec, ipSources)
return nil
} | go | func (rg *RecordGenerator) InsertState(sj state.State, domain, ns, listener string, masters, ipSources []string, spec labels.Func) error {
rg.SlaveIPs = map[string][]string{}
rg.SRVs = rrs{}
rg.As = rrs{}
rg.AAAAs = rrs{}
rg.frameworkRecords(sj, domain, spec)
rg.slaveRecords(sj, domain, spec)
rg.listenerRecord(listener, ns)
rg.masterRecord(domain, masters, sj.Leader)
rg.taskRecords(sj, domain, spec, ipSources)
return nil
} | [
"func",
"(",
"rg",
"*",
"RecordGenerator",
")",
"InsertState",
"(",
"sj",
"state",
".",
"State",
",",
"domain",
",",
"ns",
",",
"listener",
"string",
",",
"masters",
",",
"ipSources",
"[",
"]",
"string",
",",
"spec",
"labels",
".",
"Func",
")",
"error",
"{",
"rg",
".",
"SlaveIPs",
"=",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"}",
"\n",
"rg",
".",
"SRVs",
"=",
"rrs",
"{",
"}",
"\n",
"rg",
".",
"As",
"=",
"rrs",
"{",
"}",
"\n",
"rg",
".",
"AAAAs",
"=",
"rrs",
"{",
"}",
"\n",
"rg",
".",
"frameworkRecords",
"(",
"sj",
",",
"domain",
",",
"spec",
")",
"\n",
"rg",
".",
"slaveRecords",
"(",
"sj",
",",
"domain",
",",
"spec",
")",
"\n",
"rg",
".",
"listenerRecord",
"(",
"listener",
",",
"ns",
")",
"\n",
"rg",
".",
"masterRecord",
"(",
"domain",
",",
"masters",
",",
"sj",
".",
"Leader",
")",
"\n",
"rg",
".",
"taskRecords",
"(",
"sj",
",",
"domain",
",",
"spec",
",",
"ipSources",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // InsertState transforms a StateJSON into RecordGenerator RRs | [
"InsertState",
"transforms",
"a",
"StateJSON",
"into",
"RecordGenerator",
"RRs"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L205-L217 | train |
mesosphere/mesos-dns | records/generator.go | setFromLocal | func (rg *RecordGenerator) setFromLocal(host string, ns string) {
ifaces, err := net.Interfaces()
if err != nil {
logging.Error.Println(err)
}
// handle err
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
logging.Error.Println(err)
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
rg.insertRR(ns, ip.String(), rrsKindForIP(ip))
}
}
} | go | func (rg *RecordGenerator) setFromLocal(host string, ns string) {
ifaces, err := net.Interfaces()
if err != nil {
logging.Error.Println(err)
}
// handle err
for _, i := range ifaces {
addrs, err := i.Addrs()
if err != nil {
logging.Error.Println(err)
}
for _, addr := range addrs {
var ip net.IP
switch v := addr.(type) {
case *net.IPNet:
ip = v.IP
case *net.IPAddr:
ip = v.IP
}
if ip == nil || ip.IsLoopback() {
continue
}
rg.insertRR(ns, ip.String(), rrsKindForIP(ip))
}
}
} | [
"func",
"(",
"rg",
"*",
"RecordGenerator",
")",
"setFromLocal",
"(",
"host",
"string",
",",
"ns",
"string",
")",
"{",
"ifaces",
",",
"err",
":=",
"net",
".",
"Interfaces",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// handle err",
"for",
"_",
",",
"i",
":=",
"range",
"ifaces",
"{",
"addrs",
",",
"err",
":=",
"i",
".",
"Addrs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"var",
"ip",
"net",
".",
"IP",
"\n",
"switch",
"v",
":=",
"addr",
".",
"(",
"type",
")",
"{",
"case",
"*",
"net",
".",
"IPNet",
":",
"ip",
"=",
"v",
".",
"IP",
"\n",
"case",
"*",
"net",
".",
"IPAddr",
":",
"ip",
"=",
"v",
".",
"IP",
"\n",
"}",
"\n\n",
"if",
"ip",
"==",
"nil",
"||",
"ip",
".",
"IsLoopback",
"(",
")",
"{",
"continue",
"\n",
"}",
"\n\n",
"rg",
".",
"insertRR",
"(",
"ns",
",",
"ip",
".",
"String",
"(",
")",
",",
"rrsKindForIP",
"(",
"ip",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // A and AAAA records for each local interface
// If this causes problems you should explicitly set the
// listener address in config.json | [
"A",
"and",
"AAAA",
"records",
"for",
"each",
"local",
"interface",
"If",
"this",
"causes",
"problems",
"you",
"should",
"explicitly",
"set",
"the",
"listener",
"address",
"in",
"config",
".",
"json"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L500-L531 | train |
mesosphere/mesos-dns | records/generator.go | ipsTo4And6 | func ipsTo4And6(allIPs []net.IP) (ips []net.IP) {
var ipv4, ipv6 net.IP
for _, ip := range allIPs {
if ipv4 != nil && ipv6 != nil {
break
} else if t4 := ip.To4(); t4 != nil {
if ipv4 == nil {
ipv4 = t4
}
} else if t6 := ip.To16(); t6 != nil {
if ipv6 == nil {
ipv6 = t6
}
}
}
ips = []net.IP{}
if ipv4 != nil {
ips = append(ips, ipv4)
}
if ipv6 != nil {
ips = append(ips, ipv6)
}
return
} | go | func ipsTo4And6(allIPs []net.IP) (ips []net.IP) {
var ipv4, ipv6 net.IP
for _, ip := range allIPs {
if ipv4 != nil && ipv6 != nil {
break
} else if t4 := ip.To4(); t4 != nil {
if ipv4 == nil {
ipv4 = t4
}
} else if t6 := ip.To16(); t6 != nil {
if ipv6 == nil {
ipv6 = t6
}
}
}
ips = []net.IP{}
if ipv4 != nil {
ips = append(ips, ipv4)
}
if ipv6 != nil {
ips = append(ips, ipv6)
}
return
} | [
"func",
"ipsTo4And6",
"(",
"allIPs",
"[",
"]",
"net",
".",
"IP",
")",
"(",
"ips",
"[",
"]",
"net",
".",
"IP",
")",
"{",
"var",
"ipv4",
",",
"ipv6",
"net",
".",
"IP",
"\n",
"for",
"_",
",",
"ip",
":=",
"range",
"allIPs",
"{",
"if",
"ipv4",
"!=",
"nil",
"&&",
"ipv6",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"else",
"if",
"t4",
":=",
"ip",
".",
"To4",
"(",
")",
";",
"t4",
"!=",
"nil",
"{",
"if",
"ipv4",
"==",
"nil",
"{",
"ipv4",
"=",
"t4",
"\n",
"}",
"\n",
"}",
"else",
"if",
"t6",
":=",
"ip",
".",
"To16",
"(",
")",
";",
"t6",
"!=",
"nil",
"{",
"if",
"ipv6",
"==",
"nil",
"{",
"ipv6",
"=",
"t6",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"ips",
"=",
"[",
"]",
"net",
".",
"IP",
"{",
"}",
"\n",
"if",
"ipv4",
"!=",
"nil",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"ipv4",
")",
"\n",
"}",
"\n",
"if",
"ipv6",
"!=",
"nil",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"ipv6",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ipsTo4And6 returns a list with at most 1 ipv4 and 1 ipv6
// from a list of IPs | [
"ipsTo4And6",
"returns",
"a",
"list",
"with",
"at",
"most",
"1",
"ipv4",
"and",
"1",
"ipv6",
"from",
"a",
"list",
"of",
"IPs"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L572-L595 | train |
mesosphere/mesos-dns | records/generator.go | hostToIPs | func hostToIPs(hostname string) (ips []net.IP) {
if ip := net.ParseIP(hostname); ip != nil {
ips = []net.IP{ip}
} else if allIPs, err := net.LookupIP(hostname); err == nil {
ips = ipsTo4And6(allIPs)
}
if len(ips) == 0 {
logging.VeryVerbose.Printf("cannot translate hostname %q into an ipv4 or ipv6 address", hostname)
}
return
} | go | func hostToIPs(hostname string) (ips []net.IP) {
if ip := net.ParseIP(hostname); ip != nil {
ips = []net.IP{ip}
} else if allIPs, err := net.LookupIP(hostname); err == nil {
ips = ipsTo4And6(allIPs)
}
if len(ips) == 0 {
logging.VeryVerbose.Printf("cannot translate hostname %q into an ipv4 or ipv6 address", hostname)
}
return
} | [
"func",
"hostToIPs",
"(",
"hostname",
"string",
")",
"(",
"ips",
"[",
"]",
"net",
".",
"IP",
")",
"{",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"hostname",
")",
";",
"ip",
"!=",
"nil",
"{",
"ips",
"=",
"[",
"]",
"net",
".",
"IP",
"{",
"ip",
"}",
"\n",
"}",
"else",
"if",
"allIPs",
",",
"err",
":=",
"net",
".",
"LookupIP",
"(",
"hostname",
")",
";",
"err",
"==",
"nil",
"{",
"ips",
"=",
"ipsTo4And6",
"(",
"allIPs",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"ips",
")",
"==",
"0",
"{",
"logging",
".",
"VeryVerbose",
".",
"Printf",
"(",
"\"",
"\"",
",",
"hostname",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // hostToIPs attempts to parse a hostname into an ip.
// If that doesn't work it will perform a lookup and try to
// find one ipv4 and one ipv6 in the results. | [
"hostToIPs",
"attempts",
"to",
"parse",
"a",
"hostname",
"into",
"an",
"ip",
".",
"If",
"that",
"doesn",
"t",
"work",
"it",
"will",
"perform",
"a",
"lookup",
"and",
"try",
"to",
"find",
"one",
"ipv4",
"and",
"one",
"ipv6",
"in",
"the",
"results",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L600-L610 | train |
mesosphere/mesos-dns | records/generator.go | slaveIDTail | func slaveIDTail(slaveID string) string {
fields := strings.Split(slaveID, "-")
return strings.ToLower(fields[len(fields)-1])
} | go | func slaveIDTail(slaveID string) string {
fields := strings.Split(slaveID, "-")
return strings.ToLower(fields[len(fields)-1])
} | [
"func",
"slaveIDTail",
"(",
"slaveID",
"string",
")",
"string",
"{",
"fields",
":=",
"strings",
".",
"Split",
"(",
"slaveID",
",",
"\"",
"\"",
")",
"\n",
"return",
"strings",
".",
"ToLower",
"(",
"fields",
"[",
"len",
"(",
"fields",
")",
"-",
"1",
"]",
")",
"\n",
"}"
] | // return the slave number from a Mesos slave id | [
"return",
"the",
"slave",
"number",
"from",
"a",
"Mesos",
"slave",
"id"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/generator.go#L613-L616 | train |
mesosphere/mesos-dns | exchanger/exchanger.go | Decorate | func Decorate(ex Exchanger, ds ...Decorator) Exchanger {
decorated := ex
for _, decorate := range ds {
decorated = decorate(decorated)
}
return decorated
} | go | func Decorate(ex Exchanger, ds ...Decorator) Exchanger {
decorated := ex
for _, decorate := range ds {
decorated = decorate(decorated)
}
return decorated
} | [
"func",
"Decorate",
"(",
"ex",
"Exchanger",
",",
"ds",
"...",
"Decorator",
")",
"Exchanger",
"{",
"decorated",
":=",
"ex",
"\n",
"for",
"_",
",",
"decorate",
":=",
"range",
"ds",
"{",
"decorated",
"=",
"decorate",
"(",
"decorated",
")",
"\n",
"}",
"\n",
"return",
"decorated",
"\n",
"}"
] | // Decorate decorates an Exchanger with the given Decorators. | [
"Decorate",
"decorates",
"an",
"Exchanger",
"with",
"the",
"given",
"Decorators",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/exchanger/exchanger.go#L42-L48 | train |
mesosphere/mesos-dns | exchanger/exchanger.go | ErrorLogging | func ErrorLogging(l *log.Logger) Decorator {
return func(ex Exchanger) Exchanger {
return Func(func(m *dns.Msg, a string) (r *dns.Msg, rtt time.Duration, err error) {
defer func() {
if err != nil {
l.Printf("%v: exchanging %#v with %q", err, m, a)
}
}()
return ex.Exchange(m, a)
})
}
} | go | func ErrorLogging(l *log.Logger) Decorator {
return func(ex Exchanger) Exchanger {
return Func(func(m *dns.Msg, a string) (r *dns.Msg, rtt time.Duration, err error) {
defer func() {
if err != nil {
l.Printf("%v: exchanging %#v with %q", err, m, a)
}
}()
return ex.Exchange(m, a)
})
}
} | [
"func",
"ErrorLogging",
"(",
"l",
"*",
"log",
".",
"Logger",
")",
"Decorator",
"{",
"return",
"func",
"(",
"ex",
"Exchanger",
")",
"Exchanger",
"{",
"return",
"Func",
"(",
"func",
"(",
"m",
"*",
"dns",
".",
"Msg",
",",
"a",
"string",
")",
"(",
"r",
"*",
"dns",
".",
"Msg",
",",
"rtt",
"time",
".",
"Duration",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"l",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
",",
"m",
",",
"a",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"ex",
".",
"Exchange",
"(",
"m",
",",
"a",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // ErrorLogging returns a Decorator which logs an Exchanger's errors to the given
// logger. | [
"ErrorLogging",
"returns",
"a",
"Decorator",
"which",
"logs",
"an",
"Exchanger",
"s",
"errors",
"to",
"the",
"given",
"logger",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/exchanger/exchanger.go#L52-L63 | train |
mesosphere/mesos-dns | exchanger/exchanger.go | Instrumentation | func Instrumentation(total, success, failure logging.Counter) Decorator {
return func(ex Exchanger) Exchanger {
return Func(func(m *dns.Msg, a string) (r *dns.Msg, rtt time.Duration, err error) {
defer func() {
if total.Inc(); err != nil {
failure.Inc()
} else {
success.Inc()
}
}()
return ex.Exchange(m, a)
})
}
} | go | func Instrumentation(total, success, failure logging.Counter) Decorator {
return func(ex Exchanger) Exchanger {
return Func(func(m *dns.Msg, a string) (r *dns.Msg, rtt time.Duration, err error) {
defer func() {
if total.Inc(); err != nil {
failure.Inc()
} else {
success.Inc()
}
}()
return ex.Exchange(m, a)
})
}
} | [
"func",
"Instrumentation",
"(",
"total",
",",
"success",
",",
"failure",
"logging",
".",
"Counter",
")",
"Decorator",
"{",
"return",
"func",
"(",
"ex",
"Exchanger",
")",
"Exchanger",
"{",
"return",
"Func",
"(",
"func",
"(",
"m",
"*",
"dns",
".",
"Msg",
",",
"a",
"string",
")",
"(",
"r",
"*",
"dns",
".",
"Msg",
",",
"rtt",
"time",
".",
"Duration",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"total",
".",
"Inc",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"failure",
".",
"Inc",
"(",
")",
"\n",
"}",
"else",
"{",
"success",
".",
"Inc",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"ex",
".",
"Exchange",
"(",
"m",
",",
"a",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // Instrumentation returns a Decorator which instruments an Exchanger with the given
// counters. | [
"Instrumentation",
"returns",
"a",
"Decorator",
"which",
"instruments",
"an",
"Exchanger",
"with",
"the",
"given",
"counters",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/exchanger/exchanger.go#L67-L80 | train |
mesosphere/mesos-dns | httpcli/doer.go | New | func New(am AuthMechanism, cm ConfigMap, options ...Option) Doer {
defaultClient := &http.Client{}
for i := range options {
if options[i] != nil {
options[i](defaultClient)
}
}
df, ok := factoryFor(am)
if !ok {
panic(fmt.Sprintf("unregistered auth mechanism %q", am))
}
return df(cm, defaultClient)
} | go | func New(am AuthMechanism, cm ConfigMap, options ...Option) Doer {
defaultClient := &http.Client{}
for i := range options {
if options[i] != nil {
options[i](defaultClient)
}
}
df, ok := factoryFor(am)
if !ok {
panic(fmt.Sprintf("unregistered auth mechanism %q", am))
}
return df(cm, defaultClient)
} | [
"func",
"New",
"(",
"am",
"AuthMechanism",
",",
"cm",
"ConfigMap",
",",
"options",
"...",
"Option",
")",
"Doer",
"{",
"defaultClient",
":=",
"&",
"http",
".",
"Client",
"{",
"}",
"\n",
"for",
"i",
":=",
"range",
"options",
"{",
"if",
"options",
"[",
"i",
"]",
"!=",
"nil",
"{",
"options",
"[",
"i",
"]",
"(",
"defaultClient",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"df",
",",
"ok",
":=",
"factoryFor",
"(",
"am",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"am",
")",
")",
"\n",
"}",
"\n",
"return",
"df",
"(",
"cm",
",",
"defaultClient",
")",
"\n",
"}"
] | // New generates and returns an HTTP transactor given an optional IAM configuration and some set of
// functional options. | [
"New",
"generates",
"and",
"returns",
"an",
"HTTP",
"transactor",
"given",
"an",
"optional",
"IAM",
"configuration",
"and",
"some",
"set",
"of",
"functional",
"options",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/doer.go#L38-L51 | train |
mesosphere/mesos-dns | httpcli/doer.go | Timeout | func Timeout(timeout time.Duration) Option {
return func(client *http.Client) {
client.Timeout = timeout
}
} | go | func Timeout(timeout time.Duration) Option {
return func(client *http.Client) {
client.Timeout = timeout
}
} | [
"func",
"Timeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"Option",
"{",
"return",
"func",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"{",
"client",
".",
"Timeout",
"=",
"timeout",
"\n",
"}",
"\n",
"}"
] | // Timeout returns an Option that configures client timeout | [
"Timeout",
"returns",
"an",
"Option",
"that",
"configures",
"client",
"timeout"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/doer.go#L54-L58 | train |
mesosphere/mesos-dns | httpcli/doer.go | Transport | func Transport(tr http.RoundTripper) Option {
return func(client *http.Client) {
client.Transport = tr
}
} | go | func Transport(tr http.RoundTripper) Option {
return func(client *http.Client) {
client.Transport = tr
}
} | [
"func",
"Transport",
"(",
"tr",
"http",
".",
"RoundTripper",
")",
"Option",
"{",
"return",
"func",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"{",
"client",
".",
"Transport",
"=",
"tr",
"\n",
"}",
"\n",
"}"
] | // Transport returns an Option that configures client transport | [
"Transport",
"returns",
"an",
"Option",
"that",
"configures",
"client",
"transport"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/doer.go#L61-L65 | train |
mesosphere/mesos-dns | httpcli/doer.go | TLSConfig | func TLSConfig(enabled bool, caPool *x509.CertPool, cert tls.Certificate) (opt urls.Option, config *tls.Config) {
opt = urls.Scheme("http")
if enabled {
opt = urls.Scheme("https")
config = &tls.Config{
Certificates: []tls.Certificate{cert},
RootCAs: caPool,
InsecureSkipVerify: caPool == nil,
}
}
return
} | go | func TLSConfig(enabled bool, caPool *x509.CertPool, cert tls.Certificate) (opt urls.Option, config *tls.Config) {
opt = urls.Scheme("http")
if enabled {
opt = urls.Scheme("https")
config = &tls.Config{
Certificates: []tls.Certificate{cert},
RootCAs: caPool,
InsecureSkipVerify: caPool == nil,
}
}
return
} | [
"func",
"TLSConfig",
"(",
"enabled",
"bool",
",",
"caPool",
"*",
"x509",
".",
"CertPool",
",",
"cert",
"tls",
".",
"Certificate",
")",
"(",
"opt",
"urls",
".",
"Option",
",",
"config",
"*",
"tls",
".",
"Config",
")",
"{",
"opt",
"=",
"urls",
".",
"Scheme",
"(",
"\"",
"\"",
")",
"\n",
"if",
"enabled",
"{",
"opt",
"=",
"urls",
".",
"Scheme",
"(",
"\"",
"\"",
")",
"\n",
"config",
"=",
"&",
"tls",
".",
"Config",
"{",
"Certificates",
":",
"[",
"]",
"tls",
".",
"Certificate",
"{",
"cert",
"}",
",",
"RootCAs",
":",
"caPool",
",",
"InsecureSkipVerify",
":",
"caPool",
"==",
"nil",
",",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // TLSConfig generates and returns a recommended URL generation option and TLS configuration. | [
"TLSConfig",
"generates",
"and",
"returns",
"a",
"recommended",
"URL",
"generation",
"option",
"and",
"TLS",
"configuration",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/doer.go#L68-L79 | train |
mesosphere/mesos-dns | resolver/resolver.go | New | func New(version string, config records.Config) *Resolver {
generatorOptions := []records.Option{
records.WithConfig(config),
}
recordGenerator := records.NewRecordGenerator(generatorOptions...)
r := &Resolver{
version: version,
config: config,
ready: make(chan struct{}),
rs: recordGenerator,
// rand.Sources aren't safe for concurrent use, except the global one.
// See: https://github.com/golang/go/issues/3611
rng: rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())}),
masters: append([]string{""}, config.Masters...),
generatorOptions: generatorOptions,
}
timeout := 5 * time.Second
if config.Timeout != 0 {
timeout = time.Duration(config.Timeout) * time.Second
}
r.zoneFwds = make(map[string]exchanger.Forwarder)
if config.ExternalOn {
for zone, resolvers := range config.ZoneResolvers {
r.zoneFwds[zone] = exchanger.NewForwarder(resolvers, exchangers(timeout, "udp", "tcp"))
}
r.defaultFwd = exchanger.NewForwarder(
config.Resolvers, exchangers(timeout, "udp", "tcp"))
} else {
r.defaultFwd = exchanger.NewForwarder(
make([]string, 0), exchangers(timeout, "udp", "tcp"))
}
return r
} | go | func New(version string, config records.Config) *Resolver {
generatorOptions := []records.Option{
records.WithConfig(config),
}
recordGenerator := records.NewRecordGenerator(generatorOptions...)
r := &Resolver{
version: version,
config: config,
ready: make(chan struct{}),
rs: recordGenerator,
// rand.Sources aren't safe for concurrent use, except the global one.
// See: https://github.com/golang/go/issues/3611
rng: rand.New(&lockedSource{src: rand.NewSource(time.Now().UnixNano())}),
masters: append([]string{""}, config.Masters...),
generatorOptions: generatorOptions,
}
timeout := 5 * time.Second
if config.Timeout != 0 {
timeout = time.Duration(config.Timeout) * time.Second
}
r.zoneFwds = make(map[string]exchanger.Forwarder)
if config.ExternalOn {
for zone, resolvers := range config.ZoneResolvers {
r.zoneFwds[zone] = exchanger.NewForwarder(resolvers, exchangers(timeout, "udp", "tcp"))
}
r.defaultFwd = exchanger.NewForwarder(
config.Resolvers, exchangers(timeout, "udp", "tcp"))
} else {
r.defaultFwd = exchanger.NewForwarder(
make([]string, 0), exchangers(timeout, "udp", "tcp"))
}
return r
} | [
"func",
"New",
"(",
"version",
"string",
",",
"config",
"records",
".",
"Config",
")",
"*",
"Resolver",
"{",
"generatorOptions",
":=",
"[",
"]",
"records",
".",
"Option",
"{",
"records",
".",
"WithConfig",
"(",
"config",
")",
",",
"}",
"\n",
"recordGenerator",
":=",
"records",
".",
"NewRecordGenerator",
"(",
"generatorOptions",
"...",
")",
"\n",
"r",
":=",
"&",
"Resolver",
"{",
"version",
":",
"version",
",",
"config",
":",
"config",
",",
"ready",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"rs",
":",
"recordGenerator",
",",
"// rand.Sources aren't safe for concurrent use, except the global one.",
"// See: https://github.com/golang/go/issues/3611",
"rng",
":",
"rand",
".",
"New",
"(",
"&",
"lockedSource",
"{",
"src",
":",
"rand",
".",
"NewSource",
"(",
"time",
".",
"Now",
"(",
")",
".",
"UnixNano",
"(",
")",
")",
"}",
")",
",",
"masters",
":",
"append",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"config",
".",
"Masters",
"...",
")",
",",
"generatorOptions",
":",
"generatorOptions",
",",
"}",
"\n\n",
"timeout",
":=",
"5",
"*",
"time",
".",
"Second",
"\n",
"if",
"config",
".",
"Timeout",
"!=",
"0",
"{",
"timeout",
"=",
"time",
".",
"Duration",
"(",
"config",
".",
"Timeout",
")",
"*",
"time",
".",
"Second",
"\n",
"}",
"\n\n",
"r",
".",
"zoneFwds",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"exchanger",
".",
"Forwarder",
")",
"\n",
"if",
"config",
".",
"ExternalOn",
"{",
"for",
"zone",
",",
"resolvers",
":=",
"range",
"config",
".",
"ZoneResolvers",
"{",
"r",
".",
"zoneFwds",
"[",
"zone",
"]",
"=",
"exchanger",
".",
"NewForwarder",
"(",
"resolvers",
",",
"exchangers",
"(",
"timeout",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n",
"r",
".",
"defaultFwd",
"=",
"exchanger",
".",
"NewForwarder",
"(",
"config",
".",
"Resolvers",
",",
"exchangers",
"(",
"timeout",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"else",
"{",
"r",
".",
"defaultFwd",
"=",
"exchanger",
".",
"NewForwarder",
"(",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
",",
"exchangers",
"(",
"timeout",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"return",
"r",
"\n",
"}"
] | // New returns a Resolver with the given version and configuration. | [
"New",
"returns",
"a",
"Resolver",
"with",
"the",
"given",
"version",
"and",
"configuration",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L42-L77 | train |
mesosphere/mesos-dns | resolver/resolver.go | Reload | func (res *Resolver) Reload() {
t := records.NewRecordGenerator(res.generatorOptions...)
err := t.ParseState(res.config, res.masters...)
if err == nil {
timestamp := uint32(time.Now().Unix())
// may need to refactor for fairness
res.rsLock.Lock()
defer res.rsLock.Unlock()
atomic.StoreUint32(&res.config.SOASerial, timestamp)
res.rs = t
select {
case <-res.ready:
// noop because channel is already closed
default:
close(res.ready)
}
} else {
logging.Error.Printf("Warning: Error generating records: %v; keeping old DNS state", err)
}
logging.PrintCurLog()
} | go | func (res *Resolver) Reload() {
t := records.NewRecordGenerator(res.generatorOptions...)
err := t.ParseState(res.config, res.masters...)
if err == nil {
timestamp := uint32(time.Now().Unix())
// may need to refactor for fairness
res.rsLock.Lock()
defer res.rsLock.Unlock()
atomic.StoreUint32(&res.config.SOASerial, timestamp)
res.rs = t
select {
case <-res.ready:
// noop because channel is already closed
default:
close(res.ready)
}
} else {
logging.Error.Printf("Warning: Error generating records: %v; keeping old DNS state", err)
}
logging.PrintCurLog()
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"Reload",
"(",
")",
"{",
"t",
":=",
"records",
".",
"NewRecordGenerator",
"(",
"res",
".",
"generatorOptions",
"...",
")",
"\n",
"err",
":=",
"t",
".",
"ParseState",
"(",
"res",
".",
"config",
",",
"res",
".",
"masters",
"...",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"timestamp",
":=",
"uint32",
"(",
"time",
".",
"Now",
"(",
")",
".",
"Unix",
"(",
")",
")",
"\n",
"// may need to refactor for fairness",
"res",
".",
"rsLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"res",
".",
"rsLock",
".",
"Unlock",
"(",
")",
"\n",
"atomic",
".",
"StoreUint32",
"(",
"&",
"res",
".",
"config",
".",
"SOASerial",
",",
"timestamp",
")",
"\n",
"res",
".",
"rs",
"=",
"t",
"\n",
"select",
"{",
"case",
"<-",
"res",
".",
"ready",
":",
"// noop because channel is already closed",
"default",
":",
"close",
"(",
"res",
".",
"ready",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"logging",
".",
"Error",
".",
"Printf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logging",
".",
"PrintCurLog",
"(",
")",
"\n",
"}"
] | // Reload triggers a new state load from the configured mesos masters.
// This method is not goroutine-safe. | [
"Reload",
"triggers",
"a",
"new",
"state",
"load",
"from",
"the",
"configured",
"mesos",
"masters",
".",
"This",
"method",
"is",
"not",
"goroutine",
"-",
"safe",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L173-L195 | train |
mesosphere/mesos-dns | resolver/resolver.go | formatSRV | func (res *Resolver) formatSRV(name string, target string) (*dns.SRV, error) {
ttl := uint32(res.config.TTL)
h, port, err := net.SplitHostPort(target)
if err != nil {
return nil, errors.New("invalid target")
}
p, err := strconv.Atoi(port)
if err != nil {
return nil, errors.New("invalid target port")
}
return &dns.SRV{
Hdr: dns.RR_Header{
Name: name,
Rrtype: dns.TypeSRV,
Class: dns.ClassINET,
Ttl: ttl,
},
Priority: 0,
Weight: res.config.SRVRecordDefaultWeight,
Port: uint16(p),
Target: h,
}, nil
} | go | func (res *Resolver) formatSRV(name string, target string) (*dns.SRV, error) {
ttl := uint32(res.config.TTL)
h, port, err := net.SplitHostPort(target)
if err != nil {
return nil, errors.New("invalid target")
}
p, err := strconv.Atoi(port)
if err != nil {
return nil, errors.New("invalid target port")
}
return &dns.SRV{
Hdr: dns.RR_Header{
Name: name,
Rrtype: dns.TypeSRV,
Class: dns.ClassINET,
Ttl: ttl,
},
Priority: 0,
Weight: res.config.SRVRecordDefaultWeight,
Port: uint16(p),
Target: h,
}, nil
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"formatSRV",
"(",
"name",
"string",
",",
"target",
"string",
")",
"(",
"*",
"dns",
".",
"SRV",
",",
"error",
")",
"{",
"ttl",
":=",
"uint32",
"(",
"res",
".",
"config",
".",
"TTL",
")",
"\n\n",
"h",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"target",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"p",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"port",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"dns",
".",
"SRV",
"{",
"Hdr",
":",
"dns",
".",
"RR_Header",
"{",
"Name",
":",
"name",
",",
"Rrtype",
":",
"dns",
".",
"TypeSRV",
",",
"Class",
":",
"dns",
".",
"ClassINET",
",",
"Ttl",
":",
"ttl",
",",
"}",
",",
"Priority",
":",
"0",
",",
"Weight",
":",
"res",
".",
"config",
".",
"SRVRecordDefaultWeight",
",",
"Port",
":",
"uint16",
"(",
"p",
")",
",",
"Target",
":",
"h",
",",
"}",
",",
"nil",
"\n",
"}"
] | // formatSRV returns the SRV resource record for target | [
"formatSRV",
"returns",
"the",
"SRV",
"resource",
"record",
"for",
"target"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L198-L222 | train |
mesosphere/mesos-dns | resolver/resolver.go | formatA | func (res *Resolver) formatA(dom string, target string) (*dns.A, error) {
ttl := uint32(res.config.TTL)
a := net.ParseIP(target)
if a == nil {
return nil, errors.New("invalid target")
}
return &dns.A{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeA,
Class: dns.ClassINET,
Ttl: ttl},
A: a.To4(),
}, nil
} | go | func (res *Resolver) formatA(dom string, target string) (*dns.A, error) {
ttl := uint32(res.config.TTL)
a := net.ParseIP(target)
if a == nil {
return nil, errors.New("invalid target")
}
return &dns.A{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeA,
Class: dns.ClassINET,
Ttl: ttl},
A: a.To4(),
}, nil
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"formatA",
"(",
"dom",
"string",
",",
"target",
"string",
")",
"(",
"*",
"dns",
".",
"A",
",",
"error",
")",
"{",
"ttl",
":=",
"uint32",
"(",
"res",
".",
"config",
".",
"TTL",
")",
"\n\n",
"a",
":=",
"net",
".",
"ParseIP",
"(",
"target",
")",
"\n",
"if",
"a",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"dns",
".",
"A",
"{",
"Hdr",
":",
"dns",
".",
"RR_Header",
"{",
"Name",
":",
"dom",
",",
"Rrtype",
":",
"dns",
".",
"TypeA",
",",
"Class",
":",
"dns",
".",
"ClassINET",
",",
"Ttl",
":",
"ttl",
"}",
",",
"A",
":",
"a",
".",
"To4",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // returns the A resource record for target
// assumes target is a well formed IPv4 address | [
"returns",
"the",
"A",
"resource",
"record",
"for",
"target",
"assumes",
"target",
"is",
"a",
"well",
"formed",
"IPv4",
"address"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L226-L242 | train |
mesosphere/mesos-dns | resolver/resolver.go | formatAAAA | func (res *Resolver) formatAAAA(dom string, target string) (*dns.AAAA, error) {
ttl := uint32(res.config.TTL)
aaaa := net.ParseIP(target)
if aaaa == nil {
return nil, errors.New("invalid target")
}
return &dns.AAAA{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeAAAA,
Class: dns.ClassINET,
Ttl: ttl},
AAAA: aaaa.To16(),
}, nil
} | go | func (res *Resolver) formatAAAA(dom string, target string) (*dns.AAAA, error) {
ttl := uint32(res.config.TTL)
aaaa := net.ParseIP(target)
if aaaa == nil {
return nil, errors.New("invalid target")
}
return &dns.AAAA{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeAAAA,
Class: dns.ClassINET,
Ttl: ttl},
AAAA: aaaa.To16(),
}, nil
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"formatAAAA",
"(",
"dom",
"string",
",",
"target",
"string",
")",
"(",
"*",
"dns",
".",
"AAAA",
",",
"error",
")",
"{",
"ttl",
":=",
"uint32",
"(",
"res",
".",
"config",
".",
"TTL",
")",
"\n\n",
"aaaa",
":=",
"net",
".",
"ParseIP",
"(",
"target",
")",
"\n",
"if",
"aaaa",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"dns",
".",
"AAAA",
"{",
"Hdr",
":",
"dns",
".",
"RR_Header",
"{",
"Name",
":",
"dom",
",",
"Rrtype",
":",
"dns",
".",
"TypeAAAA",
",",
"Class",
":",
"dns",
".",
"ClassINET",
",",
"Ttl",
":",
"ttl",
"}",
",",
"AAAA",
":",
"aaaa",
".",
"To16",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // returns the AAAA resource record for target
// assumes target is a well formed IPv6 address | [
"returns",
"the",
"AAAA",
"resource",
"record",
"for",
"target",
"assumes",
"target",
"is",
"a",
"well",
"formed",
"IPv6",
"address"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L246-L262 | train |
mesosphere/mesos-dns | resolver/resolver.go | formatSOA | func (res *Resolver) formatSOA(dom string) *dns.SOA {
ttl := uint32(res.config.TTL)
return &dns.SOA{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: ttl,
},
Ns: res.config.SOAMname,
Mbox: res.config.SOARname,
Serial: atomic.LoadUint32(&res.config.SOASerial),
Refresh: res.config.SOARefresh,
Retry: res.config.SOARetry,
Expire: res.config.SOAExpire,
Minttl: ttl,
}
} | go | func (res *Resolver) formatSOA(dom string) *dns.SOA {
ttl := uint32(res.config.TTL)
return &dns.SOA{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeSOA,
Class: dns.ClassINET,
Ttl: ttl,
},
Ns: res.config.SOAMname,
Mbox: res.config.SOARname,
Serial: atomic.LoadUint32(&res.config.SOASerial),
Refresh: res.config.SOARefresh,
Retry: res.config.SOARetry,
Expire: res.config.SOAExpire,
Minttl: ttl,
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"formatSOA",
"(",
"dom",
"string",
")",
"*",
"dns",
".",
"SOA",
"{",
"ttl",
":=",
"uint32",
"(",
"res",
".",
"config",
".",
"TTL",
")",
"\n\n",
"return",
"&",
"dns",
".",
"SOA",
"{",
"Hdr",
":",
"dns",
".",
"RR_Header",
"{",
"Name",
":",
"dom",
",",
"Rrtype",
":",
"dns",
".",
"TypeSOA",
",",
"Class",
":",
"dns",
".",
"ClassINET",
",",
"Ttl",
":",
"ttl",
",",
"}",
",",
"Ns",
":",
"res",
".",
"config",
".",
"SOAMname",
",",
"Mbox",
":",
"res",
".",
"config",
".",
"SOARname",
",",
"Serial",
":",
"atomic",
".",
"LoadUint32",
"(",
"&",
"res",
".",
"config",
".",
"SOASerial",
")",
",",
"Refresh",
":",
"res",
".",
"config",
".",
"SOARefresh",
",",
"Retry",
":",
"res",
".",
"config",
".",
"SOARetry",
",",
"Expire",
":",
"res",
".",
"config",
".",
"SOAExpire",
",",
"Minttl",
":",
"ttl",
",",
"}",
"\n",
"}"
] | // formatSOA returns the SOA resource record for the mesos domain | [
"formatSOA",
"returns",
"the",
"SOA",
"resource",
"record",
"for",
"the",
"mesos",
"domain"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L265-L283 | train |
mesosphere/mesos-dns | resolver/resolver.go | formatNS | func (res *Resolver) formatNS(dom string) *dns.NS {
ttl := uint32(res.config.TTL)
return &dns.NS{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: ttl,
},
Ns: res.config.SOAMname,
}
} | go | func (res *Resolver) formatNS(dom string) *dns.NS {
ttl := uint32(res.config.TTL)
return &dns.NS{
Hdr: dns.RR_Header{
Name: dom,
Rrtype: dns.TypeNS,
Class: dns.ClassINET,
Ttl: ttl,
},
Ns: res.config.SOAMname,
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"formatNS",
"(",
"dom",
"string",
")",
"*",
"dns",
".",
"NS",
"{",
"ttl",
":=",
"uint32",
"(",
"res",
".",
"config",
".",
"TTL",
")",
"\n\n",
"return",
"&",
"dns",
".",
"NS",
"{",
"Hdr",
":",
"dns",
".",
"RR_Header",
"{",
"Name",
":",
"dom",
",",
"Rrtype",
":",
"dns",
".",
"TypeNS",
",",
"Class",
":",
"dns",
".",
"ClassINET",
",",
"Ttl",
":",
"ttl",
",",
"}",
",",
"Ns",
":",
"res",
".",
"config",
".",
"SOAMname",
",",
"}",
"\n",
"}"
] | // formatNS returns the NS record for the mesos domain | [
"formatNS",
"returns",
"the",
"NS",
"record",
"for",
"the",
"mesos",
"domain"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L286-L298 | train |
mesosphere/mesos-dns | resolver/resolver.go | shuffleAnswers | func shuffleAnswers(rng *rand.Rand, answers []dns.RR) []dns.RR {
n := len(answers)
for i := 0; i < n; i++ {
r := i + rng.Intn(n-i)
answers[r], answers[i] = answers[i], answers[r]
}
return answers
} | go | func shuffleAnswers(rng *rand.Rand, answers []dns.RR) []dns.RR {
n := len(answers)
for i := 0; i < n; i++ {
r := i + rng.Intn(n-i)
answers[r], answers[i] = answers[i], answers[r]
}
return answers
} | [
"func",
"shuffleAnswers",
"(",
"rng",
"*",
"rand",
".",
"Rand",
",",
"answers",
"[",
"]",
"dns",
".",
"RR",
")",
"[",
"]",
"dns",
".",
"RR",
"{",
"n",
":=",
"len",
"(",
"answers",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"n",
";",
"i",
"++",
"{",
"r",
":=",
"i",
"+",
"rng",
".",
"Intn",
"(",
"n",
"-",
"i",
")",
"\n",
"answers",
"[",
"r",
"]",
",",
"answers",
"[",
"i",
"]",
"=",
"answers",
"[",
"i",
"]",
",",
"answers",
"[",
"r",
"]",
"\n",
"}",
"\n\n",
"return",
"answers",
"\n",
"}"
] | // reorders answers for very basic load balancing | [
"reorders",
"answers",
"for",
"very",
"basic",
"load",
"balancing"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L301-L309 | train |
mesosphere/mesos-dns | resolver/resolver.go | HandleNonMesos | func (res *Resolver) HandleNonMesos(fwd exchanger.Forwarder) func(
dns.ResponseWriter, *dns.Msg) {
return func(w dns.ResponseWriter, r *dns.Msg) {
logging.CurLog.NonMesosRequests.Inc()
m, err := fwd(r, w.RemoteAddr().Network())
if err != nil {
m = new(dns.Msg).SetRcode(r, rcode(err))
} else if len(m.Answer) == 0 {
logging.CurLog.NonMesosNXDomain.Inc()
}
reply(w, m, res.config.SetTruncateBit)
}
} | go | func (res *Resolver) HandleNonMesos(fwd exchanger.Forwarder) func(
dns.ResponseWriter, *dns.Msg) {
return func(w dns.ResponseWriter, r *dns.Msg) {
logging.CurLog.NonMesosRequests.Inc()
m, err := fwd(r, w.RemoteAddr().Network())
if err != nil {
m = new(dns.Msg).SetRcode(r, rcode(err))
} else if len(m.Answer) == 0 {
logging.CurLog.NonMesosNXDomain.Inc()
}
reply(w, m, res.config.SetTruncateBit)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"HandleNonMesos",
"(",
"fwd",
"exchanger",
".",
"Forwarder",
")",
"func",
"(",
"dns",
".",
"ResponseWriter",
",",
"*",
"dns",
".",
"Msg",
")",
"{",
"return",
"func",
"(",
"w",
"dns",
".",
"ResponseWriter",
",",
"r",
"*",
"dns",
".",
"Msg",
")",
"{",
"logging",
".",
"CurLog",
".",
"NonMesosRequests",
".",
"Inc",
"(",
")",
"\n",
"m",
",",
"err",
":=",
"fwd",
"(",
"r",
",",
"w",
".",
"RemoteAddr",
"(",
")",
".",
"Network",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"m",
"=",
"new",
"(",
"dns",
".",
"Msg",
")",
".",
"SetRcode",
"(",
"r",
",",
"rcode",
"(",
"err",
")",
")",
"\n",
"}",
"else",
"if",
"len",
"(",
"m",
".",
"Answer",
")",
"==",
"0",
"{",
"logging",
".",
"CurLog",
".",
"NonMesosNXDomain",
".",
"Inc",
"(",
")",
"\n",
"}",
"\n",
"reply",
"(",
"w",
",",
"m",
",",
"res",
".",
"config",
".",
"SetTruncateBit",
")",
"\n",
"}",
"\n",
"}"
] | // HandleNonMesos handles non-mesos queries by forwarding to configured
// external DNS servers. | [
"HandleNonMesos",
"handles",
"non",
"-",
"mesos",
"queries",
"by",
"forwarding",
"to",
"configured",
"external",
"DNS",
"servers",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L313-L325 | train |
mesosphere/mesos-dns | resolver/resolver.go | reply | func reply(w dns.ResponseWriter, m *dns.Msg, setTruncateBit bool) {
m.Compress = true // https://github.com/mesosphere/mesos-dns/issues/{170,173,174}
maxsize := maxMsgSize(isUDP(w), m.IsEdns0())
truncate(m, maxsize, setTruncateBit)
if err := w.WriteMsg(m); err != nil {
logging.Error.Println(err)
}
} | go | func reply(w dns.ResponseWriter, m *dns.Msg, setTruncateBit bool) {
m.Compress = true // https://github.com/mesosphere/mesos-dns/issues/{170,173,174}
maxsize := maxMsgSize(isUDP(w), m.IsEdns0())
truncate(m, maxsize, setTruncateBit)
if err := w.WriteMsg(m); err != nil {
logging.Error.Println(err)
}
} | [
"func",
"reply",
"(",
"w",
"dns",
".",
"ResponseWriter",
",",
"m",
"*",
"dns",
".",
"Msg",
",",
"setTruncateBit",
"bool",
")",
"{",
"m",
".",
"Compress",
"=",
"true",
"// https://github.com/mesosphere/mesos-dns/issues/{170,173,174}",
"\n",
"maxsize",
":=",
"maxMsgSize",
"(",
"isUDP",
"(",
"w",
")",
",",
"m",
".",
"IsEdns0",
"(",
")",
")",
"\n",
"truncate",
"(",
"m",
",",
"maxsize",
",",
"setTruncateBit",
")",
"\n",
"if",
"err",
":=",
"w",
".",
"WriteMsg",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // reply writes the given dns.Msg out to the given dns.ResponseWriter,
// compressing the message first and truncating it accordingly. | [
"reply",
"writes",
"the",
"given",
"dns",
".",
"Msg",
"out",
"to",
"the",
"given",
"dns",
".",
"ResponseWriter",
"compressing",
"the",
"message",
"first",
"and",
"truncating",
"it",
"accordingly",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L495-L502 | train |
mesosphere/mesos-dns | resolver/resolver.go | isUDP | func isUDP(w dns.ResponseWriter) bool {
return strings.HasPrefix(w.RemoteAddr().Network(), "udp")
} | go | func isUDP(w dns.ResponseWriter) bool {
return strings.HasPrefix(w.RemoteAddr().Network(), "udp")
} | [
"func",
"isUDP",
"(",
"w",
"dns",
".",
"ResponseWriter",
")",
"bool",
"{",
"return",
"strings",
".",
"HasPrefix",
"(",
"w",
".",
"RemoteAddr",
"(",
")",
".",
"Network",
"(",
")",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // isUDP returns true if the transmission channel in use is UDP. | [
"isUDP",
"returns",
"true",
"if",
"the",
"transmission",
"channel",
"in",
"use",
"is",
"UDP",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L505-L507 | train |
mesosphere/mesos-dns | resolver/resolver.go | LaunchHTTP | func (res *Resolver) LaunchHTTP() <-chan error {
defer util.HandleCrash()
res.configureHTTP()
listenAddress := net.JoinHostPort(res.config.HTTPListener, strconv.Itoa(res.config.HTTPPort))
errCh := make(chan error, 1)
go func() {
var err error
defer func() { errCh <- err }()
if err = http.ListenAndServe(listenAddress, nil); err != nil {
err = fmt.Errorf("failed to setup http server: %v", err)
} else {
logging.Error.Println("Not serving http requests any more.")
}
}()
return errCh
} | go | func (res *Resolver) LaunchHTTP() <-chan error {
defer util.HandleCrash()
res.configureHTTP()
listenAddress := net.JoinHostPort(res.config.HTTPListener, strconv.Itoa(res.config.HTTPPort))
errCh := make(chan error, 1)
go func() {
var err error
defer func() { errCh <- err }()
if err = http.ListenAndServe(listenAddress, nil); err != nil {
err = fmt.Errorf("failed to setup http server: %v", err)
} else {
logging.Error.Println("Not serving http requests any more.")
}
}()
return errCh
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"LaunchHTTP",
"(",
")",
"<-",
"chan",
"error",
"{",
"defer",
"util",
".",
"HandleCrash",
"(",
")",
"\n\n",
"res",
".",
"configureHTTP",
"(",
")",
"\n",
"listenAddress",
":=",
"net",
".",
"JoinHostPort",
"(",
"res",
".",
"config",
".",
"HTTPListener",
",",
"strconv",
".",
"Itoa",
"(",
"res",
".",
"config",
".",
"HTTPPort",
")",
")",
"\n\n",
"errCh",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"var",
"err",
"error",
"\n",
"defer",
"func",
"(",
")",
"{",
"errCh",
"<-",
"err",
"}",
"(",
")",
"\n\n",
"if",
"err",
"=",
"http",
".",
"ListenAndServe",
"(",
"listenAddress",
",",
"nil",
")",
";",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"else",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"errCh",
"\n",
"}"
] | // LaunchHTTP starts an HTTP server for the Resolver, returning a error channel
// to which errors are asynchronously sent. | [
"LaunchHTTP",
"starts",
"an",
"HTTP",
"server",
"for",
"the",
"Resolver",
"returning",
"a",
"error",
"channel",
"to",
"which",
"errors",
"are",
"asynchronously",
"sent",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L604-L622 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestConfig | func (res *Resolver) RestConfig(req *restful.Request, resp *restful.Response) {
if err := resp.WriteAsJson(res.config); err != nil {
logging.Error.Println(err)
}
} | go | func (res *Resolver) RestConfig(req *restful.Request, resp *restful.Response) {
if err := resp.WriteAsJson(res.config); err != nil {
logging.Error.Println(err)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestConfig",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"if",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"res",
".",
"config",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RestConfig handles HTTP requests of Resolver configuration. | [
"RestConfig",
"handles",
"HTTP",
"requests",
"of",
"Resolver",
"configuration",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L625-L629 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestEnumerate | func (res *Resolver) RestEnumerate(req *restful.Request, resp *restful.Response) {
enumData := res.records().EnumData
if err := resp.WriteAsJson(enumData); err != nil {
logging.Error.Println(err)
}
} | go | func (res *Resolver) RestEnumerate(req *restful.Request, resp *restful.Response) {
enumData := res.records().EnumData
if err := resp.WriteAsJson(enumData); err != nil {
logging.Error.Println(err)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestEnumerate",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"enumData",
":=",
"res",
".",
"records",
"(",
")",
".",
"EnumData",
"\n",
"if",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"enumData",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RestEnumerate handles HTTP requests of the enumeration data | [
"RestEnumerate",
"handles",
"HTTP",
"requests",
"of",
"the",
"enumeration",
"data"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L632-L638 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestAXFR | func (res *Resolver) RestAXFR(req *restful.Request, resp *restful.Response) {
records := res.records()
AXFRRecords := models.AXFRRecords{
SRVs: records.SRVs.ToAXFRResourceRecordSet(),
As: records.As.ToAXFRResourceRecordSet(),
AAAAs: records.AAAAs.ToAXFRResourceRecordSet(),
}
AXFR := models.AXFR{
Records: AXFRRecords,
Serial: atomic.LoadUint32(&res.config.SOASerial),
Mname: res.config.SOAMname,
Rname: res.config.SOARname,
TTL: res.config.TTL,
RefreshSeconds: res.config.RefreshSeconds,
Domain: res.config.Domain,
}
if err := resp.WriteAsJson(AXFR); err != nil {
logging.Error.Println(err)
}
} | go | func (res *Resolver) RestAXFR(req *restful.Request, resp *restful.Response) {
records := res.records()
AXFRRecords := models.AXFRRecords{
SRVs: records.SRVs.ToAXFRResourceRecordSet(),
As: records.As.ToAXFRResourceRecordSet(),
AAAAs: records.AAAAs.ToAXFRResourceRecordSet(),
}
AXFR := models.AXFR{
Records: AXFRRecords,
Serial: atomic.LoadUint32(&res.config.SOASerial),
Mname: res.config.SOAMname,
Rname: res.config.SOARname,
TTL: res.config.TTL,
RefreshSeconds: res.config.RefreshSeconds,
Domain: res.config.Domain,
}
if err := resp.WriteAsJson(AXFR); err != nil {
logging.Error.Println(err)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestAXFR",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"records",
":=",
"res",
".",
"records",
"(",
")",
"\n\n",
"AXFRRecords",
":=",
"models",
".",
"AXFRRecords",
"{",
"SRVs",
":",
"records",
".",
"SRVs",
".",
"ToAXFRResourceRecordSet",
"(",
")",
",",
"As",
":",
"records",
".",
"As",
".",
"ToAXFRResourceRecordSet",
"(",
")",
",",
"AAAAs",
":",
"records",
".",
"AAAAs",
".",
"ToAXFRResourceRecordSet",
"(",
")",
",",
"}",
"\n",
"AXFR",
":=",
"models",
".",
"AXFR",
"{",
"Records",
":",
"AXFRRecords",
",",
"Serial",
":",
"atomic",
".",
"LoadUint32",
"(",
"&",
"res",
".",
"config",
".",
"SOASerial",
")",
",",
"Mname",
":",
"res",
".",
"config",
".",
"SOAMname",
",",
"Rname",
":",
"res",
".",
"config",
".",
"SOARname",
",",
"TTL",
":",
"res",
".",
"config",
".",
"TTL",
",",
"RefreshSeconds",
":",
"res",
".",
"config",
".",
"RefreshSeconds",
",",
"Domain",
":",
"res",
".",
"config",
".",
"Domain",
",",
"}",
"\n\n",
"if",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"AXFR",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RestAXFR handles HTTP requests to turn the zone into a transferable format | [
"RestAXFR",
"handles",
"HTTP",
"requests",
"to",
"turn",
"the",
"zone",
"into",
"a",
"transferable",
"format"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L641-L662 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestVersion | func (res *Resolver) RestVersion(req *restful.Request, resp *restful.Response) {
err := resp.WriteAsJson(map[string]string{
"Service": "Mesos-DNS",
"Version": res.version,
"URL": "https://github.com/mesosphere/mesos-dns",
})
if err != nil {
logging.Error.Println(err)
}
} | go | func (res *Resolver) RestVersion(req *restful.Request, resp *restful.Response) {
err := resp.WriteAsJson(map[string]string{
"Service": "Mesos-DNS",
"Version": res.version,
"URL": "https://github.com/mesosphere/mesos-dns",
})
if err != nil {
logging.Error.Println(err)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestVersion",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"res",
".",
"version",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RestVersion handles HTTP requests of Mesos-DNS version. | [
"RestVersion",
"handles",
"HTTP",
"requests",
"of",
"Mesos",
"-",
"DNS",
"version",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L665-L674 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestHost | func (res *Resolver) RestHost(req *restful.Request, resp *restful.Response) {
host := req.PathParameter("host")
// clean up host name
dom := strings.ToLower(cleanWild(host))
if dom[len(dom)-1] != '.' {
dom += "."
}
rs := res.records()
type record struct {
Host string `json:"host"`
IP string `json:"ip"`
}
aRRs := rs.As[dom]
aaaaRRs := rs.AAAAs[dom]
records := make([]record, 0, len(aRRs)+len(aaaaRRs))
for ip := range aRRs {
records = append(records, record{dom, ip})
}
for ip := range aaaaRRs {
records = append(records, record{dom, ip})
}
if len(records) == 0 {
records = append(records, record{})
}
if err := resp.WriteAsJson(records); err != nil {
logging.Error.Println(err)
}
stats(dom, res.config.Domain+".", len(aRRs) > 0)
} | go | func (res *Resolver) RestHost(req *restful.Request, resp *restful.Response) {
host := req.PathParameter("host")
// clean up host name
dom := strings.ToLower(cleanWild(host))
if dom[len(dom)-1] != '.' {
dom += "."
}
rs := res.records()
type record struct {
Host string `json:"host"`
IP string `json:"ip"`
}
aRRs := rs.As[dom]
aaaaRRs := rs.AAAAs[dom]
records := make([]record, 0, len(aRRs)+len(aaaaRRs))
for ip := range aRRs {
records = append(records, record{dom, ip})
}
for ip := range aaaaRRs {
records = append(records, record{dom, ip})
}
if len(records) == 0 {
records = append(records, record{})
}
if err := resp.WriteAsJson(records); err != nil {
logging.Error.Println(err)
}
stats(dom, res.config.Domain+".", len(aRRs) > 0)
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestHost",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"host",
":=",
"req",
".",
"PathParameter",
"(",
"\"",
"\"",
")",
"\n",
"// clean up host name",
"dom",
":=",
"strings",
".",
"ToLower",
"(",
"cleanWild",
"(",
"host",
")",
")",
"\n",
"if",
"dom",
"[",
"len",
"(",
"dom",
")",
"-",
"1",
"]",
"!=",
"'.'",
"{",
"dom",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"rs",
":=",
"res",
".",
"records",
"(",
")",
"\n\n",
"type",
"record",
"struct",
"{",
"Host",
"string",
"`json:\"host\"`",
"\n",
"IP",
"string",
"`json:\"ip\"`",
"\n",
"}",
"\n\n",
"aRRs",
":=",
"rs",
".",
"As",
"[",
"dom",
"]",
"\n",
"aaaaRRs",
":=",
"rs",
".",
"AAAAs",
"[",
"dom",
"]",
"\n",
"records",
":=",
"make",
"(",
"[",
"]",
"record",
",",
"0",
",",
"len",
"(",
"aRRs",
")",
"+",
"len",
"(",
"aaaaRRs",
")",
")",
"\n",
"for",
"ip",
":=",
"range",
"aRRs",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"dom",
",",
"ip",
"}",
")",
"\n",
"}",
"\n",
"for",
"ip",
":=",
"range",
"aaaaRRs",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"dom",
",",
"ip",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"records",
")",
"==",
"0",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"records",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"stats",
"(",
"dom",
",",
"res",
".",
"config",
".",
"Domain",
"+",
"\"",
"\"",
",",
"len",
"(",
"aRRs",
")",
">",
"0",
")",
"\n",
"}"
] | // RestHost handles HTTP requests of DNS A records of the given host. | [
"RestHost",
"handles",
"HTTP",
"requests",
"of",
"DNS",
"A",
"records",
"of",
"the",
"given",
"host",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L677-L710 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestPorts | func (res *Resolver) RestPorts(req *restful.Request, resp *restful.Response) {
err := resp.WriteErrorString(http.StatusNotImplemented, "To be implemented...")
if err != nil {
logging.Error.Println(err)
}
} | go | func (res *Resolver) RestPorts(req *restful.Request, resp *restful.Response) {
err := resp.WriteErrorString(http.StatusNotImplemented, "To be implemented...")
if err != nil {
logging.Error.Println(err)
}
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestPorts",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"err",
":=",
"resp",
".",
"WriteErrorString",
"(",
"http",
".",
"StatusNotImplemented",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] | // RestPorts is an HTTP handler which is currently not implemented. | [
"RestPorts",
"is",
"an",
"HTTP",
"handler",
"which",
"is",
"currently",
"not",
"implemented",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L727-L732 | train |
mesosphere/mesos-dns | resolver/resolver.go | RestService | func (res *Resolver) RestService(req *restful.Request, resp *restful.Response) {
service := req.PathParameter("service")
// clean up service name
dom := strings.ToLower(cleanWild(service))
if dom[len(dom)-1] != '.' {
dom += "."
}
rs := res.records()
type record struct {
Service string `json:"service"`
Host string `json:"host"`
IP string `json:"ip"`
Port string `json:"port"`
}
srvRRs := rs.SRVs[dom]
records := make([]record, 0, len(srvRRs))
for s := range srvRRs {
host, port, err := net.SplitHostPort(s)
if err != nil {
logging.Error.Println(err)
continue
}
if aR, aOk := rs.As.First(host); aOk {
records = append(records, record{service, host, aR, port})
}
if aaaaR, aaaaOk := rs.AAAAs.First(host); aaaaOk {
records = append(records, record{service, host, aaaaR, port})
}
}
if len(records) == 0 {
records = append(records, record{})
}
if err := resp.WriteAsJson(records); err != nil {
logging.Error.Println(err)
}
stats(dom, res.config.Domain+".", len(srvRRs) > 0)
} | go | func (res *Resolver) RestService(req *restful.Request, resp *restful.Response) {
service := req.PathParameter("service")
// clean up service name
dom := strings.ToLower(cleanWild(service))
if dom[len(dom)-1] != '.' {
dom += "."
}
rs := res.records()
type record struct {
Service string `json:"service"`
Host string `json:"host"`
IP string `json:"ip"`
Port string `json:"port"`
}
srvRRs := rs.SRVs[dom]
records := make([]record, 0, len(srvRRs))
for s := range srvRRs {
host, port, err := net.SplitHostPort(s)
if err != nil {
logging.Error.Println(err)
continue
}
if aR, aOk := rs.As.First(host); aOk {
records = append(records, record{service, host, aR, port})
}
if aaaaR, aaaaOk := rs.AAAAs.First(host); aaaaOk {
records = append(records, record{service, host, aaaaR, port})
}
}
if len(records) == 0 {
records = append(records, record{})
}
if err := resp.WriteAsJson(records); err != nil {
logging.Error.Println(err)
}
stats(dom, res.config.Domain+".", len(srvRRs) > 0)
} | [
"func",
"(",
"res",
"*",
"Resolver",
")",
"RestService",
"(",
"req",
"*",
"restful",
".",
"Request",
",",
"resp",
"*",
"restful",
".",
"Response",
")",
"{",
"service",
":=",
"req",
".",
"PathParameter",
"(",
"\"",
"\"",
")",
"\n",
"// clean up service name",
"dom",
":=",
"strings",
".",
"ToLower",
"(",
"cleanWild",
"(",
"service",
")",
")",
"\n",
"if",
"dom",
"[",
"len",
"(",
"dom",
")",
"-",
"1",
"]",
"!=",
"'.'",
"{",
"dom",
"+=",
"\"",
"\"",
"\n",
"}",
"\n",
"rs",
":=",
"res",
".",
"records",
"(",
")",
"\n\n",
"type",
"record",
"struct",
"{",
"Service",
"string",
"`json:\"service\"`",
"\n",
"Host",
"string",
"`json:\"host\"`",
"\n",
"IP",
"string",
"`json:\"ip\"`",
"\n",
"Port",
"string",
"`json:\"port\"`",
"\n",
"}",
"\n\n",
"srvRRs",
":=",
"rs",
".",
"SRVs",
"[",
"dom",
"]",
"\n",
"records",
":=",
"make",
"(",
"[",
"]",
"record",
",",
"0",
",",
"len",
"(",
"srvRRs",
")",
")",
"\n",
"for",
"s",
":=",
"range",
"srvRRs",
"{",
"host",
",",
"port",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"aR",
",",
"aOk",
":=",
"rs",
".",
"As",
".",
"First",
"(",
"host",
")",
";",
"aOk",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"service",
",",
"host",
",",
"aR",
",",
"port",
"}",
")",
"\n",
"}",
"\n",
"if",
"aaaaR",
",",
"aaaaOk",
":=",
"rs",
".",
"AAAAs",
".",
"First",
"(",
"host",
")",
";",
"aaaaOk",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"service",
",",
"host",
",",
"aaaaR",
",",
"port",
"}",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"records",
")",
"==",
"0",
"{",
"records",
"=",
"append",
"(",
"records",
",",
"record",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"resp",
".",
"WriteAsJson",
"(",
"records",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"stats",
"(",
"dom",
",",
"res",
".",
"config",
".",
"Domain",
"+",
"\"",
"\"",
",",
"len",
"(",
"srvRRs",
")",
">",
"0",
")",
"\n",
"}"
] | // RestService handles HTTP requests of DNS SRV records for the given name. | [
"RestService",
"handles",
"HTTP",
"requests",
"of",
"DNS",
"SRV",
"records",
"for",
"the",
"given",
"name",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L735-L776 | train |
mesosphere/mesos-dns | resolver/resolver.go | panicRecover | func panicRecover(f func(w dns.ResponseWriter, r *dns.Msg)) func(w dns.ResponseWriter, r *dns.Msg) {
return func(w dns.ResponseWriter, r *dns.Msg) {
defer func() {
if rec := recover(); rec != nil {
m := new(dns.Msg)
m.SetRcode(r, 2)
if err := w.WriteMsg(m); err != nil {
logging.Error.Println(err)
}
logging.Error.Println(rec)
}
}()
f(w, r)
}
} | go | func panicRecover(f func(w dns.ResponseWriter, r *dns.Msg)) func(w dns.ResponseWriter, r *dns.Msg) {
return func(w dns.ResponseWriter, r *dns.Msg) {
defer func() {
if rec := recover(); rec != nil {
m := new(dns.Msg)
m.SetRcode(r, 2)
if err := w.WriteMsg(m); err != nil {
logging.Error.Println(err)
}
logging.Error.Println(rec)
}
}()
f(w, r)
}
} | [
"func",
"panicRecover",
"(",
"f",
"func",
"(",
"w",
"dns",
".",
"ResponseWriter",
",",
"r",
"*",
"dns",
".",
"Msg",
")",
")",
"func",
"(",
"w",
"dns",
".",
"ResponseWriter",
",",
"r",
"*",
"dns",
".",
"Msg",
")",
"{",
"return",
"func",
"(",
"w",
"dns",
".",
"ResponseWriter",
",",
"r",
"*",
"dns",
".",
"Msg",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"rec",
":=",
"recover",
"(",
")",
";",
"rec",
"!=",
"nil",
"{",
"m",
":=",
"new",
"(",
"dns",
".",
"Msg",
")",
"\n",
"m",
".",
"SetRcode",
"(",
"r",
",",
"2",
")",
"\n",
"if",
"err",
":=",
"w",
".",
"WriteMsg",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"logging",
".",
"Error",
".",
"Println",
"(",
"rec",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"f",
"(",
"w",
",",
"r",
")",
"\n",
"}",
"\n",
"}"
] | // panicRecover catches any panics from the resolvers and sets an error
// code of server failure | [
"panicRecover",
"catches",
"any",
"panics",
"from",
"the",
"resolvers",
"and",
"sets",
"an",
"error",
"code",
"of",
"server",
"failure"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L780-L794 | train |
mesosphere/mesos-dns | resolver/resolver.go | cleanWild | func cleanWild(name string) string {
if strings.Contains(name, ".*") {
return strings.Replace(name, ".*", "", -1)
}
return name
} | go | func cleanWild(name string) string {
if strings.Contains(name, ".*") {
return strings.Replace(name, ".*", "", -1)
}
return name
} | [
"func",
"cleanWild",
"(",
"name",
"string",
")",
"string",
"{",
"if",
"strings",
".",
"Contains",
"(",
"name",
",",
"\"",
"\"",
")",
"{",
"return",
"strings",
".",
"Replace",
"(",
"name",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"-",
"1",
")",
"\n",
"}",
"\n",
"return",
"name",
"\n",
"}"
] | // cleanWild strips any wildcards out thus mapping cleanly to the
// original serviceName | [
"cleanWild",
"strips",
"any",
"wildcards",
"out",
"thus",
"mapping",
"cleanly",
"to",
"the",
"original",
"serviceName"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/resolver/resolver.go#L798-L803 | train |
mesosphere/mesos-dns | urls/urls.go | With | func (b Builder) With(options ...Option) Builder {
for i := range options {
if options[i] != nil {
options[i](&b)
}
}
return b
} | go | func (b Builder) With(options ...Option) Builder {
for i := range options {
if options[i] != nil {
options[i](&b)
}
}
return b
} | [
"func",
"(",
"b",
"Builder",
")",
"With",
"(",
"options",
"...",
"Option",
")",
"Builder",
"{",
"for",
"i",
":=",
"range",
"options",
"{",
"if",
"options",
"[",
"i",
"]",
"!=",
"nil",
"{",
"options",
"[",
"i",
"]",
"(",
"&",
"b",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"b",
"\n",
"}"
] | // With configures a net.URL via a Builder wrapper, returns the modified result | [
"With",
"configures",
"a",
"net",
".",
"URL",
"via",
"a",
"Builder",
"wrapper",
"returns",
"the",
"modified",
"result"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/urls/urls.go#L17-L24 | train |
mesosphere/mesos-dns | httpcli/basic/basic.go | Register | func Register() {
httpcli.Register(httpcli.AuthBasic, httpcli.DoerFactory(func(cm httpcli.ConfigMap, c *http.Client) (doer httpcli.Doer) {
obj := cm.FindOrPanic(httpcli.AuthBasic)
config, ok := obj.(Credentials)
if !ok {
panic(fmt.Errorf("expected Credentials instead of %#+v", obj))
}
validate(config)
if c != nil {
doer = Doer(c, config)
}
return
}))
} | go | func Register() {
httpcli.Register(httpcli.AuthBasic, httpcli.DoerFactory(func(cm httpcli.ConfigMap, c *http.Client) (doer httpcli.Doer) {
obj := cm.FindOrPanic(httpcli.AuthBasic)
config, ok := obj.(Credentials)
if !ok {
panic(fmt.Errorf("expected Credentials instead of %#+v", obj))
}
validate(config)
if c != nil {
doer = Doer(c, config)
}
return
}))
} | [
"func",
"Register",
"(",
")",
"{",
"httpcli",
".",
"Register",
"(",
"httpcli",
".",
"AuthBasic",
",",
"httpcli",
".",
"DoerFactory",
"(",
"func",
"(",
"cm",
"httpcli",
".",
"ConfigMap",
",",
"c",
"*",
"http",
".",
"Client",
")",
"(",
"doer",
"httpcli",
".",
"Doer",
")",
"{",
"obj",
":=",
"cm",
".",
"FindOrPanic",
"(",
"httpcli",
".",
"AuthBasic",
")",
"\n",
"config",
",",
"ok",
":=",
"obj",
".",
"(",
"Credentials",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"obj",
")",
")",
"\n",
"}",
"\n",
"validate",
"(",
"config",
")",
"\n",
"if",
"c",
"!=",
"nil",
"{",
"doer",
"=",
"Doer",
"(",
"c",
",",
"config",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}",
")",
")",
"\n",
"}"
] | // Register registers a DoerFactory for HTTP Basic authentication | [
"Register",
"registers",
"a",
"DoerFactory",
"for",
"HTTP",
"Basic",
"authentication"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/basic/basic.go#L11-L24 | train |
mesosphere/mesos-dns | httpcli/basic/basic.go | Doer | func Doer(client httpcli.Doer, credentials Credentials) httpcli.Doer {
return httpcli.DoerFunc(func(req *http.Request) (*http.Response, error) {
req.SetBasicAuth(credentials.Principal, credentials.Secret)
return client.Do(req)
})
} | go | func Doer(client httpcli.Doer, credentials Credentials) httpcli.Doer {
return httpcli.DoerFunc(func(req *http.Request) (*http.Response, error) {
req.SetBasicAuth(credentials.Principal, credentials.Secret)
return client.Do(req)
})
} | [
"func",
"Doer",
"(",
"client",
"httpcli",
".",
"Doer",
",",
"credentials",
"Credentials",
")",
"httpcli",
".",
"Doer",
"{",
"return",
"httpcli",
".",
"DoerFunc",
"(",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"req",
".",
"SetBasicAuth",
"(",
"credentials",
".",
"Principal",
",",
"credentials",
".",
"Secret",
")",
"\n",
"return",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Doer wraps an HTTP transactor given basic credentials | [
"Doer",
"wraps",
"an",
"HTTP",
"transactor",
"given",
"basic",
"credentials"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/basic/basic.go#L33-L38 | train |
mesosphere/mesos-dns | httpcli/config.go | ToConfigMap | func (cmo ConfigMapOptions) ToConfigMap() (m ConfigMap) {
m = make(ConfigMap)
for _, opt := range cmo {
if opt != nil {
opt(m)
}
}
if len(m) == 0 {
m = nil
}
return m
} | go | func (cmo ConfigMapOptions) ToConfigMap() (m ConfigMap) {
m = make(ConfigMap)
for _, opt := range cmo {
if opt != nil {
opt(m)
}
}
if len(m) == 0 {
m = nil
}
return m
} | [
"func",
"(",
"cmo",
"ConfigMapOptions",
")",
"ToConfigMap",
"(",
")",
"(",
"m",
"ConfigMap",
")",
"{",
"m",
"=",
"make",
"(",
"ConfigMap",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"cmo",
"{",
"if",
"opt",
"!=",
"nil",
"{",
"opt",
"(",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"len",
"(",
"m",
")",
"==",
"0",
"{",
"m",
"=",
"nil",
"\n",
"}",
"\n",
"return",
"m",
"\n",
"}"
] | // ToConfigMap generates a ConfigMap from the given options. If no map entries are generated
// then a nil ConfigMap is returned. | [
"ToConfigMap",
"generates",
"a",
"ConfigMap",
"from",
"the",
"given",
"options",
".",
"If",
"no",
"map",
"entries",
"are",
"generated",
"then",
"a",
"nil",
"ConfigMap",
"is",
"returned",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/config.go#L63-L74 | train |
mesosphere/mesos-dns | httpcli/config.go | FindOrPanic | func (cm ConfigMap) FindOrPanic(am AuthMechanism) interface{} {
obj, ok := cm[am]
if !ok {
panic(ErrMissingConfiguration)
}
return obj
} | go | func (cm ConfigMap) FindOrPanic(am AuthMechanism) interface{} {
obj, ok := cm[am]
if !ok {
panic(ErrMissingConfiguration)
}
return obj
} | [
"func",
"(",
"cm",
"ConfigMap",
")",
"FindOrPanic",
"(",
"am",
"AuthMechanism",
")",
"interface",
"{",
"}",
"{",
"obj",
",",
"ok",
":=",
"cm",
"[",
"am",
"]",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"ErrMissingConfiguration",
")",
"\n",
"}",
"\n",
"return",
"obj",
"\n",
"}"
] | // FindOrPanic returns the mapped configuration for the given auth mechanism or else panics | [
"FindOrPanic",
"returns",
"the",
"mapped",
"configuration",
"for",
"the",
"given",
"auth",
"mechanism",
"or",
"else",
"panics"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/config.go#L77-L83 | train |
mesosphere/mesos-dns | httpcli/config.go | Register | func Register(am AuthMechanism, df DoerFactory) {
registry.Lock()
defer registry.Unlock()
if _, ok := registry.factories[am]; ok {
panic(ErrDuplicateAuthRegistration)
}
registry.factories[am] = df
} | go | func Register(am AuthMechanism, df DoerFactory) {
registry.Lock()
defer registry.Unlock()
if _, ok := registry.factories[am]; ok {
panic(ErrDuplicateAuthRegistration)
}
registry.factories[am] = df
} | [
"func",
"Register",
"(",
"am",
"AuthMechanism",
",",
"df",
"DoerFactory",
")",
"{",
"registry",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registry",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"registry",
".",
"factories",
"[",
"am",
"]",
";",
"ok",
"{",
"panic",
"(",
"ErrDuplicateAuthRegistration",
")",
"\n",
"}",
"\n",
"registry",
".",
"factories",
"[",
"am",
"]",
"=",
"df",
"\n",
"}"
] | // Register associates an AuthMechanism with a DoerFactory | [
"Register",
"associates",
"an",
"AuthMechanism",
"with",
"a",
"DoerFactory"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/config.go#L86-L94 | train |
mesosphere/mesos-dns | httpcli/config.go | Validate | func Validate(am AuthMechanism, cm ConfigMap) (err error) {
df, ok := factoryFor(am)
if !ok {
err = ErrUnregisteredFactory
} else {
defer func() {
// recover from a factory panic
if v := recover(); v != nil {
if verr, ok := v.(error); ok {
err = verr
} else {
panic(v) // unexpected, forward this up the stack
}
}
}()
if shouldBeNil := df(cm, nil); shouldBeNil != nil {
err = ErrIllegalDoerFactoryImplementation
}
}
return
} | go | func Validate(am AuthMechanism, cm ConfigMap) (err error) {
df, ok := factoryFor(am)
if !ok {
err = ErrUnregisteredFactory
} else {
defer func() {
// recover from a factory panic
if v := recover(); v != nil {
if verr, ok := v.(error); ok {
err = verr
} else {
panic(v) // unexpected, forward this up the stack
}
}
}()
if shouldBeNil := df(cm, nil); shouldBeNil != nil {
err = ErrIllegalDoerFactoryImplementation
}
}
return
} | [
"func",
"Validate",
"(",
"am",
"AuthMechanism",
",",
"cm",
"ConfigMap",
")",
"(",
"err",
"error",
")",
"{",
"df",
",",
"ok",
":=",
"factoryFor",
"(",
"am",
")",
"\n",
"if",
"!",
"ok",
"{",
"err",
"=",
"ErrUnregisteredFactory",
"\n",
"}",
"else",
"{",
"defer",
"func",
"(",
")",
"{",
"// recover from a factory panic",
"if",
"v",
":=",
"recover",
"(",
")",
";",
"v",
"!=",
"nil",
"{",
"if",
"verr",
",",
"ok",
":=",
"v",
".",
"(",
"error",
")",
";",
"ok",
"{",
"err",
"=",
"verr",
"\n",
"}",
"else",
"{",
"panic",
"(",
"v",
")",
"// unexpected, forward this up the stack",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"if",
"shouldBeNil",
":=",
"df",
"(",
"cm",
",",
"nil",
")",
";",
"shouldBeNil",
"!=",
"nil",
"{",
"err",
"=",
"ErrIllegalDoerFactoryImplementation",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Validate checks that the given AuthMechainsm and ConfigMap are compatible with the
// registered set of DoerFactory instances. | [
"Validate",
"checks",
"that",
"the",
"given",
"AuthMechainsm",
"and",
"ConfigMap",
"are",
"compatible",
"with",
"the",
"registered",
"set",
"of",
"DoerFactory",
"instances",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/config.go#L113-L133 | train |
mesosphere/mesos-dns | logging/logging.go | String | func (lc *LogCounter) String() string {
return strconv.FormatUint(atomic.LoadUint64(&lc.value), 10)
} | go | func (lc *LogCounter) String() string {
return strconv.FormatUint(atomic.LoadUint64(&lc.value), 10)
} | [
"func",
"(",
"lc",
"*",
"LogCounter",
")",
"String",
"(",
")",
"string",
"{",
"return",
"strconv",
".",
"FormatUint",
"(",
"atomic",
".",
"LoadUint64",
"(",
"&",
"lc",
".",
"value",
")",
",",
"10",
")",
"\n",
"}"
] | // String returns a string represention of the counter. | [
"String",
"returns",
"a",
"string",
"represention",
"of",
"the",
"counter",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/logging/logging.go#L43-L45 | train |
mesosphere/mesos-dns | logging/logging.go | SetupLogs | func SetupLogs() {
// initialize logging flags
if glog.V(2) {
VeryVerboseFlag = true
} else if glog.V(1) {
VerboseFlag = true
}
logopts := log.Ldate | log.Ltime | log.Lshortfile
if VerboseFlag {
Verbose = log.New(os.Stdout, "VERBOSE: ", logopts)
VeryVerbose = log.New(ioutil.Discard, "VERY VERBOSE: ", logopts)
} else if VeryVerboseFlag {
Verbose = log.New(os.Stdout, "VERY VERBOSE: ", logopts)
VeryVerbose = Verbose
} else {
Verbose = log.New(ioutil.Discard, "VERBOSE: ", logopts)
VeryVerbose = log.New(ioutil.Discard, "VERY VERBOSE: ", logopts)
}
Error = log.New(os.Stderr, "ERROR: ", logopts)
} | go | func SetupLogs() {
// initialize logging flags
if glog.V(2) {
VeryVerboseFlag = true
} else if glog.V(1) {
VerboseFlag = true
}
logopts := log.Ldate | log.Ltime | log.Lshortfile
if VerboseFlag {
Verbose = log.New(os.Stdout, "VERBOSE: ", logopts)
VeryVerbose = log.New(ioutil.Discard, "VERY VERBOSE: ", logopts)
} else if VeryVerboseFlag {
Verbose = log.New(os.Stdout, "VERY VERBOSE: ", logopts)
VeryVerbose = Verbose
} else {
Verbose = log.New(ioutil.Discard, "VERBOSE: ", logopts)
VeryVerbose = log.New(ioutil.Discard, "VERY VERBOSE: ", logopts)
}
Error = log.New(os.Stderr, "ERROR: ", logopts)
} | [
"func",
"SetupLogs",
"(",
")",
"{",
"// initialize logging flags",
"if",
"glog",
".",
"V",
"(",
"2",
")",
"{",
"VeryVerboseFlag",
"=",
"true",
"\n",
"}",
"else",
"if",
"glog",
".",
"V",
"(",
"1",
")",
"{",
"VerboseFlag",
"=",
"true",
"\n",
"}",
"\n\n",
"logopts",
":=",
"log",
".",
"Ldate",
"|",
"log",
".",
"Ltime",
"|",
"log",
".",
"Lshortfile",
"\n\n",
"if",
"VerboseFlag",
"{",
"Verbose",
"=",
"log",
".",
"New",
"(",
"os",
".",
"Stdout",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"VeryVerbose",
"=",
"log",
".",
"New",
"(",
"ioutil",
".",
"Discard",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"}",
"else",
"if",
"VeryVerboseFlag",
"{",
"Verbose",
"=",
"log",
".",
"New",
"(",
"os",
".",
"Stdout",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"VeryVerbose",
"=",
"Verbose",
"\n",
"}",
"else",
"{",
"Verbose",
"=",
"log",
".",
"New",
"(",
"ioutil",
".",
"Discard",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"VeryVerbose",
"=",
"log",
".",
"New",
"(",
"ioutil",
".",
"Discard",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"}",
"\n\n",
"Error",
"=",
"log",
".",
"New",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\"",
",",
"logopts",
")",
"\n",
"}"
] | // SetupLogs provides the following logs
// Verbose = optional verbosity
// VeryVerbose = optional verbosity
// Error = stderr | [
"SetupLogs",
"provides",
"the",
"following",
"logs",
"Verbose",
"=",
"optional",
"verbosity",
"VeryVerbose",
"=",
"optional",
"verbosity",
"Error",
"=",
"stderr"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/logging/logging.go#L82-L104 | train |
mesosphere/mesos-dns | detect/masters.go | NewMasters | func NewMasters(masters []string, changed chan<- []string) *Masters {
return &Masters{
masters: append([]string{""}, masters...),
changed: changed,
}
} | go | func NewMasters(masters []string, changed chan<- []string) *Masters {
return &Masters{
masters: append([]string{""}, masters...),
changed: changed,
}
} | [
"func",
"NewMasters",
"(",
"masters",
"[",
"]",
"string",
",",
"changed",
"chan",
"<-",
"[",
"]",
"string",
")",
"*",
"Masters",
"{",
"return",
"&",
"Masters",
"{",
"masters",
":",
"append",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"masters",
"...",
")",
",",
"changed",
":",
"changed",
",",
"}",
"\n",
"}"
] | // NewMasters returns a new Masters detector with the given initial masters
// and the given changed channel to which master changes will be sent to.
// Initially the leader is unknown which is represented by
// setting the first item of the sent masters slice to be empty. | [
"NewMasters",
"returns",
"a",
"new",
"Masters",
"detector",
"with",
"the",
"given",
"initial",
"masters",
"and",
"the",
"given",
"changed",
"channel",
"to",
"which",
"master",
"changes",
"will",
"be",
"sent",
"to",
".",
"Initially",
"the",
"leader",
"is",
"unknown",
"which",
"is",
"represented",
"by",
"setting",
"the",
"first",
"item",
"of",
"the",
"sent",
"masters",
"slice",
"to",
"be",
"empty",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/detect/masters.go#L36-L41 | train |
mesosphere/mesos-dns | detect/masters.go | OnMasterChanged | func (ms *Masters) OnMasterChanged(leader *mesos.MasterInfo) {
logging.VeryVerbose.Println("Updated leader: ", leader)
ms.masters = ordered(masterAddr(leader), ms.masters[1:])
emit(ms.changed, ms.masters)
} | go | func (ms *Masters) OnMasterChanged(leader *mesos.MasterInfo) {
logging.VeryVerbose.Println("Updated leader: ", leader)
ms.masters = ordered(masterAddr(leader), ms.masters[1:])
emit(ms.changed, ms.masters)
} | [
"func",
"(",
"ms",
"*",
"Masters",
")",
"OnMasterChanged",
"(",
"leader",
"*",
"mesos",
".",
"MasterInfo",
")",
"{",
"logging",
".",
"VeryVerbose",
".",
"Println",
"(",
"\"",
"\"",
",",
"leader",
")",
"\n",
"ms",
".",
"masters",
"=",
"ordered",
"(",
"masterAddr",
"(",
"leader",
")",
",",
"ms",
".",
"masters",
"[",
"1",
":",
"]",
")",
"\n",
"emit",
"(",
"ms",
".",
"changed",
",",
"ms",
".",
"masters",
")",
"\n",
"}"
] | // OnMasterChanged sets the given MasterInfo as the current leader
// leaving the remaining masters unchanged and emits the current masters state.
// It implements the detector.MasterChanged interface. | [
"OnMasterChanged",
"sets",
"the",
"given",
"MasterInfo",
"as",
"the",
"current",
"leader",
"leaving",
"the",
"remaining",
"masters",
"unchanged",
"and",
"emits",
"the",
"current",
"masters",
"state",
".",
"It",
"implements",
"the",
"detector",
".",
"MasterChanged",
"interface",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/detect/masters.go#L46-L50 | train |
mesosphere/mesos-dns | detect/masters.go | UpdatedMasters | func (ms *Masters) UpdatedMasters(infos []*mesos.MasterInfo) {
logging.VeryVerbose.Println("Updated masters: ", infos)
masters := make([]string, 0, len(infos))
for _, info := range infos {
if addr := masterAddr(info); addr != "" {
masters = append(masters, addr)
}
}
ms.masters = ordered(ms.masters[0], masters)
emit(ms.changed, ms.masters)
} | go | func (ms *Masters) UpdatedMasters(infos []*mesos.MasterInfo) {
logging.VeryVerbose.Println("Updated masters: ", infos)
masters := make([]string, 0, len(infos))
for _, info := range infos {
if addr := masterAddr(info); addr != "" {
masters = append(masters, addr)
}
}
ms.masters = ordered(ms.masters[0], masters)
emit(ms.changed, ms.masters)
} | [
"func",
"(",
"ms",
"*",
"Masters",
")",
"UpdatedMasters",
"(",
"infos",
"[",
"]",
"*",
"mesos",
".",
"MasterInfo",
")",
"{",
"logging",
".",
"VeryVerbose",
".",
"Println",
"(",
"\"",
"\"",
",",
"infos",
")",
"\n",
"masters",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"infos",
")",
")",
"\n",
"for",
"_",
",",
"info",
":=",
"range",
"infos",
"{",
"if",
"addr",
":=",
"masterAddr",
"(",
"info",
")",
";",
"addr",
"!=",
"\"",
"\"",
"{",
"masters",
"=",
"append",
"(",
"masters",
",",
"addr",
")",
"\n",
"}",
"\n",
"}",
"\n",
"ms",
".",
"masters",
"=",
"ordered",
"(",
"ms",
".",
"masters",
"[",
"0",
"]",
",",
"masters",
")",
"\n",
"emit",
"(",
"ms",
".",
"changed",
",",
"ms",
".",
"masters",
")",
"\n",
"}"
] | // UpdatedMasters sets the given slice of MasterInfo as the current remaining masters
// leaving the current leader unchanged and emits the current masters state.
// It implements the detector.AllMasters interface. | [
"UpdatedMasters",
"sets",
"the",
"given",
"slice",
"of",
"MasterInfo",
"as",
"the",
"current",
"remaining",
"masters",
"leaving",
"the",
"current",
"leader",
"unchanged",
"and",
"emits",
"the",
"current",
"masters",
"state",
".",
"It",
"implements",
"the",
"detector",
".",
"AllMasters",
"interface",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/detect/masters.go#L55-L65 | train |
mesosphere/mesos-dns | detect/masters.go | ordered | func ordered(leader string, masters []string) []string {
ms := append(make([]string, 0, len(masters)+1), leader)
for _, m := range masters {
if m != leader {
ms = append(ms, m)
}
}
return ms
} | go | func ordered(leader string, masters []string) []string {
ms := append(make([]string, 0, len(masters)+1), leader)
for _, m := range masters {
if m != leader {
ms = append(ms, m)
}
}
return ms
} | [
"func",
"ordered",
"(",
"leader",
"string",
",",
"masters",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"ms",
":=",
"append",
"(",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"masters",
")",
"+",
"1",
")",
",",
"leader",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"masters",
"{",
"if",
"m",
"!=",
"leader",
"{",
"ms",
"=",
"append",
"(",
"ms",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ms",
"\n",
"}"
] | // ordered returns a slice of masters with the given leader in the first position | [
"ordered",
"returns",
"a",
"slice",
"of",
"masters",
"with",
"the",
"given",
"leader",
"in",
"the",
"first",
"position"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/detect/masters.go#L72-L80 | train |
mesosphere/mesos-dns | exchanger/forwarder.go | Forward | func (f Forwarder) Forward(m *dns.Msg, proto string) (*dns.Msg, error) {
return f(m, proto)
} | go | func (f Forwarder) Forward(m *dns.Msg, proto string) (*dns.Msg, error) {
return f(m, proto)
} | [
"func",
"(",
"f",
"Forwarder",
")",
"Forward",
"(",
"m",
"*",
"dns",
".",
"Msg",
",",
"proto",
"string",
")",
"(",
"*",
"dns",
".",
"Msg",
",",
"error",
")",
"{",
"return",
"f",
"(",
"m",
",",
"proto",
")",
"\n",
"}"
] | // Forward is an utility method that calls f itself. | [
"Forward",
"is",
"an",
"utility",
"method",
"that",
"calls",
"f",
"itself",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/exchanger/forwarder.go#L15-L17 | train |
mesosphere/mesos-dns | httpcli/iam/iam.go | Doer | func Doer(client *http.Client, config Config) httpcli.Doer {
return httpcli.DoerFunc(func(req *http.Request) (*http.Response, error) {
// TODO if we still have a valid token, try using it first
token := jwt.New(jwt.SigningMethodRS256)
token.Claims["uid"] = config.ID
token.Claims["exp"] = time.Now().Add(time.Hour).Unix()
// SignedString will treat secret as PEM-encoded key
tokenStr, err := token.SignedString([]byte(config.PrivateKey))
if err != nil {
return nil, err
}
authReq := struct {
UID string `json:"uid"`
Token string `json:"token,omitempty"`
}{
UID: config.ID,
Token: tokenStr,
}
b, err := json.Marshal(authReq)
if err != nil {
return nil, err
}
authBody := bytes.NewBuffer(b)
resp, err := client.Post(config.LoginEndpoint, "application/json", authBody)
if err != nil {
return nil, err
}
defer errorutil.Ignore(resp.Body.Close)
if resp.StatusCode != 200 {
return nil, httpcli.ErrAuthFailed
}
var authResp struct {
Token string `json:"token"`
}
err = json.NewDecoder(resp.Body).Decode(&authResp)
if err != nil {
return nil, err
}
if req.Header == nil {
req.Header = make(http.Header)
}
req.Header.Set("Authorization", "token="+authResp.Token)
return client.Do(req)
})
} | go | func Doer(client *http.Client, config Config) httpcli.Doer {
return httpcli.DoerFunc(func(req *http.Request) (*http.Response, error) {
// TODO if we still have a valid token, try using it first
token := jwt.New(jwt.SigningMethodRS256)
token.Claims["uid"] = config.ID
token.Claims["exp"] = time.Now().Add(time.Hour).Unix()
// SignedString will treat secret as PEM-encoded key
tokenStr, err := token.SignedString([]byte(config.PrivateKey))
if err != nil {
return nil, err
}
authReq := struct {
UID string `json:"uid"`
Token string `json:"token,omitempty"`
}{
UID: config.ID,
Token: tokenStr,
}
b, err := json.Marshal(authReq)
if err != nil {
return nil, err
}
authBody := bytes.NewBuffer(b)
resp, err := client.Post(config.LoginEndpoint, "application/json", authBody)
if err != nil {
return nil, err
}
defer errorutil.Ignore(resp.Body.Close)
if resp.StatusCode != 200 {
return nil, httpcli.ErrAuthFailed
}
var authResp struct {
Token string `json:"token"`
}
err = json.NewDecoder(resp.Body).Decode(&authResp)
if err != nil {
return nil, err
}
if req.Header == nil {
req.Header = make(http.Header)
}
req.Header.Set("Authorization", "token="+authResp.Token)
return client.Do(req)
})
} | [
"func",
"Doer",
"(",
"client",
"*",
"http",
".",
"Client",
",",
"config",
"Config",
")",
"httpcli",
".",
"Doer",
"{",
"return",
"httpcli",
".",
"DoerFunc",
"(",
"func",
"(",
"req",
"*",
"http",
".",
"Request",
")",
"(",
"*",
"http",
".",
"Response",
",",
"error",
")",
"{",
"// TODO if we still have a valid token, try using it first",
"token",
":=",
"jwt",
".",
"New",
"(",
"jwt",
".",
"SigningMethodRS256",
")",
"\n",
"token",
".",
"Claims",
"[",
"\"",
"\"",
"]",
"=",
"config",
".",
"ID",
"\n",
"token",
".",
"Claims",
"[",
"\"",
"\"",
"]",
"=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"time",
".",
"Hour",
")",
".",
"Unix",
"(",
")",
"\n",
"// SignedString will treat secret as PEM-encoded key",
"tokenStr",
",",
"err",
":=",
"token",
".",
"SignedString",
"(",
"[",
"]",
"byte",
"(",
"config",
".",
"PrivateKey",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"authReq",
":=",
"struct",
"{",
"UID",
"string",
"`json:\"uid\"`",
"\n",
"Token",
"string",
"`json:\"token,omitempty\"`",
"\n",
"}",
"{",
"UID",
":",
"config",
".",
"ID",
",",
"Token",
":",
"tokenStr",
",",
"}",
"\n\n",
"b",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"authReq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"authBody",
":=",
"bytes",
".",
"NewBuffer",
"(",
"b",
")",
"\n",
"resp",
",",
"err",
":=",
"client",
".",
"Post",
"(",
"config",
".",
"LoginEndpoint",
",",
"\"",
"\"",
",",
"authBody",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"errorutil",
".",
"Ignore",
"(",
"resp",
".",
"Body",
".",
"Close",
")",
"\n",
"if",
"resp",
".",
"StatusCode",
"!=",
"200",
"{",
"return",
"nil",
",",
"httpcli",
".",
"ErrAuthFailed",
"\n",
"}",
"\n\n",
"var",
"authResp",
"struct",
"{",
"Token",
"string",
"`json:\"token\"`",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"NewDecoder",
"(",
"resp",
".",
"Body",
")",
".",
"Decode",
"(",
"&",
"authResp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"req",
".",
"Header",
"==",
"nil",
"{",
"req",
".",
"Header",
"=",
"make",
"(",
"http",
".",
"Header",
")",
"\n",
"}",
"\n",
"req",
".",
"Header",
".",
"Set",
"(",
"\"",
"\"",
",",
"\"",
"\"",
"+",
"authResp",
".",
"Token",
")",
"\n\n",
"return",
"client",
".",
"Do",
"(",
"req",
")",
"\n",
"}",
")",
"\n",
"}"
] | // Doer wraps an HTTP transactor given an IAM configuration | [
"Doer",
"wraps",
"an",
"HTTP",
"transactor",
"given",
"an",
"IAM",
"configuration"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/httpcli/iam/iam.go#L38-L88 | train |
mesosphere/mesos-dns | records/labels/labels.go | DomainFrag | func DomainFrag(name, sep string, label Func) string {
var labels []string
for _, part := range strings.Split(name, sep) {
if lab := label(part); lab != "" {
labels = append(labels, lab)
}
}
return strings.Join(labels, sep)
} | go | func DomainFrag(name, sep string, label Func) string {
var labels []string
for _, part := range strings.Split(name, sep) {
if lab := label(part); lab != "" {
labels = append(labels, lab)
}
}
return strings.Join(labels, sep)
} | [
"func",
"DomainFrag",
"(",
"name",
",",
"sep",
"string",
",",
"label",
"Func",
")",
"string",
"{",
"var",
"labels",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"part",
":=",
"range",
"strings",
".",
"Split",
"(",
"name",
",",
"sep",
")",
"{",
"if",
"lab",
":=",
"label",
"(",
"part",
")",
";",
"lab",
"!=",
"\"",
"\"",
"{",
"labels",
"=",
"append",
"(",
"labels",
",",
"lab",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"labels",
",",
"sep",
")",
"\n",
"}"
] | // DomainFrag mangles the given name in order to produce a valid domain fragment.
// A valid domain fragment will consist of one or more host name labels
// concatenated by the given separator. | [
"DomainFrag",
"mangles",
"the",
"given",
"name",
"in",
"order",
"to",
"produce",
"a",
"valid",
"domain",
"fragment",
".",
"A",
"valid",
"domain",
"fragment",
"will",
"consist",
"of",
"one",
"or",
"more",
"host",
"name",
"labels",
"concatenated",
"by",
"the",
"given",
"separator",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/labels/labels.go#L14-L22 | train |
mesosphere/mesos-dns | records/labels/labels.go | label | func label(name []byte, maxlen int, left, right string) []byte {
return trimCut(bytes.Map(mapping, name), maxlen, left, right)
} | go | func label(name []byte, maxlen int, left, right string) []byte {
return trimCut(bytes.Map(mapping, name), maxlen, left, right)
} | [
"func",
"label",
"(",
"name",
"[",
"]",
"byte",
",",
"maxlen",
"int",
",",
"left",
",",
"right",
"string",
")",
"[",
"]",
"byte",
"{",
"return",
"trimCut",
"(",
"bytes",
".",
"Map",
"(",
"mapping",
",",
"name",
")",
",",
"maxlen",
",",
"left",
",",
"right",
")",
"\n",
"}"
] | // label computes a label from the given name with maxlen length and the
// left and right cutsets trimmed from their respective ends. | [
"label",
"computes",
"a",
"label",
"from",
"the",
"given",
"name",
"with",
"maxlen",
"length",
"and",
"the",
"left",
"and",
"right",
"cutsets",
"trimmed",
"from",
"their",
"respective",
"ends",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/labels/labels.go#L41-L43 | train |
mesosphere/mesos-dns | records/labels/labels.go | mapping | func mapping(r rune) rune {
switch {
case r >= 'A' && r <= 'Z':
return r - ('A' - 'a')
case r >= 'a' && r <= 'z':
fallthrough
case r >= '0' && r <= '9':
return r
case r == '-' || r == '.' || r == '_':
return '-'
default:
return -1
}
} | go | func mapping(r rune) rune {
switch {
case r >= 'A' && r <= 'Z':
return r - ('A' - 'a')
case r >= 'a' && r <= 'z':
fallthrough
case r >= '0' && r <= '9':
return r
case r == '-' || r == '.' || r == '_':
return '-'
default:
return -1
}
} | [
"func",
"mapping",
"(",
"r",
"rune",
")",
"rune",
"{",
"switch",
"{",
"case",
"r",
">=",
"'A'",
"&&",
"r",
"<=",
"'Z'",
":",
"return",
"r",
"-",
"(",
"'A'",
"-",
"'a'",
")",
"\n",
"case",
"r",
">=",
"'a'",
"&&",
"r",
"<=",
"'z'",
":",
"fallthrough",
"\n",
"case",
"r",
">=",
"'0'",
"&&",
"r",
"<=",
"'9'",
":",
"return",
"r",
"\n",
"case",
"r",
"==",
"'-'",
"||",
"r",
"==",
"'.'",
"||",
"r",
"==",
"'_'",
":",
"return",
"'-'",
"\n",
"default",
":",
"return",
"-",
"1",
"\n",
"}",
"\n",
"}"
] | // mapping maps a given rune to its valid DNS label counterpart. | [
"mapping",
"maps",
"a",
"given",
"rune",
"to",
"its",
"valid",
"DNS",
"label",
"counterpart",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/labels/labels.go#L46-L59 | train |
mesosphere/mesos-dns | records/state/state.go | Ports | func (r Resources) Ports() []string {
if r.PortRanges == "" || r.PortRanges == "[]" {
return []string{}
}
rhs := strings.Split(r.PortRanges, "[")[1]
lhs := strings.Split(rhs, "]")[0]
yports := []string{}
mports := strings.Split(lhs, ",")
for _, port := range mports {
tmp := strings.TrimSpace(port)
pz := strings.Split(tmp, "-")
lo, err := strconv.Atoi(pz[0])
if err != nil {
logging.Error.Println(err)
continue
}
hi, err := strconv.Atoi(pz[1])
if err != nil {
logging.Error.Println(err)
continue
}
for t := lo; t <= hi; t++ {
yports = append(yports, strconv.Itoa(t))
}
}
return yports
} | go | func (r Resources) Ports() []string {
if r.PortRanges == "" || r.PortRanges == "[]" {
return []string{}
}
rhs := strings.Split(r.PortRanges, "[")[1]
lhs := strings.Split(rhs, "]")[0]
yports := []string{}
mports := strings.Split(lhs, ",")
for _, port := range mports {
tmp := strings.TrimSpace(port)
pz := strings.Split(tmp, "-")
lo, err := strconv.Atoi(pz[0])
if err != nil {
logging.Error.Println(err)
continue
}
hi, err := strconv.Atoi(pz[1])
if err != nil {
logging.Error.Println(err)
continue
}
for t := lo; t <= hi; t++ {
yports = append(yports, strconv.Itoa(t))
}
}
return yports
} | [
"func",
"(",
"r",
"Resources",
")",
"Ports",
"(",
")",
"[",
"]",
"string",
"{",
"if",
"r",
".",
"PortRanges",
"==",
"\"",
"\"",
"||",
"r",
".",
"PortRanges",
"==",
"\"",
"\"",
"{",
"return",
"[",
"]",
"string",
"{",
"}",
"\n",
"}",
"\n\n",
"rhs",
":=",
"strings",
".",
"Split",
"(",
"r",
".",
"PortRanges",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
"\n",
"lhs",
":=",
"strings",
".",
"Split",
"(",
"rhs",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n\n",
"yports",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"mports",
":=",
"strings",
".",
"Split",
"(",
"lhs",
",",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"port",
":=",
"range",
"mports",
"{",
"tmp",
":=",
"strings",
".",
"TrimSpace",
"(",
"port",
")",
"\n",
"pz",
":=",
"strings",
".",
"Split",
"(",
"tmp",
",",
"\"",
"\"",
")",
"\n",
"lo",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"pz",
"[",
"0",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"hi",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"pz",
"[",
"1",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"for",
"t",
":=",
"lo",
";",
"t",
"<=",
"hi",
";",
"t",
"++",
"{",
"yports",
"=",
"append",
"(",
"yports",
",",
"strconv",
".",
"Itoa",
"(",
"t",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"yports",
"\n",
"}"
] | // Ports returns a slice of individual ports expanded from PortRanges. | [
"Ports",
"returns",
"a",
"slice",
"of",
"individual",
"ports",
"expanded",
"from",
"PortRanges",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L19-L49 | train |
mesosphere/mesos-dns | records/state/state.go | IP | func (t *Task) IP(srcs ...string) string {
if ips := t.IPs(srcs...); len(ips) > 0 {
return ips[0].String()
}
return ""
} | go | func (t *Task) IP(srcs ...string) string {
if ips := t.IPs(srcs...); len(ips) > 0 {
return ips[0].String()
}
return ""
} | [
"func",
"(",
"t",
"*",
"Task",
")",
"IP",
"(",
"srcs",
"...",
"string",
")",
"string",
"{",
"if",
"ips",
":=",
"t",
".",
"IPs",
"(",
"srcs",
"...",
")",
";",
"len",
"(",
"ips",
")",
">",
"0",
"{",
"return",
"ips",
"[",
"0",
"]",
".",
"String",
"(",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // IP returns the first Task IP found in the given sources. | [
"IP",
"returns",
"the",
"first",
"Task",
"IP",
"found",
"in",
"the",
"given",
"sources",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L106-L111 | train |
mesosphere/mesos-dns | records/state/state.go | IPs | func (t *Task) IPs(srcs ...string) (ips []net.IP) {
if t == nil {
return nil
}
for i := range srcs {
if src, ok := sources[srcs[i]]; ok {
for _, srcIP := range src(t) {
if ip := net.ParseIP(srcIP); len(ip) > 0 {
ips = append(ips, ip)
}
}
}
}
return ips
} | go | func (t *Task) IPs(srcs ...string) (ips []net.IP) {
if t == nil {
return nil
}
for i := range srcs {
if src, ok := sources[srcs[i]]; ok {
for _, srcIP := range src(t) {
if ip := net.ParseIP(srcIP); len(ip) > 0 {
ips = append(ips, ip)
}
}
}
}
return ips
} | [
"func",
"(",
"t",
"*",
"Task",
")",
"IPs",
"(",
"srcs",
"...",
"string",
")",
"(",
"ips",
"[",
"]",
"net",
".",
"IP",
")",
"{",
"if",
"t",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"srcs",
"{",
"if",
"src",
",",
"ok",
":=",
"sources",
"[",
"srcs",
"[",
"i",
"]",
"]",
";",
"ok",
"{",
"for",
"_",
",",
"srcIP",
":=",
"range",
"src",
"(",
"t",
")",
"{",
"if",
"ip",
":=",
"net",
".",
"ParseIP",
"(",
"srcIP",
")",
";",
"len",
"(",
"ip",
")",
">",
"0",
"{",
"ips",
"=",
"append",
"(",
"ips",
",",
"ip",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"ips",
"\n",
"}"
] | // IPs returns a slice of IPs sourced from the given sources with ascending
// priority. | [
"IPs",
"returns",
"a",
"slice",
"of",
"IPs",
"sourced",
"from",
"the",
"given",
"sources",
"with",
"ascending",
"priority",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L115-L129 | train |
mesosphere/mesos-dns | records/state/state.go | statusIPs | func statusIPs(st []Status, src func(*Status) []string) []string {
// the state we extract from mesos makes no guarantees re: the order
// of the task statuses so we should check the timestamps to avoid problems
// down the line. we can't rely on seeing the same sequence. (@joris)
// https://github.com/apache/mesos/blob/0.24.0/src/slave/slave.cpp#L5226-L5238
ts, j := -1.0, -1
for i := range st {
if st[i].State == "TASK_RUNNING" && st[i].Timestamp > ts {
ts, j = st[i].Timestamp, i
}
}
if j >= 0 {
return src(&st[j])
}
return nil
} | go | func statusIPs(st []Status, src func(*Status) []string) []string {
// the state we extract from mesos makes no guarantees re: the order
// of the task statuses so we should check the timestamps to avoid problems
// down the line. we can't rely on seeing the same sequence. (@joris)
// https://github.com/apache/mesos/blob/0.24.0/src/slave/slave.cpp#L5226-L5238
ts, j := -1.0, -1
for i := range st {
if st[i].State == "TASK_RUNNING" && st[i].Timestamp > ts {
ts, j = st[i].Timestamp, i
}
}
if j >= 0 {
return src(&st[j])
}
return nil
} | [
"func",
"statusIPs",
"(",
"st",
"[",
"]",
"Status",
",",
"src",
"func",
"(",
"*",
"Status",
")",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"// the state we extract from mesos makes no guarantees re: the order",
"// of the task statuses so we should check the timestamps to avoid problems",
"// down the line. we can't rely on seeing the same sequence. (@joris)",
"// https://github.com/apache/mesos/blob/0.24.0/src/slave/slave.cpp#L5226-L5238",
"ts",
",",
"j",
":=",
"-",
"1.0",
",",
"-",
"1",
"\n",
"for",
"i",
":=",
"range",
"st",
"{",
"if",
"st",
"[",
"i",
"]",
".",
"State",
"==",
"\"",
"\"",
"&&",
"st",
"[",
"i",
"]",
".",
"Timestamp",
">",
"ts",
"{",
"ts",
",",
"j",
"=",
"st",
"[",
"i",
"]",
".",
"Timestamp",
",",
"i",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"j",
">=",
"0",
"{",
"return",
"src",
"(",
"&",
"st",
"[",
"j",
"]",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // statusIPs returns the latest running status IPs extracted with the given src | [
"statusIPs",
"returns",
"the",
"latest",
"running",
"status",
"IPs",
"extracted",
"with",
"the",
"given",
"src"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L186-L201 | train |
mesosphere/mesos-dns | records/state/state.go | HostPort | func (f Framework) HostPort() (string, string) {
if f.PID.UPID != nil {
return f.PID.Host, f.PID.Port
}
return f.Hostname, ""
} | go | func (f Framework) HostPort() (string, string) {
if f.PID.UPID != nil {
return f.PID.Host, f.PID.Port
}
return f.Hostname, ""
} | [
"func",
"(",
"f",
"Framework",
")",
"HostPort",
"(",
")",
"(",
"string",
",",
"string",
")",
"{",
"if",
"f",
".",
"PID",
".",
"UPID",
"!=",
"nil",
"{",
"return",
"f",
".",
"PID",
".",
"Host",
",",
"f",
".",
"PID",
".",
"Port",
"\n",
"}",
"\n",
"return",
"f",
".",
"Hostname",
",",
"\"",
"\"",
"\n",
"}"
] | // HostPort returns the hostname and port where a framework's scheduler is
// listening on. | [
"HostPort",
"returns",
"the",
"hostname",
"and",
"port",
"where",
"a",
"framework",
"s",
"scheduler",
"is",
"listening",
"on",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L227-L232 | train |
mesosphere/mesos-dns | records/state/state.go | UnmarshalJSON | func (p *PID) UnmarshalJSON(data []byte) (err error) {
p.UPID, err = upid.Parse(string(bytes.Trim(data, `" `)))
return err
} | go | func (p *PID) UnmarshalJSON(data []byte) (err error) {
p.UPID, err = upid.Parse(string(bytes.Trim(data, `" `)))
return err
} | [
"func",
"(",
"p",
"*",
"PID",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"err",
"error",
")",
"{",
"p",
".",
"UPID",
",",
"err",
"=",
"upid",
".",
"Parse",
"(",
"string",
"(",
"bytes",
".",
"Trim",
"(",
"data",
",",
"`\" `",
")",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // UnmarshalJSON implements the json.Unmarshaler interface for PIDs. | [
"UnmarshalJSON",
"implements",
"the",
"json",
".",
"Unmarshaler",
"interface",
"for",
"PIDs",
"."
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/state/state.go#L245-L248 | train |
mesosphere/mesos-dns | records/config.go | NewConfig | func NewConfig() Config {
return Config{
ZkDetectionTimeout: 30,
RefreshSeconds: 60,
TTL: 60,
SRVRecordDefaultWeight: 1,
Domain: "mesos",
Port: 53,
Timeout: 5,
StateTimeoutSeconds: 300,
SOARname: "root.ns1.mesos",
SOAMname: "ns1.mesos",
SOARefresh: 60,
SOARetry: 600,
SOAExpire: 86400,
SOAMinttl: 60,
ZoneResolvers: map[string][]string{},
Resolvers: []string{"8.8.8.8"},
Listener: "0.0.0.0",
HTTPListener: "0.0.0.0",
HTTPPort: 8123,
DNSOn: true,
HTTPOn: true,
ExternalOn: true,
SetTruncateBit: true,
RecurseOn: true,
IPSources: []string{"netinfo", "mesos", "host"},
EnumerationOn: true,
MesosAuthentication: httpcli.AuthNone,
}
} | go | func NewConfig() Config {
return Config{
ZkDetectionTimeout: 30,
RefreshSeconds: 60,
TTL: 60,
SRVRecordDefaultWeight: 1,
Domain: "mesos",
Port: 53,
Timeout: 5,
StateTimeoutSeconds: 300,
SOARname: "root.ns1.mesos",
SOAMname: "ns1.mesos",
SOARefresh: 60,
SOARetry: 600,
SOAExpire: 86400,
SOAMinttl: 60,
ZoneResolvers: map[string][]string{},
Resolvers: []string{"8.8.8.8"},
Listener: "0.0.0.0",
HTTPListener: "0.0.0.0",
HTTPPort: 8123,
DNSOn: true,
HTTPOn: true,
ExternalOn: true,
SetTruncateBit: true,
RecurseOn: true,
IPSources: []string{"netinfo", "mesos", "host"},
EnumerationOn: true,
MesosAuthentication: httpcli.AuthNone,
}
} | [
"func",
"NewConfig",
"(",
")",
"Config",
"{",
"return",
"Config",
"{",
"ZkDetectionTimeout",
":",
"30",
",",
"RefreshSeconds",
":",
"60",
",",
"TTL",
":",
"60",
",",
"SRVRecordDefaultWeight",
":",
"1",
",",
"Domain",
":",
"\"",
"\"",
",",
"Port",
":",
"53",
",",
"Timeout",
":",
"5",
",",
"StateTimeoutSeconds",
":",
"300",
",",
"SOARname",
":",
"\"",
"\"",
",",
"SOAMname",
":",
"\"",
"\"",
",",
"SOARefresh",
":",
"60",
",",
"SOARetry",
":",
"600",
",",
"SOAExpire",
":",
"86400",
",",
"SOAMinttl",
":",
"60",
",",
"ZoneResolvers",
":",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
"{",
"}",
",",
"Resolvers",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
"}",
",",
"Listener",
":",
"\"",
"\"",
",",
"HTTPListener",
":",
"\"",
"\"",
",",
"HTTPPort",
":",
"8123",
",",
"DNSOn",
":",
"true",
",",
"HTTPOn",
":",
"true",
",",
"ExternalOn",
":",
"true",
",",
"SetTruncateBit",
":",
"true",
",",
"RecurseOn",
":",
"true",
",",
"IPSources",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"EnumerationOn",
":",
"true",
",",
"MesosAuthentication",
":",
"httpcli",
".",
"AuthNone",
",",
"}",
"\n",
"}"
] | // NewConfig return the default config of the resolver | [
"NewConfig",
"return",
"the",
"default",
"config",
"of",
"the",
"resolver"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/config.go#L114-L144 | train |
mesosphere/mesos-dns | records/config.go | SetConfig | func SetConfig(cjson string) Config {
c, err := readConfig(cjson)
if err != nil {
logging.Error.Fatal(err)
}
logging.Verbose.Printf("config loaded from %q", c.File)
// validate and complete configuration file
err = validateEnabledServices(c)
if err != nil {
logging.Error.Fatalf("service validation failed: %v", err)
}
if err = validateMasters(c.Masters); err != nil {
logging.Error.Fatal(err)
}
c.initResolvers()
if err = validateIPSources(c.IPSources); err != nil {
logging.Error.Fatalf("IPSources validation failed: %v", err)
}
if c.StateTimeoutSeconds <= 0 {
logging.Error.Fatal("Invalid HTTP Timeout: ", c.StateTimeoutSeconds)
}
c.Domain = strings.ToLower(c.Domain)
err = validateDomainName(c.Domain)
if err != nil {
logging.Error.Fatalf("%s is not a valid domain name", c.Domain)
}
c.initSOA()
c.initCertificates()
c.initMesosAuthentication()
c.log()
return *c
} | go | func SetConfig(cjson string) Config {
c, err := readConfig(cjson)
if err != nil {
logging.Error.Fatal(err)
}
logging.Verbose.Printf("config loaded from %q", c.File)
// validate and complete configuration file
err = validateEnabledServices(c)
if err != nil {
logging.Error.Fatalf("service validation failed: %v", err)
}
if err = validateMasters(c.Masters); err != nil {
logging.Error.Fatal(err)
}
c.initResolvers()
if err = validateIPSources(c.IPSources); err != nil {
logging.Error.Fatalf("IPSources validation failed: %v", err)
}
if c.StateTimeoutSeconds <= 0 {
logging.Error.Fatal("Invalid HTTP Timeout: ", c.StateTimeoutSeconds)
}
c.Domain = strings.ToLower(c.Domain)
err = validateDomainName(c.Domain)
if err != nil {
logging.Error.Fatalf("%s is not a valid domain name", c.Domain)
}
c.initSOA()
c.initCertificates()
c.initMesosAuthentication()
c.log()
return *c
} | [
"func",
"SetConfig",
"(",
"cjson",
"string",
")",
"Config",
"{",
"c",
",",
"err",
":=",
"readConfig",
"(",
"cjson",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n",
"logging",
".",
"Verbose",
".",
"Printf",
"(",
"\"",
"\"",
",",
"c",
".",
"File",
")",
"\n",
"// validate and complete configuration file",
"err",
"=",
"validateEnabledServices",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
"=",
"validateMasters",
"(",
"c",
".",
"Masters",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Fatal",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"c",
".",
"initResolvers",
"(",
")",
"\n\n",
"if",
"err",
"=",
"validateIPSources",
"(",
"c",
".",
"IPSources",
")",
";",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"c",
".",
"StateTimeoutSeconds",
"<=",
"0",
"{",
"logging",
".",
"Error",
".",
"Fatal",
"(",
"\"",
"\"",
",",
"c",
".",
"StateTimeoutSeconds",
")",
"\n",
"}",
"\n\n",
"c",
".",
"Domain",
"=",
"strings",
".",
"ToLower",
"(",
"c",
".",
"Domain",
")",
"\n\n",
"err",
"=",
"validateDomainName",
"(",
"c",
".",
"Domain",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Fatalf",
"(",
"\"",
"\"",
",",
"c",
".",
"Domain",
")",
"\n",
"}",
"\n\n",
"c",
".",
"initSOA",
"(",
")",
"\n",
"c",
".",
"initCertificates",
"(",
")",
"\n",
"c",
".",
"initMesosAuthentication",
"(",
")",
"\n",
"c",
".",
"log",
"(",
")",
"\n\n",
"return",
"*",
"c",
"\n",
"}"
] | // SetConfig instantiates a Config struct read in from config.json | [
"SetConfig",
"instantiates",
"a",
"Config",
"struct",
"read",
"in",
"from",
"config",
".",
"json"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/config.go#L147-L185 | train |
mesosphere/mesos-dns | records/config.go | nonLocalAddies | func nonLocalAddies(cservers []string) []string {
bad := localAddies()
good := []string{}
for i := 0; i < len(cservers); i++ {
local := false
for x := 0; x < len(bad); x++ {
if cservers[i] == bad[x] {
local = true
}
}
if !local {
good = append(good, cservers[i])
}
}
return good
} | go | func nonLocalAddies(cservers []string) []string {
bad := localAddies()
good := []string{}
for i := 0; i < len(cservers); i++ {
local := false
for x := 0; x < len(bad); x++ {
if cservers[i] == bad[x] {
local = true
}
}
if !local {
good = append(good, cservers[i])
}
}
return good
} | [
"func",
"nonLocalAddies",
"(",
"cservers",
"[",
"]",
"string",
")",
"[",
"]",
"string",
"{",
"bad",
":=",
"localAddies",
"(",
")",
"\n\n",
"good",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"cservers",
")",
";",
"i",
"++",
"{",
"local",
":=",
"false",
"\n",
"for",
"x",
":=",
"0",
";",
"x",
"<",
"len",
"(",
"bad",
")",
";",
"x",
"++",
"{",
"if",
"cservers",
"[",
"i",
"]",
"==",
"bad",
"[",
"x",
"]",
"{",
"local",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"local",
"{",
"good",
"=",
"append",
"(",
"good",
",",
"cservers",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"good",
"\n",
"}"
] | // Returns non-local nameserver entries | [
"Returns",
"non",
"-",
"local",
"nameserver",
"entries"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/config.go#L384-L403 | train |
mesosphere/mesos-dns | records/config.go | localAddies | func localAddies() []string {
addies, err := net.InterfaceAddrs()
if err != nil {
logging.Error.Println(err)
}
bad := []string{}
for i := 0; i < len(addies); i++ {
ip, _, err := net.ParseCIDR(addies[i].String())
if err != nil {
logging.Error.Println(err)
}
// The servers in cservers above could include
// ipv6, so we should include local ipv6 for
// that filtering
if t4 := ip.To4(); t4 != nil {
bad = append(bad, t4.String())
} else if t6 := ip.To16(); t6 != nil {
bad = append(bad, t6.String())
}
}
return bad
} | go | func localAddies() []string {
addies, err := net.InterfaceAddrs()
if err != nil {
logging.Error.Println(err)
}
bad := []string{}
for i := 0; i < len(addies); i++ {
ip, _, err := net.ParseCIDR(addies[i].String())
if err != nil {
logging.Error.Println(err)
}
// The servers in cservers above could include
// ipv6, so we should include local ipv6 for
// that filtering
if t4 := ip.To4(); t4 != nil {
bad = append(bad, t4.String())
} else if t6 := ip.To16(); t6 != nil {
bad = append(bad, t6.String())
}
}
return bad
} | [
"func",
"localAddies",
"(",
")",
"[",
"]",
"string",
"{",
"addies",
",",
"err",
":=",
"net",
".",
"InterfaceAddrs",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"bad",
":=",
"[",
"]",
"string",
"{",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"addies",
")",
";",
"i",
"++",
"{",
"ip",
",",
"_",
",",
"err",
":=",
"net",
".",
"ParseCIDR",
"(",
"addies",
"[",
"i",
"]",
".",
"String",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"logging",
".",
"Error",
".",
"Println",
"(",
"err",
")",
"\n",
"}",
"\n",
"// The servers in cservers above could include",
"// ipv6, so we should include local ipv6 for",
"// that filtering",
"if",
"t4",
":=",
"ip",
".",
"To4",
"(",
")",
";",
"t4",
"!=",
"nil",
"{",
"bad",
"=",
"append",
"(",
"bad",
",",
"t4",
".",
"String",
"(",
")",
")",
"\n",
"}",
"else",
"if",
"t6",
":=",
"ip",
".",
"To16",
"(",
")",
";",
"t6",
"!=",
"nil",
"{",
"bad",
"=",
"append",
"(",
"bad",
",",
"t6",
".",
"String",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"bad",
"\n",
"}"
] | // Returns an array of local ipv4 addresses | [
"Returns",
"an",
"array",
"of",
"local",
"ipv4",
"addresses"
] | 65cb06fff5493c3caa8fc00d26e89fbedab9d95e | https://github.com/mesosphere/mesos-dns/blob/65cb06fff5493c3caa8fc00d26e89fbedab9d95e/records/config.go#L406-L430 | train |
libp2p/go-reuseport | interface.go | Listen | func Listen(network, address string) (net.Listener, error) {
return listenConfig.Listen(context.Background(), network, address)
} | go | func Listen(network, address string) (net.Listener, error) {
return listenConfig.Listen(context.Background(), network, address)
} | [
"func",
"Listen",
"(",
"network",
",",
"address",
"string",
")",
"(",
"net",
".",
"Listener",
",",
"error",
")",
"{",
"return",
"listenConfig",
".",
"Listen",
"(",
"context",
".",
"Background",
"(",
")",
",",
"network",
",",
"address",
")",
"\n",
"}"
] | // Listen listens at the given network and address. see net.Listen
// Returns a net.Listener created from a file discriptor for a socket
// with SO_REUSEPORT and SO_REUSEADDR option set. | [
"Listen",
"listens",
"at",
"the",
"given",
"network",
"and",
"address",
".",
"see",
"net",
".",
"Listen",
"Returns",
"a",
"net",
".",
"Listener",
"created",
"from",
"a",
"file",
"discriptor",
"for",
"a",
"socket",
"with",
"SO_REUSEPORT",
"and",
"SO_REUSEADDR",
"option",
"set",
"."
] | b72b23b78b80078df1a7991f6ca39942cb8cc5e1 | https://github.com/libp2p/go-reuseport/blob/b72b23b78b80078df1a7991f6ca39942cb8cc5e1/interface.go#L40-L42 | train |
libp2p/go-reuseport | interface.go | ListenPacket | func ListenPacket(network, address string) (net.PacketConn, error) {
return listenConfig.ListenPacket(context.Background(), network, address)
} | go | func ListenPacket(network, address string) (net.PacketConn, error) {
return listenConfig.ListenPacket(context.Background(), network, address)
} | [
"func",
"ListenPacket",
"(",
"network",
",",
"address",
"string",
")",
"(",
"net",
".",
"PacketConn",
",",
"error",
")",
"{",
"return",
"listenConfig",
".",
"ListenPacket",
"(",
"context",
".",
"Background",
"(",
")",
",",
"network",
",",
"address",
")",
"\n",
"}"
] | // ListenPacket listens at the given network and address. see net.ListenPacket
// Returns a net.Listener created from a file discriptor for a socket
// with SO_REUSEPORT and SO_REUSEADDR option set. | [
"ListenPacket",
"listens",
"at",
"the",
"given",
"network",
"and",
"address",
".",
"see",
"net",
".",
"ListenPacket",
"Returns",
"a",
"net",
".",
"Listener",
"created",
"from",
"a",
"file",
"discriptor",
"for",
"a",
"socket",
"with",
"SO_REUSEPORT",
"and",
"SO_REUSEADDR",
"option",
"set",
"."
] | b72b23b78b80078df1a7991f6ca39942cb8cc5e1 | https://github.com/libp2p/go-reuseport/blob/b72b23b78b80078df1a7991f6ca39942cb8cc5e1/interface.go#L47-L49 | train |
libp2p/go-reuseport | interface.go | Dial | func Dial(network, laddr, raddr string) (net.Conn, error) {
nla, err := ResolveAddr(network, laddr)
if err != nil {
return nil, errors.Wrap(err, "resolving local addr")
}
d := net.Dialer{
Control: Control,
LocalAddr: nla,
}
return d.Dial(network, raddr)
} | go | func Dial(network, laddr, raddr string) (net.Conn, error) {
nla, err := ResolveAddr(network, laddr)
if err != nil {
return nil, errors.Wrap(err, "resolving local addr")
}
d := net.Dialer{
Control: Control,
LocalAddr: nla,
}
return d.Dial(network, raddr)
} | [
"func",
"Dial",
"(",
"network",
",",
"laddr",
",",
"raddr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"nla",
",",
"err",
":=",
"ResolveAddr",
"(",
"network",
",",
"laddr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"d",
":=",
"net",
".",
"Dialer",
"{",
"Control",
":",
"Control",
",",
"LocalAddr",
":",
"nla",
",",
"}",
"\n",
"return",
"d",
".",
"Dial",
"(",
"network",
",",
"raddr",
")",
"\n",
"}"
] | // Dial dials the given network and address. see net.Dialer.Dial
// Returns a net.Conn created from a file descriptor for a socket
// with SO_REUSEPORT and SO_REUSEADDR option set. | [
"Dial",
"dials",
"the",
"given",
"network",
"and",
"address",
".",
"see",
"net",
".",
"Dialer",
".",
"Dial",
"Returns",
"a",
"net",
".",
"Conn",
"created",
"from",
"a",
"file",
"descriptor",
"for",
"a",
"socket",
"with",
"SO_REUSEPORT",
"and",
"SO_REUSEADDR",
"option",
"set",
"."
] | b72b23b78b80078df1a7991f6ca39942cb8cc5e1 | https://github.com/libp2p/go-reuseport/blob/b72b23b78b80078df1a7991f6ca39942cb8cc5e1/interface.go#L54-L64 | train |
etcd-io/gofail | runtime/failpoint.go | Acquire | func (fp *Failpoint) Acquire() (interface{}, error) {
fp.mu.RLock()
if fp.t == nil {
fp.mu.RUnlock()
return nil, ErrDisabled
}
v, err := fp.t.eval()
if v == nil {
err = ErrDisabled
}
if err != nil {
fp.mu.RUnlock()
}
return v, err
} | go | func (fp *Failpoint) Acquire() (interface{}, error) {
fp.mu.RLock()
if fp.t == nil {
fp.mu.RUnlock()
return nil, ErrDisabled
}
v, err := fp.t.eval()
if v == nil {
err = ErrDisabled
}
if err != nil {
fp.mu.RUnlock()
}
return v, err
} | [
"func",
"(",
"fp",
"*",
"Failpoint",
")",
"Acquire",
"(",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"fp",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"if",
"fp",
".",
"t",
"==",
"nil",
"{",
"fp",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"return",
"nil",
",",
"ErrDisabled",
"\n",
"}",
"\n",
"v",
",",
"err",
":=",
"fp",
".",
"t",
".",
"eval",
"(",
")",
"\n",
"if",
"v",
"==",
"nil",
"{",
"err",
"=",
"ErrDisabled",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fp",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"}",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // Acquire gets evalutes the failpoint terms; if the failpoint
// is active, it will return a value. Otherwise, returns a non-nil error. | [
"Acquire",
"gets",
"evalutes",
"the",
"failpoint",
"terms",
";",
"if",
"the",
"failpoint",
"is",
"active",
"it",
"will",
"return",
"a",
"value",
".",
"Otherwise",
"returns",
"a",
"non",
"-",
"nil",
"error",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/failpoint.go#L35-L49 | train |
etcd-io/gofail | runtime/failpoint.go | BadType | func (fp *Failpoint) BadType(v interface{}, t string) {
fmt.Printf("failpoint: %q got value %v of type \"%T\" but expected type %q\n", fp.t.fpath, v, v, t)
} | go | func (fp *Failpoint) BadType(v interface{}, t string) {
fmt.Printf("failpoint: %q got value %v of type \"%T\" but expected type %q\n", fp.t.fpath, v, v, t)
} | [
"func",
"(",
"fp",
"*",
"Failpoint",
")",
"BadType",
"(",
"v",
"interface",
"{",
"}",
",",
"t",
"string",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
",",
"fp",
".",
"t",
".",
"fpath",
",",
"v",
",",
"v",
",",
"t",
")",
"\n",
"}"
] | // BadType is called when the failpoint evaluates to the wrong type. | [
"BadType",
"is",
"called",
"when",
"the",
"failpoint",
"evaluates",
"to",
"the",
"wrong",
"type",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/failpoint.go#L55-L57 | train |
etcd-io/gofail | code/failpoint.go | newFailpoint | func newFailpoint(l string) (*Failpoint, error) {
if !strings.HasPrefix(strings.TrimSpace(l), "// gofail:") {
// not a failpoint
return nil, nil
}
cmd := strings.SplitAfter(l, "// gofail:")[1]
fields := strings.Fields(cmd)
if len(fields) != 3 || fields[0] != "var" {
return nil, fmt.Errorf("failpoint: malformed comment header %q", l)
}
return &Failpoint{name: fields[1], varType: fields[2], ws: strings.Split(l, "//")[0]}, nil
} | go | func newFailpoint(l string) (*Failpoint, error) {
if !strings.HasPrefix(strings.TrimSpace(l), "// gofail:") {
// not a failpoint
return nil, nil
}
cmd := strings.SplitAfter(l, "// gofail:")[1]
fields := strings.Fields(cmd)
if len(fields) != 3 || fields[0] != "var" {
return nil, fmt.Errorf("failpoint: malformed comment header %q", l)
}
return &Failpoint{name: fields[1], varType: fields[2], ws: strings.Split(l, "//")[0]}, nil
} | [
"func",
"newFailpoint",
"(",
"l",
"string",
")",
"(",
"*",
"Failpoint",
",",
"error",
")",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"strings",
".",
"TrimSpace",
"(",
"l",
")",
",",
"\"",
"\"",
")",
"{",
"// not a failpoint",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"cmd",
":=",
"strings",
".",
"SplitAfter",
"(",
"l",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
"\n",
"fields",
":=",
"strings",
".",
"Fields",
"(",
"cmd",
")",
"\n",
"if",
"len",
"(",
"fields",
")",
"!=",
"3",
"||",
"fields",
"[",
"0",
"]",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
")",
"\n",
"}",
"\n",
"return",
"&",
"Failpoint",
"{",
"name",
":",
"fields",
"[",
"1",
"]",
",",
"varType",
":",
"fields",
"[",
"2",
"]",
",",
"ws",
":",
"strings",
".",
"Split",
"(",
"l",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"}",
",",
"nil",
"\n",
"}"
] | // newFailpoint makes a new failpoint based on the a line containing a
// failpoint comment header. | [
"newFailpoint",
"makes",
"a",
"new",
"failpoint",
"based",
"on",
"the",
"a",
"line",
"containing",
"a",
"failpoint",
"comment",
"header",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/code/failpoint.go#L34-L45 | train |
etcd-io/gofail | code/failpoint.go | flush | func (fp *Failpoint) flush(dst io.Writer) error {
if len(fp.code) == 0 {
return fp.flushSingle(dst)
}
return fp.flushMulti(dst)
} | go | func (fp *Failpoint) flush(dst io.Writer) error {
if len(fp.code) == 0 {
return fp.flushSingle(dst)
}
return fp.flushMulti(dst)
} | [
"func",
"(",
"fp",
"*",
"Failpoint",
")",
"flush",
"(",
"dst",
"io",
".",
"Writer",
")",
"error",
"{",
"if",
"len",
"(",
"fp",
".",
"code",
")",
"==",
"0",
"{",
"return",
"fp",
".",
"flushSingle",
"(",
"dst",
")",
"\n",
"}",
"\n",
"return",
"fp",
".",
"flushMulti",
"(",
"dst",
")",
"\n",
"}"
] | // flush writes the failpoint code to a buffer | [
"flush",
"writes",
"the",
"failpoint",
"code",
"to",
"a",
"buffer"
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/code/failpoint.go#L48-L53 | train |
etcd-io/gofail | code/rewrite.go | ToFailpoints | func ToFailpoints(wdst io.Writer, rsrc io.Reader) (fps []*Failpoint, err error) {
var curfp *Failpoint
dst := bufio.NewWriter(wdst)
defer func() {
if err == nil && curfp != nil {
err = curfp.flush(dst)
}
if err == nil {
err = dst.Flush()
}
}()
src := bufio.NewReader(rsrc)
for err == nil {
l, rerr := src.ReadString('\n')
if curfp != nil {
if strings.HasPrefix(strings.TrimSpace(l), "//") {
if len(l) > 0 && l[len(l)-1] == '\n' {
l = l[:len(l)-1]
}
curfp.code = append(curfp.code, strings.Replace(l, "//", "\t", 1))
continue
} else {
curfp.flush(dst)
fps = append(fps, curfp)
curfp = nil
}
} else if label := gofailLabel(l); label != "" {
// expose gofail label
l = label
} else if curfp, err = newFailpoint(l); err != nil {
return
} else if curfp != nil {
// found a new failpoint
continue
}
if _, err = dst.WriteString(l); err != nil {
return
}
if rerr == io.EOF {
break
}
}
return
} | go | func ToFailpoints(wdst io.Writer, rsrc io.Reader) (fps []*Failpoint, err error) {
var curfp *Failpoint
dst := bufio.NewWriter(wdst)
defer func() {
if err == nil && curfp != nil {
err = curfp.flush(dst)
}
if err == nil {
err = dst.Flush()
}
}()
src := bufio.NewReader(rsrc)
for err == nil {
l, rerr := src.ReadString('\n')
if curfp != nil {
if strings.HasPrefix(strings.TrimSpace(l), "//") {
if len(l) > 0 && l[len(l)-1] == '\n' {
l = l[:len(l)-1]
}
curfp.code = append(curfp.code, strings.Replace(l, "//", "\t", 1))
continue
} else {
curfp.flush(dst)
fps = append(fps, curfp)
curfp = nil
}
} else if label := gofailLabel(l); label != "" {
// expose gofail label
l = label
} else if curfp, err = newFailpoint(l); err != nil {
return
} else if curfp != nil {
// found a new failpoint
continue
}
if _, err = dst.WriteString(l); err != nil {
return
}
if rerr == io.EOF {
break
}
}
return
} | [
"func",
"ToFailpoints",
"(",
"wdst",
"io",
".",
"Writer",
",",
"rsrc",
"io",
".",
"Reader",
")",
"(",
"fps",
"[",
"]",
"*",
"Failpoint",
",",
"err",
"error",
")",
"{",
"var",
"curfp",
"*",
"Failpoint",
"\n\n",
"dst",
":=",
"bufio",
".",
"NewWriter",
"(",
"wdst",
")",
"\n",
"defer",
"func",
"(",
")",
"{",
"if",
"err",
"==",
"nil",
"&&",
"curfp",
"!=",
"nil",
"{",
"err",
"=",
"curfp",
".",
"flush",
"(",
"dst",
")",
"\n",
"}",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"dst",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"src",
":=",
"bufio",
".",
"NewReader",
"(",
"rsrc",
")",
"\n",
"for",
"err",
"==",
"nil",
"{",
"l",
",",
"rerr",
":=",
"src",
".",
"ReadString",
"(",
"'\\n'",
")",
"\n",
"if",
"curfp",
"!=",
"nil",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"strings",
".",
"TrimSpace",
"(",
"l",
")",
",",
"\"",
"\"",
")",
"{",
"if",
"len",
"(",
"l",
")",
">",
"0",
"&&",
"l",
"[",
"len",
"(",
"l",
")",
"-",
"1",
"]",
"==",
"'\\n'",
"{",
"l",
"=",
"l",
"[",
":",
"len",
"(",
"l",
")",
"-",
"1",
"]",
"\n",
"}",
"\n",
"curfp",
".",
"code",
"=",
"append",
"(",
"curfp",
".",
"code",
",",
"strings",
".",
"Replace",
"(",
"l",
",",
"\"",
"\"",
",",
"\"",
"\\t",
"\"",
",",
"1",
")",
")",
"\n",
"continue",
"\n",
"}",
"else",
"{",
"curfp",
".",
"flush",
"(",
"dst",
")",
"\n",
"fps",
"=",
"append",
"(",
"fps",
",",
"curfp",
")",
"\n",
"curfp",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"else",
"if",
"label",
":=",
"gofailLabel",
"(",
"l",
")",
";",
"label",
"!=",
"\"",
"\"",
"{",
"// expose gofail label",
"l",
"=",
"label",
"\n",
"}",
"else",
"if",
"curfp",
",",
"err",
"=",
"newFailpoint",
"(",
"l",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"else",
"if",
"curfp",
"!=",
"nil",
"{",
"// found a new failpoint",
"continue",
"\n",
"}",
"\n",
"if",
"_",
",",
"err",
"=",
"dst",
".",
"WriteString",
"(",
"l",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"rerr",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ToFailpoints turns all gofail comments into failpoint code. Returns a list of
// all failpoints it activated. | [
"ToFailpoints",
"turns",
"all",
"gofail",
"comments",
"into",
"failpoint",
"code",
".",
"Returns",
"a",
"list",
"of",
"all",
"failpoints",
"it",
"activated",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/code/rewrite.go#L26-L71 | train |
etcd-io/gofail | code/rewrite.go | ToComments | func ToComments(wdst io.Writer, rsrc io.Reader) (fps []*Failpoint, err error) {
src := bufio.NewReader(rsrc)
dst := bufio.NewWriter(wdst)
ws := ""
unmatchedBraces := 0
for err == nil {
l, rerr := src.ReadString('\n')
err = rerr
lTrim := strings.TrimSpace(l)
if unmatchedBraces > 0 {
opening, closing := numBraces(l)
unmatchedBraces += opening - closing
if unmatchedBraces == 0 {
// strip off badType footer
lTrim = strings.Split(lTrim, "; __badType")[0]
}
s := ws + "//" + wsPrefix(l, ws)[1:] + lTrim + "\n"
dst.WriteString(s)
continue
}
isHdr := strings.Contains(l, ", __fpErr := __fp_") && strings.HasPrefix(lTrim, "if")
if isHdr {
ws = strings.Split(l, "i")[0]
n := strings.Split(strings.Split(l, "__fp_")[1], ".")[0]
t := strings.Split(strings.Split(l, ".(")[1], ")")[0]
dst.WriteString(ws + "// gofail: var " + n + " " + t + "\n")
if !strings.Contains(l, "; __badType") {
// not single liner
unmatchedBraces = 1
}
fps = append(fps, &Failpoint{name: n, varType: t})
continue
}
if isLabel := strings.Contains(l, "\t/* gofail-label */"); isLabel {
l = strings.Replace(l, "/* gofail-label */", "// gofail:", 1)
}
if _, werr := dst.WriteString(l); werr != nil {
return fps, werr
}
}
if err == io.EOF {
err = nil
}
dst.Flush()
return
} | go | func ToComments(wdst io.Writer, rsrc io.Reader) (fps []*Failpoint, err error) {
src := bufio.NewReader(rsrc)
dst := bufio.NewWriter(wdst)
ws := ""
unmatchedBraces := 0
for err == nil {
l, rerr := src.ReadString('\n')
err = rerr
lTrim := strings.TrimSpace(l)
if unmatchedBraces > 0 {
opening, closing := numBraces(l)
unmatchedBraces += opening - closing
if unmatchedBraces == 0 {
// strip off badType footer
lTrim = strings.Split(lTrim, "; __badType")[0]
}
s := ws + "//" + wsPrefix(l, ws)[1:] + lTrim + "\n"
dst.WriteString(s)
continue
}
isHdr := strings.Contains(l, ", __fpErr := __fp_") && strings.HasPrefix(lTrim, "if")
if isHdr {
ws = strings.Split(l, "i")[0]
n := strings.Split(strings.Split(l, "__fp_")[1], ".")[0]
t := strings.Split(strings.Split(l, ".(")[1], ")")[0]
dst.WriteString(ws + "// gofail: var " + n + " " + t + "\n")
if !strings.Contains(l, "; __badType") {
// not single liner
unmatchedBraces = 1
}
fps = append(fps, &Failpoint{name: n, varType: t})
continue
}
if isLabel := strings.Contains(l, "\t/* gofail-label */"); isLabel {
l = strings.Replace(l, "/* gofail-label */", "// gofail:", 1)
}
if _, werr := dst.WriteString(l); werr != nil {
return fps, werr
}
}
if err == io.EOF {
err = nil
}
dst.Flush()
return
} | [
"func",
"ToComments",
"(",
"wdst",
"io",
".",
"Writer",
",",
"rsrc",
"io",
".",
"Reader",
")",
"(",
"fps",
"[",
"]",
"*",
"Failpoint",
",",
"err",
"error",
")",
"{",
"src",
":=",
"bufio",
".",
"NewReader",
"(",
"rsrc",
")",
"\n",
"dst",
":=",
"bufio",
".",
"NewWriter",
"(",
"wdst",
")",
"\n",
"ws",
":=",
"\"",
"\"",
"\n",
"unmatchedBraces",
":=",
"0",
"\n",
"for",
"err",
"==",
"nil",
"{",
"l",
",",
"rerr",
":=",
"src",
".",
"ReadString",
"(",
"'\\n'",
")",
"\n",
"err",
"=",
"rerr",
"\n",
"lTrim",
":=",
"strings",
".",
"TrimSpace",
"(",
"l",
")",
"\n\n",
"if",
"unmatchedBraces",
">",
"0",
"{",
"opening",
",",
"closing",
":=",
"numBraces",
"(",
"l",
")",
"\n",
"unmatchedBraces",
"+=",
"opening",
"-",
"closing",
"\n",
"if",
"unmatchedBraces",
"==",
"0",
"{",
"// strip off badType footer",
"lTrim",
"=",
"strings",
".",
"Split",
"(",
"lTrim",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"}",
"\n",
"s",
":=",
"ws",
"+",
"\"",
"\"",
"+",
"wsPrefix",
"(",
"l",
",",
"ws",
")",
"[",
"1",
":",
"]",
"+",
"lTrim",
"+",
"\"",
"\\n",
"\"",
"\n",
"dst",
".",
"WriteString",
"(",
"s",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"isHdr",
":=",
"strings",
".",
"Contains",
"(",
"l",
",",
"\"",
"\"",
")",
"&&",
"strings",
".",
"HasPrefix",
"(",
"lTrim",
",",
"\"",
"\"",
")",
"\n",
"if",
"isHdr",
"{",
"ws",
"=",
"strings",
".",
"Split",
"(",
"l",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"n",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"Split",
"(",
"l",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"t",
":=",
"strings",
".",
"Split",
"(",
"strings",
".",
"Split",
"(",
"l",
",",
"\"",
"\"",
")",
"[",
"1",
"]",
",",
"\"",
"\"",
")",
"[",
"0",
"]",
"\n",
"dst",
".",
"WriteString",
"(",
"ws",
"+",
"\"",
"\"",
"+",
"n",
"+",
"\"",
"\"",
"+",
"t",
"+",
"\"",
"\\n",
"\"",
")",
"\n",
"if",
"!",
"strings",
".",
"Contains",
"(",
"l",
",",
"\"",
"\"",
")",
"{",
"// not single liner",
"unmatchedBraces",
"=",
"1",
"\n",
"}",
"\n",
"fps",
"=",
"append",
"(",
"fps",
",",
"&",
"Failpoint",
"{",
"name",
":",
"n",
",",
"varType",
":",
"t",
"}",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"isLabel",
":=",
"strings",
".",
"Contains",
"(",
"l",
",",
"\"",
"\\t",
"\"",
")",
";",
"isLabel",
"{",
"l",
"=",
"strings",
".",
"Replace",
"(",
"l",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"1",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"werr",
":=",
"dst",
".",
"WriteString",
"(",
"l",
")",
";",
"werr",
"!=",
"nil",
"{",
"return",
"fps",
",",
"werr",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"dst",
".",
"Flush",
"(",
")",
"\n",
"return",
"\n",
"}"
] | // ToComments turns all failpoint code into GOFAIL comments. It returns
// a list of all failpoints it deactivated. | [
"ToComments",
"turns",
"all",
"failpoint",
"code",
"into",
"GOFAIL",
"comments",
".",
"It",
"returns",
"a",
"list",
"of",
"all",
"failpoints",
"it",
"deactivated",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/code/rewrite.go#L75-L124 | train |
etcd-io/gofail | code/rewrite.go | wsPrefix | func wsPrefix(l, wsPfx string) string {
lws := ""
if len(wsPfx) == 0 {
lws = l
} else {
wsSplit := strings.SplitAfter(l, wsPfx)
if len(wsSplit) < 2 {
return ""
}
lws = strings.Join(wsSplit[1:], "")
}
for i, c := range lws {
if !unicode.IsSpace(c) {
return lws[:i]
}
}
return lws
} | go | func wsPrefix(l, wsPfx string) string {
lws := ""
if len(wsPfx) == 0 {
lws = l
} else {
wsSplit := strings.SplitAfter(l, wsPfx)
if len(wsSplit) < 2 {
return ""
}
lws = strings.Join(wsSplit[1:], "")
}
for i, c := range lws {
if !unicode.IsSpace(c) {
return lws[:i]
}
}
return lws
} | [
"func",
"wsPrefix",
"(",
"l",
",",
"wsPfx",
"string",
")",
"string",
"{",
"lws",
":=",
"\"",
"\"",
"\n",
"if",
"len",
"(",
"wsPfx",
")",
"==",
"0",
"{",
"lws",
"=",
"l",
"\n",
"}",
"else",
"{",
"wsSplit",
":=",
"strings",
".",
"SplitAfter",
"(",
"l",
",",
"wsPfx",
")",
"\n",
"if",
"len",
"(",
"wsSplit",
")",
"<",
"2",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"lws",
"=",
"strings",
".",
"Join",
"(",
"wsSplit",
"[",
"1",
":",
"]",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"lws",
"{",
"if",
"!",
"unicode",
".",
"IsSpace",
"(",
"c",
")",
"{",
"return",
"lws",
"[",
":",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"lws",
"\n",
"}"
] | // wsPrefix computes the left padding of a line given a whitespace prefix. | [
"wsPrefix",
"computes",
"the",
"left",
"padding",
"of",
"a",
"line",
"given",
"a",
"whitespace",
"prefix",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/code/rewrite.go#L150-L167 | train |
etcd-io/gofail | runtime/runtime.go | Enable | func Enable(failpath, inTerms string) error {
unlock, err := enableAndLock(failpath, inTerms)
if unlock != nil {
unlock()
}
return err
} | go | func Enable(failpath, inTerms string) error {
unlock, err := enableAndLock(failpath, inTerms)
if unlock != nil {
unlock()
}
return err
} | [
"func",
"Enable",
"(",
"failpath",
",",
"inTerms",
"string",
")",
"error",
"{",
"unlock",
",",
"err",
":=",
"enableAndLock",
"(",
"failpath",
",",
"inTerms",
")",
"\n",
"if",
"unlock",
"!=",
"nil",
"{",
"unlock",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Enable sets a failpoint to a given failpoint description. | [
"Enable",
"sets",
"a",
"failpoint",
"to",
"a",
"given",
"failpoint",
"description",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/runtime.go#L56-L62 | train |
etcd-io/gofail | runtime/runtime.go | enableAndLock | func enableAndLock(failpath, inTerms string) (func(), error) {
t, err := newTerms(failpath, inTerms)
if err != nil {
fmt.Printf("failed to enable \"%s=%s\" (%v)\n", failpath, inTerms, err)
return nil, err
}
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return nil, ErrNoExist
}
fp.mu.Lock()
fp.t = t
return func() { fp.mu.Unlock() }, nil
} | go | func enableAndLock(failpath, inTerms string) (func(), error) {
t, err := newTerms(failpath, inTerms)
if err != nil {
fmt.Printf("failed to enable \"%s=%s\" (%v)\n", failpath, inTerms, err)
return nil, err
}
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return nil, ErrNoExist
}
fp.mu.Lock()
fp.t = t
return func() { fp.mu.Unlock() }, nil
} | [
"func",
"enableAndLock",
"(",
"failpath",
",",
"inTerms",
"string",
")",
"(",
"func",
"(",
")",
",",
"error",
")",
"{",
"t",
",",
"err",
":=",
"newTerms",
"(",
"failpath",
",",
"inTerms",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\\"",
"\\\"",
"\\n",
"\"",
",",
"failpath",
",",
"inTerms",
",",
"err",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"failpointsMu",
".",
"RLock",
"(",
")",
"\n",
"fp",
":=",
"failpoints",
"[",
"failpath",
"]",
"\n",
"failpointsMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"fp",
"==",
"nil",
"{",
"return",
"nil",
",",
"ErrNoExist",
"\n",
"}",
"\n",
"fp",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"fp",
".",
"t",
"=",
"t",
"\n",
"return",
"func",
"(",
")",
"{",
"fp",
".",
"mu",
".",
"Unlock",
"(",
")",
"}",
",",
"nil",
"\n",
"}"
] | // enableAndLock enables a failpoint and returns a function to unlock it | [
"enableAndLock",
"enables",
"a",
"failpoint",
"and",
"returns",
"a",
"function",
"to",
"unlock",
"it"
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/runtime.go#L65-L80 | train |
etcd-io/gofail | runtime/runtime.go | Disable | func Disable(failpath string) error {
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return ErrNoExist
}
fp.mu.Lock()
defer fp.mu.Unlock()
if fp.t == nil {
return ErrDisabled
}
fp.t = nil
return nil
} | go | func Disable(failpath string) error {
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return ErrNoExist
}
fp.mu.Lock()
defer fp.mu.Unlock()
if fp.t == nil {
return ErrDisabled
}
fp.t = nil
return nil
} | [
"func",
"Disable",
"(",
"failpath",
"string",
")",
"error",
"{",
"failpointsMu",
".",
"RLock",
"(",
")",
"\n",
"fp",
":=",
"failpoints",
"[",
"failpath",
"]",
"\n",
"failpointsMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"fp",
"==",
"nil",
"{",
"return",
"ErrNoExist",
"\n",
"}",
"\n",
"fp",
".",
"mu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"fp",
".",
"mu",
".",
"Unlock",
"(",
")",
"\n",
"if",
"fp",
".",
"t",
"==",
"nil",
"{",
"return",
"ErrDisabled",
"\n",
"}",
"\n",
"fp",
".",
"t",
"=",
"nil",
"\n",
"return",
"nil",
"\n",
"}"
] | // Disable stops a failpoint from firing. | [
"Disable",
"stops",
"a",
"failpoint",
"from",
"firing",
"."
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/runtime.go#L83-L97 | train |
etcd-io/gofail | runtime/runtime.go | Status | func Status(failpath string) (string, error) {
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return "", ErrNoExist
}
fp.mu.RLock()
t := fp.t
fp.mu.RUnlock()
if t == nil {
return "", ErrDisabled
}
return t.desc, nil
} | go | func Status(failpath string) (string, error) {
failpointsMu.RLock()
fp := failpoints[failpath]
failpointsMu.RUnlock()
if fp == nil {
return "", ErrNoExist
}
fp.mu.RLock()
t := fp.t
fp.mu.RUnlock()
if t == nil {
return "", ErrDisabled
}
return t.desc, nil
} | [
"func",
"Status",
"(",
"failpath",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"failpointsMu",
".",
"RLock",
"(",
")",
"\n",
"fp",
":=",
"failpoints",
"[",
"failpath",
"]",
"\n",
"failpointsMu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"fp",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"ErrNoExist",
"\n",
"}",
"\n",
"fp",
".",
"mu",
".",
"RLock",
"(",
")",
"\n",
"t",
":=",
"fp",
".",
"t",
"\n",
"fp",
".",
"mu",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"ErrDisabled",
"\n",
"}",
"\n",
"return",
"t",
".",
"desc",
",",
"nil",
"\n",
"}"
] | // Status gives the current setting for the failpoint | [
"Status",
"gives",
"the",
"current",
"setting",
"for",
"the",
"failpoint"
] | 51ce9a71510a58bad5ae66ddd278ef28762a1550 | https://github.com/etcd-io/gofail/blob/51ce9a71510a58bad5ae66ddd278ef28762a1550/runtime/runtime.go#L100-L114 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.