id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1 value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
15,600 | LindsayBradford/go-dbf | godbf/dbftable.go | AddNewRecord | func (dt *DbfTable) AddNewRecord() (newRecordNumber int) {
if dt.dataEntryStarted == false {
dt.dataEntryStarted = true
}
newRecord := make([]byte, dt.lengthOfEachRecord)
dt.dataStore = appendSlice(dt.dataStore, newRecord)
// since row numbers are "0" based first we set newRecordNumber
// and then increment number of records in dbase table
newRecordNumber = int(dt.numberOfRecords)
//fmt.Printf("Number of rows before:%d\n", dt.numberOfRecords)
dt.numberOfRecords++
s := uint32ToBytes(dt.numberOfRecords)
dt.dataStore[4] = s[0]
dt.dataStore[5] = s[1]
dt.dataStore[6] = s[2]
dt.dataStore[7] = s[3]
//fmt.Printf("Number of rows after:%d\n", dt.numberOfRecords)
return newRecordNumber
} | go | func (dt *DbfTable) AddNewRecord() (newRecordNumber int) {
if dt.dataEntryStarted == false {
dt.dataEntryStarted = true
}
newRecord := make([]byte, dt.lengthOfEachRecord)
dt.dataStore = appendSlice(dt.dataStore, newRecord)
// since row numbers are "0" based first we set newRecordNumber
// and then increment number of records in dbase table
newRecordNumber = int(dt.numberOfRecords)
//fmt.Printf("Number of rows before:%d\n", dt.numberOfRecords)
dt.numberOfRecords++
s := uint32ToBytes(dt.numberOfRecords)
dt.dataStore[4] = s[0]
dt.dataStore[5] = s[1]
dt.dataStore[6] = s[2]
dt.dataStore[7] = s[3]
//fmt.Printf("Number of rows after:%d\n", dt.numberOfRecords)
return newRecordNumber
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"AddNewRecord",
"(",
")",
"(",
"newRecordNumber",
"int",
")",
"{",
"if",
"dt",
".",
"dataEntryStarted",
"==",
"false",
"{",
"dt",
".",
"dataEntryStarted",
"=",
"true",
"\n",
"}",
"\n\n",
"newRecord",
":=",
"make",... | // AddNewRecord adds a new empty record to the table, and returns the index number of the record. | [
"AddNewRecord",
"adds",
"a",
"new",
"empty",
"record",
"to",
"the",
"table",
"and",
"returns",
"the",
"index",
"number",
"of",
"the",
"record",
"."
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L324-L347 |
15,601 | LindsayBradford/go-dbf | godbf/dbftable.go | SetFieldValueByName | func (dt *DbfTable) SetFieldValueByName(row int, fieldName string, value string) (err error) {
if fieldIndex, found := dt.fieldMap[fieldName]; found {
return dt.SetFieldValue(row, fieldIndex, value)
}
return errors.New("Field name \"" + fieldName + "\" does not exist")
} | go | func (dt *DbfTable) SetFieldValueByName(row int, fieldName string, value string) (err error) {
if fieldIndex, found := dt.fieldMap[fieldName]; found {
return dt.SetFieldValue(row, fieldIndex, value)
}
return errors.New("Field name \"" + fieldName + "\" does not exist")
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"SetFieldValueByName",
"(",
"row",
"int",
",",
"fieldName",
"string",
",",
"value",
"string",
")",
"(",
"err",
"error",
")",
"{",
"if",
"fieldIndex",
",",
"found",
":=",
"dt",
".",
"fieldMap",
"[",
"fieldName",
... | // SetFieldValueByName sets the value for the given row and field name as specified
// If the field name does not exist, or the value is incompatible with the field's type, an error is returned. | [
"SetFieldValueByName",
"sets",
"the",
"value",
"for",
"the",
"given",
"row",
"and",
"field",
"name",
"as",
"specified",
"If",
"the",
"field",
"name",
"does",
"not",
"exist",
"or",
"the",
"value",
"is",
"incompatible",
"with",
"the",
"field",
"s",
"type",
"... | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L356-L361 |
15,602 | LindsayBradford/go-dbf | godbf/dbftable.go | SetFieldValue | func (dt *DbfTable) SetFieldValue(row int, fieldIndex int, value string) (err error) {
b := []byte(dt.encoder.ConvertString(value))
fieldLength := int(dt.fields[fieldIndex].length)
//DEBUG
//fmt.Printf("dt.numberOfBytesInHeader=%v\n\n", dt.numberOfBytesInHeader)
//fmt.Printf("dt.lengthOfEachRecord=%v\n\n", dt.lengthOfEachRecord)
// locate the offset of the field in DbfTable dataStore
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
recordOffset := 1
for i := 0; i < len(dt.fields); i++ {
if i == fieldIndex {
break
} else {
recordOffset += int(dt.fields[i].length)
}
}
dt.fillFieldWithBlanks(fieldLength, offset, recordOffset)
// write new value
switch dt.fields[fieldIndex].fieldType {
case Character, Logical, Date:
for i := 0; i < len(b) && i < fieldLength; i++ {
dt.dataStore[offset+recordOffset+i] = b[i]
}
case Float, Numeric:
for i := 0; i < fieldLength; i++ {
// fmt.Printf("i:%v\n", i)
if i < len(b) {
dt.dataStore[offset+recordOffset+(fieldLength-i-1)] = b[(len(b)-1)-i]
} else {
break
}
}
}
return
//fmt.Printf("field value:%#v\n", []byte(value))
//fmt.Printf("field index:%#v\n", fieldIndex)
//fmt.Printf("field fixedFieldLength:%v\n", dt.Fields[fieldIndex].fixedFieldLength)
//fmt.Printf("string to byte:%#v\n", b)
} | go | func (dt *DbfTable) SetFieldValue(row int, fieldIndex int, value string) (err error) {
b := []byte(dt.encoder.ConvertString(value))
fieldLength := int(dt.fields[fieldIndex].length)
//DEBUG
//fmt.Printf("dt.numberOfBytesInHeader=%v\n\n", dt.numberOfBytesInHeader)
//fmt.Printf("dt.lengthOfEachRecord=%v\n\n", dt.lengthOfEachRecord)
// locate the offset of the field in DbfTable dataStore
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
recordOffset := 1
for i := 0; i < len(dt.fields); i++ {
if i == fieldIndex {
break
} else {
recordOffset += int(dt.fields[i].length)
}
}
dt.fillFieldWithBlanks(fieldLength, offset, recordOffset)
// write new value
switch dt.fields[fieldIndex].fieldType {
case Character, Logical, Date:
for i := 0; i < len(b) && i < fieldLength; i++ {
dt.dataStore[offset+recordOffset+i] = b[i]
}
case Float, Numeric:
for i := 0; i < fieldLength; i++ {
// fmt.Printf("i:%v\n", i)
if i < len(b) {
dt.dataStore[offset+recordOffset+(fieldLength-i-1)] = b[(len(b)-1)-i]
} else {
break
}
}
}
return
//fmt.Printf("field value:%#v\n", []byte(value))
//fmt.Printf("field index:%#v\n", fieldIndex)
//fmt.Printf("field fixedFieldLength:%v\n", dt.Fields[fieldIndex].fixedFieldLength)
//fmt.Printf("string to byte:%#v\n", b)
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"SetFieldValue",
"(",
"row",
"int",
",",
"fieldIndex",
"int",
",",
"value",
"string",
")",
"(",
"err",
"error",
")",
"{",
"b",
":=",
"[",
"]",
"byte",
"(",
"dt",
".",
"encoder",
".",
"ConvertString",
"(",
"v... | // SetFieldValue sets the value for the given row and field index as specified
// If the field index is invalid, or the value is incompatible with the field's type, an error is returned. | [
"SetFieldValue",
"sets",
"the",
"value",
"for",
"the",
"given",
"row",
"and",
"field",
"index",
"as",
"specified",
"If",
"the",
"field",
"index",
"is",
"invalid",
"or",
"the",
"value",
"is",
"incompatible",
"with",
"the",
"field",
"s",
"type",
"an",
"error... | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L365-L417 |
15,603 | LindsayBradford/go-dbf | godbf/dbftable.go | FieldValue | func (dt *DbfTable) FieldValue(row int, fieldIndex int) (value string) {
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
recordOffset := 1
for i := 0; i < len(dt.fields); i++ {
if i == fieldIndex {
break
} else {
recordOffset += int(dt.fields[i].length)
}
}
temp := dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.fields[fieldIndex].length))]
enforceBlankPadding(temp)
s := dt.decoder.ConvertString(string(temp))
//fmt.Printf("utf-8 value:[%#v] original value:[%#v]\n", s, string(temp))
value = strings.TrimSpace(s)
//fmt.Printf("raw value:[%#v]\n", dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.Fields[fieldIndex].fixedFieldLength))])
//fmt.Printf("utf-8 value:[%#v]\n", []byte(s))
//value = string(dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.Fields[fieldIndex].fixedFieldLength))])
return
} | go | func (dt *DbfTable) FieldValue(row int, fieldIndex int) (value string) {
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
recordOffset := 1
for i := 0; i < len(dt.fields); i++ {
if i == fieldIndex {
break
} else {
recordOffset += int(dt.fields[i].length)
}
}
temp := dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.fields[fieldIndex].length))]
enforceBlankPadding(temp)
s := dt.decoder.ConvertString(string(temp))
//fmt.Printf("utf-8 value:[%#v] original value:[%#v]\n", s, string(temp))
value = strings.TrimSpace(s)
//fmt.Printf("raw value:[%#v]\n", dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.Fields[fieldIndex].fixedFieldLength))])
//fmt.Printf("utf-8 value:[%#v]\n", []byte(s))
//value = string(dt.dataStore[(offset + recordOffset):((offset + recordOffset) + int(dt.Fields[fieldIndex].fixedFieldLength))])
return
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"FieldValue",
"(",
"row",
"int",
",",
"fieldIndex",
"int",
")",
"(",
"value",
"string",
")",
"{",
"offset",
":=",
"int",
"(",
"dt",
".",
"numberOfBytesInHeader",
")",
"\n",
"lengthOfRecord",
":=",
"int",
"(",
"d... | //FieldValue returns the content for the record at the given row and field index as a string
// If the row or field index is invalid, an error is returned . | [
"FieldValue",
"returns",
"the",
"content",
"for",
"the",
"record",
"at",
"the",
"given",
"row",
"and",
"field",
"index",
"as",
"a",
"string",
"If",
"the",
"row",
"or",
"field",
"index",
"is",
"invalid",
"an",
"error",
"is",
"returned",
"."
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L427-L457 |
15,604 | LindsayBradford/go-dbf | godbf/dbftable.go | Float64FieldValueByName | func (dt *DbfTable) Float64FieldValueByName(row int, fieldName string) (value float64, err error) {
valueAsString, err := dt.FieldValueByName(row, fieldName)
return strconv.ParseFloat(valueAsString, 64)
} | go | func (dt *DbfTable) Float64FieldValueByName(row int, fieldName string) (value float64, err error) {
valueAsString, err := dt.FieldValueByName(row, fieldName)
return strconv.ParseFloat(valueAsString, 64)
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"Float64FieldValueByName",
"(",
"row",
"int",
",",
"fieldName",
"string",
")",
"(",
"value",
"float64",
",",
"err",
"error",
")",
"{",
"valueAsString",
",",
"err",
":=",
"dt",
".",
"FieldValueByName",
"(",
"row",
... | // Float64FieldValueByName returns the value of a field given row number and name provided as a float64 | [
"Float64FieldValueByName",
"returns",
"the",
"value",
"of",
"a",
"field",
"given",
"row",
"number",
"and",
"name",
"provided",
"as",
"a",
"float64"
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L470-L473 |
15,605 | LindsayBradford/go-dbf | godbf/dbftable.go | Int64FieldValueByName | func (dt *DbfTable) Int64FieldValueByName(row int, fieldName string) (value int64, err error) {
valueAsString, err := dt.FieldValueByName(row, fieldName)
return strconv.ParseInt(valueAsString, 0, 64)
} | go | func (dt *DbfTable) Int64FieldValueByName(row int, fieldName string) (value int64, err error) {
valueAsString, err := dt.FieldValueByName(row, fieldName)
return strconv.ParseInt(valueAsString, 0, 64)
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"Int64FieldValueByName",
"(",
"row",
"int",
",",
"fieldName",
"string",
")",
"(",
"value",
"int64",
",",
"err",
"error",
")",
"{",
"valueAsString",
",",
"err",
":=",
"dt",
".",
"FieldValueByName",
"(",
"row",
",",... | // Int64FieldValueByName returns the value of a field given row number and name provided as an int64 | [
"Int64FieldValueByName",
"returns",
"the",
"value",
"of",
"a",
"field",
"given",
"row",
"number",
"and",
"name",
"provided",
"as",
"an",
"int64"
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L476-L479 |
15,606 | LindsayBradford/go-dbf | godbf/dbftable.go | FieldValueByName | func (dt *DbfTable) FieldValueByName(row int, fieldName string) (value string, err error) {
if fieldIndex, entryFound := dt.fieldMap[fieldName]; entryFound {
return dt.FieldValue(row, fieldIndex), err
}
err = errors.New("Field name \"" + fieldName + "\" does not exist")
return
} | go | func (dt *DbfTable) FieldValueByName(row int, fieldName string) (value string, err error) {
if fieldIndex, entryFound := dt.fieldMap[fieldName]; entryFound {
return dt.FieldValue(row, fieldIndex), err
}
err = errors.New("Field name \"" + fieldName + "\" does not exist")
return
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"FieldValueByName",
"(",
"row",
"int",
",",
"fieldName",
"string",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"if",
"fieldIndex",
",",
"entryFound",
":=",
"dt",
".",
"fieldMap",
"[",
"fieldName",
... | // FieldValueByName returns the value of a field given row number and name provided | [
"FieldValueByName",
"returns",
"the",
"value",
"of",
"a",
"field",
"given",
"row",
"number",
"and",
"name",
"provided"
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L482-L488 |
15,607 | LindsayBradford/go-dbf | godbf/dbftable.go | RowIsDeleted | func (dt *DbfTable) RowIsDeleted(row int) bool {
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
return dt.dataStore[offset:(offset + 1)][0] == 0x2A
} | go | func (dt *DbfTable) RowIsDeleted(row int) bool {
offset := int(dt.numberOfBytesInHeader)
lengthOfRecord := int(dt.lengthOfEachRecord)
offset = offset + (row * lengthOfRecord)
return dt.dataStore[offset:(offset + 1)][0] == 0x2A
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"RowIsDeleted",
"(",
"row",
"int",
")",
"bool",
"{",
"offset",
":=",
"int",
"(",
"dt",
".",
"numberOfBytesInHeader",
")",
"\n",
"lengthOfRecord",
":=",
"int",
"(",
"dt",
".",
"lengthOfEachRecord",
")",
"\n",
"offs... | //RowIsDeleted returns whether a row has marked as deleted | [
"RowIsDeleted",
"returns",
"whether",
"a",
"row",
"has",
"marked",
"as",
"deleted"
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L491-L496 |
15,608 | LindsayBradford/go-dbf | godbf/dbftable.go | GetRowAsSlice | func (dt *DbfTable) GetRowAsSlice(row int) []string {
s := make([]string, len(dt.Fields()))
for i := 0; i < len(dt.Fields()); i++ {
s[i] = dt.FieldValue(row, i)
}
return s
} | go | func (dt *DbfTable) GetRowAsSlice(row int) []string {
s := make([]string, len(dt.Fields()))
for i := 0; i < len(dt.Fields()); i++ {
s[i] = dt.FieldValue(row, i)
}
return s
} | [
"func",
"(",
"dt",
"*",
"DbfTable",
")",
"GetRowAsSlice",
"(",
"row",
"int",
")",
"[",
"]",
"string",
"{",
"s",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"len",
"(",
"dt",
".",
"Fields",
"(",
")",
")",
")",
"\n\n",
"for",
"i",
":=",
"0",
";... | // GetRowAsSlice return the record values for the row specified as a string slice | [
"GetRowAsSlice",
"return",
"the",
"record",
"values",
"for",
"the",
"row",
"specified",
"as",
"a",
"string",
"slice"
] | 5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f | https://github.com/LindsayBradford/go-dbf/blob/5f7a16f88561c4d09bd4e74d6c3d1f95e074de3f/godbf/dbftable.go#L499-L508 |
15,609 | sourcegraph/syntaxhighlight | highlight.go | Class | func (c HTMLConfig) Class(kind Kind) string {
switch kind {
case String:
return c.String
case Keyword:
return c.Keyword
case Comment:
return c.Comment
case Type:
return c.Type
case Literal:
return c.Literal
case Punctuation:
return c.Punctuation
case Plaintext:
return c.Plaintext
case Tag:
return c.Tag
case HTMLTag:
return c.HTMLTag
case HTMLAttrName:
return c.HTMLAttrName
case HTMLAttrValue:
return c.HTMLAttrValue
case Decimal:
return c.Decimal
}
return ""
} | go | func (c HTMLConfig) Class(kind Kind) string {
switch kind {
case String:
return c.String
case Keyword:
return c.Keyword
case Comment:
return c.Comment
case Type:
return c.Type
case Literal:
return c.Literal
case Punctuation:
return c.Punctuation
case Plaintext:
return c.Plaintext
case Tag:
return c.Tag
case HTMLTag:
return c.HTMLTag
case HTMLAttrName:
return c.HTMLAttrName
case HTMLAttrValue:
return c.HTMLAttrValue
case Decimal:
return c.Decimal
}
return ""
} | [
"func",
"(",
"c",
"HTMLConfig",
")",
"Class",
"(",
"kind",
"Kind",
")",
"string",
"{",
"switch",
"kind",
"{",
"case",
"String",
":",
"return",
"c",
".",
"String",
"\n",
"case",
"Keyword",
":",
"return",
"c",
".",
"Keyword",
"\n",
"case",
"Comment",
"... | // Class returns the set class for a given token Kind. | [
"Class",
"returns",
"the",
"set",
"class",
"for",
"a",
"given",
"token",
"Kind",
"."
] | bd320f5d308e1a3c4314c678d8227a0d72574ae7 | https://github.com/sourcegraph/syntaxhighlight/blob/bd320f5d308e1a3c4314c678d8227a0d72574ae7/highlight.go#L72-L100 |
15,610 | sourcegraph/syntaxhighlight | highlight.go | NewScannerReader | func NewScannerReader(src io.Reader) *scanner.Scanner {
var s scanner.Scanner
s.Init(src)
s.Error = func(_ *scanner.Scanner, _ string) {}
s.Whitespace = 0
s.Mode = s.Mode ^ scanner.SkipComments
return &s
} | go | func NewScannerReader(src io.Reader) *scanner.Scanner {
var s scanner.Scanner
s.Init(src)
s.Error = func(_ *scanner.Scanner, _ string) {}
s.Whitespace = 0
s.Mode = s.Mode ^ scanner.SkipComments
return &s
} | [
"func",
"NewScannerReader",
"(",
"src",
"io",
".",
"Reader",
")",
"*",
"scanner",
".",
"Scanner",
"{",
"var",
"s",
"scanner",
".",
"Scanner",
"\n",
"s",
".",
"Init",
"(",
"src",
")",
"\n",
"s",
".",
"Error",
"=",
"func",
"(",
"_",
"*",
"scanner",
... | // NewScannerReader takes a reader src and creates a Scanner. | [
"NewScannerReader",
"takes",
"a",
"reader",
"src",
"and",
"creates",
"a",
"Scanner",
"."
] | bd320f5d308e1a3c4314c678d8227a0d72574ae7 | https://github.com/sourcegraph/syntaxhighlight/blob/bd320f5d308e1a3c4314c678d8227a0d72574ae7/highlight.go#L265-L272 |
15,611 | istio/glog | glog.go | V | func V(level Level) Verbose {
return Verbose(zap.L().Core().Enabled(zap.DebugLevel))
} | go | func V(level Level) Verbose {
return Verbose(zap.L().Core().Enabled(zap.DebugLevel))
} | [
"func",
"V",
"(",
"level",
"Level",
")",
"Verbose",
"{",
"return",
"Verbose",
"(",
"zap",
".",
"L",
"(",
")",
".",
"Core",
"(",
")",
".",
"Enabled",
"(",
"zap",
".",
"DebugLevel",
")",
")",
"\n",
"}"
] | // V is a shim | [
"V",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L42-L44 |
15,612 | istio/glog | glog.go | Infof | func (v Verbose) Infof(format string, args ...interface{}) {
zap.S().Debugf(format, args...)
} | go | func (v Verbose) Infof(format string, args ...interface{}) {
zap.S().Debugf(format, args...)
} | [
"func",
"(",
"v",
"Verbose",
")",
"Infof",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"zap",
".",
"S",
"(",
")",
".",
"Debugf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] | // Infof is a shim | [
"Infof",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L58-L60 |
15,613 | istio/glog | glog.go | Warningln | func Warningln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Warn(s, "\n")
} | go | func Warningln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Warn(s, "\n")
} | [
"func",
"Warningln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
":=",
"fmt",
".",
"Sprint",
"(",
"args",
")",
"\n",
"zap",
".",
"S",
"(",
")",
".",
"Warn",
"(",
"s",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] | // Warningln is a shim | [
"Warningln",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L94-L97 |
15,614 | istio/glog | glog.go | Errorln | func Errorln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Error(s, "\n")
} | go | func Errorln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Error(s, "\n")
} | [
"func",
"Errorln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
":=",
"fmt",
".",
"Sprint",
"(",
"args",
")",
"\n",
"zap",
".",
"S",
"(",
")",
".",
"Error",
"(",
"s",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"}"
] | // Errorln is a shim | [
"Errorln",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L115-L118 |
15,615 | istio/glog | glog.go | ExitDepth | func ExitDepth(depth int, args ...interface{}) {
zap.S().Error(args...)
os.Exit(1)
} | go | func ExitDepth(depth int, args ...interface{}) {
zap.S().Error(args...)
os.Exit(1)
} | [
"func",
"ExitDepth",
"(",
"depth",
"int",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"zap",
".",
"S",
"(",
")",
".",
"Error",
"(",
"args",
"...",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}"
] | // ExitDepth is a shim | [
"ExitDepth",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L157-L160 |
15,616 | istio/glog | glog.go | Exitln | func Exitln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Error(s, "\n")
os.Exit(1)
} | go | func Exitln(args ...interface{}) {
s := fmt.Sprint(args)
zap.S().Error(s, "\n")
os.Exit(1)
} | [
"func",
"Exitln",
"(",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
":=",
"fmt",
".",
"Sprint",
"(",
"args",
")",
"\n",
"zap",
".",
"S",
"(",
")",
".",
"Error",
"(",
"s",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"os",
".",
"Exit",
"(",
"1... | // Exitln is a shim | [
"Exitln",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L163-L167 |
15,617 | istio/glog | glog.go | Exitf | func Exitf(format string, args ...interface{}) {
zap.S().Errorf(format, args...)
os.Exit(1)
} | go | func Exitf(format string, args ...interface{}) {
zap.S().Errorf(format, args...)
os.Exit(1)
} | [
"func",
"Exitf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"zap",
".",
"S",
"(",
")",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}"
] | // Exitf is a shim | [
"Exitf",
"is",
"a",
"shim"
] | d7cfb6fa2ccda15565f68f204d68907c80a5c977 | https://github.com/istio/glog/blob/d7cfb6fa2ccda15565f68f204d68907c80a5c977/glog.go#L170-L173 |
15,618 | volatiletech/abcweb | abcsessions/redis.go | All | func (r *RedisStorer) All() ([]string, error) {
var sessions []string
iter := r.client.Scan(0, "", 0).Iterator()
for iter.Next() {
sessions = append(sessions, iter.Val())
}
err := iter.Err()
return sessions, errors.Wrap(err, "unable to iterate redis store")
} | go | func (r *RedisStorer) All() ([]string, error) {
var sessions []string
iter := r.client.Scan(0, "", 0).Iterator()
for iter.Next() {
sessions = append(sessions, iter.Val())
}
err := iter.Err()
return sessions, errors.Wrap(err, "unable to iterate redis store")
} | [
"func",
"(",
"r",
"*",
"RedisStorer",
")",
"All",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"sessions",
"[",
"]",
"string",
"\n\n",
"iter",
":=",
"r",
".",
"client",
".",
"Scan",
"(",
"0",
",",
"\"",
"\"",
",",
"0",
")... | // All keys in the redis store | [
"All",
"keys",
"in",
"the",
"redis",
"store"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/redis.go#L51-L60 |
15,619 | volatiletech/abcweb | abcsessions/cookie_overseer.go | NewCookieOverseer | func NewCookieOverseer(opts CookieOptions, secretKey []byte) *CookieOverseer {
if len(opts.Name) == 0 {
panic("cookie name must be provided")
}
block, err := aes.NewCipher(secretKey)
if err != nil {
panic(err)
}
gcm, err := cipher.NewGCM(block)
if err != nil {
panic(err)
}
o := &CookieOverseer{
options: opts,
secretKey: secretKey,
gcmBlockMode: gcm,
}
o.resetExpiryMiddleware.resetter = o
return o
} | go | func NewCookieOverseer(opts CookieOptions, secretKey []byte) *CookieOverseer {
if len(opts.Name) == 0 {
panic("cookie name must be provided")
}
block, err := aes.NewCipher(secretKey)
if err != nil {
panic(err)
}
gcm, err := cipher.NewGCM(block)
if err != nil {
panic(err)
}
o := &CookieOverseer{
options: opts,
secretKey: secretKey,
gcmBlockMode: gcm,
}
o.resetExpiryMiddleware.resetter = o
return o
} | [
"func",
"NewCookieOverseer",
"(",
"opts",
"CookieOptions",
",",
"secretKey",
"[",
"]",
"byte",
")",
"*",
"CookieOverseer",
"{",
"if",
"len",
"(",
"opts",
".",
"Name",
")",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"block",
","... | // NewCookieOverseer creates an overseer from cookie options and a secret key
// for use in encryption. Panic's on any errors that deal with cryptography. | [
"NewCookieOverseer",
"creates",
"an",
"overseer",
"from",
"cookie",
"options",
"and",
"a",
"secret",
"key",
"for",
"use",
"in",
"encryption",
".",
"Panic",
"s",
"on",
"any",
"errors",
"that",
"deal",
"with",
"cryptography",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L27-L50 |
15,620 | volatiletech/abcweb | abcsessions/cookie_overseer.go | Get | func (c *CookieOverseer) Get(w http.ResponseWriter, r *http.Request) (string, error) {
val, err := c.options.getCookieValue(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session value from cookie")
}
return c.decode(val)
} | go | func (c *CookieOverseer) Get(w http.ResponseWriter, r *http.Request) (string, error) {
val, err := c.options.getCookieValue(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session value from cookie")
}
return c.decode(val)
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"Get",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"val",
",",
"err",
":=",
"c",
".",
"options",
".",
"getCookieValue",
"(... | // Get a value from the cookie overseer | [
"Get",
"a",
"value",
"from",
"the",
"cookie",
"overseer"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L53-L60 |
15,621 | volatiletech/abcweb | abcsessions/cookie_overseer.go | Set | func (c *CookieOverseer) Set(w http.ResponseWriter, r *http.Request, value string) error {
ev, err := c.encode(value)
if err != nil {
return errors.Wrap(err, "unable to encode session value into cookie")
}
w.(cookieWriter).SetCookie(c.options.makeCookie(ev))
return nil
} | go | func (c *CookieOverseer) Set(w http.ResponseWriter, r *http.Request, value string) error {
ev, err := c.encode(value)
if err != nil {
return errors.Wrap(err, "unable to encode session value into cookie")
}
w.(cookieWriter).SetCookie(c.options.makeCookie(ev))
return nil
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"Set",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"value",
"string",
")",
"error",
"{",
"ev",
",",
"err",
":=",
"c",
".",
"encode",
"(",
"value",
")",
"\n",
"... | // Set a value into the cookie overseer | [
"Set",
"a",
"value",
"into",
"the",
"cookie",
"overseer"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L63-L72 |
15,622 | volatiletech/abcweb | abcsessions/cookie_overseer.go | Del | func (c *CookieOverseer) Del(w http.ResponseWriter, r *http.Request) error {
c.options.deleteCookie(w)
return nil
} | go | func (c *CookieOverseer) Del(w http.ResponseWriter, r *http.Request) error {
c.options.deleteCookie(w)
return nil
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"Del",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"c",
".",
"options",
".",
"deleteCookie",
"(",
"w",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Del a value from the cookie overseer | [
"Del",
"a",
"value",
"from",
"the",
"cookie",
"overseer"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L75-L78 |
15,623 | volatiletech/abcweb | abcsessions/cookie_overseer.go | Regenerate | func (c *CookieOverseer) Regenerate(w http.ResponseWriter, r *http.Request) error {
panic("cookie sessions do not use session ids")
} | go | func (c *CookieOverseer) Regenerate(w http.ResponseWriter, r *http.Request) error {
panic("cookie sessions do not use session ids")
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"Regenerate",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // Regenerate for the cookie overseer will panic because cookie sessions
// do not have session IDs, only values. | [
"Regenerate",
"for",
"the",
"cookie",
"overseer",
"will",
"panic",
"because",
"cookie",
"sessions",
"do",
"not",
"have",
"session",
"IDs",
"only",
"values",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L82-L84 |
15,624 | volatiletech/abcweb | abcsessions/cookie_overseer.go | SessionID | func (c *CookieOverseer) SessionID(w http.ResponseWriter, r *http.Request) (string, error) {
panic("cookie sessions do not use session ids")
} | go | func (c *CookieOverseer) SessionID(w http.ResponseWriter, r *http.Request) (string, error) {
panic("cookie sessions do not use session ids")
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"SessionID",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // SessionID for the cookie overseer will panic because cookie sessions
// do not have session IDs, only values. | [
"SessionID",
"for",
"the",
"cookie",
"overseer",
"will",
"panic",
"because",
"cookie",
"sessions",
"do",
"not",
"have",
"session",
"IDs",
"only",
"values",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L88-L90 |
15,625 | volatiletech/abcweb | abcsessions/cookie_overseer.go | encode | func (c *CookieOverseer) encode(plaintext string) (string, error) {
nonce := make([]byte, c.gcmBlockMode.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return "", errors.Wrap(err, "failed to encode session cookie value")
}
// Append ciphertext to the end of nonce so we have the nonce for decrypt
ciphertext := c.gcmBlockMode.Seal(nonce, nonce, []byte(plaintext), nil)
return base64.StdEncoding.EncodeToString(ciphertext), nil
} | go | func (c *CookieOverseer) encode(plaintext string) (string, error) {
nonce := make([]byte, c.gcmBlockMode.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return "", errors.Wrap(err, "failed to encode session cookie value")
}
// Append ciphertext to the end of nonce so we have the nonce for decrypt
ciphertext := c.gcmBlockMode.Seal(nonce, nonce, []byte(plaintext), nil)
return base64.StdEncoding.EncodeToString(ciphertext), nil
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"encode",
"(",
"plaintext",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"nonce",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"c",
".",
"gcmBlockMode",
".",
"NonceSize",
"(",
")",
")",
"\n",
"if"... | // encode into base64'd aes-gcm | [
"encode",
"into",
"base64",
"d",
"aes",
"-",
"gcm"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L110-L119 |
15,626 | volatiletech/abcweb | abcsessions/cookie_overseer.go | decode | func (c *CookieOverseer) decode(ciphertext string) (string, error) {
ct, err := base64.StdEncoding.DecodeString(ciphertext)
if err != nil {
return "", nil
}
if len(ct) <= c.gcmBlockMode.NonceSize() {
return "", errors.New("failed to decode session cookie value")
}
// Nonce comes from the first n bytes (n = NonceSize)
plaintext, err := c.gcmBlockMode.Open(nil,
ct[:c.gcmBlockMode.NonceSize()],
ct[c.gcmBlockMode.NonceSize():],
nil)
if err != nil {
return "", errors.Wrap(err, "unable to open gcm block mode")
}
return string(plaintext), nil
} | go | func (c *CookieOverseer) decode(ciphertext string) (string, error) {
ct, err := base64.StdEncoding.DecodeString(ciphertext)
if err != nil {
return "", nil
}
if len(ct) <= c.gcmBlockMode.NonceSize() {
return "", errors.New("failed to decode session cookie value")
}
// Nonce comes from the first n bytes (n = NonceSize)
plaintext, err := c.gcmBlockMode.Open(nil,
ct[:c.gcmBlockMode.NonceSize()],
ct[c.gcmBlockMode.NonceSize():],
nil)
if err != nil {
return "", errors.Wrap(err, "unable to open gcm block mode")
}
return string(plaintext), nil
} | [
"func",
"(",
"c",
"*",
"CookieOverseer",
")",
"decode",
"(",
"ciphertext",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"ct",
",",
"err",
":=",
"base64",
".",
"StdEncoding",
".",
"DecodeString",
"(",
"ciphertext",
")",
"\n",
"if",
"err",
"!=",... | // decode base64'd aes-gcm | [
"decode",
"base64",
"d",
"aes",
"-",
"gcm"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_overseer.go#L122-L143 |
15,627 | volatiletech/abcweb | abcmiddleware/log.go | Zap | func (m Middleware) Zap(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
t := time.Now()
zw := &zapResponseWriter{ResponseWriter: w}
// Serve the request
next.ServeHTTP(zw, r)
// Write the request log line
writeZap(m.Log, r, t, zw.status, zw.size)
}
return http.HandlerFunc(fn)
} | go | func (m Middleware) Zap(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
t := time.Now()
zw := &zapResponseWriter{ResponseWriter: w}
// Serve the request
next.ServeHTTP(zw, r)
// Write the request log line
writeZap(m.Log, r, t, zw.status, zw.size)
}
return http.HandlerFunc(fn)
} | [
"func",
"(",
"m",
"Middleware",
")",
"Zap",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"t",
":=",
"time",
".... | // Zap middleware handles web request logging using Zap | [
"Zap",
"middleware",
"handles",
"web",
"request",
"logging",
"using",
"Zap"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/log.go#L21-L34 |
15,628 | volatiletech/abcweb | abcmiddleware/log.go | RequestIDLogger | func (m Middleware) RequestIDLogger(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
requestID := chimiddleware.GetReqID(r.Context())
derivedLogger := m.Log.With(zap.String("request_id", requestID))
r = r.WithContext(context.WithValue(r.Context(), CtxLoggerKey, derivedLogger))
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | go | func (m Middleware) RequestIDLogger(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
requestID := chimiddleware.GetReqID(r.Context())
derivedLogger := m.Log.With(zap.String("request_id", requestID))
r = r.WithContext(context.WithValue(r.Context(), CtxLoggerKey, derivedLogger))
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | [
"func",
"(",
"m",
"Middleware",
")",
"RequestIDLogger",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"requestID",
... | // RequestIDLogger middleware creates a derived logger to include logging of the
// Request ID, and inserts it into the context object | [
"RequestIDLogger",
"middleware",
"creates",
"a",
"derived",
"logger",
"to",
"include",
"logging",
"of",
"the",
"Request",
"ID",
"and",
"inserts",
"it",
"into",
"the",
"context",
"object"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/log.go#L38-L47 |
15,629 | volatiletech/abcweb | abcmiddleware/log.go | Log | func Log(r *http.Request) *zap.Logger {
v := r.Context().Value(CtxLoggerKey)
log, ok := v.(*zap.Logger)
if !ok {
panic("cannot get derived request id logger from context object")
}
return log
} | go | func Log(r *http.Request) *zap.Logger {
v := r.Context().Value(CtxLoggerKey)
log, ok := v.(*zap.Logger)
if !ok {
panic("cannot get derived request id logger from context object")
}
return log
} | [
"func",
"Log",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"*",
"zap",
".",
"Logger",
"{",
"v",
":=",
"r",
".",
"Context",
"(",
")",
".",
"Value",
"(",
"CtxLoggerKey",
")",
"\n",
"log",
",",
"ok",
":=",
"v",
".",
"(",
"*",
"zap",
".",
"Logger... | // Log returns the Request ID scoped logger from the request Context
// and panics if it cannot be found. This function is only ever used
// by your controllers if your app uses the RequestID middlewares,
// otherwise you should use the controller's receiver logger directly. | [
"Log",
"returns",
"the",
"Request",
"ID",
"scoped",
"logger",
"from",
"the",
"request",
"Context",
"and",
"panics",
"if",
"it",
"cannot",
"be",
"found",
".",
"This",
"function",
"is",
"only",
"ever",
"used",
"by",
"your",
"controllers",
"if",
"your",
"app"... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/log.go#L53-L60 |
15,630 | volatiletech/abcweb | abcmiddleware/recover.go | Recover | func (m Middleware) Recover(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
var protocol string
if r.TLS == nil {
protocol = "http"
} else {
protocol = "https"
}
var log *zap.Logger
v := r.Context().Value(CtxLoggerKey)
if v != nil {
var ok bool
log, ok = v.(*zap.Logger)
if !ok {
panic("cannot get derived request id logger from context object")
}
// log with the request_id scoped logger
log.Error(fmt.Sprintf("%s request error", protocol),
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
zap.String("error", fmt.Sprintf("%+v", err)),
)
} else {
// log with the logger attached to middleware struct if
// cannot find request_id scoped logger
m.Log.Error(fmt.Sprintf("%s request error", protocol),
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
zap.String("error", fmt.Sprintf("%+v", err)),
)
}
// Return a http 500 with the HTTP body of "Internal Server Error"
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
}()
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | go | func (m Middleware) Recover(next http.Handler) http.Handler {
fn := func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
var protocol string
if r.TLS == nil {
protocol = "http"
} else {
protocol = "https"
}
var log *zap.Logger
v := r.Context().Value(CtxLoggerKey)
if v != nil {
var ok bool
log, ok = v.(*zap.Logger)
if !ok {
panic("cannot get derived request id logger from context object")
}
// log with the request_id scoped logger
log.Error(fmt.Sprintf("%s request error", protocol),
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
zap.String("error", fmt.Sprintf("%+v", err)),
)
} else {
// log with the logger attached to middleware struct if
// cannot find request_id scoped logger
m.Log.Error(fmt.Sprintf("%s request error", protocol),
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
zap.String("error", fmt.Sprintf("%+v", err)),
)
}
// Return a http 500 with the HTTP body of "Internal Server Error"
http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
}
}()
next.ServeHTTP(w, r)
}
return http.HandlerFunc(fn)
} | [
"func",
"(",
"m",
"Middleware",
")",
"Recover",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"fn",
":=",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"defer",
"func",
"(... | // Recover middleware recovers panics that occur and gracefully logs their error | [
"Recover",
"middleware",
"recovers",
"panics",
"that",
"occur",
"and",
"gracefully",
"logs",
"their",
"error"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/recover.go#L11-L63 |
15,631 | volatiletech/abcweb | cert/cert.go | Template | func Template(appName, commonName string) (*x509.Certificate, error) {
// generate a random serial number (a real cert authority would have some logic behind this)
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
return nil, errors.New("failed to generate serial number: " + err.Error())
}
tmpl := x509.Certificate{
IsCA: true,
SerialNumber: serialNumber,
Subject: pkix.Name{
Organization: []string{appName},
CommonName: commonName,
},
SignatureAlgorithm: x509.SHA256WithRSA,
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour * 24 * 365 * 4), // valid for 4 years
BasicConstraintsValid: true,
}
return &tmpl, nil
} | go | func Template(appName, commonName string) (*x509.Certificate, error) {
// generate a random serial number (a real cert authority would have some logic behind this)
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
if err != nil {
return nil, errors.New("failed to generate serial number: " + err.Error())
}
tmpl := x509.Certificate{
IsCA: true,
SerialNumber: serialNumber,
Subject: pkix.Name{
Organization: []string{appName},
CommonName: commonName,
},
SignatureAlgorithm: x509.SHA256WithRSA,
NotBefore: time.Now(),
NotAfter: time.Now().Add(time.Hour * 24 * 365 * 4), // valid for 4 years
BasicConstraintsValid: true,
}
return &tmpl, nil
} | [
"func",
"Template",
"(",
"appName",
",",
"commonName",
"string",
")",
"(",
"*",
"x509",
".",
"Certificate",
",",
"error",
")",
"{",
"// generate a random serial number (a real cert authority would have some logic behind this)",
"serialNumberLimit",
":=",
"new",
"(",
"big"... | // Template is a helper function to create a cert template with a
// serial number and other required fields | [
"Template",
"is",
"a",
"helper",
"function",
"to",
"create",
"a",
"cert",
"template",
"with",
"a",
"serial",
"number",
"and",
"other",
"required",
"fields"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cert/cert.go#L18-L41 |
15,632 | volatiletech/abcweb | cert/cert.go | WriteCertFile | func WriteCertFile(outFile afero.File, template *x509.Certificate, pub interface{}, priv interface{}) error {
certDER, err := x509.CreateCertificate(rand.Reader, template, template, pub, priv)
if err != nil {
return err
}
// PEM encode the certificate (this is a standard TLS encoding)
b := &pem.Block{
Type: "CERTIFICATE",
Bytes: certDER,
}
return pem.Encode(outFile, b)
} | go | func WriteCertFile(outFile afero.File, template *x509.Certificate, pub interface{}, priv interface{}) error {
certDER, err := x509.CreateCertificate(rand.Reader, template, template, pub, priv)
if err != nil {
return err
}
// PEM encode the certificate (this is a standard TLS encoding)
b := &pem.Block{
Type: "CERTIFICATE",
Bytes: certDER,
}
return pem.Encode(outFile, b)
} | [
"func",
"WriteCertFile",
"(",
"outFile",
"afero",
".",
"File",
",",
"template",
"*",
"x509",
".",
"Certificate",
",",
"pub",
"interface",
"{",
"}",
",",
"priv",
"interface",
"{",
"}",
")",
"error",
"{",
"certDER",
",",
"err",
":=",
"x509",
".",
"Create... | // WriteCertFile writes the cert.pem certificate file | [
"WriteCertFile",
"writes",
"the",
"cert",
".",
"pem",
"certificate",
"file"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cert/cert.go#L44-L57 |
15,633 | volatiletech/abcweb | cert/cert.go | WritePrivateKey | func WritePrivateKey(outFile afero.File, key *rsa.PrivateKey) error {
b := &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(key),
}
return pem.Encode(outFile, b)
} | go | func WritePrivateKey(outFile afero.File, key *rsa.PrivateKey) error {
b := &pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(key),
}
return pem.Encode(outFile, b)
} | [
"func",
"WritePrivateKey",
"(",
"outFile",
"afero",
".",
"File",
",",
"key",
"*",
"rsa",
".",
"PrivateKey",
")",
"error",
"{",
"b",
":=",
"&",
"pem",
".",
"Block",
"{",
"Type",
":",
"\"",
"\"",
",",
"Bytes",
":",
"x509",
".",
"MarshalPKCS1PrivateKey",
... | // WritePrivateKey writes the private.key private key file | [
"WritePrivateKey",
"writes",
"the",
"private",
".",
"key",
"private",
"key",
"file"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cert/cert.go#L60-L67 |
15,634 | volatiletech/abcweb | abcserver/routes.go | NewNotFoundHandler | func NewNotFoundHandler(manifest map[string]string) *NotFound {
return &NotFound{
Templates: NotFoundTemplates{
NotFound: "errors/404",
InternalServerError: "errors/500",
},
AssetsManifest: manifest,
}
} | go | func NewNotFoundHandler(manifest map[string]string) *NotFound {
return &NotFound{
Templates: NotFoundTemplates{
NotFound: "errors/404",
InternalServerError: "errors/500",
},
AssetsManifest: manifest,
}
} | [
"func",
"NewNotFoundHandler",
"(",
"manifest",
"map",
"[",
"string",
"]",
"string",
")",
"*",
"NotFound",
"{",
"return",
"&",
"NotFound",
"{",
"Templates",
":",
"NotFoundTemplates",
"{",
"NotFound",
":",
"\"",
"\"",
",",
"InternalServerError",
":",
"\"",
"\"... | // NewNotFoundHandler creates a new handler | [
"NewNotFoundHandler",
"creates",
"a",
"new",
"handler"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcserver/routes.go#L49-L57 |
15,635 | volatiletech/abcweb | abcserver/routes.go | Handler | func (m *MethodNotAllowed) Handler(render abcrender.Renderer) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// Get the Request ID scoped logger
log := abcmiddleware.Log(r)
log.Warn("method not allowed",
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
)
if err := render.HTML(w, http.StatusMethodNotAllowed, m.Templates.MethodNotAllowed, nil); err != nil {
panic(err)
}
}
} | go | func (m *MethodNotAllowed) Handler(render abcrender.Renderer) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// Get the Request ID scoped logger
log := abcmiddleware.Log(r)
log.Warn("method not allowed",
zap.String("method", r.Method),
zap.String("uri", r.RequestURI),
zap.Bool("tls", r.TLS != nil),
zap.String("protocol", r.Proto),
zap.String("host", r.Host),
zap.String("remote_addr", r.RemoteAddr),
)
if err := render.HTML(w, http.StatusMethodNotAllowed, m.Templates.MethodNotAllowed, nil); err != nil {
panic(err)
}
}
} | [
"func",
"(",
"m",
"*",
"MethodNotAllowed",
")",
"Handler",
"(",
"render",
"abcrender",
".",
"Renderer",
")",
"http",
".",
"HandlerFunc",
"{",
"return",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"/... | // Handler is a wrapper around the MethodNotAllowed handler.
// The MethodNotAllowed handler is called when someone attempts an operation
// against a route that does not support that operation, for example
// attempting a POST against a route that only supports a GET. | [
"Handler",
"is",
"a",
"wrapper",
"around",
"the",
"MethodNotAllowed",
"handler",
".",
"The",
"MethodNotAllowed",
"handler",
"is",
"called",
"when",
"someone",
"attempts",
"an",
"operation",
"against",
"a",
"route",
"that",
"does",
"not",
"support",
"that",
"oper... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcserver/routes.go#L168-L186 |
15,636 | volatiletech/abcweb | abcconfig/config.go | Bind | func (c *Config) Bind(flags *pflag.FlagSet, cfg interface{}) (*viper.Viper, error) {
v, err := c.NewSubViper(flags, cfg)
if err != nil {
return v, err
}
if err := UnmarshalAppConfig(cfg, v); err != nil {
return v, err
}
val := reflect.Indirect(reflect.ValueOf(cfg))
// Check if there's a DBConfig object in the cfg struct.
// If found, then validate all fields on it are set appropriately.
for i := 0; i < val.NumField(); i++ {
dbCfg, ok := val.Field(i).Interface().(DBConfig)
if !ok {
continue
}
if err := ValidateDBConfig(dbCfg); err != nil {
return v, err
}
break
}
return v, nil
} | go | func (c *Config) Bind(flags *pflag.FlagSet, cfg interface{}) (*viper.Viper, error) {
v, err := c.NewSubViper(flags, cfg)
if err != nil {
return v, err
}
if err := UnmarshalAppConfig(cfg, v); err != nil {
return v, err
}
val := reflect.Indirect(reflect.ValueOf(cfg))
// Check if there's a DBConfig object in the cfg struct.
// If found, then validate all fields on it are set appropriately.
for i := 0; i < val.NumField(); i++ {
dbCfg, ok := val.Field(i).Interface().(DBConfig)
if !ok {
continue
}
if err := ValidateDBConfig(dbCfg); err != nil {
return v, err
}
break
}
return v, nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"Bind",
"(",
"flags",
"*",
"pflag",
".",
"FlagSet",
",",
"cfg",
"interface",
"{",
"}",
")",
"(",
"*",
"viper",
".",
"Viper",
",",
"error",
")",
"{",
"v",
",",
"err",
":=",
"c",
".",
"NewSubViper",
"(",
"fla... | // Bind your passed in config flags to a new viper
// instance, retrieves the active environment section of your config file using
// that viper instance, and then loads your server and db config into
// the passed in cfg struct and validates the db config is set appropriately. | [
"Bind",
"your",
"passed",
"in",
"config",
"flags",
"to",
"a",
"new",
"viper",
"instance",
"retrieves",
"the",
"active",
"environment",
"section",
"of",
"your",
"config",
"file",
"using",
"that",
"viper",
"instance",
"and",
"then",
"loads",
"your",
"server",
... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L116-L142 |
15,637 | volatiletech/abcweb | abcconfig/config.go | NewSubViper | func (c *Config) NewSubViper(flags *pflag.FlagSet, cfg interface{}) (*viper.Viper, error) {
v := viper.New()
if flags != nil {
if err := v.BindPFlags(flags); err != nil {
return nil, err
}
}
if err := c.ConfigureViper(v); err != nil {
return nil, err
}
// Use the env from the config if it's not explicitly set
env := c.LoadEnv
if env == "" {
env = v.GetString("env")
}
v = v.Sub(env)
if v == nil {
return nil, fmt.Errorf("cannot find env section named %s", env)
}
mappings, err := GetTagMappings(cfg)
if err != nil {
return nil, errors.Wrap(err, "unable to get tag mappings for config struct")
}
if c.EnvPrefix != "" {
for _, m := range mappings {
v.BindEnv(m.chain, strings.Join([]string{c.EnvPrefix, m.env}, "_"))
}
} else {
for _, m := range mappings {
v.BindEnv(m.chain, m.env)
}
}
if v == nil {
return nil, fmt.Errorf("unable to load environment %q from %q", env, c.File)
}
if flags != nil {
if err := v.BindPFlags(flags); err != nil {
return nil, err
}
}
v.Set("env", env)
return v, nil
} | go | func (c *Config) NewSubViper(flags *pflag.FlagSet, cfg interface{}) (*viper.Viper, error) {
v := viper.New()
if flags != nil {
if err := v.BindPFlags(flags); err != nil {
return nil, err
}
}
if err := c.ConfigureViper(v); err != nil {
return nil, err
}
// Use the env from the config if it's not explicitly set
env := c.LoadEnv
if env == "" {
env = v.GetString("env")
}
v = v.Sub(env)
if v == nil {
return nil, fmt.Errorf("cannot find env section named %s", env)
}
mappings, err := GetTagMappings(cfg)
if err != nil {
return nil, errors.Wrap(err, "unable to get tag mappings for config struct")
}
if c.EnvPrefix != "" {
for _, m := range mappings {
v.BindEnv(m.chain, strings.Join([]string{c.EnvPrefix, m.env}, "_"))
}
} else {
for _, m := range mappings {
v.BindEnv(m.chain, m.env)
}
}
if v == nil {
return nil, fmt.Errorf("unable to load environment %q from %q", env, c.File)
}
if flags != nil {
if err := v.BindPFlags(flags); err != nil {
return nil, err
}
}
v.Set("env", env)
return v, nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"NewSubViper",
"(",
"flags",
"*",
"pflag",
".",
"FlagSet",
",",
"cfg",
"interface",
"{",
"}",
")",
"(",
"*",
"viper",
".",
"Viper",
",",
"error",
")",
"{",
"v",
":=",
"viper",
".",
"New",
"(",
")",
"\n\n",
... | // NewSubViper returns a viper instance activated against the active environment
// configuration subsection and initialized with the config.toml
// configuration file and the environment variable prefix.
// It also takes in the configuration struct so that it can generate the env
// mappings. | [
"NewSubViper",
"returns",
"a",
"viper",
"instance",
"activated",
"against",
"the",
"active",
"environment",
"configuration",
"subsection",
"and",
"initialized",
"with",
"the",
"config",
".",
"toml",
"configuration",
"file",
"and",
"the",
"environment",
"variable",
"... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L149-L200 |
15,638 | volatiletech/abcweb | abcconfig/config.go | ConfigureViper | func (c *Config) ConfigureViper(v *viper.Viper) error {
v.SetConfigType("toml")
v.SetConfigFile(c.File)
v.SetEnvPrefix(c.EnvPrefix)
v.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
if err := v.ReadInConfig(); err != nil {
return err
}
v.AutomaticEnv()
return nil
} | go | func (c *Config) ConfigureViper(v *viper.Viper) error {
v.SetConfigType("toml")
v.SetConfigFile(c.File)
v.SetEnvPrefix(c.EnvPrefix)
v.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
if err := v.ReadInConfig(); err != nil {
return err
}
v.AutomaticEnv()
return nil
} | [
"func",
"(",
"c",
"*",
"Config",
")",
"ConfigureViper",
"(",
"v",
"*",
"viper",
".",
"Viper",
")",
"error",
"{",
"v",
".",
"SetConfigType",
"(",
"\"",
"\"",
")",
"\n",
"v",
".",
"SetConfigFile",
"(",
"c",
".",
"File",
")",
"\n",
"v",
".",
"SetEnv... | // ConfigureViper sets the viper object to use the passed in config toml file
// and also configures the configuration environment variables. | [
"ConfigureViper",
"sets",
"the",
"viper",
"object",
"to",
"use",
"the",
"passed",
"in",
"config",
"toml",
"file",
"and",
"also",
"configures",
"the",
"configuration",
"environment",
"variables",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L204-L215 |
15,639 | volatiletech/abcweb | abcconfig/config.go | UnmarshalAppConfig | func UnmarshalAppConfig(cfg interface{}, v *viper.Viper) error {
err := v.Unmarshal(cfg)
if err != nil {
return err
}
val := reflect.Indirect(reflect.ValueOf(cfg))
// if cfg has an imbedded AppConfig then we need to unmarshal
// directly into that and overwrite it in the parent struct,
// since its another layer of indirection and viper
// can't handle it magically.
for i := 0; i < val.NumField(); i++ {
appCfg, ok := val.Field(i).Interface().(AppConfig)
if !ok {
continue
}
v.Unmarshal(&appCfg)
val.Field(i).Set(reflect.ValueOf(appCfg))
// overwrite val to point to the AppConfig so DBConfig can be set below.
val = val.Field(i)
break
}
// Find *DBConfig and set object appropriately
for i := 0; i < val.NumField(); i++ {
dbCfg, ok := val.Field(i).Interface().(DBConfig)
if !ok {
continue
}
if dbCfg.DB == "postgres" {
if dbCfg.Port == 0 {
dbCfg.Port = 5432
}
if dbCfg.SSLMode == "" {
dbCfg.SSLMode = "require"
}
} else if dbCfg.DB == "mysql" {
if dbCfg.Port == 0 {
dbCfg.Port = 3306
}
if dbCfg.SSLMode == "" {
dbCfg.SSLMode = "true"
}
}
val.Field(i).Set(reflect.ValueOf(dbCfg))
// Finished working on the db cfg struct, so break out
break
}
return nil
} | go | func UnmarshalAppConfig(cfg interface{}, v *viper.Viper) error {
err := v.Unmarshal(cfg)
if err != nil {
return err
}
val := reflect.Indirect(reflect.ValueOf(cfg))
// if cfg has an imbedded AppConfig then we need to unmarshal
// directly into that and overwrite it in the parent struct,
// since its another layer of indirection and viper
// can't handle it magically.
for i := 0; i < val.NumField(); i++ {
appCfg, ok := val.Field(i).Interface().(AppConfig)
if !ok {
continue
}
v.Unmarshal(&appCfg)
val.Field(i).Set(reflect.ValueOf(appCfg))
// overwrite val to point to the AppConfig so DBConfig can be set below.
val = val.Field(i)
break
}
// Find *DBConfig and set object appropriately
for i := 0; i < val.NumField(); i++ {
dbCfg, ok := val.Field(i).Interface().(DBConfig)
if !ok {
continue
}
if dbCfg.DB == "postgres" {
if dbCfg.Port == 0 {
dbCfg.Port = 5432
}
if dbCfg.SSLMode == "" {
dbCfg.SSLMode = "require"
}
} else if dbCfg.DB == "mysql" {
if dbCfg.Port == 0 {
dbCfg.Port = 3306
}
if dbCfg.SSLMode == "" {
dbCfg.SSLMode = "true"
}
}
val.Field(i).Set(reflect.ValueOf(dbCfg))
// Finished working on the db cfg struct, so break out
break
}
return nil
} | [
"func",
"UnmarshalAppConfig",
"(",
"cfg",
"interface",
"{",
"}",
",",
"v",
"*",
"viper",
".",
"Viper",
")",
"error",
"{",
"err",
":=",
"v",
".",
"Unmarshal",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
... | // UnmarshalAppConfig unmarshals the viper's configured config file
// into the passed in cfg object containing an AppConfig | [
"UnmarshalAppConfig",
"unmarshals",
"the",
"viper",
"s",
"configured",
"config",
"file",
"into",
"the",
"passed",
"in",
"cfg",
"object",
"containing",
"an",
"AppConfig"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L219-L274 |
15,640 | volatiletech/abcweb | abcconfig/config.go | ValidateDBConfig | func ValidateDBConfig(cfg DBConfig) error {
err := vala.BeginValidation().Validate(
vala.StringNotEmpty(cfg.DB, "db"),
vala.StringNotEmpty(cfg.User, "user"),
vala.StringNotEmpty(cfg.Host, "host"),
vala.Not(vala.Equals(cfg.Port, 0, "port")),
vala.StringNotEmpty(cfg.DBName, "dbname"),
vala.StringNotEmpty(cfg.SSLMode, "sslmode"),
).Check()
if err != nil {
return err
}
if cfg.DB != "postgres" && cfg.DB != "mysql" {
return errors.New("not a valid driver name")
}
return nil
} | go | func ValidateDBConfig(cfg DBConfig) error {
err := vala.BeginValidation().Validate(
vala.StringNotEmpty(cfg.DB, "db"),
vala.StringNotEmpty(cfg.User, "user"),
vala.StringNotEmpty(cfg.Host, "host"),
vala.Not(vala.Equals(cfg.Port, 0, "port")),
vala.StringNotEmpty(cfg.DBName, "dbname"),
vala.StringNotEmpty(cfg.SSLMode, "sslmode"),
).Check()
if err != nil {
return err
}
if cfg.DB != "postgres" && cfg.DB != "mysql" {
return errors.New("not a valid driver name")
}
return nil
} | [
"func",
"ValidateDBConfig",
"(",
"cfg",
"DBConfig",
")",
"error",
"{",
"err",
":=",
"vala",
".",
"BeginValidation",
"(",
")",
".",
"Validate",
"(",
"vala",
".",
"StringNotEmpty",
"(",
"cfg",
".",
"DB",
",",
"\"",
"\"",
")",
",",
"vala",
".",
"StringNot... | // ValidateDBConfig returns an error if any of the required db config
// fields are not set to their appropriate values. | [
"ValidateDBConfig",
"returns",
"an",
"error",
"if",
"any",
"of",
"the",
"required",
"db",
"config",
"fields",
"are",
"not",
"set",
"to",
"their",
"appropriate",
"values",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L278-L296 |
15,641 | volatiletech/abcweb | abcconfig/config.go | GetTagMappings | func GetTagMappings(cfg interface{}) (Mappings, error) {
return getTagMappingsRecursive("", reflect.Indirect(reflect.ValueOf(cfg)))
} | go | func GetTagMappings(cfg interface{}) (Mappings, error) {
return getTagMappingsRecursive("", reflect.Indirect(reflect.ValueOf(cfg)))
} | [
"func",
"GetTagMappings",
"(",
"cfg",
"interface",
"{",
"}",
")",
"(",
"Mappings",
",",
"error",
")",
"{",
"return",
"getTagMappingsRecursive",
"(",
"\"",
"\"",
",",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"cfg",
")",
")",
")",
... | // GetTagMappings returns the viper .BindEnv mappings for an entire config
// struct. | [
"GetTagMappings",
"returns",
"the",
"viper",
".",
"BindEnv",
"mappings",
"for",
"an",
"entire",
"config",
"struct",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcconfig/config.go#L363-L365 |
15,642 | volatiletech/abcweb | abcdatabase/database.go | GetConnStr | func GetConnStr(cfg abcconfig.DBConfig) (string, error) {
if len(cfg.DB) == 0 {
return "", errors.New("db field in config.toml must be provided")
}
if cfg.DB == "postgres" {
return drivers.PostgresBuildQueryString(cfg.User, cfg.Pass, cfg.DBName, cfg.Host, cfg.Port, cfg.SSLMode), nil
} else if cfg.DB == "mysql" {
return drivers.MySQLBuildQueryString(cfg.User, cfg.Pass, cfg.DBName, cfg.Host, cfg.Port, cfg.SSLMode), nil
}
return "", fmt.Errorf("cannot get connection string for unknown database %q", cfg.DB)
} | go | func GetConnStr(cfg abcconfig.DBConfig) (string, error) {
if len(cfg.DB) == 0 {
return "", errors.New("db field in config.toml must be provided")
}
if cfg.DB == "postgres" {
return drivers.PostgresBuildQueryString(cfg.User, cfg.Pass, cfg.DBName, cfg.Host, cfg.Port, cfg.SSLMode), nil
} else if cfg.DB == "mysql" {
return drivers.MySQLBuildQueryString(cfg.User, cfg.Pass, cfg.DBName, cfg.Host, cfg.Port, cfg.SSLMode), nil
}
return "", fmt.Errorf("cannot get connection string for unknown database %q", cfg.DB)
} | [
"func",
"GetConnStr",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"len",
"(",
"cfg",
".",
"DB",
")",
"==",
"0",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}... | // GetConnStr returns a connection string for the database software used | [
"GetConnStr",
"returns",
"a",
"connection",
"string",
"for",
"the",
"database",
"software",
"used"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L34-L46 |
15,643 | volatiletech/abcweb | abcdatabase/database.go | SetupDBData | func SetupDBData(cfg abcconfig.DBConfig, testdata TestdataFunc) (int, error) {
var err error
appPath := git.GetAppPath()
err = createTestDB(cfg)
if err != nil {
return 0, err
}
count, err := RunMigrations(cfg, filepath.Join(appPath, "db", "migrations"))
if err != nil {
return count, errors.Wrap(err, "cannot execute migrations up")
}
testdataFile := filepath.Join(appPath, "db", "testdata.sql")
err = SetupTestdata(cfg, testdataFile, testdata)
return count, err
} | go | func SetupDBData(cfg abcconfig.DBConfig, testdata TestdataFunc) (int, error) {
var err error
appPath := git.GetAppPath()
err = createTestDB(cfg)
if err != nil {
return 0, err
}
count, err := RunMigrations(cfg, filepath.Join(appPath, "db", "migrations"))
if err != nil {
return count, errors.Wrap(err, "cannot execute migrations up")
}
testdataFile := filepath.Join(appPath, "db", "testdata.sql")
err = SetupTestdata(cfg, testdataFile, testdata)
return count, err
} | [
"func",
"SetupDBData",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
",",
"testdata",
"TestdataFunc",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"appPath",
":=",
"git",
".",
"GetAppPath",
"(",
")",
"\n\n",
"err",
"=",
"createTest... | // SetupDBData executes the migrations "up" against the passed in database
// and also inserts the test data defined in testdata.sql and executes
// the passed in TestdataFunc handler if present, and then returns the
// number of migrations run. | [
"SetupDBData",
"executes",
"the",
"migrations",
"up",
"against",
"the",
"passed",
"in",
"database",
"and",
"also",
"inserts",
"the",
"test",
"data",
"defined",
"in",
"testdata",
".",
"sql",
"and",
"executes",
"the",
"passed",
"in",
"TestdataFunc",
"handler",
"... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L127-L146 |
15,644 | volatiletech/abcweb | abcdatabase/database.go | RunMigrations | func RunMigrations(cfg abcconfig.DBConfig, migrationsPath string) (int, error) {
connStr, err := GetConnStr(cfg)
if err != nil {
return 0, err
}
count, err := mig.Up(cfg.DB, connStr, migrationsPath)
if err != nil {
return count, err
}
return count, nil
} | go | func RunMigrations(cfg abcconfig.DBConfig, migrationsPath string) (int, error) {
connStr, err := GetConnStr(cfg)
if err != nil {
return 0, err
}
count, err := mig.Up(cfg.DB, connStr, migrationsPath)
if err != nil {
return count, err
}
return count, nil
} | [
"func",
"RunMigrations",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
",",
"migrationsPath",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"connStr",
",",
"err",
":=",
"GetConnStr",
"(",
"cfg",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",... | // RunMigrations executes the migrations "up" against the passed in database
// and returns the number of migrations run. | [
"RunMigrations",
"executes",
"the",
"migrations",
"up",
"against",
"the",
"passed",
"in",
"database",
"and",
"returns",
"the",
"number",
"of",
"migrations",
"run",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L190-L202 |
15,645 | volatiletech/abcweb | abcdatabase/database.go | ExecuteScript | func ExecuteScript(cfg abcconfig.DBConfig, script []byte) error {
rdr := bytes.NewReader(script)
if cfg.DB == "postgres" {
passFilePath, err := pgPassFile(cfg)
if err != nil {
return err
}
defer os.Remove(passFilePath)
cmd := exec.Command("psql", cfg.DBName, "-v", "ON_ERROR_STOP=1")
cmd.Stdin = rdr
cmd.Env = append(os.Environ(), pgEnv(cfg, passFilePath)...)
res, err := cmd.CombinedOutput()
if err != nil {
fmt.Printf(string(res))
}
return err
} else if cfg.DB == "mysql" {
passFile, err := mysqlPassFile(cfg)
if err != nil {
return err
}
defer os.Remove(passFile)
cmd := exec.Command("mysql", fmt.Sprintf("--defaults-file=%s", passFile), "--database", cfg.DBName)
cmd.Stdin = rdr
res, err := cmd.CombinedOutput()
if err != nil {
fmt.Println(string(res))
}
return err
}
return fmt.Errorf("cannot execute sql script, incompatible database %q", cfg.DB)
} | go | func ExecuteScript(cfg abcconfig.DBConfig, script []byte) error {
rdr := bytes.NewReader(script)
if cfg.DB == "postgres" {
passFilePath, err := pgPassFile(cfg)
if err != nil {
return err
}
defer os.Remove(passFilePath)
cmd := exec.Command("psql", cfg.DBName, "-v", "ON_ERROR_STOP=1")
cmd.Stdin = rdr
cmd.Env = append(os.Environ(), pgEnv(cfg, passFilePath)...)
res, err := cmd.CombinedOutput()
if err != nil {
fmt.Printf(string(res))
}
return err
} else if cfg.DB == "mysql" {
passFile, err := mysqlPassFile(cfg)
if err != nil {
return err
}
defer os.Remove(passFile)
cmd := exec.Command("mysql", fmt.Sprintf("--defaults-file=%s", passFile), "--database", cfg.DBName)
cmd.Stdin = rdr
res, err := cmd.CombinedOutput()
if err != nil {
fmt.Println(string(res))
}
return err
}
return fmt.Errorf("cannot execute sql script, incompatible database %q", cfg.DB)
} | [
"func",
"ExecuteScript",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
",",
"script",
"[",
"]",
"byte",
")",
"error",
"{",
"rdr",
":=",
"bytes",
".",
"NewReader",
"(",
"script",
")",
"\n\n",
"if",
"cfg",
".",
"DB",
"==",
"\"",
"\"",
"{",
"passFilePath",
... | // ExecuteScript executes the passed in SQL script against the passed in db | [
"ExecuteScript",
"executes",
"the",
"passed",
"in",
"SQL",
"script",
"against",
"the",
"passed",
"in",
"db"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L244-L283 |
15,646 | volatiletech/abcweb | abcdatabase/database.go | pgEnv | func pgEnv(cfg abcconfig.DBConfig, passFilePath string) []string {
return []string{
fmt.Sprintf("PGHOST=%s", cfg.Host),
fmt.Sprintf("PGPORT=%d", cfg.Port),
fmt.Sprintf("PGUSER=%s", cfg.User),
fmt.Sprintf("PGPASSFILE=%s", passFilePath),
}
} | go | func pgEnv(cfg abcconfig.DBConfig, passFilePath string) []string {
return []string{
fmt.Sprintf("PGHOST=%s", cfg.Host),
fmt.Sprintf("PGPORT=%d", cfg.Port),
fmt.Sprintf("PGUSER=%s", cfg.User),
fmt.Sprintf("PGPASSFILE=%s", passFilePath),
}
} | [
"func",
"pgEnv",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
",",
"passFilePath",
"string",
")",
"[",
"]",
"string",
"{",
"return",
"[",
"]",
"string",
"{",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cfg",
".",
"Host",
")",
",",
"fmt",
".",
"Sprin... | // pgEnv returns a slice of the connection related environment variables | [
"pgEnv",
"returns",
"a",
"slice",
"of",
"the",
"connection",
"related",
"environment",
"variables"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L332-L339 |
15,647 | volatiletech/abcweb | abcdatabase/database.go | pgPassFile | func pgPassFile(cfg abcconfig.DBConfig) (string, error) {
tmp, err := ioutil.TempFile("", "pgpass")
if err != nil {
return "", errors.New("failed to create postgres pass file")
}
defer tmp.Close()
fmt.Fprintf(tmp, "%s:%d:%s:%s", cfg.Host, cfg.Port, cfg.DBName, cfg.User)
if len(cfg.Pass) != 0 {
fmt.Fprintf(tmp, ":%s", cfg.Pass)
}
fmt.Fprintln(tmp)
return tmp.Name(), nil
} | go | func pgPassFile(cfg abcconfig.DBConfig) (string, error) {
tmp, err := ioutil.TempFile("", "pgpass")
if err != nil {
return "", errors.New("failed to create postgres pass file")
}
defer tmp.Close()
fmt.Fprintf(tmp, "%s:%d:%s:%s", cfg.Host, cfg.Port, cfg.DBName, cfg.User)
if len(cfg.Pass) != 0 {
fmt.Fprintf(tmp, ":%s", cfg.Pass)
}
fmt.Fprintln(tmp)
return tmp.Name(), nil
} | [
"func",
"pgPassFile",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
")",
"(",
"string",
",",
"error",
")",
"{",
"tmp",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
... | // pgPassFile creates a file in the temp directory containing the connection
// details and password for the database to be passed into the mysql cmdline cmd | [
"pgPassFile",
"creates",
"a",
"file",
"in",
"the",
"temp",
"directory",
"containing",
"the",
"connection",
"details",
"and",
"password",
"for",
"the",
"database",
"to",
"be",
"passed",
"into",
"the",
"mysql",
"cmdline",
"cmd"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L343-L357 |
15,648 | volatiletech/abcweb | abcdatabase/database.go | mysqlPassFile | func mysqlPassFile(cfg abcconfig.DBConfig) (string, error) {
tmp, err := ioutil.TempFile("", "mysqlpass")
if err != nil {
return "", errors.Wrap(err, "failed to create mysql pass file")
}
defer tmp.Close()
fmt.Fprintln(tmp, "[client]")
fmt.Fprintf(tmp, "host=%s\n", cfg.Host)
fmt.Fprintf(tmp, "port=%d\n", cfg.Port)
fmt.Fprintf(tmp, "user=%s\n", cfg.User)
fmt.Fprintf(tmp, "password=%s\n", cfg.Pass)
var sslMode string
switch cfg.SSLMode {
case "true":
sslMode = "REQUIRED"
case "false":
sslMode = "DISABLED"
default:
sslMode = "PREFERRED"
}
fmt.Fprintf(tmp, "ssl-mode=%s\n", sslMode)
return tmp.Name(), nil
} | go | func mysqlPassFile(cfg abcconfig.DBConfig) (string, error) {
tmp, err := ioutil.TempFile("", "mysqlpass")
if err != nil {
return "", errors.Wrap(err, "failed to create mysql pass file")
}
defer tmp.Close()
fmt.Fprintln(tmp, "[client]")
fmt.Fprintf(tmp, "host=%s\n", cfg.Host)
fmt.Fprintf(tmp, "port=%d\n", cfg.Port)
fmt.Fprintf(tmp, "user=%s\n", cfg.User)
fmt.Fprintf(tmp, "password=%s\n", cfg.Pass)
var sslMode string
switch cfg.SSLMode {
case "true":
sslMode = "REQUIRED"
case "false":
sslMode = "DISABLED"
default:
sslMode = "PREFERRED"
}
fmt.Fprintf(tmp, "ssl-mode=%s\n", sslMode)
return tmp.Name(), nil
} | [
"func",
"mysqlPassFile",
"(",
"cfg",
"abcconfig",
".",
"DBConfig",
")",
"(",
"string",
",",
"error",
")",
"{",
"tmp",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",... | // mysqlPassFile creates a file in the temp directory containing the connection
// details and password for the database to be passed into the mysql cmdline cmd | [
"mysqlPassFile",
"creates",
"a",
"file",
"in",
"the",
"temp",
"directory",
"containing",
"the",
"connection",
"details",
"and",
"password",
"for",
"the",
"database",
"to",
"be",
"passed",
"into",
"the",
"mysql",
"cmdline",
"cmd"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcdatabase/database.go#L361-L387 |
15,649 | volatiletech/abcweb | config/config.go | Initialize | func Initialize(env *pflag.Flag) (*Configuration, error) {
c := &Configuration{}
path, err := getAppPath()
if err != nil {
return nil, err
}
c.AppPath = path
c.AppName = getAppName(c.AppPath)
c.AppEnvName = strmangle.EnvAppName(c.AppName)
c.ActiveEnv = getActiveEnv(c.AppPath, c.AppName)
// If ActiveEnv is not set via env var or config file,
// OR the user has passed in an override value through a flag,
// then set it to the flag value.
if env != nil && (c.ActiveEnv == "" || env.Changed) {
c.ActiveEnv = env.Value.String()
}
c.ModeViper = NewModeViper(c.AppPath, c.AppEnvName, c.ActiveEnv)
return c, nil
} | go | func Initialize(env *pflag.Flag) (*Configuration, error) {
c := &Configuration{}
path, err := getAppPath()
if err != nil {
return nil, err
}
c.AppPath = path
c.AppName = getAppName(c.AppPath)
c.AppEnvName = strmangle.EnvAppName(c.AppName)
c.ActiveEnv = getActiveEnv(c.AppPath, c.AppName)
// If ActiveEnv is not set via env var or config file,
// OR the user has passed in an override value through a flag,
// then set it to the flag value.
if env != nil && (c.ActiveEnv == "" || env.Changed) {
c.ActiveEnv = env.Value.String()
}
c.ModeViper = NewModeViper(c.AppPath, c.AppEnvName, c.ActiveEnv)
return c, nil
} | [
"func",
"Initialize",
"(",
"env",
"*",
"pflag",
".",
"Flag",
")",
"(",
"*",
"Configuration",
",",
"error",
")",
"{",
"c",
":=",
"&",
"Configuration",
"{",
"}",
"\n\n",
"path",
",",
"err",
":=",
"getAppPath",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil"... | // Initialize the config | [
"Initialize",
"the",
"config"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/config/config.go#L55-L76 |
15,650 | volatiletech/abcweb | config/config.go | InitializeP | func InitializeP(env *pflag.Flag) *Configuration {
c, err := Initialize(env)
if err != nil {
panic(err)
}
return c
} | go | func InitializeP(env *pflag.Flag) *Configuration {
c, err := Initialize(env)
if err != nil {
panic(err)
}
return c
} | [
"func",
"InitializeP",
"(",
"env",
"*",
"pflag",
".",
"Flag",
")",
"*",
"Configuration",
"{",
"c",
",",
"err",
":=",
"Initialize",
"(",
"env",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"c",
"... | // InitializeP the config but panic if anything goes wrong | [
"InitializeP",
"the",
"config",
"but",
"panic",
"if",
"anything",
"goes",
"wrong"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/config/config.go#L79-L86 |
15,651 | volatiletech/abcweb | config/config.go | getAppName | func getAppName(appPath string) string {
// Is "/" on both Windows and Linux
split := strings.Split(appPath, "/")
return split[len(split)-1]
} | go | func getAppName(appPath string) string {
// Is "/" on both Windows and Linux
split := strings.Split(appPath, "/")
return split[len(split)-1]
} | [
"func",
"getAppName",
"(",
"appPath",
"string",
")",
"string",
"{",
"// Is \"/\" on both Windows and Linux",
"split",
":=",
"strings",
".",
"Split",
"(",
"appPath",
",",
"\"",
"\"",
")",
"\n",
"return",
"split",
"[",
"len",
"(",
"split",
")",
"-",
"1",
"]"... | // getAppName gets the appname portion of a project path | [
"getAppName",
"gets",
"the",
"appname",
"portion",
"of",
"a",
"project",
"path"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/config/config.go#L201-L205 |
15,652 | volatiletech/abcweb | config/config.go | CheckEnv | func (c *Configuration) CheckEnv() error {
if c.ActiveEnv == "" {
return fmt.Errorf("No active environment chosen. Please choose an environment using the \"env\" flag in config.toml or the $%s_ENV environment variable", c.AppEnvName)
}
return nil
} | go | func (c *Configuration) CheckEnv() error {
if c.ActiveEnv == "" {
return fmt.Errorf("No active environment chosen. Please choose an environment using the \"env\" flag in config.toml or the $%s_ENV environment variable", c.AppEnvName)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Configuration",
")",
"CheckEnv",
"(",
")",
"error",
"{",
"if",
"c",
".",
"ActiveEnv",
"==",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"c",
".",
"AppEnvName",
")",
"\n",
"}",
"\n... | // CheckEnv outputs an error if no ActiveEnv is found | [
"CheckEnv",
"outputs",
"an",
"error",
"if",
"no",
"ActiveEnv",
"is",
"found"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/config/config.go#L219-L224 |
15,653 | volatiletech/abcweb | abcmiddleware/errors.go | NewErrorManager | func NewErrorManager(render abcrender.Renderer) *errorManager {
return &errorManager{
render: render,
errors: []ErrorContainer{},
}
} | go | func NewErrorManager(render abcrender.Renderer) *errorManager {
return &errorManager{
render: render,
errors: []ErrorContainer{},
}
} | [
"func",
"NewErrorManager",
"(",
"render",
"abcrender",
".",
"Renderer",
")",
"*",
"errorManager",
"{",
"return",
"&",
"errorManager",
"{",
"render",
":",
"render",
",",
"errors",
":",
"[",
"]",
"ErrorContainer",
"{",
"}",
",",
"}",
"\n",
"}"
] | // NewErrorManager creates an error manager that can be used to
// create an error handler to wrap your controllers with | [
"NewErrorManager",
"creates",
"an",
"error",
"manager",
"that",
"can",
"be",
"used",
"to",
"create",
"an",
"error",
"handler",
"to",
"wrap",
"your",
"controllers",
"with"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/errors.go#L40-L45 |
15,654 | volatiletech/abcweb | abcmiddleware/errors.go | Remove | func (m *errorManager) Remove(e ErrorContainer) {
for i, v := range m.errors {
if reflect.DeepEqual(v, e) {
m.errors = append(m.errors[:i], m.errors[i+1:]...)
}
}
} | go | func (m *errorManager) Remove(e ErrorContainer) {
for i, v := range m.errors {
if reflect.DeepEqual(v, e) {
m.errors = append(m.errors[:i], m.errors[i+1:]...)
}
}
} | [
"func",
"(",
"m",
"*",
"errorManager",
")",
"Remove",
"(",
"e",
"ErrorContainer",
")",
"{",
"for",
"i",
",",
"v",
":=",
"range",
"m",
".",
"errors",
"{",
"if",
"reflect",
".",
"DeepEqual",
"(",
"v",
",",
"e",
")",
"{",
"m",
".",
"errors",
"=",
... | // Remove a ErrorContainer from the error manager | [
"Remove",
"a",
"ErrorContainer",
"from",
"the",
"error",
"manager"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/errors.go#L70-L76 |
15,655 | volatiletech/abcweb | abcmiddleware/errors.go | Add | func (m *errorManager) Add(e ErrorContainer) {
m.errors = append(m.errors, e)
} | go | func (m *errorManager) Add(e ErrorContainer) {
m.errors = append(m.errors, e)
} | [
"func",
"(",
"m",
"*",
"errorManager",
")",
"Add",
"(",
"e",
"ErrorContainer",
")",
"{",
"m",
".",
"errors",
"=",
"append",
"(",
"m",
".",
"errors",
",",
"e",
")",
"\n",
"}"
] | // Add a new ErrorContainer to the error manager | [
"Add",
"a",
"new",
"ErrorContainer",
"to",
"the",
"error",
"manager"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcmiddleware/errors.go#L79-L81 |
15,656 | volatiletech/abcweb | abcsessions/middleware.go | Write | func (s *sessionsResponseWriter) Write(buf []byte) (int, error) {
if !s.wroteHeader {
s.WriteHeader(http.StatusOK)
}
return s.ResponseWriter.Write(buf)
} | go | func (s *sessionsResponseWriter) Write(buf []byte) (int, error) {
if !s.wroteHeader {
s.WriteHeader(http.StatusOK)
}
return s.ResponseWriter.Write(buf)
} | [
"func",
"(",
"s",
"*",
"sessionsResponseWriter",
")",
"Write",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"!",
"s",
".",
"wroteHeader",
"{",
"s",
".",
"WriteHeader",
"(",
"http",
".",
"StatusOK",
")",
"\n",
"}",
... | // Write calls the underlying ResponseWriter Write func | [
"Write",
"calls",
"the",
"underlying",
"ResponseWriter",
"Write",
"func"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/middleware.go#L27-L32 |
15,657 | volatiletech/abcweb | abcsessions/middleware.go | WriteHeader | func (s *sessionsResponseWriter) WriteHeader(code int) {
s.wroteHeader = true
// Set all the cookies in the cookie buffer
if !s.wroteCookies {
s.wroteCookies = true
for _, c := range s.cookies {
http.SetCookie(s.ResponseWriter, c)
}
}
s.ResponseWriter.WriteHeader(code)
} | go | func (s *sessionsResponseWriter) WriteHeader(code int) {
s.wroteHeader = true
// Set all the cookies in the cookie buffer
if !s.wroteCookies {
s.wroteCookies = true
for _, c := range s.cookies {
http.SetCookie(s.ResponseWriter, c)
}
}
s.ResponseWriter.WriteHeader(code)
} | [
"func",
"(",
"s",
"*",
"sessionsResponseWriter",
")",
"WriteHeader",
"(",
"code",
"int",
")",
"{",
"s",
".",
"wroteHeader",
"=",
"true",
"\n\n",
"// Set all the cookies in the cookie buffer",
"if",
"!",
"s",
".",
"wroteCookies",
"{",
"s",
".",
"wroteCookies",
... | // WriteHeader sets all cookies in the buffer on the underlying ResponseWriter's
// headers and calls the underlying ResponseWriter WriteHeader func | [
"WriteHeader",
"sets",
"all",
"cookies",
"in",
"the",
"buffer",
"on",
"the",
"underlying",
"ResponseWriter",
"s",
"headers",
"and",
"calls",
"the",
"underlying",
"ResponseWriter",
"WriteHeader",
"func"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/middleware.go#L36-L48 |
15,658 | volatiletech/abcweb | abcsessions/middleware.go | MiddlewareWithReset | func (m resetExpiryMiddleware) MiddlewareWithReset(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Convert the response writer to a sessions response, so we can
// use its cookie buffering and writing capabilities
w = newSessionsResponseWriter(w)
err := m.resetter.ResetExpiry(w, r)
// It's possible that the session hasn't been created yet
// so there's nothing to reset. In that case, do not explode.
if err != nil && !IsNoSessionError(err) {
panic(err)
}
next.ServeHTTP(w, r)
})
} | go | func (m resetExpiryMiddleware) MiddlewareWithReset(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Convert the response writer to a sessions response, so we can
// use its cookie buffering and writing capabilities
w = newSessionsResponseWriter(w)
err := m.resetter.ResetExpiry(w, r)
// It's possible that the session hasn't been created yet
// so there's nothing to reset. In that case, do not explode.
if err != nil && !IsNoSessionError(err) {
panic(err)
}
next.ServeHTTP(w, r)
})
} | [
"func",
"(",
"m",
"resetExpiryMiddleware",
")",
"MiddlewareWithReset",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",... | // Middleware converts the ResponseWriter object to a sessionsResponseWriter
// for buffering cookies across session API requests.
// The sessionsResponseWriter implements cookieWriter.
//
// MiddlewareWithReset also resets the users session expiry on each request.
// If you do not want this added functionality use Middleware instead. | [
"Middleware",
"converts",
"the",
"ResponseWriter",
"object",
"to",
"a",
"sessionsResponseWriter",
"for",
"buffering",
"cookies",
"across",
"session",
"API",
"requests",
".",
"The",
"sessionsResponseWriter",
"implements",
"cookieWriter",
".",
"MiddlewareWithReset",
"also",... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/middleware.go#L92-L107 |
15,659 | volatiletech/abcweb | abcserver/server.go | Write | func (s serverErrLogger) Write(b []byte) (int, error) {
s.log.Debug(string(b))
return 0, nil
} | go | func (s serverErrLogger) Write(b []byte) (int, error) {
s.log.Debug(string(b))
return 0, nil
} | [
"func",
"(",
"s",
"serverErrLogger",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"s",
".",
"log",
".",
"Debug",
"(",
"string",
"(",
"b",
")",
")",
"\n",
"return",
"0",
",",
"nil",
"\n",
"}"
] | // Implement Write to log server errors using the zap logger | [
"Implement",
"Write",
"to",
"log",
"server",
"errors",
"using",
"the",
"zap",
"logger"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcserver/server.go#L26-L29 |
15,660 | volatiletech/abcweb | abcserver/server.go | StartServer | func StartServer(cfg abcconfig.ServerConfig, router http.Handler, logger *zap.Logger) error {
var err error
server := http.Server{
ReadTimeout: cfg.ReadTimeout,
WriteTimeout: cfg.WriteTimeout,
IdleTimeout: cfg.IdleTimeout,
ErrorLog: log.New(serverErrLogger{logger}, "", 0),
Handler: router,
}
server.TLSConfig = &tls.Config{
// Causes servers to use Go's default ciphersuite preferences,
// which are tuned to avoid attacks. Does nothing on clients.
PreferServerCipherSuites: true,
// Only use curves which have assembly implementations
CurvePreferences: []tls.CurveID{
tls.CurveP256,
tls.X25519, // Go 1.8 only
},
}
// subscribe to SIGINT signals
quit := make(chan os.Signal)
signal.Notify(quit, os.Interrupt)
// Start server graceful shutdown goroutine
go func() {
<-quit
log.Println("Shutting down server...")
if err := server.Shutdown(context.Background()); err != nil {
log.Fatalf("could not shutdown: %v", err)
}
}()
if len(cfg.TLSBind) > 0 {
logger.Info("starting https listener", zap.String("bind", cfg.TLSBind))
server.Addr = cfg.TLSBind
// Redirect http requests to https
go Redirect(cfg, logger)
if err := server.ListenAndServeTLS(cfg.TLSCertFile, cfg.TLSKeyFile); err != nil {
fmt.Printf("failed to ListenAndServeTLS: %v", err)
return nil
}
} else {
logger.Info("starting http listener", zap.String("bind", cfg.Bind))
server.Addr = cfg.Bind
if err := server.ListenAndServe(); err != nil {
fmt.Printf("failed to ListenAndServe: %v", err)
return nil
}
}
return errors.Wrap(err, "failed to StartServer")
} | go | func StartServer(cfg abcconfig.ServerConfig, router http.Handler, logger *zap.Logger) error {
var err error
server := http.Server{
ReadTimeout: cfg.ReadTimeout,
WriteTimeout: cfg.WriteTimeout,
IdleTimeout: cfg.IdleTimeout,
ErrorLog: log.New(serverErrLogger{logger}, "", 0),
Handler: router,
}
server.TLSConfig = &tls.Config{
// Causes servers to use Go's default ciphersuite preferences,
// which are tuned to avoid attacks. Does nothing on clients.
PreferServerCipherSuites: true,
// Only use curves which have assembly implementations
CurvePreferences: []tls.CurveID{
tls.CurveP256,
tls.X25519, // Go 1.8 only
},
}
// subscribe to SIGINT signals
quit := make(chan os.Signal)
signal.Notify(quit, os.Interrupt)
// Start server graceful shutdown goroutine
go func() {
<-quit
log.Println("Shutting down server...")
if err := server.Shutdown(context.Background()); err != nil {
log.Fatalf("could not shutdown: %v", err)
}
}()
if len(cfg.TLSBind) > 0 {
logger.Info("starting https listener", zap.String("bind", cfg.TLSBind))
server.Addr = cfg.TLSBind
// Redirect http requests to https
go Redirect(cfg, logger)
if err := server.ListenAndServeTLS(cfg.TLSCertFile, cfg.TLSKeyFile); err != nil {
fmt.Printf("failed to ListenAndServeTLS: %v", err)
return nil
}
} else {
logger.Info("starting http listener", zap.String("bind", cfg.Bind))
server.Addr = cfg.Bind
if err := server.ListenAndServe(); err != nil {
fmt.Printf("failed to ListenAndServe: %v", err)
return nil
}
}
return errors.Wrap(err, "failed to StartServer")
} | [
"func",
"StartServer",
"(",
"cfg",
"abcconfig",
".",
"ServerConfig",
",",
"router",
"http",
".",
"Handler",
",",
"logger",
"*",
"zap",
".",
"Logger",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"server",
":=",
"http",
".",
"Server",
"{",
"ReadTimeout... | // StartServer starts the web server on the specified port, and can be
// gracefully shut down by sending an os.Interrupt signal to the server.
// This is a blocking call. | [
"StartServer",
"starts",
"the",
"web",
"server",
"on",
"the",
"specified",
"port",
"and",
"can",
"be",
"gracefully",
"shut",
"down",
"by",
"sending",
"an",
"os",
".",
"Interrupt",
"signal",
"to",
"the",
"server",
".",
"This",
"is",
"a",
"blocking",
"call",... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcserver/server.go#L34-L89 |
15,661 | volatiletech/abcweb | abcserver/server.go | Redirect | func Redirect(cfg abcconfig.ServerConfig, logger *zap.Logger) {
var err error
// Get https port from TLS Bind
_, httpsPort, err := net.SplitHostPort(cfg.TLSBind)
if err != nil {
log.Fatal("failed to get port from tls bind", zap.Error(err))
}
logger.Info("starting http -> https redirect listener", zap.String("bind", cfg.Bind))
server := http.Server{
Addr: cfg.Bind,
// Do not set IdleTimeout, so Go uses ReadTimeout value.
// IdleTimeout config value too high for redirect listener.
ReadTimeout: cfg.ReadTimeout,
WriteTimeout: cfg.WriteTimeout,
ErrorLog: log.New(serverErrLogger{logger}, "", 0),
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Remove port if it exists so we can replace it with https port
httpHost := r.Host
if strings.ContainsRune(r.Host, ':') {
httpHost, _, err = net.SplitHostPort(r.Host)
if err != nil {
logger.Error("failed to get http host from request", zap.String("host", r.Host), zap.Error(err))
w.WriteHeader(http.StatusBadRequest)
io.WriteString(w, "invalid host header")
return
}
}
var url string
if httpsPort != "443" {
url = fmt.Sprintf("https://%s:%s%s", httpHost, httpsPort, r.RequestURI)
} else {
url = fmt.Sprintf("https://%s%s", httpHost, r.RequestURI)
}
logger.Info("redirect", zap.String("host", r.Host), zap.String("path", r.URL.String()), zap.String("redirecturl", url))
http.Redirect(w, r, url, http.StatusMovedPermanently)
}),
}
// Start permanent listener
err = server.ListenAndServe()
logger.Fatal("http redirect listener failed", zap.Error(err))
} | go | func Redirect(cfg abcconfig.ServerConfig, logger *zap.Logger) {
var err error
// Get https port from TLS Bind
_, httpsPort, err := net.SplitHostPort(cfg.TLSBind)
if err != nil {
log.Fatal("failed to get port from tls bind", zap.Error(err))
}
logger.Info("starting http -> https redirect listener", zap.String("bind", cfg.Bind))
server := http.Server{
Addr: cfg.Bind,
// Do not set IdleTimeout, so Go uses ReadTimeout value.
// IdleTimeout config value too high for redirect listener.
ReadTimeout: cfg.ReadTimeout,
WriteTimeout: cfg.WriteTimeout,
ErrorLog: log.New(serverErrLogger{logger}, "", 0),
Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Remove port if it exists so we can replace it with https port
httpHost := r.Host
if strings.ContainsRune(r.Host, ':') {
httpHost, _, err = net.SplitHostPort(r.Host)
if err != nil {
logger.Error("failed to get http host from request", zap.String("host", r.Host), zap.Error(err))
w.WriteHeader(http.StatusBadRequest)
io.WriteString(w, "invalid host header")
return
}
}
var url string
if httpsPort != "443" {
url = fmt.Sprintf("https://%s:%s%s", httpHost, httpsPort, r.RequestURI)
} else {
url = fmt.Sprintf("https://%s%s", httpHost, r.RequestURI)
}
logger.Info("redirect", zap.String("host", r.Host), zap.String("path", r.URL.String()), zap.String("redirecturl", url))
http.Redirect(w, r, url, http.StatusMovedPermanently)
}),
}
// Start permanent listener
err = server.ListenAndServe()
logger.Fatal("http redirect listener failed", zap.Error(err))
} | [
"func",
"Redirect",
"(",
"cfg",
"abcconfig",
".",
"ServerConfig",
",",
"logger",
"*",
"zap",
".",
"Logger",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// Get https port from TLS Bind",
"_",
",",
"httpsPort",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",... | // Redirect listens on the non-https port, and redirects all requests to https | [
"Redirect",
"listens",
"on",
"the",
"non",
"-",
"https",
"port",
"and",
"redirects",
"all",
"requests",
"to",
"https"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcserver/server.go#L92-L138 |
15,662 | volatiletech/abcweb | abcsessions/memory.go | NewMemoryStorer | func NewMemoryStorer(maxAge, cleanInterval time.Duration) (*MemoryStorer, error) {
if (maxAge != 0 && cleanInterval == 0) || (cleanInterval != 0 && maxAge == 0) {
panic("if max age or clean interval is set, the other must also be set")
}
m := &MemoryStorer{
sessions: make(map[string]memorySession),
maxAge: maxAge,
cleanInterval: cleanInterval,
}
return m, nil
} | go | func NewMemoryStorer(maxAge, cleanInterval time.Duration) (*MemoryStorer, error) {
if (maxAge != 0 && cleanInterval == 0) || (cleanInterval != 0 && maxAge == 0) {
panic("if max age or clean interval is set, the other must also be set")
}
m := &MemoryStorer{
sessions: make(map[string]memorySession),
maxAge: maxAge,
cleanInterval: cleanInterval,
}
return m, nil
} | [
"func",
"NewMemoryStorer",
"(",
"maxAge",
",",
"cleanInterval",
"time",
".",
"Duration",
")",
"(",
"*",
"MemoryStorer",
",",
"error",
")",
"{",
"if",
"(",
"maxAge",
"!=",
"0",
"&&",
"cleanInterval",
"==",
"0",
")",
"||",
"(",
"cleanInterval",
"!=",
"0",
... | // NewMemoryStorer initializes and returns a new MemoryStorer object.
// It takes the maxAge of how long each session should live in memory,
// and a cleanInterval duration which defines how often the clean
// task should check for maxAge sessions to be removed from memory.
// Persistent storage can be attained by setting maxAge and cleanInterval
// to zero, however the memory will be wiped when the server is restarted. | [
"NewMemoryStorer",
"initializes",
"and",
"returns",
"a",
"new",
"MemoryStorer",
"object",
".",
"It",
"takes",
"the",
"maxAge",
"of",
"how",
"long",
"each",
"session",
"should",
"live",
"in",
"memory",
"and",
"a",
"cleanInterval",
"duration",
"which",
"defines",
... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/memory.go#L44-L56 |
15,663 | volatiletech/abcweb | abcsessions/memory.go | All | func (m *MemoryStorer) All() ([]string, error) {
m.mut.RLock()
defer m.mut.RUnlock()
sessions := make([]string, len(m.sessions))
i := 0
for id := range m.sessions {
sessions[i] = id
i++
}
return sessions, nil
} | go | func (m *MemoryStorer) All() ([]string, error) {
m.mut.RLock()
defer m.mut.RUnlock()
sessions := make([]string, len(m.sessions))
i := 0
for id := range m.sessions {
sessions[i] = id
i++
}
return sessions, nil
} | [
"func",
"(",
"m",
"*",
"MemoryStorer",
")",
"All",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"m",
".",
"mut",
".",
"RLock",
"(",
")",
"\n",
"defer",
"m",
".",
"mut",
".",
"RUnlock",
"(",
")",
"\n\n",
"sessions",
":=",
"make",
... | // All keys in the memory store | [
"All",
"keys",
"in",
"the",
"memory",
"store"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/memory.go#L59-L72 |
15,664 | volatiletech/abcweb | abcsessions/memory.go | Clean | func (m *MemoryStorer) Clean() {
t := time.Now().UTC()
m.mut.Lock()
for id, session := range m.sessions {
if t.After(session.expires) {
delete(m.sessions, id)
}
}
m.mut.Unlock()
} | go | func (m *MemoryStorer) Clean() {
t := time.Now().UTC()
m.mut.Lock()
for id, session := range m.sessions {
if t.After(session.expires) {
delete(m.sessions, id)
}
}
m.mut.Unlock()
} | [
"func",
"(",
"m",
"*",
"MemoryStorer",
")",
"Clean",
"(",
")",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n",
"m",
".",
"mut",
".",
"Lock",
"(",
")",
"\n",
"for",
"id",
",",
"session",
":=",
"range",
"m",
".",
"se... | // Clean checks all sessions in memory to see if they are older than
// maxAge by checking their expiry. If it finds an expired session
// it will remove it from memory. | [
"Clean",
"checks",
"all",
"sessions",
"in",
"memory",
"to",
"see",
"if",
"they",
"are",
"older",
"than",
"maxAge",
"by",
"checking",
"their",
"expiry",
".",
"If",
"it",
"finds",
"an",
"expired",
"session",
"it",
"will",
"remove",
"it",
"from",
"memory",
... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/memory.go#L125-L134 |
15,665 | volatiletech/abcweb | abcsessions/memory.go | StartCleaner | func (m *MemoryStorer) StartCleaner() {
if m.maxAge == 0 || m.cleanInterval == 0 {
panic("both max age and clean interval must be set to non-zero")
}
// init quit chan
m.quit = make(chan struct{})
m.wg.Add(1)
// Start the cleaner infinite loop go routine.
// StopCleaner() can be used to kill this go routine.
go m.cleanerLoop()
} | go | func (m *MemoryStorer) StartCleaner() {
if m.maxAge == 0 || m.cleanInterval == 0 {
panic("both max age and clean interval must be set to non-zero")
}
// init quit chan
m.quit = make(chan struct{})
m.wg.Add(1)
// Start the cleaner infinite loop go routine.
// StopCleaner() can be used to kill this go routine.
go m.cleanerLoop()
} | [
"func",
"(",
"m",
"*",
"MemoryStorer",
")",
"StartCleaner",
"(",
")",
"{",
"if",
"m",
".",
"maxAge",
"==",
"0",
"||",
"m",
".",
"cleanInterval",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// init quit chan",
"m",
".",
"quit"... | // StartCleaner starts the memory session cleaner go routine. This go routine
// will delete expired sessions from the memory map on the cleanInterval interval. | [
"StartCleaner",
"starts",
"the",
"memory",
"session",
"cleaner",
"go",
"routine",
".",
"This",
"go",
"routine",
"will",
"delete",
"expired",
"sessions",
"from",
"the",
"memory",
"map",
"on",
"the",
"cleanInterval",
"interval",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/memory.go#L138-L151 |
15,666 | volatiletech/abcweb | cmd/generate.go | modelsCmdPreRun | func modelsCmdPreRun(cmd *cobra.Command, args []string) error {
var err error
cnf, err = config.Initialize(cmd.Flags().Lookup("env"))
if err != nil {
return err
}
cnf.ModeViper.BindPFlags(modelsCmd.Flags())
err = cnf.CheckEnv()
if err != nil {
return err
}
return modelsCmdSetup(cmd, args)
} | go | func modelsCmdPreRun(cmd *cobra.Command, args []string) error {
var err error
cnf, err = config.Initialize(cmd.Flags().Lookup("env"))
if err != nil {
return err
}
cnf.ModeViper.BindPFlags(modelsCmd.Flags())
err = cnf.CheckEnv()
if err != nil {
return err
}
return modelsCmdSetup(cmd, args)
} | [
"func",
"modelsCmdPreRun",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"cnf",
",",
"err",
"=",
"config",
".",
"Initialize",
"(",
"cmd",
".",
"Flags",
"(",
")",
".",
"Loo... | // modelsCmdPreRun sets up the modelsCmdState and modelsCmdConfig objects | [
"modelsCmdPreRun",
"sets",
"up",
"the",
"modelsCmdState",
"and",
"modelsCmdConfig",
"objects"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cmd/generate.go#L136-L151 |
15,667 | volatiletech/abcweb | strmangle/strmangle.go | replaceNonAlpha | func replaceNonAlpha(s string, replace byte) string {
byts := []byte(s)
newByts := make([]byte, len(byts))
for i := 0; i < len(byts); i++ {
if byts[i] < 'A' || (byts[i] > 'Z' && byts[i] < 'a') || byts[i] > 'z' {
newByts[i] = replace
} else {
newByts[i] = byts[i]
}
}
return string(newByts)
} | go | func replaceNonAlpha(s string, replace byte) string {
byts := []byte(s)
newByts := make([]byte, len(byts))
for i := 0; i < len(byts); i++ {
if byts[i] < 'A' || (byts[i] > 'Z' && byts[i] < 'a') || byts[i] > 'z' {
newByts[i] = replace
} else {
newByts[i] = byts[i]
}
}
return string(newByts)
} | [
"func",
"replaceNonAlpha",
"(",
"s",
"string",
",",
"replace",
"byte",
")",
"string",
"{",
"byts",
":=",
"[",
"]",
"byte",
"(",
"s",
")",
"\n",
"newByts",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"byts",
")",
")",
"\n\n",
"for",
"i",... | // replaceNonAlpha replaces non alphabet characters with the replace byte. | [
"replaceNonAlpha",
"replaces",
"non",
"alphabet",
"characters",
"with",
"the",
"replace",
"byte",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/strmangle/strmangle.go#L43-L56 |
15,668 | volatiletech/abcweb | cmd/dev.go | startGulp | func startGulp(publicPathEnv string, ctx context.Context) error {
_, err := os.Stat(filepath.Join(cnf.AppPath, "gulpfile.js"))
if os.IsNotExist(err) {
fmt.Println("No gulpfile.js present, skipping gulp watch")
return nil
} else if err != nil {
return err
}
_, err = exec.LookPath("gulp")
if err != nil {
fmt.Println("Cannot find gulp in PATH. Is it installed?")
return nil
}
cmd := exec.Command("gulp", "watch")
cmd.Stdin = os.Stdin
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
cmd.Env = append([]string{publicPathEnv}, os.Environ()...)
return cmd.Run()
} | go | func startGulp(publicPathEnv string, ctx context.Context) error {
_, err := os.Stat(filepath.Join(cnf.AppPath, "gulpfile.js"))
if os.IsNotExist(err) {
fmt.Println("No gulpfile.js present, skipping gulp watch")
return nil
} else if err != nil {
return err
}
_, err = exec.LookPath("gulp")
if err != nil {
fmt.Println("Cannot find gulp in PATH. Is it installed?")
return nil
}
cmd := exec.Command("gulp", "watch")
cmd.Stdin = os.Stdin
cmd.Stderr = os.Stderr
cmd.Stdout = os.Stdout
cmd.Env = append([]string{publicPathEnv}, os.Environ()...)
return cmd.Run()
} | [
"func",
"startGulp",
"(",
"publicPathEnv",
"string",
",",
"ctx",
"context",
".",
"Context",
")",
"error",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"filepath",
".",
"Join",
"(",
"cnf",
".",
"AppPath",
",",
"\"",
"\"",
")",
")",
"\n",
"if"... | // startGulp starts "gulp watch" if it can find gulpfile.js and the gulp command. | [
"startGulp",
"starts",
"gulp",
"watch",
"if",
"it",
"can",
"find",
"gulpfile",
".",
"js",
"and",
"the",
"gulp",
"command",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cmd/dev.go#L118-L141 |
15,669 | volatiletech/abcweb | cmd/dev.go | startRefresh | func startRefresh(publicPathEnv string, ctx context.Context) (*refresh.Manager, error) {
cfgFile := filepath.Join(cnf.AppPath, "watch.toml")
_, err := os.Stat(cfgFile)
if err != nil && !os.IsNotExist(err) {
return nil, err
}
c := &refreshConfig{
AppRoot: ".",
IgnoredFolders: []string{"vendor", "log", "logs", "tmp", "node_modules", "bin", "templates"},
IncludedExtensions: []string{".go", ".toml"},
BuildPath: os.TempDir(),
BuildDelay: 200,
BinaryName: "watch-build",
CommandFlags: []string{},
CommandEnv: []string{
fmt.Sprintf("%s_ENV=%s", cnf.AppEnvName, cnf.ActiveEnv),
},
EnableColors: true,
}
// Only read the config file if it exists, otherwise use the defaults above.
if !os.IsNotExist(err) {
_, err = toml.DecodeFile(cfgFile, c)
if err != nil {
return nil, err
}
}
// Append the APPNAME_SERVER_PUBLIC_PATH environment var to refresh libs CommandEnv.
c.CommandEnv = append(c.CommandEnv, publicPathEnv)
rc := &refresh.Configuration{
AppRoot: c.AppRoot,
IgnoredFolders: c.IgnoredFolders,
IncludedExtensions: c.IncludedExtensions,
BuildPath: c.BuildPath,
BuildDelay: c.BuildDelay,
BinaryName: c.BinaryName,
CommandFlags: c.CommandFlags,
CommandEnv: c.CommandEnv,
EnableColors: c.EnableColors,
LogName: c.LogName,
}
r := refresh.NewWithContext(rc, ctx)
return r, nil
} | go | func startRefresh(publicPathEnv string, ctx context.Context) (*refresh.Manager, error) {
cfgFile := filepath.Join(cnf.AppPath, "watch.toml")
_, err := os.Stat(cfgFile)
if err != nil && !os.IsNotExist(err) {
return nil, err
}
c := &refreshConfig{
AppRoot: ".",
IgnoredFolders: []string{"vendor", "log", "logs", "tmp", "node_modules", "bin", "templates"},
IncludedExtensions: []string{".go", ".toml"},
BuildPath: os.TempDir(),
BuildDelay: 200,
BinaryName: "watch-build",
CommandFlags: []string{},
CommandEnv: []string{
fmt.Sprintf("%s_ENV=%s", cnf.AppEnvName, cnf.ActiveEnv),
},
EnableColors: true,
}
// Only read the config file if it exists, otherwise use the defaults above.
if !os.IsNotExist(err) {
_, err = toml.DecodeFile(cfgFile, c)
if err != nil {
return nil, err
}
}
// Append the APPNAME_SERVER_PUBLIC_PATH environment var to refresh libs CommandEnv.
c.CommandEnv = append(c.CommandEnv, publicPathEnv)
rc := &refresh.Configuration{
AppRoot: c.AppRoot,
IgnoredFolders: c.IgnoredFolders,
IncludedExtensions: c.IncludedExtensions,
BuildPath: c.BuildPath,
BuildDelay: c.BuildDelay,
BinaryName: c.BinaryName,
CommandFlags: c.CommandFlags,
CommandEnv: c.CommandEnv,
EnableColors: c.EnableColors,
LogName: c.LogName,
}
r := refresh.NewWithContext(rc, ctx)
return r, nil
} | [
"func",
"startRefresh",
"(",
"publicPathEnv",
"string",
",",
"ctx",
"context",
".",
"Context",
")",
"(",
"*",
"refresh",
".",
"Manager",
",",
"error",
")",
"{",
"cfgFile",
":=",
"filepath",
".",
"Join",
"(",
"cnf",
".",
"AppPath",
",",
"\"",
"\"",
")",... | // startRefresh starts the refresh server to watch go files for recompilation. | [
"startRefresh",
"starts",
"the",
"refresh",
"server",
"to",
"watch",
"go",
"files",
"for",
"recompilation",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/cmd/dev.go#L159-L208 |
15,670 | volatiletech/abcweb | abcsessions/sessions.go | IsNoSessionError | func IsNoSessionError(err error) bool {
_, ok := err.(noSessionInterface)
if ok {
return ok
}
_, ok = errors.Cause(err).(noSessionInterface)
return ok
} | go | func IsNoSessionError(err error) bool {
_, ok := err.(noSessionInterface)
if ok {
return ok
}
_, ok = errors.Cause(err).(noSessionInterface)
return ok
} | [
"func",
"IsNoSessionError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"noSessionInterface",
")",
"\n",
"if",
"ok",
"{",
"return",
"ok",
"\n",
"}",
"\n\n",
"_",
",",
"ok",
"=",
"errors",
".",
"Cause",
"(",
"err",
... | // IsNoSessionError checks an error to see if it means that there was no session | [
"IsNoSessionError",
"checks",
"an",
"error",
"to",
"see",
"if",
"it",
"means",
"that",
"there",
"was",
"no",
"session"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L85-L93 |
15,671 | volatiletech/abcweb | abcsessions/sessions.go | IsNoMapKeyError | func IsNoMapKeyError(err error) bool {
_, ok := err.(noMapKeyInterface)
if ok {
return ok
}
_, ok = errors.Cause(err).(noMapKeyInterface)
return ok
} | go | func IsNoMapKeyError(err error) bool {
_, ok := err.(noMapKeyInterface)
if ok {
return ok
}
_, ok = errors.Cause(err).(noMapKeyInterface)
return ok
} | [
"func",
"IsNoMapKeyError",
"(",
"err",
"error",
")",
"bool",
"{",
"_",
",",
"ok",
":=",
"err",
".",
"(",
"noMapKeyInterface",
")",
"\n",
"if",
"ok",
"{",
"return",
"ok",
"\n",
"}",
"\n\n",
"_",
",",
"ok",
"=",
"errors",
".",
"Cause",
"(",
"err",
... | // IsNoMapKeyError checks an error to see if it means that there was
// no session map key | [
"IsNoMapKeyError",
"checks",
"an",
"error",
"to",
"see",
"if",
"it",
"means",
"that",
"there",
"was",
"no",
"session",
"map",
"key"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L97-L105 |
15,672 | volatiletech/abcweb | abcsessions/sessions.go | Set | func Set(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, value string) error {
var sess session
sessMap := make(map[string]string)
val, err := overseer.Get(w, r)
if err != nil && !IsNoSessionError(err) {
return errors.Wrap(err, "unable to get session")
}
if !IsNoSessionError(err) {
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session object")
}
if sess.Value != nil {
err = json.Unmarshal(*sess.Value, &sessMap)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session map value")
}
}
}
sessMap[key] = value
mv, err := json.Marshal(sessMap)
if err != nil {
return errors.Wrap(err, "unable to marshal session map value")
}
sess.Value = (*json.RawMessage)(&mv)
ret, err := json.Marshal(sess)
if err != nil {
return errors.Wrap(err, "unable to marshal session object")
}
return overseer.Set(w, r, string(ret))
} | go | func Set(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, value string) error {
var sess session
sessMap := make(map[string]string)
val, err := overseer.Get(w, r)
if err != nil && !IsNoSessionError(err) {
return errors.Wrap(err, "unable to get session")
}
if !IsNoSessionError(err) {
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session object")
}
if sess.Value != nil {
err = json.Unmarshal(*sess.Value, &sessMap)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session map value")
}
}
}
sessMap[key] = value
mv, err := json.Marshal(sessMap)
if err != nil {
return errors.Wrap(err, "unable to marshal session map value")
}
sess.Value = (*json.RawMessage)(&mv)
ret, err := json.Marshal(sess)
if err != nil {
return errors.Wrap(err, "unable to marshal session object")
}
return overseer.Set(w, r, string(ret))
} | [
"func",
"Set",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
",",
"value",
"string",
")",
"error",
"{",
"var",
"sess",
"session",
"\n",
"sessMap",
":=",
"make",
"(",
... | // Set is a JSON helper used for storing key-value session values.
// Set modifies the marshalled map stored in the session to include the key value pair passed in. | [
"Set",
"is",
"a",
"JSON",
"helper",
"used",
"for",
"storing",
"key",
"-",
"value",
"session",
"values",
".",
"Set",
"modifies",
"the",
"marshalled",
"map",
"stored",
"in",
"the",
"session",
"to",
"include",
"the",
"key",
"value",
"pair",
"passed",
"in",
... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L154-L191 |
15,673 | volatiletech/abcweb | abcsessions/sessions.go | Get | func Get(overseer Overseer, w http.ResponseWriter, r *http.Request, key string) (string, error) {
val, err := overseer.Get(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session")
}
var sess session
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session object")
}
var sessMap map[string]string
err = json.Unmarshal(*sess.Value, &sessMap)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session map value")
}
mapVal, ok := sessMap[key]
if !ok {
return "", errNoMapKey{}
}
return mapVal, nil
} | go | func Get(overseer Overseer, w http.ResponseWriter, r *http.Request, key string) (string, error) {
val, err := overseer.Get(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session")
}
var sess session
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session object")
}
var sessMap map[string]string
err = json.Unmarshal(*sess.Value, &sessMap)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session map value")
}
mapVal, ok := sessMap[key]
if !ok {
return "", errNoMapKey{}
}
return mapVal, nil
} | [
"func",
"Get",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"val",
",",
"err",
":=",
"overseer",
".",
"Get",
"(",
"w",... | // Get is a JSON helper used for retrieving key-value session values.
// Get returns the value pointed to by the key of the marshalled map stored in the session. | [
"Get",
"is",
"a",
"JSON",
"helper",
"used",
"for",
"retrieving",
"key",
"-",
"value",
"session",
"values",
".",
"Get",
"returns",
"the",
"value",
"pointed",
"to",
"by",
"the",
"key",
"of",
"the",
"marshalled",
"map",
"stored",
"in",
"the",
"session",
"."... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L195-L219 |
15,674 | volatiletech/abcweb | abcsessions/sessions.go | GetObj | func GetObj(overseer Overseer, w http.ResponseWriter, r *http.Request, pointer interface{}) error {
val, err := overseer.Get(w, r)
if err != nil {
return errors.Wrap(err, "unable to get session")
}
var sess session
// json unmarshal the outter session struct
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session object")
}
// json unmarshal the RawMessage value into the users pointer
err = json.Unmarshal(*sess.Value, pointer)
return errors.Wrap(err, "unable to unmarshal session value into pointer")
} | go | func GetObj(overseer Overseer, w http.ResponseWriter, r *http.Request, pointer interface{}) error {
val, err := overseer.Get(w, r)
if err != nil {
return errors.Wrap(err, "unable to get session")
}
var sess session
// json unmarshal the outter session struct
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return errors.Wrap(err, "unable to unmarshal session object")
}
// json unmarshal the RawMessage value into the users pointer
err = json.Unmarshal(*sess.Value, pointer)
return errors.Wrap(err, "unable to unmarshal session value into pointer")
} | [
"func",
"GetObj",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"pointer",
"interface",
"{",
"}",
")",
"error",
"{",
"val",
",",
"err",
":=",
"overseer",
".",
"Get",
"(",
"w",
",",
... | // GetObj is a JSON helper used for retrieving object or variable session values.
// GetObj unmarshals the session value into the pointer pointed to by pointer. | [
"GetObj",
"is",
"a",
"JSON",
"helper",
"used",
"for",
"retrieving",
"object",
"or",
"variable",
"session",
"values",
".",
"GetObj",
"unmarshals",
"the",
"session",
"value",
"into",
"the",
"pointer",
"pointed",
"to",
"by",
"pointer",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L296-L312 |
15,675 | volatiletech/abcweb | abcsessions/sessions.go | GetFlash | func GetFlash(overseer Overseer, w http.ResponseWriter, r *http.Request, key string) (string, error) {
var sess session
val, err := overseer.Get(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session")
}
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session object")
}
fv, ok := sess.Flash[key]
if !ok {
return "", errNoMapKey{}
}
var ret string
err = json.Unmarshal(*fv, &ret)
if err != nil {
return ret, errors.Wrap(err, "unable to unmarshal flash value")
}
delete(sess.Flash, key)
mv, err := json.Marshal(sess)
if err != nil {
return ret, errors.Wrap(err, "unable to marshal session object")
}
err = overseer.Set(w, r, string(mv))
return ret, errors.Wrap(err, "unable to set flash session object")
} | go | func GetFlash(overseer Overseer, w http.ResponseWriter, r *http.Request, key string) (string, error) {
var sess session
val, err := overseer.Get(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session")
}
err = json.Unmarshal([]byte(val), &sess)
if err != nil {
return "", errors.Wrap(err, "unable to unmarshal session object")
}
fv, ok := sess.Flash[key]
if !ok {
return "", errNoMapKey{}
}
var ret string
err = json.Unmarshal(*fv, &ret)
if err != nil {
return ret, errors.Wrap(err, "unable to unmarshal flash value")
}
delete(sess.Flash, key)
mv, err := json.Marshal(sess)
if err != nil {
return ret, errors.Wrap(err, "unable to marshal session object")
}
err = overseer.Set(w, r, string(mv))
return ret, errors.Wrap(err, "unable to set flash session object")
} | [
"func",
"GetFlash",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"sess",
"session",
"\n\n",
"val",
",",
"err",
":... | // GetFlash retrieves a flash message from the session then deletes it | [
"GetFlash",
"retrieves",
"a",
"flash",
"message",
"from",
"the",
"session",
"then",
"deletes",
"it"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L347-L380 |
15,676 | volatiletech/abcweb | abcsessions/sessions.go | AddFlashObj | func AddFlashObj(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, value interface{}) error {
mv, err := json.Marshal(value)
if err != nil {
return errors.Wrap(err, "unable to marshal flash value")
}
return AddFlash(overseer, w, r, key, string(mv))
} | go | func AddFlashObj(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, value interface{}) error {
mv, err := json.Marshal(value)
if err != nil {
return errors.Wrap(err, "unable to marshal flash value")
}
return AddFlash(overseer, w, r, key, string(mv))
} | [
"func",
"AddFlashObj",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"mv",
",",
"err",
":=",
"json",
".",
"Ma... | // AddFlashObj adds a flash message to the session that will be deleted when it is retrieved with GetFlash | [
"AddFlashObj",
"adds",
"a",
"flash",
"message",
"to",
"the",
"session",
"that",
"will",
"be",
"deleted",
"when",
"it",
"is",
"retrieved",
"with",
"GetFlash"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L383-L390 |
15,677 | volatiletech/abcweb | abcsessions/sessions.go | GetFlashObj | func GetFlashObj(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, pointer interface{}) error {
val, err := GetFlash(overseer, w, r, key)
if err != nil {
return errors.Wrap(err, "unable to get flash object")
}
return json.Unmarshal([]byte(val), pointer)
} | go | func GetFlashObj(overseer Overseer, w http.ResponseWriter, r *http.Request, key string, pointer interface{}) error {
val, err := GetFlash(overseer, w, r, key)
if err != nil {
return errors.Wrap(err, "unable to get flash object")
}
return json.Unmarshal([]byte(val), pointer)
} | [
"func",
"GetFlashObj",
"(",
"overseer",
"Overseer",
",",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"key",
"string",
",",
"pointer",
"interface",
"{",
"}",
")",
"error",
"{",
"val",
",",
"err",
":=",
"GetFlash",
"("... | // GetFlashObj unmarshals a flash message from the session into the users pointer
// then deletes it from the session. | [
"GetFlashObj",
"unmarshals",
"a",
"flash",
"message",
"from",
"the",
"session",
"into",
"the",
"users",
"pointer",
"then",
"deletes",
"it",
"from",
"the",
"session",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/sessions.go#L394-L401 |
15,678 | volatiletech/abcweb | abcsessions/disk.go | NewDiskStorer | func NewDiskStorer(folderPath string, maxAge, cleanInterval time.Duration) (*DiskStorer, error) {
if (maxAge != 0 && cleanInterval == 0) || (cleanInterval != 0 && maxAge == 0) {
panic("if max age or clean interval is set, the other must also be set")
}
d := &DiskStorer{
folderPath: folderPath,
maxAge: maxAge,
cleanInterval: cleanInterval,
}
// Create the storage folder if it does not exist
_, err := os.Stat(folderPath)
if os.IsNotExist(err) {
err := os.Mkdir(folderPath, os.FileMode(int(0755)))
if err != nil {
return nil, errors.Wrapf(err, "unable to make directory: %s", folderPath)
}
}
return d, nil
} | go | func NewDiskStorer(folderPath string, maxAge, cleanInterval time.Duration) (*DiskStorer, error) {
if (maxAge != 0 && cleanInterval == 0) || (cleanInterval != 0 && maxAge == 0) {
panic("if max age or clean interval is set, the other must also be set")
}
d := &DiskStorer{
folderPath: folderPath,
maxAge: maxAge,
cleanInterval: cleanInterval,
}
// Create the storage folder if it does not exist
_, err := os.Stat(folderPath)
if os.IsNotExist(err) {
err := os.Mkdir(folderPath, os.FileMode(int(0755)))
if err != nil {
return nil, errors.Wrapf(err, "unable to make directory: %s", folderPath)
}
}
return d, nil
} | [
"func",
"NewDiskStorer",
"(",
"folderPath",
"string",
",",
"maxAge",
",",
"cleanInterval",
"time",
".",
"Duration",
")",
"(",
"*",
"DiskStorer",
",",
"error",
")",
"{",
"if",
"(",
"maxAge",
"!=",
"0",
"&&",
"cleanInterval",
"==",
"0",
")",
"||",
"(",
"... | // NewDiskStorer initializes and returns a new DiskStorer object.
// It takes the maxAge of how long each session should live on disk,
// and a cleanInterval duration which defines how often the clean
// task should check for maxAge expired sessions to be removed from disk.
// Persistent storage can be attained by setting maxAge and cleanInterval
// to zero. | [
"NewDiskStorer",
"initializes",
"and",
"returns",
"a",
"new",
"DiskStorer",
"object",
".",
"It",
"takes",
"the",
"maxAge",
"of",
"how",
"long",
"each",
"session",
"should",
"live",
"on",
"disk",
"and",
"a",
"cleanInterval",
"duration",
"which",
"defines",
"how... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/disk.go#L48-L69 |
15,679 | volatiletech/abcweb | abcsessions/disk.go | All | func (d *DiskStorer) All() ([]string, error) {
files, err := ioutil.ReadDir(d.folderPath)
if err != nil {
return []string{}, errors.Wrapf(err, "unable to read directory: %s", d.folderPath)
}
sessions := make([]string, len(files))
for i := 0; i < len(files); i++ {
sessions[i] = files[i].Name()
}
return sessions, nil
} | go | func (d *DiskStorer) All() ([]string, error) {
files, err := ioutil.ReadDir(d.folderPath)
if err != nil {
return []string{}, errors.Wrapf(err, "unable to read directory: %s", d.folderPath)
}
sessions := make([]string, len(files))
for i := 0; i < len(files); i++ {
sessions[i] = files[i].Name()
}
return sessions, nil
} | [
"func",
"(",
"d",
"*",
"DiskStorer",
")",
"All",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"d",
".",
"folderPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"[... | // All keys in the disk store | [
"All",
"keys",
"in",
"the",
"disk",
"store"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/disk.go#L72-L85 |
15,680 | volatiletech/abcweb | abcsessions/disk.go | StartCleaner | func (d *DiskStorer) StartCleaner() {
if d.maxAge == 0 || d.cleanInterval == 0 {
panic("both max age and clean interval must be set to non-zero")
}
// init quit chan
d.quit = make(chan struct{})
d.wg.Add(1)
// Start the cleaner infinite loop go routine.
// StopCleaner() can be used to kill this go routine.
go d.cleanerLoop()
} | go | func (d *DiskStorer) StartCleaner() {
if d.maxAge == 0 || d.cleanInterval == 0 {
panic("both max age and clean interval must be set to non-zero")
}
// init quit chan
d.quit = make(chan struct{})
d.wg.Add(1)
// Start the cleaner infinite loop go routine.
// StopCleaner() can be used to kill this go routine.
go d.cleanerLoop()
} | [
"func",
"(",
"d",
"*",
"DiskStorer",
")",
"StartCleaner",
"(",
")",
"{",
"if",
"d",
".",
"maxAge",
"==",
"0",
"||",
"d",
".",
"cleanInterval",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// init quit chan",
"d",
".",
"quit",
... | // StartCleaner starts the disk session cleaner go routine. This go routine
// will delete expired disk sessions on the cleanInterval interval. | [
"StartCleaner",
"starts",
"the",
"disk",
"session",
"cleaner",
"go",
"routine",
".",
"This",
"go",
"routine",
"will",
"delete",
"expired",
"disk",
"sessions",
"on",
"the",
"cleanInterval",
"interval",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/disk.go#L167-L180 |
15,681 | volatiletech/abcweb | abcsessions/disk.go | Clean | func (d *DiskStorer) Clean() {
t := time.Now().UTC()
files, err := ioutil.ReadDir(d.folderPath)
if err != nil {
panic(err)
}
for _, file := range files {
tspec := times.Get(file)
// File is expired
if tspec.AccessTime().UTC().UTC().Add(d.maxAge).Before(t) {
filePath := path.Join(d.folderPath, file.Name())
d.mut.Lock()
_, err := os.Stat(filePath)
// If the file has been deleted manually from the server
// in between the time we read the directory and now, it will
// fail here with a ErrNotExist. If so, continue gracefully.
// It would be innefficient to hold a lock for the duration of
// the loop, so we only lock when we find an expired file.
if os.IsNotExist(err) {
d.mut.Unlock()
continue
} else if err != nil {
panic(err)
}
err = os.Remove(filePath)
d.mut.Unlock()
if err != nil {
panic(err)
}
}
}
} | go | func (d *DiskStorer) Clean() {
t := time.Now().UTC()
files, err := ioutil.ReadDir(d.folderPath)
if err != nil {
panic(err)
}
for _, file := range files {
tspec := times.Get(file)
// File is expired
if tspec.AccessTime().UTC().UTC().Add(d.maxAge).Before(t) {
filePath := path.Join(d.folderPath, file.Name())
d.mut.Lock()
_, err := os.Stat(filePath)
// If the file has been deleted manually from the server
// in between the time we read the directory and now, it will
// fail here with a ErrNotExist. If so, continue gracefully.
// It would be innefficient to hold a lock for the duration of
// the loop, so we only lock when we find an expired file.
if os.IsNotExist(err) {
d.mut.Unlock()
continue
} else if err != nil {
panic(err)
}
err = os.Remove(filePath)
d.mut.Unlock()
if err != nil {
panic(err)
}
}
}
} | [
"func",
"(",
"d",
"*",
"DiskStorer",
")",
"Clean",
"(",
")",
"{",
"t",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
"\n\n",
"files",
",",
"err",
":=",
"ioutil",
".",
"ReadDir",
"(",
"d",
".",
"folderPath",
")",
"\n\n",
"if",
"err",... | // Clean checks all session files on disk to see if they are older than
// maxAge by checking their access time. If it finds an expired session file
// it will remove it from disk. | [
"Clean",
"checks",
"all",
"session",
"files",
"on",
"disk",
"to",
"see",
"if",
"they",
"are",
"older",
"than",
"maxAge",
"by",
"checking",
"their",
"access",
"time",
".",
"If",
"it",
"finds",
"an",
"expired",
"session",
"file",
"it",
"will",
"remove",
"i... | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/disk.go#L202-L239 |
15,682 | volatiletech/abcweb | abcsessions/storage_overseer.go | NewStorageOverseer | func NewStorageOverseer(opts CookieOptions, storer Storer) *StorageOverseer {
if len(opts.Name) == 0 {
panic("cookie name must be provided")
}
o := &StorageOverseer{
Storer: storer,
options: opts,
}
o.resetExpiryMiddleware.resetter = o
return o
} | go | func NewStorageOverseer(opts CookieOptions, storer Storer) *StorageOverseer {
if len(opts.Name) == 0 {
panic("cookie name must be provided")
}
o := &StorageOverseer{
Storer: storer,
options: opts,
}
o.resetExpiryMiddleware.resetter = o
return o
} | [
"func",
"NewStorageOverseer",
"(",
"opts",
"CookieOptions",
",",
"storer",
"Storer",
")",
"*",
"StorageOverseer",
"{",
"if",
"len",
"(",
"opts",
".",
"Name",
")",
"==",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"o",
":=",
"&",
"Stor... | // NewStorageOverseer returns a new storage overseer | [
"NewStorageOverseer",
"returns",
"a",
"new",
"storage",
"overseer"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L18-L31 |
15,683 | volatiletech/abcweb | abcsessions/storage_overseer.go | Get | func (s *StorageOverseer) Get(w http.ResponseWriter, r *http.Request) (value string, err error) {
sessID, err := s.options.getCookieValue(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session id from cookie")
}
val, err := s.Storer.Get(sessID)
if err != nil {
return "", errors.Wrap(err, "unable to get session value")
}
return val, nil
} | go | func (s *StorageOverseer) Get(w http.ResponseWriter, r *http.Request) (value string, err error) {
sessID, err := s.options.getCookieValue(w, r)
if err != nil {
return "", errors.Wrap(err, "unable to get session id from cookie")
}
val, err := s.Storer.Get(sessID)
if err != nil {
return "", errors.Wrap(err, "unable to get session value")
}
return val, nil
} | [
"func",
"(",
"s",
"*",
"StorageOverseer",
")",
"Get",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"sessID",
",",
"err",
":=",
"s",
".",
"options",
".",
... | // Get looks in the cookie for the session ID and retrieves the value string stored in the session. | [
"Get",
"looks",
"in",
"the",
"cookie",
"for",
"the",
"session",
"ID",
"and",
"retrieves",
"the",
"value",
"string",
"stored",
"in",
"the",
"session",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L34-L46 |
15,684 | volatiletech/abcweb | abcsessions/storage_overseer.go | Set | func (s *StorageOverseer) Set(w http.ResponseWriter, r *http.Request, value string) error {
// Reuse the existing cookie ID if it exists
sessID, _ := s.options.getCookieValue(w, r)
if len(sessID) == 0 {
sessID = uuid.NewV4().String()
}
err := s.Storer.Set(sessID, value)
if err != nil {
return errors.Wrap(err, "unable to set session value")
}
w.(cookieWriter).SetCookie(s.options.makeCookie(sessID))
return nil
} | go | func (s *StorageOverseer) Set(w http.ResponseWriter, r *http.Request, value string) error {
// Reuse the existing cookie ID if it exists
sessID, _ := s.options.getCookieValue(w, r)
if len(sessID) == 0 {
sessID = uuid.NewV4().String()
}
err := s.Storer.Set(sessID, value)
if err != nil {
return errors.Wrap(err, "unable to set session value")
}
w.(cookieWriter).SetCookie(s.options.makeCookie(sessID))
return nil
} | [
"func",
"(",
"s",
"*",
"StorageOverseer",
")",
"Set",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
",",
"value",
"string",
")",
"error",
"{",
"// Reuse the existing cookie ID if it exists",
"sessID",
",",
"_",
":=",
"s",
... | // Set looks in the cookie for the session ID and modifies the session with the new value.
// If the session does not exist it creates a new one. | [
"Set",
"looks",
"in",
"the",
"cookie",
"for",
"the",
"session",
"ID",
"and",
"modifies",
"the",
"session",
"with",
"the",
"new",
"value",
".",
"If",
"the",
"session",
"does",
"not",
"exist",
"it",
"creates",
"a",
"new",
"one",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L50-L66 |
15,685 | volatiletech/abcweb | abcsessions/storage_overseer.go | Del | func (s *StorageOverseer) Del(w http.ResponseWriter, r *http.Request) error {
sessID, err := s.options.getCookieValue(w, r)
if err != nil {
return nil
}
s.options.deleteCookie(w)
err = s.Storer.Del(sessID)
if IsNoSessionError(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "unable to delete server-side session")
}
return nil
} | go | func (s *StorageOverseer) Del(w http.ResponseWriter, r *http.Request) error {
sessID, err := s.options.getCookieValue(w, r)
if err != nil {
return nil
}
s.options.deleteCookie(w)
err = s.Storer.Del(sessID)
if IsNoSessionError(err) {
return nil
} else if err != nil {
return errors.Wrap(err, "unable to delete server-side session")
}
return nil
} | [
"func",
"(",
"s",
"*",
"StorageOverseer",
")",
"Del",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"sessID",
",",
"err",
":=",
"s",
".",
"options",
".",
"getCookieValue",
"(",
"w",
",",
"r",
")"... | // Del deletes the session if it exists and sets the session cookie to expire instantly. | [
"Del",
"deletes",
"the",
"session",
"if",
"it",
"exists",
"and",
"sets",
"the",
"session",
"cookie",
"to",
"expire",
"instantly",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L69-L85 |
15,686 | volatiletech/abcweb | abcsessions/storage_overseer.go | Regenerate | func (s *StorageOverseer) Regenerate(w http.ResponseWriter, r *http.Request) error {
id, err := s.options.getCookieValue(w, r)
if err != nil {
return errors.Wrap(err, "unable to get session id from cookie")
}
val, err := s.Storer.Get(id)
if err != nil {
return errors.Wrap(err, "unable to get session value")
}
// Delete the old session
_ = s.Storer.Del(id)
// Generate a new ID
id = uuid.NewV4().String()
// Create a new session with the old value
if err = s.Storer.Set(id, val); err != nil {
return errors.Wrap(err, "unable to set session value")
}
// Override the old cookie with the new cookie
w.(cookieWriter).SetCookie(s.options.makeCookie(id))
return nil
} | go | func (s *StorageOverseer) Regenerate(w http.ResponseWriter, r *http.Request) error {
id, err := s.options.getCookieValue(w, r)
if err != nil {
return errors.Wrap(err, "unable to get session id from cookie")
}
val, err := s.Storer.Get(id)
if err != nil {
return errors.Wrap(err, "unable to get session value")
}
// Delete the old session
_ = s.Storer.Del(id)
// Generate a new ID
id = uuid.NewV4().String()
// Create a new session with the old value
if err = s.Storer.Set(id, val); err != nil {
return errors.Wrap(err, "unable to set session value")
}
// Override the old cookie with the new cookie
w.(cookieWriter).SetCookie(s.options.makeCookie(id))
return nil
} | [
"func",
"(",
"s",
"*",
"StorageOverseer",
")",
"Regenerate",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"error",
"{",
"id",
",",
"err",
":=",
"s",
".",
"options",
".",
"getCookieValue",
"(",
"w",
",",
"r",
... | // Regenerate a new session ID for your current session | [
"Regenerate",
"a",
"new",
"session",
"ID",
"for",
"your",
"current",
"session"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L88-L114 |
15,687 | volatiletech/abcweb | abcsessions/storage_overseer.go | SessionID | func (s *StorageOverseer) SessionID(w http.ResponseWriter, r *http.Request) (string, error) {
return s.options.getCookieValue(w, r)
} | go | func (s *StorageOverseer) SessionID(w http.ResponseWriter, r *http.Request) (string, error) {
return s.options.getCookieValue(w, r)
} | [
"func",
"(",
"s",
"*",
"StorageOverseer",
")",
"SessionID",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"string",
",",
"error",
")",
"{",
"return",
"s",
".",
"options",
".",
"getCookieValue",
"(",
"w",
",... | // SessionID returns the session ID stored in the cookie's value field.
// It will return a errNoSession error if no session exists. | [
"SessionID",
"returns",
"the",
"session",
"ID",
"stored",
"in",
"the",
"cookie",
"s",
"value",
"field",
".",
"It",
"will",
"return",
"a",
"errNoSession",
"error",
"if",
"no",
"session",
"exists",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/storage_overseer.go#L118-L120 |
15,688 | volatiletech/abcweb | abcrender/render.go | HTML | func (r *Render) HTML(w io.Writer, status int, name string, binding interface{}) error {
return r.Render.HTML(w, status, name, binding)
} | go | func (r *Render) HTML(w io.Writer, status int, name string, binding interface{}) error {
return r.Render.HTML(w, status, name, binding)
} | [
"func",
"(",
"r",
"*",
"Render",
")",
"HTML",
"(",
"w",
"io",
".",
"Writer",
",",
"status",
"int",
",",
"name",
"string",
",",
"binding",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"r",
".",
"Render",
".",
"HTML",
"(",
"w",
",",
"status"... | // HTML renders a HTML template by calling unrolled Render package's HTML function | [
"HTML",
"renders",
"a",
"HTML",
"template",
"by",
"calling",
"unrolled",
"Render",
"package",
"s",
"HTML",
"function"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L47-L49 |
15,689 | volatiletech/abcweb | abcrender/render.go | HTMLWithLayout | func (r *Render) HTMLWithLayout(w io.Writer, status int, name string, binding interface{}, layout string) error {
return r.Render.HTML(w, status, name, binding, render.HTMLOptions{Layout: layout})
} | go | func (r *Render) HTMLWithLayout(w io.Writer, status int, name string, binding interface{}, layout string) error {
return r.Render.HTML(w, status, name, binding, render.HTMLOptions{Layout: layout})
} | [
"func",
"(",
"r",
"*",
"Render",
")",
"HTMLWithLayout",
"(",
"w",
"io",
".",
"Writer",
",",
"status",
"int",
",",
"name",
"string",
",",
"binding",
"interface",
"{",
"}",
",",
"layout",
"string",
")",
"error",
"{",
"return",
"r",
".",
"Render",
".",
... | // HTMLWithLayout renders a HTML template using a specified layout file by calling
// unrolled Render package's HTML function with a HTMLOptions argument | [
"HTMLWithLayout",
"renders",
"a",
"HTML",
"template",
"using",
"a",
"specified",
"layout",
"file",
"by",
"calling",
"unrolled",
"Render",
"package",
"s",
"HTML",
"function",
"with",
"a",
"HTMLOptions",
"argument"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L53-L55 |
15,690 | volatiletech/abcweb | abcrender/render.go | New | func New(opts render.Options, manifest map[string]string) Renderer {
return &Render{
Render: render.New(opts),
assetsManifest: manifest,
}
} | go | func New(opts render.Options, manifest map[string]string) Renderer {
return &Render{
Render: render.New(opts),
assetsManifest: manifest,
}
} | [
"func",
"New",
"(",
"opts",
"render",
".",
"Options",
",",
"manifest",
"map",
"[",
"string",
"]",
"string",
")",
"Renderer",
"{",
"return",
"&",
"Render",
"{",
"Render",
":",
"render",
".",
"New",
"(",
"opts",
")",
",",
"assetsManifest",
":",
"manifest... | // New returns a new Render with AssetsManifest and Render set | [
"New",
"returns",
"a",
"new",
"Render",
"with",
"AssetsManifest",
"and",
"Render",
"set"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L58-L63 |
15,691 | volatiletech/abcweb | abcrender/render.go | GetManifest | func GetManifest(publicPath string) (map[string]string, error) {
manifestPath := filepath.Join(publicPath, "assets", "manifest.json")
contents, err := ioutil.ReadFile(manifestPath)
if err != nil {
return nil, err
}
if len(contents) == 0 {
return nil, errors.New("manifest.json is empty")
}
manifest := map[string]string{}
err = json.Unmarshal(contents, &manifest)
if err != nil {
return nil, errors.Wrap(err, "cannot unmarshal manifest.json")
}
if len(manifest) == 0 {
return nil, errors.New("manifest.json has no file mappings")
}
return manifest, nil
} | go | func GetManifest(publicPath string) (map[string]string, error) {
manifestPath := filepath.Join(publicPath, "assets", "manifest.json")
contents, err := ioutil.ReadFile(manifestPath)
if err != nil {
return nil, err
}
if len(contents) == 0 {
return nil, errors.New("manifest.json is empty")
}
manifest := map[string]string{}
err = json.Unmarshal(contents, &manifest)
if err != nil {
return nil, errors.Wrap(err, "cannot unmarshal manifest.json")
}
if len(manifest) == 0 {
return nil, errors.New("manifest.json has no file mappings")
}
return manifest, nil
} | [
"func",
"GetManifest",
"(",
"publicPath",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"manifestPath",
":=",
"filepath",
".",
"Join",
"(",
"publicPath",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"contents",
",",
... | // GetManifest reads the manifest.json file in the public assets folder
// and returns a map of its mappings. Returns error if manifest.json not found. | [
"GetManifest",
"reads",
"the",
"manifest",
".",
"json",
"file",
"in",
"the",
"public",
"assets",
"folder",
"and",
"returns",
"a",
"map",
"of",
"its",
"mappings",
".",
"Returns",
"error",
"if",
"manifest",
".",
"json",
"not",
"found",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L67-L87 |
15,692 | volatiletech/abcweb | abcrender/render.go | AppHelpers | func AppHelpers(manifest map[string]string) template.FuncMap {
return template.FuncMap{
"liveReload": liveReloadHelper,
"jsPath": func(relpath string) string { return manifestHelper("js", relpath, manifest) },
"cssPath": func(relpath string) string { return manifestHelper("css", relpath, manifest) },
"imgPath": func(relpath string) string { return manifestHelper("img", relpath, manifest) },
"videoPath": func(relpath string) string { return manifestHelper("video", relpath, manifest) },
"audioPath": func(relpath string) string { return manifestHelper("audio", relpath, manifest) },
"fontPath": func(relpath string) string { return manifestHelper("font", relpath, manifest) },
"assetPath": func(relpath string) string {
v, ok := manifest[relpath]
if !ok {
return "/assets/" + relpath
}
return "/assets/" + v
},
// wrap full asset paths in include tags
"cssTag": cssTag,
"jsTag": jsTag,
"joinPath": func(pieces ...string) string { return strings.Join(pieces, "/") },
// return all javascript include tags for all twitter bootstrap js plugins
// for the default bootstrap install.
"jsBootstrap": jsBootstrap,
}
} | go | func AppHelpers(manifest map[string]string) template.FuncMap {
return template.FuncMap{
"liveReload": liveReloadHelper,
"jsPath": func(relpath string) string { return manifestHelper("js", relpath, manifest) },
"cssPath": func(relpath string) string { return manifestHelper("css", relpath, manifest) },
"imgPath": func(relpath string) string { return manifestHelper("img", relpath, manifest) },
"videoPath": func(relpath string) string { return manifestHelper("video", relpath, manifest) },
"audioPath": func(relpath string) string { return manifestHelper("audio", relpath, manifest) },
"fontPath": func(relpath string) string { return manifestHelper("font", relpath, manifest) },
"assetPath": func(relpath string) string {
v, ok := manifest[relpath]
if !ok {
return "/assets/" + relpath
}
return "/assets/" + v
},
// wrap full asset paths in include tags
"cssTag": cssTag,
"jsTag": jsTag,
"joinPath": func(pieces ...string) string { return strings.Join(pieces, "/") },
// return all javascript include tags for all twitter bootstrap js plugins
// for the default bootstrap install.
"jsBootstrap": jsBootstrap,
}
} | [
"func",
"AppHelpers",
"(",
"manifest",
"map",
"[",
"string",
"]",
"string",
")",
"template",
".",
"FuncMap",
"{",
"return",
"template",
".",
"FuncMap",
"{",
"\"",
"\"",
":",
"liveReloadHelper",
",",
"\"",
"\"",
":",
"func",
"(",
"relpath",
"string",
")",... | // AppHelpers takes in the assets manifest and returns a map of the template
// helper functions. | [
"AppHelpers",
"takes",
"in",
"the",
"assets",
"manifest",
"and",
"returns",
"a",
"map",
"of",
"the",
"template",
"helper",
"functions",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L91-L118 |
15,693 | volatiletech/abcweb | abcrender/render.go | liveReloadHelper | func liveReloadHelper(relpath string, host string) string {
return fmt.Sprintf("/assets/js/%s?host=%s", relpath, host)
} | go | func liveReloadHelper(relpath string, host string) string {
return fmt.Sprintf("/assets/js/%s?host=%s", relpath, host)
} | [
"func",
"liveReloadHelper",
"(",
"relpath",
"string",
",",
"host",
"string",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"relpath",
",",
"host",
")",
"\n",
"}"
] | // liveReloadHelper is a helper to include the livereload javascript file
// and pass through a host queryparam so that it works properly. | [
"liveReloadHelper",
"is",
"a",
"helper",
"to",
"include",
"the",
"livereload",
"javascript",
"file",
"and",
"pass",
"through",
"a",
"host",
"queryparam",
"so",
"that",
"it",
"works",
"properly",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L130-L132 |
15,694 | volatiletech/abcweb | abcrender/render.go | cssTag | func cssTag(relpath string) template.HTML {
return template.HTML(fmt.Sprintf("<link href=\"%s\" rel=\"stylesheet\">", relpath))
} | go | func cssTag(relpath string) template.HTML {
return template.HTML(fmt.Sprintf("<link href=\"%s\" rel=\"stylesheet\">", relpath))
} | [
"func",
"cssTag",
"(",
"relpath",
"string",
")",
"template",
".",
"HTML",
"{",
"return",
"template",
".",
"HTML",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\\\"",
"\\\"",
"\"",
",",
"relpath",
")",
")",
"\n",
"}"
] | // cssTag wraps the asset path in a css link include tag | [
"cssTag",
"wraps",
"the",
"asset",
"path",
"in",
"a",
"css",
"link",
"include",
"tag"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L135-L137 |
15,695 | volatiletech/abcweb | abcrender/render.go | jsTag | func jsTag(relpath string) template.HTML {
return template.HTML(fmt.Sprintf("<script src=\"%s\"></script>", relpath))
} | go | func jsTag(relpath string) template.HTML {
return template.HTML(fmt.Sprintf("<script src=\"%s\"></script>", relpath))
} | [
"func",
"jsTag",
"(",
"relpath",
"string",
")",
"template",
".",
"HTML",
"{",
"return",
"template",
".",
"HTML",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"relpath",
")",
")",
"\n",
"}"
] | // jsTag wraps the asset path in a javascript script include tag | [
"jsTag",
"wraps",
"the",
"asset",
"path",
"in",
"a",
"javascript",
"script",
"include",
"tag"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L140-L142 |
15,696 | volatiletech/abcweb | abcrender/render.go | jsBootstrap | func jsBootstrap() template.HTML {
files := []string{
"/assets/js/bootstrap/transition.js",
"/assets/js/bootstrap/util.js",
"/assets/js/bootstrap/alert.js",
"/assets/js/bootstrap/button.js",
"/assets/js/bootstrap/carousel.js",
"/assets/js/bootstrap/collapse.js",
"/assets/js/bootstrap/dropdown.js",
"/assets/js/bootstrap/modal.js",
"/assets/js/bootstrap/scrollspy.js",
"/assets/js/bootstrap/tab.js",
"/assets/js/bootstrap/tooltip.js",
"/assets/js/bootstrap/popover.js",
}
buf := bytes.Buffer{}
for _, file := range files {
buf.WriteString(fmt.Sprintf("<script src=\"%s\"></script>\n", file))
}
return template.HTML(buf.String())
} | go | func jsBootstrap() template.HTML {
files := []string{
"/assets/js/bootstrap/transition.js",
"/assets/js/bootstrap/util.js",
"/assets/js/bootstrap/alert.js",
"/assets/js/bootstrap/button.js",
"/assets/js/bootstrap/carousel.js",
"/assets/js/bootstrap/collapse.js",
"/assets/js/bootstrap/dropdown.js",
"/assets/js/bootstrap/modal.js",
"/assets/js/bootstrap/scrollspy.js",
"/assets/js/bootstrap/tab.js",
"/assets/js/bootstrap/tooltip.js",
"/assets/js/bootstrap/popover.js",
}
buf := bytes.Buffer{}
for _, file := range files {
buf.WriteString(fmt.Sprintf("<script src=\"%s\"></script>\n", file))
}
return template.HTML(buf.String())
} | [
"func",
"jsBootstrap",
"(",
")",
"template",
".",
"HTML",
"{",
"files",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"... | // jsBootstrap returns all javascript include tags for all twitter bootstrap
// js plugins for the default generated bootstrap install. | [
"jsBootstrap",
"returns",
"all",
"javascript",
"include",
"tags",
"for",
"all",
"twitter",
"bootstrap",
"js",
"plugins",
"for",
"the",
"default",
"generated",
"bootstrap",
"install",
"."
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcrender/render.go#L146-L167 |
15,697 | volatiletech/abcweb | abcsessions/cookie_options.go | NewCookieOptions | func NewCookieOptions() CookieOptions {
return CookieOptions{
Name: "id",
Path: "/",
MaxAge: 0,
Secure: true,
HTTPOnly: true,
}
} | go | func NewCookieOptions() CookieOptions {
return CookieOptions{
Name: "id",
Path: "/",
MaxAge: 0,
Secure: true,
HTTPOnly: true,
}
} | [
"func",
"NewCookieOptions",
"(",
")",
"CookieOptions",
"{",
"return",
"CookieOptions",
"{",
"Name",
":",
"\"",
"\"",
",",
"Path",
":",
"\"",
"\"",
",",
"MaxAge",
":",
"0",
",",
"Secure",
":",
"true",
",",
"HTTPOnly",
":",
"true",
",",
"}",
"\n",
"}"
... | // NewCookieOptions gives healthy defaults for session cookies | [
"NewCookieOptions",
"gives",
"healthy",
"defaults",
"for",
"session",
"cookies"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_options.go#L27-L35 |
15,698 | volatiletech/abcweb | abcsessions/cookie_options.go | deleteCookie | func (c CookieOptions) deleteCookie(w http.ResponseWriter) {
cookie := &http.Cookie{
// If the browser refuses to delete it, set value to "" so subsequent
// requests replace it when it does not point to a valid session id.
Path: c.Path,
Domain: c.Domain,
Value: "",
Name: c.Name,
MaxAge: -1,
Expires: time.Now().UTC().AddDate(-1, 0, 0),
HttpOnly: c.HTTPOnly,
Secure: c.Secure,
}
w.(cookieWriter).SetCookie(cookie)
} | go | func (c CookieOptions) deleteCookie(w http.ResponseWriter) {
cookie := &http.Cookie{
// If the browser refuses to delete it, set value to "" so subsequent
// requests replace it when it does not point to a valid session id.
Path: c.Path,
Domain: c.Domain,
Value: "",
Name: c.Name,
MaxAge: -1,
Expires: time.Now().UTC().AddDate(-1, 0, 0),
HttpOnly: c.HTTPOnly,
Secure: c.Secure,
}
w.(cookieWriter).SetCookie(cookie)
} | [
"func",
"(",
"c",
"CookieOptions",
")",
"deleteCookie",
"(",
"w",
"http",
".",
"ResponseWriter",
")",
"{",
"cookie",
":=",
"&",
"http",
".",
"Cookie",
"{",
"// If the browser refuses to delete it, set value to \"\" so subsequent",
"// requests replace it when it does not po... | // deleteCookie sets the cookie to a deleted value to force the client to delete | [
"deleteCookie",
"sets",
"the",
"cookie",
"to",
"a",
"deleted",
"value",
"to",
"force",
"the",
"client",
"to",
"delete"
] | 9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66 | https://github.com/volatiletech/abcweb/blob/9e9ffe4fa86ed4e557dcc4b9d59ca5d3d91c6a66/abcsessions/cookie_options.go#L56-L71 |
15,699 | nbari/violetear | trie.go | contains | func (t *Trie) contains(path, version string) (*Trie, bool) {
for _, n := range t.Node {
if n.path == path && n.version == version {
return n, true
}
}
return nil, false
} | go | func (t *Trie) contains(path, version string) (*Trie, bool) {
for _, n := range t.Node {
if n.path == path && n.version == version {
return n, true
}
}
return nil, false
} | [
"func",
"(",
"t",
"*",
"Trie",
")",
"contains",
"(",
"path",
",",
"version",
"string",
")",
"(",
"*",
"Trie",
",",
"bool",
")",
"{",
"for",
"_",
",",
"n",
":=",
"range",
"t",
".",
"Node",
"{",
"if",
"n",
".",
"path",
"==",
"path",
"&&",
"n",
... | // contains check if path exists on node | [
"contains",
"check",
"if",
"path",
"exists",
"on",
"node"
] | 971f3729520176a408b28de36d6f283f13b8e6d3 | https://github.com/nbari/violetear/blob/971f3729520176a408b28de36d6f283f13b8e6d3/trie.go#L27-L34 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.