repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
xo/xo | internal/loader.go | LoadForeignKeys | func (tl TypeLoader) LoadForeignKeys(args *ArgType, tableMap map[string]*Type) (map[string]*ForeignKey, error) {
var err error
fkMap := map[string]*ForeignKey{}
for _, t := range tableMap {
// load keys per table
err = tl.LoadTableForeignKeys(args, tableMap, t, fkMap)
if err != nil {
return nil, err
}
}
// determine foreign key names
for _, fk := range fkMap {
fk.Name = args.ForeignKeyName(fkMap, fk)
}
// generate templates
for _, fk := range fkMap {
err = args.ExecuteTemplate(ForeignKeyTemplate, fk.Type.Name, fk.ForeignKey.ForeignKeyName, fk)
if err != nil {
return nil, err
}
}
return fkMap, nil
} | go | func (tl TypeLoader) LoadForeignKeys(args *ArgType, tableMap map[string]*Type) (map[string]*ForeignKey, error) {
var err error
fkMap := map[string]*ForeignKey{}
for _, t := range tableMap {
// load keys per table
err = tl.LoadTableForeignKeys(args, tableMap, t, fkMap)
if err != nil {
return nil, err
}
}
// determine foreign key names
for _, fk := range fkMap {
fk.Name = args.ForeignKeyName(fkMap, fk)
}
// generate templates
for _, fk := range fkMap {
err = args.ExecuteTemplate(ForeignKeyTemplate, fk.Type.Name, fk.ForeignKey.ForeignKeyName, fk)
if err != nil {
return nil, err
}
}
return fkMap, nil
} | [
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadForeignKeys",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"fkMap",
":=",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
"{",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"// load keys per table",
"err",
"=",
"tl",
".",
"LoadTableForeignKeys",
"(",
"args",
",",
"tableMap",
",",
"t",
",",
"fkMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// determine foreign key names",
"for",
"_",
",",
"fk",
":=",
"range",
"fkMap",
"{",
"fk",
".",
"Name",
"=",
"args",
".",
"ForeignKeyName",
"(",
"fkMap",
",",
"fk",
")",
"\n",
"}",
"\n\n",
"// generate templates",
"for",
"_",
",",
"fk",
":=",
"range",
"fkMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"ForeignKeyTemplate",
",",
"fk",
".",
"Type",
".",
"Name",
",",
"fk",
".",
"ForeignKey",
".",
"ForeignKeyName",
",",
"fk",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"fkMap",
",",
"nil",
"\n",
"}"
] | // LoadForeignKeys loads foreign keys. | [
"LoadForeignKeys",
"loads",
"foreign",
"keys",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L553-L579 | train |
xo/xo | internal/loader.go | LoadTableForeignKeys | func (tl TypeLoader) LoadTableForeignKeys(args *ArgType, tableMap map[string]*Type, typeTpl *Type, fkMap map[string]*ForeignKey) error {
var err error
// load foreign keys
foreignKeyList, err := tl.ForeignKeyList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// loop over foreign keys for table
for _, fk := range foreignKeyList {
var refTpl *Type
var col, refCol *Field
colLoop:
// find column
for _, f := range typeTpl.Fields {
if f.Col.ColumnName == fk.ColumnName {
col = f
break colLoop
}
}
refTplLoop:
// find ref table
for _, t := range tableMap {
if t.Table.TableName == fk.RefTableName {
refTpl = t
break refTplLoop
}
}
refColLoop:
// find ref column
for _, f := range refTpl.Fields {
if f.Col.ColumnName == fk.RefColumnName {
refCol = f
break refColLoop
}
}
// no ref col, but have ref tpl, so use primary key
if refTpl != nil && refCol == nil {
refCol = refTpl.PrimaryKey
}
// check everything was found
if col == nil || refTpl == nil || refCol == nil {
return errors.New("could not find col, refTpl, or refCol")
}
// foreign key name
if fk.ForeignKeyName == "" {
fk.ForeignKeyName = typeTpl.Table.TableName + "_" + col.Col.ColumnName + "_fkey"
}
// create foreign key template
fkMap[fk.ForeignKeyName] = &ForeignKey{
Schema: args.Schema,
Type: typeTpl,
Field: col,
RefType: refTpl,
RefField: refCol,
ForeignKey: fk,
}
}
return nil
} | go | func (tl TypeLoader) LoadTableForeignKeys(args *ArgType, tableMap map[string]*Type, typeTpl *Type, fkMap map[string]*ForeignKey) error {
var err error
// load foreign keys
foreignKeyList, err := tl.ForeignKeyList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// loop over foreign keys for table
for _, fk := range foreignKeyList {
var refTpl *Type
var col, refCol *Field
colLoop:
// find column
for _, f := range typeTpl.Fields {
if f.Col.ColumnName == fk.ColumnName {
col = f
break colLoop
}
}
refTplLoop:
// find ref table
for _, t := range tableMap {
if t.Table.TableName == fk.RefTableName {
refTpl = t
break refTplLoop
}
}
refColLoop:
// find ref column
for _, f := range refTpl.Fields {
if f.Col.ColumnName == fk.RefColumnName {
refCol = f
break refColLoop
}
}
// no ref col, but have ref tpl, so use primary key
if refTpl != nil && refCol == nil {
refCol = refTpl.PrimaryKey
}
// check everything was found
if col == nil || refTpl == nil || refCol == nil {
return errors.New("could not find col, refTpl, or refCol")
}
// foreign key name
if fk.ForeignKeyName == "" {
fk.ForeignKeyName = typeTpl.Table.TableName + "_" + col.Col.ColumnName + "_fkey"
}
// create foreign key template
fkMap[fk.ForeignKeyName] = &ForeignKey{
Schema: args.Schema,
Type: typeTpl,
Field: col,
RefType: refTpl,
RefField: refCol,
ForeignKey: fk,
}
}
return nil
} | [
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadTableForeignKeys",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
",",
"typeTpl",
"*",
"Type",
",",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// load foreign keys",
"foreignKeyList",
",",
"err",
":=",
"tl",
".",
"ForeignKeyList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"typeTpl",
".",
"Table",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// loop over foreign keys for table",
"for",
"_",
",",
"fk",
":=",
"range",
"foreignKeyList",
"{",
"var",
"refTpl",
"*",
"Type",
"\n",
"var",
"col",
",",
"refCol",
"*",
"Field",
"\n\n",
"colLoop",
":",
"// find column",
"for",
"_",
",",
"f",
":=",
"range",
"typeTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"fk",
".",
"ColumnName",
"{",
"col",
"=",
"f",
"\n",
"break",
"colLoop",
"\n",
"}",
"\n",
"}",
"\n\n",
"refTplLoop",
":",
"// find ref table",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"if",
"t",
".",
"Table",
".",
"TableName",
"==",
"fk",
".",
"RefTableName",
"{",
"refTpl",
"=",
"t",
"\n",
"break",
"refTplLoop",
"\n",
"}",
"\n",
"}",
"\n\n",
"refColLoop",
":",
"// find ref column",
"for",
"_",
",",
"f",
":=",
"range",
"refTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"fk",
".",
"RefColumnName",
"{",
"refCol",
"=",
"f",
"\n",
"break",
"refColLoop",
"\n",
"}",
"\n",
"}",
"\n\n",
"// no ref col, but have ref tpl, so use primary key",
"if",
"refTpl",
"!=",
"nil",
"&&",
"refCol",
"==",
"nil",
"{",
"refCol",
"=",
"refTpl",
".",
"PrimaryKey",
"\n",
"}",
"\n\n",
"// check everything was found",
"if",
"col",
"==",
"nil",
"||",
"refTpl",
"==",
"nil",
"||",
"refCol",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// foreign key name",
"if",
"fk",
".",
"ForeignKeyName",
"==",
"\"",
"\"",
"{",
"fk",
".",
"ForeignKeyName",
"=",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"",
"\"",
"+",
"col",
".",
"Col",
".",
"ColumnName",
"+",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// create foreign key template",
"fkMap",
"[",
"fk",
".",
"ForeignKeyName",
"]",
"=",
"&",
"ForeignKey",
"{",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Field",
":",
"col",
",",
"RefType",
":",
"refTpl",
",",
"RefField",
":",
"refCol",
",",
"ForeignKey",
":",
"fk",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // LoadTableForeignKeys loads schema foreign key definitions per table. | [
"LoadTableForeignKeys",
"loads",
"schema",
"foreign",
"key",
"definitions",
"per",
"table",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L582-L650 | train |
xo/xo | internal/loader.go | LoadIndexes | func (tl TypeLoader) LoadIndexes(args *ArgType, tableMap map[string]*Type) (map[string]*Index, error) {
var err error
ixMap := map[string]*Index{}
for _, t := range tableMap {
// load table indexes
err = tl.LoadTableIndexes(args, t, ixMap)
if err != nil {
return nil, err
}
}
// generate templates
for _, ix := range ixMap {
err = args.ExecuteTemplate(IndexTemplate, ix.Type.Name, ix.Index.IndexName, ix)
if err != nil {
return nil, err
}
}
return ixMap, nil
} | go | func (tl TypeLoader) LoadIndexes(args *ArgType, tableMap map[string]*Type) (map[string]*Index, error) {
var err error
ixMap := map[string]*Index{}
for _, t := range tableMap {
// load table indexes
err = tl.LoadTableIndexes(args, t, ixMap)
if err != nil {
return nil, err
}
}
// generate templates
for _, ix := range ixMap {
err = args.ExecuteTemplate(IndexTemplate, ix.Type.Name, ix.Index.IndexName, ix)
if err != nil {
return nil, err
}
}
return ixMap, nil
} | [
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadIndexes",
"(",
"args",
"*",
"ArgType",
",",
"tableMap",
"map",
"[",
"string",
"]",
"*",
"Type",
")",
"(",
"map",
"[",
"string",
"]",
"*",
"Index",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"ixMap",
":=",
"map",
"[",
"string",
"]",
"*",
"Index",
"{",
"}",
"\n",
"for",
"_",
",",
"t",
":=",
"range",
"tableMap",
"{",
"// load table indexes",
"err",
"=",
"tl",
".",
"LoadTableIndexes",
"(",
"args",
",",
"t",
",",
"ixMap",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// generate templates",
"for",
"_",
",",
"ix",
":=",
"range",
"ixMap",
"{",
"err",
"=",
"args",
".",
"ExecuteTemplate",
"(",
"IndexTemplate",
",",
"ix",
".",
"Type",
".",
"Name",
",",
"ix",
".",
"Index",
".",
"IndexName",
",",
"ix",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"ixMap",
",",
"nil",
"\n",
"}"
] | // LoadIndexes loads schema index definitions. | [
"LoadIndexes",
"loads",
"schema",
"index",
"definitions",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L653-L674 | train |
xo/xo | internal/loader.go | LoadTableIndexes | func (tl TypeLoader) LoadTableIndexes(args *ArgType, typeTpl *Type, ixMap map[string]*Index) error {
var err error
var priIxLoaded bool
// load indexes
indexList, err := tl.IndexList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// process indexes
for _, ix := range indexList {
// save whether or not the primary key index was processed
priIxLoaded = priIxLoaded || ix.IsPrimary || (ix.Origin == "pk")
// create index template
ixTpl := &Index{
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{},
Index: ix,
}
// load index columns
err = tl.LoadIndexColumns(args, ixTpl)
if err != nil {
return err
}
// build func name
args.BuildIndexFuncName(ixTpl)
ixMap[typeTpl.Table.TableName+"_"+ix.IndexName] = ixTpl
}
// search for primary key if it was skipped being set in the type
pk := typeTpl.PrimaryKey
if pk == nil {
for _, f := range typeTpl.Fields {
if f.Col.IsPrimaryKey {
pk = f
break
}
}
}
// if no primary key index loaded, but a primary key column was defined in
// the type, then create the definition here. this is needed for sqlite, as
// sqlite doesn't define primary keys in its index list
if args.LoaderType != "ora" && !priIxLoaded && pk != nil {
ixName := typeTpl.Table.TableName + "_" + pk.Col.ColumnName + "_pkey"
ixMap[ixName] = &Index{
FuncName: typeTpl.Name + "By" + pk.Name,
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{pk},
Index: &models.Index{
IndexName: ixName,
IsUnique: true,
IsPrimary: true,
},
}
}
return nil
} | go | func (tl TypeLoader) LoadTableIndexes(args *ArgType, typeTpl *Type, ixMap map[string]*Index) error {
var err error
var priIxLoaded bool
// load indexes
indexList, err := tl.IndexList(args.DB, args.Schema, typeTpl.Table.TableName)
if err != nil {
return err
}
// process indexes
for _, ix := range indexList {
// save whether or not the primary key index was processed
priIxLoaded = priIxLoaded || ix.IsPrimary || (ix.Origin == "pk")
// create index template
ixTpl := &Index{
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{},
Index: ix,
}
// load index columns
err = tl.LoadIndexColumns(args, ixTpl)
if err != nil {
return err
}
// build func name
args.BuildIndexFuncName(ixTpl)
ixMap[typeTpl.Table.TableName+"_"+ix.IndexName] = ixTpl
}
// search for primary key if it was skipped being set in the type
pk := typeTpl.PrimaryKey
if pk == nil {
for _, f := range typeTpl.Fields {
if f.Col.IsPrimaryKey {
pk = f
break
}
}
}
// if no primary key index loaded, but a primary key column was defined in
// the type, then create the definition here. this is needed for sqlite, as
// sqlite doesn't define primary keys in its index list
if args.LoaderType != "ora" && !priIxLoaded && pk != nil {
ixName := typeTpl.Table.TableName + "_" + pk.Col.ColumnName + "_pkey"
ixMap[ixName] = &Index{
FuncName: typeTpl.Name + "By" + pk.Name,
Schema: args.Schema,
Type: typeTpl,
Fields: []*Field{pk},
Index: &models.Index{
IndexName: ixName,
IsUnique: true,
IsPrimary: true,
},
}
}
return nil
} | [
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadTableIndexes",
"(",
"args",
"*",
"ArgType",
",",
"typeTpl",
"*",
"Type",
",",
"ixMap",
"map",
"[",
"string",
"]",
"*",
"Index",
")",
"error",
"{",
"var",
"err",
"error",
"\n",
"var",
"priIxLoaded",
"bool",
"\n\n",
"// load indexes",
"indexList",
",",
"err",
":=",
"tl",
".",
"IndexList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"typeTpl",
".",
"Table",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// process indexes",
"for",
"_",
",",
"ix",
":=",
"range",
"indexList",
"{",
"// save whether or not the primary key index was processed",
"priIxLoaded",
"=",
"priIxLoaded",
"||",
"ix",
".",
"IsPrimary",
"||",
"(",
"ix",
".",
"Origin",
"==",
"\"",
"\"",
")",
"\n\n",
"// create index template",
"ixTpl",
":=",
"&",
"Index",
"{",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Fields",
":",
"[",
"]",
"*",
"Field",
"{",
"}",
",",
"Index",
":",
"ix",
",",
"}",
"\n\n",
"// load index columns",
"err",
"=",
"tl",
".",
"LoadIndexColumns",
"(",
"args",
",",
"ixTpl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// build func name",
"args",
".",
"BuildIndexFuncName",
"(",
"ixTpl",
")",
"\n\n",
"ixMap",
"[",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"",
"\"",
"+",
"ix",
".",
"IndexName",
"]",
"=",
"ixTpl",
"\n",
"}",
"\n\n",
"// search for primary key if it was skipped being set in the type",
"pk",
":=",
"typeTpl",
".",
"PrimaryKey",
"\n",
"if",
"pk",
"==",
"nil",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"typeTpl",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"IsPrimaryKey",
"{",
"pk",
"=",
"f",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// if no primary key index loaded, but a primary key column was defined in",
"// the type, then create the definition here. this is needed for sqlite, as",
"// sqlite doesn't define primary keys in its index list",
"if",
"args",
".",
"LoaderType",
"!=",
"\"",
"\"",
"&&",
"!",
"priIxLoaded",
"&&",
"pk",
"!=",
"nil",
"{",
"ixName",
":=",
"typeTpl",
".",
"Table",
".",
"TableName",
"+",
"\"",
"\"",
"+",
"pk",
".",
"Col",
".",
"ColumnName",
"+",
"\"",
"\"",
"\n",
"ixMap",
"[",
"ixName",
"]",
"=",
"&",
"Index",
"{",
"FuncName",
":",
"typeTpl",
".",
"Name",
"+",
"\"",
"\"",
"+",
"pk",
".",
"Name",
",",
"Schema",
":",
"args",
".",
"Schema",
",",
"Type",
":",
"typeTpl",
",",
"Fields",
":",
"[",
"]",
"*",
"Field",
"{",
"pk",
"}",
",",
"Index",
":",
"&",
"models",
".",
"Index",
"{",
"IndexName",
":",
"ixName",
",",
"IsUnique",
":",
"true",
",",
"IsPrimary",
":",
"true",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // LoadTableIndexes loads schema index definitions per table. | [
"LoadTableIndexes",
"loads",
"schema",
"index",
"definitions",
"per",
"table",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L677-L742 | train |
xo/xo | internal/loader.go | LoadIndexColumns | func (tl TypeLoader) LoadIndexColumns(args *ArgType, ixTpl *Index) error {
var err error
// load index columns
indexCols, err := tl.IndexColumnList(args.DB, args.Schema, ixTpl.Type.Table.TableName, ixTpl.Index.IndexName)
if err != nil {
return err
}
// process index columns
for _, ic := range indexCols {
var field *Field
fieldLoop:
// find field
for _, f := range ixTpl.Type.Fields {
if f.Col.ColumnName == ic.ColumnName {
field = f
break fieldLoop
}
}
if field == nil {
continue
}
ixTpl.Fields = append(ixTpl.Fields, field)
}
return nil
} | go | func (tl TypeLoader) LoadIndexColumns(args *ArgType, ixTpl *Index) error {
var err error
// load index columns
indexCols, err := tl.IndexColumnList(args.DB, args.Schema, ixTpl.Type.Table.TableName, ixTpl.Index.IndexName)
if err != nil {
return err
}
// process index columns
for _, ic := range indexCols {
var field *Field
fieldLoop:
// find field
for _, f := range ixTpl.Type.Fields {
if f.Col.ColumnName == ic.ColumnName {
field = f
break fieldLoop
}
}
if field == nil {
continue
}
ixTpl.Fields = append(ixTpl.Fields, field)
}
return nil
} | [
"func",
"(",
"tl",
"TypeLoader",
")",
"LoadIndexColumns",
"(",
"args",
"*",
"ArgType",
",",
"ixTpl",
"*",
"Index",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// load index columns",
"indexCols",
",",
"err",
":=",
"tl",
".",
"IndexColumnList",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"ixTpl",
".",
"Type",
".",
"Table",
".",
"TableName",
",",
"ixTpl",
".",
"Index",
".",
"IndexName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// process index columns",
"for",
"_",
",",
"ic",
":=",
"range",
"indexCols",
"{",
"var",
"field",
"*",
"Field",
"\n\n",
"fieldLoop",
":",
"// find field",
"for",
"_",
",",
"f",
":=",
"range",
"ixTpl",
".",
"Type",
".",
"Fields",
"{",
"if",
"f",
".",
"Col",
".",
"ColumnName",
"==",
"ic",
".",
"ColumnName",
"{",
"field",
"=",
"f",
"\n",
"break",
"fieldLoop",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"field",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"ixTpl",
".",
"Fields",
"=",
"append",
"(",
"ixTpl",
".",
"Fields",
",",
"field",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // LoadIndexColumns loads the index column information. | [
"LoadIndexColumns",
"loads",
"the",
"index",
"column",
"information",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/loader.go#L745-L775 | train |
xo/xo | examples/django/postgres/authpermission.xo.go | AuthPermissionByContentTypeIDCodename | func AuthPermissionByContentTypeIDCodename(db XODB, contentTypeID int, codename string) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE content_type_id = $1 AND codename = $2`
// run query
XOLog(sqlstr, contentTypeID, codename)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, contentTypeID, codename).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | go | func AuthPermissionByContentTypeIDCodename(db XODB, contentTypeID int, codename string) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE content_type_id = $1 AND codename = $2`
// run query
XOLog(sqlstr, contentTypeID, codename)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, contentTypeID, codename).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | [
"func",
"AuthPermissionByContentTypeIDCodename",
"(",
"db",
"XODB",
",",
"contentTypeID",
"int",
",",
"codename",
"string",
")",
"(",
"*",
"AuthPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name, content_type_id, codename `",
"+",
"`FROM public.auth_permission `",
"+",
"`WHERE content_type_id = $1 AND codename = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"contentTypeID",
",",
"codename",
")",
"\n",
"ap",
":=",
"AuthPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"contentTypeID",
",",
"codename",
")",
".",
"Scan",
"(",
"&",
"ap",
".",
"ID",
",",
"&",
"ap",
".",
"Name",
",",
"&",
"ap",
".",
"ContentTypeID",
",",
"&",
"ap",
".",
"Codename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ap",
",",
"nil",
"\n",
"}"
] | // AuthPermissionByContentTypeIDCodename retrieves a row from 'public.auth_permission' as a AuthPermission.
//
// Generated from index 'auth_permission_content_type_id_01ab375a_uniq'. | [
"AuthPermissionByContentTypeIDCodename",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_permission",
"as",
"a",
"AuthPermission",
".",
"Generated",
"from",
"index",
"auth_permission_content_type_id_01ab375a_uniq",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authpermission.xo.go#L210-L231 | train |
xo/xo | examples/django/postgres/authpermission.xo.go | AuthPermissionByID | func AuthPermissionByID(db XODB, id int) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | go | func AuthPermissionByID(db XODB, id int) (*AuthPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, name, content_type_id, codename ` +
`FROM public.auth_permission ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
ap := AuthPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&ap.ID, &ap.Name, &ap.ContentTypeID, &ap.Codename)
if err != nil {
return nil, err
}
return &ap, nil
} | [
"func",
"AuthPermissionByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, name, content_type_id, codename `",
"+",
"`FROM public.auth_permission `",
"+",
"`WHERE id = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"ap",
":=",
"AuthPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"ap",
".",
"ID",
",",
"&",
"ap",
".",
"Name",
",",
"&",
"ap",
".",
"ContentTypeID",
",",
"&",
"ap",
".",
"Codename",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ap",
",",
"nil",
"\n",
"}"
] | // AuthPermissionByID retrieves a row from 'public.auth_permission' as a AuthPermission.
//
// Generated from index 'auth_permission_pkey'. | [
"AuthPermissionByID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_permission",
"as",
"a",
"AuthPermission",
".",
"Generated",
"from",
"index",
"auth_permission_pkey",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authpermission.xo.go#L236-L257 | train |
xo/xo | models/sequence.xo.go | PgSequences | func PgSequences(db XODB, schema string) ([]*Sequence, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.relname ` + // ::varchar AS table_name
`FROM pg_class s ` +
`JOIN pg_depend d ON d.objid = s.oid ` +
`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid ` +
`JOIN pg_namespace n ON n.oid = s.relnamespace ` +
`WHERE n.nspname = $1 AND s.relkind = 'S'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Sequence{}
for q.Next() {
s := Sequence{}
// scan
err = q.Scan(&s.TableName)
if err != nil {
return nil, err
}
res = append(res, &s)
}
return res, nil
} | go | func PgSequences(db XODB, schema string) ([]*Sequence, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`t.relname ` + // ::varchar AS table_name
`FROM pg_class s ` +
`JOIN pg_depend d ON d.objid = s.oid ` +
`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid ` +
`JOIN pg_namespace n ON n.oid = s.relnamespace ` +
`WHERE n.nspname = $1 AND s.relkind = 'S'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Sequence{}
for q.Next() {
s := Sequence{}
// scan
err = q.Scan(&s.TableName)
if err != nil {
return nil, err
}
res = append(res, &s)
}
return res, nil
} | [
"func",
"PgSequences",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"Sequence",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`t.relname `",
"+",
"// ::varchar AS table_name",
"`FROM pg_class s `",
"+",
"`JOIN pg_depend d ON d.objid = s.oid `",
"+",
"`JOIN pg_class t ON d.objid = s.oid AND d.refobjid = t.oid `",
"+",
"`JOIN pg_namespace n ON n.oid = s.relnamespace `",
"+",
"`WHERE n.nspname = $1 AND s.relkind = 'S'`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"Sequence",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"s",
":=",
"Sequence",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"s",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"s",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgSequences runs a custom query, returning results as Sequence. | [
"PgSequences",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Sequence",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/sequence.xo.go#L12-L47 | train |
xo/xo | models/sqcolumn.xo.go | SqTableColumns | func SqTableColumns(db XODB, table string) ([]*SqColumn, error) {
var err error
// sql query
var sqlstr = `PRAGMA table_info(` + table + `)`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqColumn{}
for q.Next() {
sc := SqColumn{}
// scan
err = q.Scan(&sc.FieldOrdinal, &sc.ColumnName, &sc.DataType, &sc.NotNull, &sc.DefaultValue, &sc.PkColIndex)
if err != nil {
return nil, err
}
res = append(res, &sc)
}
return res, nil
} | go | func SqTableColumns(db XODB, table string) ([]*SqColumn, error) {
var err error
// sql query
var sqlstr = `PRAGMA table_info(` + table + `)`
// run query
XOLog(sqlstr)
q, err := db.Query(sqlstr, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*SqColumn{}
for q.Next() {
sc := SqColumn{}
// scan
err = q.Scan(&sc.FieldOrdinal, &sc.ColumnName, &sc.DataType, &sc.NotNull, &sc.DefaultValue, &sc.PkColIndex)
if err != nil {
return nil, err
}
res = append(res, &sc)
}
return res, nil
} | [
"func",
"SqTableColumns",
"(",
"db",
"XODB",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"SqColumn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"var",
"sqlstr",
"=",
"`PRAGMA table_info(`",
"+",
"table",
"+",
"`)`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"SqColumn",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"sc",
":=",
"SqColumn",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"sc",
".",
"FieldOrdinal",
",",
"&",
"sc",
".",
"ColumnName",
",",
"&",
"sc",
".",
"DataType",
",",
"&",
"sc",
".",
"NotNull",
",",
"&",
"sc",
".",
"DefaultValue",
",",
"&",
"sc",
".",
"PkColIndex",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"sc",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // SqTableColumns runs a custom query, returning results as SqColumn. | [
"SqTableColumns",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"SqColumn",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/sqcolumn.xo.go#L21-L50 | train |
xo/xo | examples/django/oracle/authuseruserpermission.xo.go | Save | func (auup *AuthUserUserPermission) Save(db XODB) error {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
} | go | func (auup *AuthUserUserPermission) Save(db XODB) error {
if auup.Exists() {
return auup.Update(db)
}
return auup.Insert(db)
} | [
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"auup",
".",
"Exists",
"(",
")",
"{",
"return",
"auup",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n\n",
"return",
"auup",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] | // Save saves the AuthUserUserPermission to the database. | [
"Save",
"saves",
"the",
"AuthUserUserPermission",
"to",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L90-L96 | train |
xo/xo | examples/django/oracle/authuseruserpermission.xo.go | AuthUserUserPermissionByUserIDPermissionID | func AuthUserUserPermissionByUserIDPermissionID(db XODB, userID float64, permissionID float64) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, userID, permissionID)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, permissionID).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | go | func AuthUserUserPermissionByUserIDPermissionID(db XODB, userID float64, permissionID float64) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, userID, permissionID)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, userID, permissionID).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | [
"func",
"AuthUserUserPermissionByUserIDPermissionID",
"(",
"db",
"XODB",
",",
"userID",
"float64",
",",
"permissionID",
"float64",
")",
"(",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM django.auth_user_user_permissions `",
"+",
"`WHERE user_id = :1 AND permission_id = :2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"userID",
",",
"permissionID",
")",
"\n",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"userID",
",",
"permissionID",
")",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"auup",
",",
"nil",
"\n",
"}"
] | // AuthUserUserPermissionByUserIDPermissionID retrieves a row from 'django.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_use_user_id_14a6b632_uniq'. | [
"AuthUserUserPermissionByUserIDPermissionID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_use_user_id_14a6b632_uniq",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L145-L166 | train |
xo/xo | examples/django/oracle/authuseruserpermission.xo.go | AuthUserUserPermissionsByUserID | func AuthUserUserPermissionsByUserID(db XODB, userID float64) ([]*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1`
// run query
XOLog(sqlstr, userID)
q, err := db.Query(sqlstr, userID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserUserPermission{}
for q.Next() {
auup := AuthUserUserPermission{
_exists: true,
}
// scan
err = q.Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &auup)
}
return res, nil
} | go | func AuthUserUserPermissionsByUserID(db XODB, userID float64) ([]*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM django.auth_user_user_permissions ` +
`WHERE user_id = :1`
// run query
XOLog(sqlstr, userID)
q, err := db.Query(sqlstr, userID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserUserPermission{}
for q.Next() {
auup := AuthUserUserPermission{
_exists: true,
}
// scan
err = q.Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
res = append(res, &auup)
}
return res, nil
} | [
"func",
"AuthUserUserPermissionsByUserID",
"(",
"db",
"XODB",
",",
"userID",
"float64",
")",
"(",
"[",
"]",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM django.auth_user_user_permissions `",
"+",
"`WHERE user_id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"userID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"userID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"AuthUserUserPermission",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"auup",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // AuthUserUserPermissionsByUserID retrieves a row from 'django.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_user_user_permissions1cca'. | [
"AuthUserUserPermissionsByUserID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_user_user_permissions1cca",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuseruserpermission.xo.go#L171-L205 | train |
xo/xo | examples/django/sqlite3/djangomigration.xo.go | Save | func (dm *DjangoMigration) Save(db XODB) error {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
} | go | func (dm *DjangoMigration) Save(db XODB) error {
if dm.Exists() {
return dm.Update(db)
}
return dm.Insert(db)
} | [
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Save",
"(",
"db",
"XODB",
")",
"error",
"{",
"if",
"dm",
".",
"Exists",
"(",
")",
"{",
"return",
"dm",
".",
"Update",
"(",
"db",
")",
"\n",
"}",
"\n\n",
"return",
"dm",
".",
"Insert",
"(",
"db",
")",
"\n",
"}"
] | // Save saves the DjangoMigration to the database. | [
"Save",
"saves",
"the",
"DjangoMigration",
"to",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/djangomigration.xo.go#L94-L100 | train |
xo/xo | loaders/mysql.go | MySchema | func MySchema(args *internal.ArgType) (string, error) {
var err error
// sql query
const sqlstr = `SELECT SCHEMA()`
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
} | go | func MySchema(args *internal.ArgType) (string, error) {
var err error
// sql query
const sqlstr = `SELECT SCHEMA()`
var schema string
// run query
models.XOLog(sqlstr)
err = args.DB.QueryRow(sqlstr).Scan(&schema)
if err != nil {
return "", err
}
return schema, nil
} | [
"func",
"MySchema",
"(",
"args",
"*",
"internal",
".",
"ArgType",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT SCHEMA()`",
"\n\n",
"var",
"schema",
"string",
"\n\n",
"// run query",
"models",
".",
"XOLog",
"(",
"sqlstr",
")",
"\n",
"err",
"=",
"args",
".",
"DB",
".",
"QueryRow",
"(",
"sqlstr",
")",
".",
"Scan",
"(",
"&",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"schema",
",",
"nil",
"\n",
"}"
] | // MySchema retrieves the name of the current schema. | [
"MySchema",
"retrieves",
"the",
"name",
"of",
"the",
"current",
"schema",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L35-L51 | train |
xo/xo | loaders/mysql.go | MyEnumValues | func MyEnumValues(db models.XODB, schema string, enum string) ([]*models.EnumValue, error) {
var err error
// load enum vals
res, err := models.MyEnumValues(db, schema, enum)
if err != nil {
return nil, err
}
// process enum vals
enumVals := []*models.EnumValue{}
for i, ev := range strings.Split(res.EnumValues[1:len(res.EnumValues)-1], "','") {
enumVals = append(enumVals, &models.EnumValue{
EnumValue: ev,
ConstValue: i + 1,
})
}
return enumVals, nil
} | go | func MyEnumValues(db models.XODB, schema string, enum string) ([]*models.EnumValue, error) {
var err error
// load enum vals
res, err := models.MyEnumValues(db, schema, enum)
if err != nil {
return nil, err
}
// process enum vals
enumVals := []*models.EnumValue{}
for i, ev := range strings.Split(res.EnumValues[1:len(res.EnumValues)-1], "','") {
enumVals = append(enumVals, &models.EnumValue{
EnumValue: ev,
ConstValue: i + 1,
})
}
return enumVals, nil
} | [
"func",
"MyEnumValues",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"enum",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"EnumValue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// load enum vals",
"res",
",",
"err",
":=",
"models",
".",
"MyEnumValues",
"(",
"db",
",",
"schema",
",",
"enum",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// process enum vals",
"enumVals",
":=",
"[",
"]",
"*",
"models",
".",
"EnumValue",
"{",
"}",
"\n",
"for",
"i",
",",
"ev",
":=",
"range",
"strings",
".",
"Split",
"(",
"res",
".",
"EnumValues",
"[",
"1",
":",
"len",
"(",
"res",
".",
"EnumValues",
")",
"-",
"1",
"]",
",",
"\"",
"\"",
")",
"{",
"enumVals",
"=",
"append",
"(",
"enumVals",
",",
"&",
"models",
".",
"EnumValue",
"{",
"EnumValue",
":",
"ev",
",",
"ConstValue",
":",
"i",
"+",
"1",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"enumVals",
",",
"nil",
"\n",
"}"
] | // MyEnumValues loads the enum values. | [
"MyEnumValues",
"loads",
"the",
"enum",
"values",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L221-L240 | train |
xo/xo | loaders/mysql.go | MyTables | func MyTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MyTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Autoincrementing included
autoIncrements, err := models.MyAutoIncrements(db, schema)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.MyAutoIncrement{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the autoincrement
for _, autoInc := range autoIncrements {
if autoInc.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | go | func MyTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MyTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Autoincrementing included
autoIncrements, err := models.MyAutoIncrements(db, schema)
if err != nil {
// Set it to an empty set on error.
autoIncrements = []*models.MyAutoIncrement{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the autoincrement
for _, autoInc := range autoIncrements {
if autoInc.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | [
"func",
"MyTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// get the tables",
"rows",
",",
"err",
":=",
"models",
".",
"MyTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// get the tables that have Autoincrementing included",
"autoIncrements",
",",
"err",
":=",
"models",
".",
"MyAutoIncrements",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Set it to an empty set on error.",
"autoIncrements",
"=",
"[",
"]",
"*",
"models",
".",
"MyAutoIncrement",
"{",
"}",
"\n",
"}",
"\n\n",
"// Add information about manual FK.",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"// Look for a match in the table name where it contains the autoincrement",
"for",
"_",
",",
"autoInc",
":=",
"range",
"autoIncrements",
"{",
"if",
"autoInc",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] | // MyTables returns the MySql tables with the manual PK information added.
// ManualPk is true when the table's primary key is not autoincrement. | [
"MyTables",
"returns",
"the",
"MySql",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"s",
"primary",
"key",
"is",
"not",
"autoincrement",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L244-L278 | train |
xo/xo | loaders/mysql.go | MyQueryColumns | func MyQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MyTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
} | go | func MyQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MyTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
} | [
"func",
"MyQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// create temporary view xoid",
"xoid",
":=",
"\"",
"\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE VIEW `",
"+",
"xoid",
"+",
"` AS (`",
"+",
"strings",
".",
"Join",
"(",
"inspect",
",",
"\"",
"\\n",
"\"",
")",
"+",
"`)`",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// load columns",
"cols",
",",
"err",
":=",
"models",
".",
"MyTableColumns",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"xoid",
")",
"\n\n",
"// drop inspect view",
"dropq",
":=",
"`DROP VIEW `",
"+",
"xoid",
"\n",
"models",
".",
"XOLog",
"(",
"dropq",
")",
"\n",
"_",
",",
"_",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"dropq",
")",
"\n\n",
"// load column information",
"return",
"cols",
",",
"err",
"\n",
"}"
] | // MyQueryColumns parses the query and generates a type for it. | [
"MyQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mysql.go#L281-L303 | train |
xo/xo | internal/argtype.go | NewDefaultArgs | func NewDefaultArgs() *ArgType {
fkMode := FkModeSmart
return &ArgType{
Suffix: ".xo.go",
Int32Type: "int",
Uint32Type: "uint",
ForeignKeyMode: &fkMode,
QueryParamDelimiter: "%%",
NameConflictSuffix: "Val",
// KnownTypeMap is the collection of known Go types.
KnownTypeMap: map[string]bool{
"bool": true,
"string": true,
"byte": true,
"rune": true,
"int": true,
"int16": true,
"int32": true,
"int64": true,
"uint": true,
"uint8": true,
"uint16": true,
"uint32": true,
"uint64": true,
"float32": true,
"float64": true,
"Slice": true,
"StringSlice": true,
},
// ShortNameTypeMap is the collection of Go style short names for types, mainly
// used for use with declaring a func receiver on a type.
ShortNameTypeMap: map[string]string{
"bool": "b",
"string": "s",
"byte": "b",
"rune": "r",
"int": "i",
"int16": "i",
"int32": "i",
"int64": "i",
"uint": "u",
"uint8": "u",
"uint16": "u",
"uint32": "u",
"uint64": "u",
"float32": "f",
"float64": "f",
"Slice": "s",
"StringSlice": "ss",
},
}
} | go | func NewDefaultArgs() *ArgType {
fkMode := FkModeSmart
return &ArgType{
Suffix: ".xo.go",
Int32Type: "int",
Uint32Type: "uint",
ForeignKeyMode: &fkMode,
QueryParamDelimiter: "%%",
NameConflictSuffix: "Val",
// KnownTypeMap is the collection of known Go types.
KnownTypeMap: map[string]bool{
"bool": true,
"string": true,
"byte": true,
"rune": true,
"int": true,
"int16": true,
"int32": true,
"int64": true,
"uint": true,
"uint8": true,
"uint16": true,
"uint32": true,
"uint64": true,
"float32": true,
"float64": true,
"Slice": true,
"StringSlice": true,
},
// ShortNameTypeMap is the collection of Go style short names for types, mainly
// used for use with declaring a func receiver on a type.
ShortNameTypeMap: map[string]string{
"bool": "b",
"string": "s",
"byte": "b",
"rune": "r",
"int": "i",
"int16": "i",
"int32": "i",
"int64": "i",
"uint": "u",
"uint8": "u",
"uint16": "u",
"uint32": "u",
"uint64": "u",
"float32": "f",
"float64": "f",
"Slice": "s",
"StringSlice": "ss",
},
}
} | [
"func",
"NewDefaultArgs",
"(",
")",
"*",
"ArgType",
"{",
"fkMode",
":=",
"FkModeSmart",
"\n\n",
"return",
"&",
"ArgType",
"{",
"Suffix",
":",
"\"",
"\"",
",",
"Int32Type",
":",
"\"",
"\"",
",",
"Uint32Type",
":",
"\"",
"\"",
",",
"ForeignKeyMode",
":",
"&",
"fkMode",
",",
"QueryParamDelimiter",
":",
"\"",
"\"",
",",
"NameConflictSuffix",
":",
"\"",
"\"",
",",
"// KnownTypeMap is the collection of known Go types.",
"KnownTypeMap",
":",
"map",
"[",
"string",
"]",
"bool",
"{",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"\"",
"\"",
":",
"true",
",",
"}",
",",
"// ShortNameTypeMap is the collection of Go style short names for types, mainly",
"// used for use with declaring a func receiver on a type.",
"ShortNameTypeMap",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewDefaultArgs returns the default arguments. | [
"NewDefaultArgs",
"returns",
"the",
"default",
"arguments",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/argtype.go#L156-L210 | train |
xo/xo | models/msidentity.xo.go | MsIdentities | func MsIdentities(db XODB, schema string) ([]*MsIdentity, error) {
var err error
// sql query
const sqlstr = `SELECT o.name as table_name ` +
`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id ` +
`WHERE c.is_identity = 1 ` +
`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MsIdentity{}
for q.Next() {
mi := MsIdentity{}
// scan
err = q.Scan(&mi.TableName)
if err != nil {
return nil, err
}
res = append(res, &mi)
}
return res, nil
} | go | func MsIdentities(db XODB, schema string) ([]*MsIdentity, error) {
var err error
// sql query
const sqlstr = `SELECT o.name as table_name ` +
`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id ` +
`WHERE c.is_identity = 1 ` +
`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*MsIdentity{}
for q.Next() {
mi := MsIdentity{}
// scan
err = q.Scan(&mi.TableName)
if err != nil {
return nil, err
}
res = append(res, &mi)
}
return res, nil
} | [
"func",
"MsIdentities",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"MsIdentity",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT o.name as table_name `",
"+",
"`FROM sys.objects o inner join sys.columns c on o.object_id = c.object_id `",
"+",
"`WHERE c.is_identity = 1 `",
"+",
"`AND schema_name(o.schema_id) = $1 AND o.type = 'U'`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"MsIdentity",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"mi",
":=",
"MsIdentity",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"mi",
".",
"TableName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"mi",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // MsIdentities runs a custom query, returning results as MsIdentity. | [
"MsIdentities",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"MsIdentity",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/msidentity.xo.go#L12-L44 | train |
xo/xo | loaders/postgres.go | PgRelkind | func PgRelkind(relType internal.RelType) string {
var s string
switch relType {
case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
} | go | func PgRelkind(relType internal.RelType) string {
var s string
switch relType {
case internal.Table:
s = "r"
case internal.View:
s = "v"
default:
panic("unsupported RelType")
}
return s
} | [
"func",
"PgRelkind",
"(",
"relType",
"internal",
".",
"RelType",
")",
"string",
"{",
"var",
"s",
"string",
"\n",
"switch",
"relType",
"{",
"case",
"internal",
".",
"Table",
":",
"s",
"=",
"\"",
"\"",
"\n",
"case",
"internal",
".",
"View",
":",
"s",
"=",
"\"",
"\"",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"s",
"\n",
"}"
] | // PgRelkind returns the postgres string representation for RelType. | [
"PgRelkind",
"returns",
"the",
"postgres",
"string",
"representation",
"for",
"RelType",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L39-L50 | train |
xo/xo | loaders/postgres.go | PgQueryStrip | func PgQueryStrip(query []string, queryComments []string) {
for i, l := range query {
pos := pgQueryStripRE.FindStringIndex(l)
if pos != nil {
query[i] = l[:pos[0]] + l[pos[1]:]
queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
} | go | func PgQueryStrip(query []string, queryComments []string) {
for i, l := range query {
pos := pgQueryStripRE.FindStringIndex(l)
if pos != nil {
query[i] = l[:pos[0]] + l[pos[1]:]
queryComments[i+1] = l[pos[0]:pos[1]]
} else {
queryComments[i+1] = ""
}
}
} | [
"func",
"PgQueryStrip",
"(",
"query",
"[",
"]",
"string",
",",
"queryComments",
"[",
"]",
"string",
")",
"{",
"for",
"i",
",",
"l",
":=",
"range",
"query",
"{",
"pos",
":=",
"pgQueryStripRE",
".",
"FindStringIndex",
"(",
"l",
")",
"\n",
"if",
"pos",
"!=",
"nil",
"{",
"query",
"[",
"i",
"]",
"=",
"l",
"[",
":",
"pos",
"[",
"0",
"]",
"]",
"+",
"l",
"[",
"pos",
"[",
"1",
"]",
":",
"]",
"\n",
"queryComments",
"[",
"i",
"+",
"1",
"]",
"=",
"l",
"[",
"pos",
"[",
"0",
"]",
":",
"pos",
"[",
"1",
"]",
"]",
"\n",
"}",
"else",
"{",
"queryComments",
"[",
"i",
"+",
"1",
"]",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // PgQueryStrip strips stuff. | [
"PgQueryStrip",
"strips",
"stuff",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L219-L229 | train |
xo/xo | loaders/postgres.go | PgTables | func PgTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.PgTables(db, schema, relkind)
if err != nil {
return nil, err
}
// Get the tables that have a sequence defined.
sequences, err := models.PgSequences(db, schema)
if err != nil {
// Set it to an empty set on error.
sequences = []*models.Sequence{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the sequence
for _, sequence := range sequences {
if sequence.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | go | func PgTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.PgTables(db, schema, relkind)
if err != nil {
return nil, err
}
// Get the tables that have a sequence defined.
sequences, err := models.PgSequences(db, schema)
if err != nil {
// Set it to an empty set on error.
sequences = []*models.Sequence{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the sequence
for _, sequence := range sequences {
if sequence.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | [
"func",
"PgTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// get the tables",
"rows",
",",
"err",
":=",
"models",
".",
"PgTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Get the tables that have a sequence defined.",
"sequences",
",",
"err",
":=",
"models",
".",
"PgSequences",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Set it to an empty set on error.",
"sequences",
"=",
"[",
"]",
"*",
"models",
".",
"Sequence",
"{",
"}",
"\n",
"}",
"\n\n",
"// Add information about manual FK.",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"// Look for a match in the table name where it contains the sequence",
"for",
"_",
",",
"sequence",
":=",
"range",
"sequences",
"{",
"if",
"sequence",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] | // PgTables returns the Postgres tables with the manual PK information added.
// ManualPk is true when the table does not have a sequence defined. | [
"PgTables",
"returns",
"the",
"Postgres",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"does",
"not",
"have",
"a",
"sequence",
"defined",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L233-L267 | train |
xo/xo | loaders/postgres.go | PgQueryColumns | func PgQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// query to determine schema name where temporary view was created
var nspq = `SELECT n.nspname ` +
`FROM pg_class c ` +
`JOIN pg_namespace n ON n.oid = c.relnamespace ` +
`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`
// run query
var schema string
models.XOLog(nspq, xoid)
err = args.DB.QueryRow(nspq, xoid).Scan(&schema)
if err != nil {
return nil, err
}
// load column information
return models.PgTableColumns(args.DB, schema, xoid, false)
} | go | func PgQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE TEMPORARY VIEW ` + xoid + ` AS (` + strings.Join(inspect, "\n") + `)`
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// query to determine schema name where temporary view was created
var nspq = `SELECT n.nspname ` +
`FROM pg_class c ` +
`JOIN pg_namespace n ON n.oid = c.relnamespace ` +
`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`
// run query
var schema string
models.XOLog(nspq, xoid)
err = args.DB.QueryRow(nspq, xoid).Scan(&schema)
if err != nil {
return nil, err
}
// load column information
return models.PgTableColumns(args.DB, schema, xoid, false)
} | [
"func",
"PgQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// create temporary view xoid",
"xoid",
":=",
"\"",
"\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE TEMPORARY VIEW `",
"+",
"xoid",
"+",
"` AS (`",
"+",
"strings",
".",
"Join",
"(",
"inspect",
",",
"\"",
"\\n",
"\"",
")",
"+",
"`)`",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// query to determine schema name where temporary view was created",
"var",
"nspq",
"=",
"`SELECT n.nspname `",
"+",
"`FROM pg_class c `",
"+",
"`JOIN pg_namespace n ON n.oid = c.relnamespace `",
"+",
"`WHERE n.nspname LIKE 'pg_temp%' AND c.relname = $1`",
"\n\n",
"// run query",
"var",
"schema",
"string",
"\n",
"models",
".",
"XOLog",
"(",
"nspq",
",",
"xoid",
")",
"\n",
"err",
"=",
"args",
".",
"DB",
".",
"QueryRow",
"(",
"nspq",
",",
"xoid",
")",
".",
"Scan",
"(",
"&",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// load column information",
"return",
"models",
".",
"PgTableColumns",
"(",
"args",
".",
"DB",
",",
"schema",
",",
"xoid",
",",
"false",
")",
"\n",
"}"
] | // PgQueryColumns parses the query and generates a type for it. | [
"PgQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L270-L298 | train |
xo/xo | loaders/postgres.go | PgIndexColumns | func PgIndexColumns(db models.XODB, schema string, table string, index string) ([]*models.IndexColumn, error) {
var err error
// load columns
cols, err := models.PgIndexColumns(db, schema, index)
if err != nil {
return nil, err
}
// load col order
colOrd, err := models.PgGetColOrder(db, schema, index)
if err != nil {
return nil, err
}
// build schema name used in errors
s := schema
if s != "" {
s = s + "."
}
// put cols in order using colOrder
ret := []*models.IndexColumn{}
for _, v := range strings.Split(colOrd.Ord, " ") {
cid, err := strconv.Atoi(v)
if err != nil {
return nil, fmt.Errorf("could not convert %s%s index %s column %s to int", s, table, index, v)
}
// find column
found := false
var c *models.IndexColumn
for _, ic := range cols {
if cid == ic.Cid {
found = true
c = ic
break
}
}
// sanity check
if !found {
return nil, fmt.Errorf("could not find %s%s index %s column id %d", s, table, index, cid)
}
ret = append(ret, c)
}
return ret, nil
} | go | func PgIndexColumns(db models.XODB, schema string, table string, index string) ([]*models.IndexColumn, error) {
var err error
// load columns
cols, err := models.PgIndexColumns(db, schema, index)
if err != nil {
return nil, err
}
// load col order
colOrd, err := models.PgGetColOrder(db, schema, index)
if err != nil {
return nil, err
}
// build schema name used in errors
s := schema
if s != "" {
s = s + "."
}
// put cols in order using colOrder
ret := []*models.IndexColumn{}
for _, v := range strings.Split(colOrd.Ord, " ") {
cid, err := strconv.Atoi(v)
if err != nil {
return nil, fmt.Errorf("could not convert %s%s index %s column %s to int", s, table, index, v)
}
// find column
found := false
var c *models.IndexColumn
for _, ic := range cols {
if cid == ic.Cid {
found = true
c = ic
break
}
}
// sanity check
if !found {
return nil, fmt.Errorf("could not find %s%s index %s column id %d", s, table, index, cid)
}
ret = append(ret, c)
}
return ret, nil
} | [
"func",
"PgIndexColumns",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
",",
"index",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"IndexColumn",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// load columns",
"cols",
",",
"err",
":=",
"models",
".",
"PgIndexColumns",
"(",
"db",
",",
"schema",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// load col order",
"colOrd",
",",
"err",
":=",
"models",
".",
"PgGetColOrder",
"(",
"db",
",",
"schema",
",",
"index",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// build schema name used in errors",
"s",
":=",
"schema",
"\n",
"if",
"s",
"!=",
"\"",
"\"",
"{",
"s",
"=",
"s",
"+",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// put cols in order using colOrder",
"ret",
":=",
"[",
"]",
"*",
"models",
".",
"IndexColumn",
"{",
"}",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"strings",
".",
"Split",
"(",
"colOrd",
".",
"Ord",
",",
"\"",
"\"",
")",
"{",
"cid",
",",
"err",
":=",
"strconv",
".",
"Atoi",
"(",
"v",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
",",
"table",
",",
"index",
",",
"v",
")",
"\n",
"}",
"\n\n",
"// find column",
"found",
":=",
"false",
"\n",
"var",
"c",
"*",
"models",
".",
"IndexColumn",
"\n",
"for",
"_",
",",
"ic",
":=",
"range",
"cols",
"{",
"if",
"cid",
"==",
"ic",
".",
"Cid",
"{",
"found",
"=",
"true",
"\n",
"c",
"=",
"ic",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"// sanity check",
"if",
"!",
"found",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
",",
"table",
",",
"index",
",",
"cid",
")",
"\n",
"}",
"\n\n",
"ret",
"=",
"append",
"(",
"ret",
",",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"ret",
",",
"nil",
"\n",
"}"
] | // PgIndexColumns returns the column list for an index. | [
"PgIndexColumns",
"returns",
"the",
"column",
"list",
"for",
"an",
"index",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/postgres.go#L301-L350 | train |
xo/xo | examples/django/postgres/djangocontenttype.xo.go | Update | func (dct *DjangoContentType) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dct._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_content_type SET (` +
`app_label, model` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, dct.AppLabel, dct.Model, dct.ID)
_, err = db.Exec(sqlstr, dct.AppLabel, dct.Model, dct.ID)
return err
} | go | func (dct *DjangoContentType) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dct._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_content_type SET (` +
`app_label, model` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, dct.AppLabel, dct.Model, dct.ID)
_, err = db.Exec(sqlstr, dct.AppLabel, dct.Model, dct.ID)
return err
} | [
"func",
"(",
"dct",
"*",
"DjangoContentType",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dct",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dct",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE public.django_content_type SET (`",
"+",
"`app_label, model`",
"+",
"`) = ( `",
"+",
"`$1, $2`",
"+",
"`) WHERE id = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dct",
".",
"AppLabel",
",",
"dct",
".",
"Model",
",",
"dct",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dct",
".",
"AppLabel",
",",
"dct",
".",
"Model",
",",
"dct",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the DjangoContentType in the database. | [
"Update",
"updates",
"the",
"DjangoContentType",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangocontenttype.xo.go#L60-L84 | train |
xo/xo | examples/django/postgres/djangocontenttype.xo.go | Delete | func (dct *DjangoContentType) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return nil
}
// if deleted, bail
if dct._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.django_content_type WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err = db.Exec(sqlstr, dct.ID)
if err != nil {
return err
}
// set deleted
dct._deleted = true
return nil
} | go | func (dct *DjangoContentType) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dct._exists {
return nil
}
// if deleted, bail
if dct._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.django_content_type WHERE id = $1`
// run query
XOLog(sqlstr, dct.ID)
_, err = db.Exec(sqlstr, dct.ID)
if err != nil {
return err
}
// set deleted
dct._deleted = true
return nil
} | [
"func",
"(",
"dct",
"*",
"DjangoContentType",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dct",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dct",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM public.django_content_type WHERE id = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dct",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dct",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"dct",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the DjangoContentType from the database. | [
"Delete",
"deletes",
"the",
"DjangoContentType",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangocontenttype.xo.go#L131-L158 | train |
xo/xo | examples/django/oracle/authgrouppermission.xo.go | AuthGroupPermissionByGroupIDPermissionID | func AuthGroupPermissionByGroupIDPermissionID(db XODB, groupID float64, permissionID float64) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE group_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, groupID, permissionID)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, groupID, permissionID).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
} | go | func AuthGroupPermissionByGroupIDPermissionID(db XODB, groupID float64, permissionID float64) (*AuthGroupPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, group_id, permission_id ` +
`FROM django.auth_group_permissions ` +
`WHERE group_id = :1 AND permission_id = :2`
// run query
XOLog(sqlstr, groupID, permissionID)
agp := AuthGroupPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, groupID, permissionID).Scan(&agp.ID, &agp.GroupID, &agp.PermissionID)
if err != nil {
return nil, err
}
return &agp, nil
} | [
"func",
"AuthGroupPermissionByGroupIDPermissionID",
"(",
"db",
"XODB",
",",
"groupID",
"float64",
",",
"permissionID",
"float64",
")",
"(",
"*",
"AuthGroupPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, group_id, permission_id `",
"+",
"`FROM django.auth_group_permissions `",
"+",
"`WHERE group_id = :1 AND permission_id = :2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"groupID",
",",
"permissionID",
")",
"\n",
"agp",
":=",
"AuthGroupPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"groupID",
",",
"permissionID",
")",
".",
"Scan",
"(",
"&",
"agp",
".",
"ID",
",",
"&",
"agp",
".",
"GroupID",
",",
"&",
"agp",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"agp",
",",
"nil",
"\n",
"}"
] | // AuthGroupPermissionByGroupIDPermissionID retrieves a row from 'django.auth_group_permissions' as a AuthGroupPermission.
//
// Generated from index 'auth_gr_group_id_0cd325b0_uniq'. | [
"AuthGroupPermissionByGroupIDPermissionID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_group_permissions",
"as",
"a",
"AuthGroupPermission",
".",
"Generated",
"from",
"index",
"auth_gr_group_id_0cd325b0_uniq",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authgrouppermission.xo.go#L145-L166 | train |
xo/xo | models/procparam.xo.go | PgProcParams | func PgProcParams(db XODB, schema string, proc string) ([]*ProcParam, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) ` + // ::varchar AS param_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1 AND p.proname = $2`
// run query
XOLog(sqlstr, schema, proc)
q, err := db.Query(sqlstr, schema, proc)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*ProcParam{}
for q.Next() {
pp := ProcParam{}
// scan
err = q.Scan(&pp.ParamType)
if err != nil {
return nil, err
}
res = append(res, &pp)
}
return res, nil
} | go | func PgProcParams(db XODB, schema string, proc string) ([]*ProcParam, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) ` + // ::varchar AS param_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1 AND p.proname = $2`
// run query
XOLog(sqlstr, schema, proc)
q, err := db.Query(sqlstr, schema, proc)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*ProcParam{}
for q.Next() {
pp := ProcParam{}
// scan
err = q.Scan(&pp.ParamType)
if err != nil {
return nil, err
}
res = append(res, &pp)
}
return res, nil
} | [
"func",
"PgProcParams",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"proc",
"string",
")",
"(",
"[",
"]",
"*",
"ProcParam",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`UNNEST(STRING_TO_ARRAY(oidvectortypes(p.proargtypes), ', ')) `",
"+",
"// ::varchar AS param_type",
"`FROM pg_proc p `",
"+",
"`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid `",
"+",
"`WHERE n.nspname = $1 AND p.proname = $2`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"proc",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"proc",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"ProcParam",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"pp",
":=",
"ProcParam",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"pp",
".",
"ParamType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"pp",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgProcParams runs a custom query, returning results as ProcParam. | [
"PgProcParams",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"ProcParam",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/procparam.xo.go#L12-L45 | train |
xo/xo | examples/django/mysql/authusergroup.xo.go | AuthUserGroupsByGroupID | func AuthUserGroupsByGroupID(db XODB, groupID int) ([]*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE group_id = ?`
// run query
XOLog(sqlstr, groupID)
q, err := db.Query(sqlstr, groupID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserGroup{}
for q.Next() {
aug := AuthUserGroup{
_exists: true,
}
// scan
err = q.Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
res = append(res, &aug)
}
return res, nil
} | go | func AuthUserGroupsByGroupID(db XODB, groupID int) ([]*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE group_id = ?`
// run query
XOLog(sqlstr, groupID)
q, err := db.Query(sqlstr, groupID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*AuthUserGroup{}
for q.Next() {
aug := AuthUserGroup{
_exists: true,
}
// scan
err = q.Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
res = append(res, &aug)
}
return res, nil
} | [
"func",
"AuthUserGroupsByGroupID",
"(",
"db",
"XODB",
",",
"groupID",
"int",
")",
"(",
"[",
"]",
"*",
"AuthUserGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, group_id `",
"+",
"`FROM django.auth_user_groups `",
"+",
"`WHERE group_id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"groupID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"groupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"AuthUserGroup",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"aug",
":=",
"AuthUserGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"aug",
".",
"ID",
",",
"&",
"aug",
".",
"UserID",
",",
"&",
"aug",
".",
"GroupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"aug",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // AuthUserGroupsByGroupID retrieves a row from 'django.auth_user_groups' as a AuthUserGroup.
//
// Generated from index 'auth_user_groups_group_id_97559544_fk_auth_group_id'. | [
"AuthUserGroupsByGroupID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_groups",
"as",
"a",
"AuthUserGroup",
".",
"Generated",
"from",
"index",
"auth_user_groups_group_id_97559544_fk_auth_group_id",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authusergroup.xo.go#L147-L181 | train |
xo/xo | examples/django/mysql/authusergroup.xo.go | AuthUserGroupByID | func AuthUserGroupByID(db XODB, id int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
} | go | func AuthUserGroupByID(db XODB, id int) (*AuthUserGroup, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, group_id ` +
`FROM django.auth_user_groups ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
aug := AuthUserGroup{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&aug.ID, &aug.UserID, &aug.GroupID)
if err != nil {
return nil, err
}
return &aug, nil
} | [
"func",
"AuthUserGroupByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthUserGroup",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, group_id `",
"+",
"`FROM django.auth_user_groups `",
"+",
"`WHERE id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"aug",
":=",
"AuthUserGroup",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"aug",
".",
"ID",
",",
"&",
"aug",
".",
"UserID",
",",
"&",
"aug",
".",
"GroupID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"aug",
",",
"nil",
"\n",
"}"
] | // AuthUserGroupByID retrieves a row from 'django.auth_user_groups' as a AuthUserGroup.
//
// Generated from index 'auth_user_groups_id_pkey'. | [
"AuthUserGroupByID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user_groups",
"as",
"a",
"AuthUserGroup",
".",
"Generated",
"from",
"index",
"auth_user_groups_id_pkey",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authusergroup.xo.go#L186-L207 | train |
xo/xo | loaders/mssql.go | MsParseType | func MsParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
var typ string
switch dt {
case "tinyint", "bit":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "char", "varchar", "text", "nchar", "nvarchar", "ntext", "smallmoney", "money":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
case "smallint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "int":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigint":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "smallserial":
nilVal = "0"
typ = "uint16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "serial":
nilVal = "0"
typ = args.Uint32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigserial":
nilVal = "0"
typ = "uint64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "real":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "numeric", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "binary", "varbinary":
typ = "[]byte"
case "datetime", "datetime2", "timestamp":
nilVal = "time.Time{}"
typ = "time.Time"
case "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "interval":
typ = "*time.Duration"
default:
if strings.HasPrefix(dt, args.Schema+".") {
// in the same schema, so chop off
typ = snaker.SnakeToCamelIdentifier(dt[len(args.Schema)+1:])
nilVal = typ + "(0)"
} else {
typ = snaker.SnakeToCamelIdentifier(dt)
nilVal = typ + "{}"
}
}
return precision, nilVal, typ
} | go | func MsParseType(args *internal.ArgType, dt string, nullable bool) (int, string, string) {
precision := 0
nilVal := "nil"
// extract precision
dt, precision, _ = args.ParsePrecision(dt)
var typ string
switch dt {
case "tinyint", "bit":
nilVal = "false"
typ = "bool"
if nullable {
nilVal = "sql.NullBool{}"
typ = "sql.NullBool"
}
case "char", "varchar", "text", "nchar", "nvarchar", "ntext", "smallmoney", "money":
nilVal = `""`
typ = "string"
if nullable {
nilVal = "sql.NullString{}"
typ = "sql.NullString"
}
case "smallint":
nilVal = "0"
typ = "int16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "int":
nilVal = "0"
typ = args.Int32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigint":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "smallserial":
nilVal = "0"
typ = "uint16"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "serial":
nilVal = "0"
typ = args.Uint32Type
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "bigserial":
nilVal = "0"
typ = "uint64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "real":
nilVal = "0.0"
typ = "float32"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "numeric", "decimal":
nilVal = "0.0"
typ = "float64"
if nullable {
nilVal = "sql.NullFloat64{}"
typ = "sql.NullFloat64"
}
case "binary", "varbinary":
typ = "[]byte"
case "datetime", "datetime2", "timestamp":
nilVal = "time.Time{}"
typ = "time.Time"
case "time with time zone", "time without time zone", "timestamp without time zone":
nilVal = "0"
typ = "int64"
if nullable {
nilVal = "sql.NullInt64{}"
typ = "sql.NullInt64"
}
case "interval":
typ = "*time.Duration"
default:
if strings.HasPrefix(dt, args.Schema+".") {
// in the same schema, so chop off
typ = snaker.SnakeToCamelIdentifier(dt[len(args.Schema)+1:])
nilVal = typ + "(0)"
} else {
typ = snaker.SnakeToCamelIdentifier(dt)
nilVal = typ + "{}"
}
}
return precision, nilVal, typ
} | [
"func",
"MsParseType",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"dt",
"string",
",",
"nullable",
"bool",
")",
"(",
"int",
",",
"string",
",",
"string",
")",
"{",
"precision",
":=",
"0",
"\n",
"nilVal",
":=",
"\"",
"\"",
"\n\n",
"// extract precision",
"dt",
",",
"precision",
",",
"_",
"=",
"args",
".",
"ParsePrecision",
"(",
"dt",
")",
"\n\n",
"var",
"typ",
"string",
"\n",
"switch",
"dt",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"nilVal",
"=",
"`\"\"`",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"args",
".",
"Int32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"args",
".",
"Uint32Type",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"typ",
"=",
"\"",
"\"",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
":",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"if",
"nullable",
"{",
"nilVal",
"=",
"\"",
"\"",
"\n",
"typ",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"case",
"\"",
"\"",
":",
"typ",
"=",
"\"",
"\"",
"\n\n",
"default",
":",
"if",
"strings",
".",
"HasPrefix",
"(",
"dt",
",",
"args",
".",
"Schema",
"+",
"\"",
"\"",
")",
"{",
"// in the same schema, so chop off",
"typ",
"=",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"dt",
"[",
"len",
"(",
"args",
".",
"Schema",
")",
"+",
"1",
":",
"]",
")",
"\n",
"nilVal",
"=",
"typ",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"typ",
"=",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"dt",
")",
"\n",
"nilVal",
"=",
"typ",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"precision",
",",
"nilVal",
",",
"typ",
"\n",
"}"
] | // MsParseType parse a mssql type into a Go type based on the column
// definition. | [
"MsParseType",
"parse",
"a",
"mssql",
"type",
"into",
"a",
"Go",
"type",
"based",
"on",
"the",
"column",
"definition",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L68-L182 | train |
xo/xo | loaders/mssql.go | MsQueryColumns | func MsQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// process inspect -- cannot have 'order by' in a CREATE VIEW
ins := []string{}
for _, l := range inspect {
if !strings.HasPrefix(strings.ToUpper(l), "ORDER BY ") {
ins = append(ins, l)
}
}
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS ` + strings.Join(ins, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MsTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
} | go | func MsQueryColumns(args *internal.ArgType, inspect []string) ([]*models.Column, error) {
var err error
// process inspect -- cannot have 'order by' in a CREATE VIEW
ins := []string{}
for _, l := range inspect {
if !strings.HasPrefix(strings.ToUpper(l), "ORDER BY ") {
ins = append(ins, l)
}
}
// create temporary view xoid
xoid := "_xo_" + internal.GenRandomID()
viewq := `CREATE VIEW ` + xoid + ` AS ` + strings.Join(ins, "\n")
models.XOLog(viewq)
_, err = args.DB.Exec(viewq)
if err != nil {
return nil, err
}
// load columns
cols, err := models.MsTableColumns(args.DB, args.Schema, xoid)
// drop inspect view
dropq := `DROP VIEW ` + xoid
models.XOLog(dropq)
_, _ = args.DB.Exec(dropq)
// load column information
return cols, err
} | [
"func",
"MsQueryColumns",
"(",
"args",
"*",
"internal",
".",
"ArgType",
",",
"inspect",
"[",
"]",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// process inspect -- cannot have 'order by' in a CREATE VIEW",
"ins",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"l",
":=",
"range",
"inspect",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"strings",
".",
"ToUpper",
"(",
"l",
")",
",",
"\"",
"\"",
")",
"{",
"ins",
"=",
"append",
"(",
"ins",
",",
"l",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// create temporary view xoid",
"xoid",
":=",
"\"",
"\"",
"+",
"internal",
".",
"GenRandomID",
"(",
")",
"\n",
"viewq",
":=",
"`CREATE VIEW `",
"+",
"xoid",
"+",
"` AS `",
"+",
"strings",
".",
"Join",
"(",
"ins",
",",
"\"",
"\\n",
"\"",
")",
"\n",
"models",
".",
"XOLog",
"(",
"viewq",
")",
"\n",
"_",
",",
"err",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"viewq",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// load columns",
"cols",
",",
"err",
":=",
"models",
".",
"MsTableColumns",
"(",
"args",
".",
"DB",
",",
"args",
".",
"Schema",
",",
"xoid",
")",
"\n\n",
"// drop inspect view",
"dropq",
":=",
"`DROP VIEW `",
"+",
"xoid",
"\n",
"models",
".",
"XOLog",
"(",
"dropq",
")",
"\n",
"_",
",",
"_",
"=",
"args",
".",
"DB",
".",
"Exec",
"(",
"dropq",
")",
"\n\n",
"// load column information",
"return",
"cols",
",",
"err",
"\n",
"}"
] | // MsQueryColumns parses the query and generates a type for it. | [
"MsQueryColumns",
"parses",
"the",
"query",
"and",
"generates",
"a",
"type",
"for",
"it",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L185-L215 | train |
xo/xo | loaders/mssql.go | MsTables | func MsTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MsTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Identity included
identities, err := models.MsIdentities(db, schema)
if err != nil {
// Set it to an empty set on error.
identities = []*models.MsIdentity{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the identity
for _, identity := range identities {
if identity.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | go | func MsTables(db models.XODB, schema string, relkind string) ([]*models.Table, error) {
var err error
// get the tables
rows, err := models.MsTables(db, schema, relkind)
if err != nil {
return nil, err
}
// get the tables that have Identity included
identities, err := models.MsIdentities(db, schema)
if err != nil {
// Set it to an empty set on error.
identities = []*models.MsIdentity{}
}
// Add information about manual FK.
var tables []*models.Table
for _, row := range rows {
manualPk := true
// Look for a match in the table name where it contains the identity
for _, identity := range identities {
if identity.TableName == row.TableName {
manualPk = false
}
}
tables = append(tables, &models.Table{
TableName: row.TableName,
Type: row.Type,
ManualPk: manualPk,
})
}
return tables, nil
} | [
"func",
"MsTables",
"(",
"db",
"models",
".",
"XODB",
",",
"schema",
"string",
",",
"relkind",
"string",
")",
"(",
"[",
"]",
"*",
"models",
".",
"Table",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// get the tables",
"rows",
",",
"err",
":=",
"models",
".",
"MsTables",
"(",
"db",
",",
"schema",
",",
"relkind",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// get the tables that have Identity included",
"identities",
",",
"err",
":=",
"models",
".",
"MsIdentities",
"(",
"db",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Set it to an empty set on error.",
"identities",
"=",
"[",
"]",
"*",
"models",
".",
"MsIdentity",
"{",
"}",
"\n",
"}",
"\n\n",
"// Add information about manual FK.",
"var",
"tables",
"[",
"]",
"*",
"models",
".",
"Table",
"\n",
"for",
"_",
",",
"row",
":=",
"range",
"rows",
"{",
"manualPk",
":=",
"true",
"\n",
"// Look for a match in the table name where it contains the identity",
"for",
"_",
",",
"identity",
":=",
"range",
"identities",
"{",
"if",
"identity",
".",
"TableName",
"==",
"row",
".",
"TableName",
"{",
"manualPk",
"=",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"tables",
"=",
"append",
"(",
"tables",
",",
"&",
"models",
".",
"Table",
"{",
"TableName",
":",
"row",
".",
"TableName",
",",
"Type",
":",
"row",
".",
"Type",
",",
"ManualPk",
":",
"manualPk",
",",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"tables",
",",
"nil",
"\n",
"}"
] | // MsTables returns the MsSQL tables with the manual PK information added.
// ManualPk is true when the table's primary key is not an identity. | [
"MsTables",
"returns",
"the",
"MsSQL",
"tables",
"with",
"the",
"manual",
"PK",
"information",
"added",
".",
"ManualPk",
"is",
"true",
"when",
"the",
"table",
"s",
"primary",
"key",
"is",
"not",
"an",
"identity",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/loaders/mssql.go#L219-L253 | train |
xo/xo | examples/django/mysql/djangoadminlog.xo.go | Delete | func (dal *DjangoAdminLog) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return nil
}
// if deleted, bail
if dal._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_admin_log WHERE id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.Exec(sqlstr, dal.ID)
if err != nil {
return err
}
// set deleted
dal._deleted = true
return nil
} | go | func (dal *DjangoAdminLog) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return nil
}
// if deleted, bail
if dal._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_admin_log WHERE id = ?`
// run query
XOLog(sqlstr, dal.ID)
_, err = db.Exec(sqlstr, dal.ID)
if err != nil {
return err
}
// set deleted
dal._deleted = true
return nil
} | [
"func",
"(",
"dal",
"*",
"DjangoAdminLog",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dal",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dal",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM django.django_admin_log WHERE id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dal",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dal",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"dal",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the DjangoAdminLog from the database. | [
"Delete",
"deletes",
"the",
"DjangoAdminLog",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangoadminlog.xo.go#L108-L135 | train |
xo/xo | examples/django/mysql/djangosession.xo.go | DjangoSessionsByExpireDate | func DjangoSessionsByExpireDate(db XODB, expireDate *time.Time) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE expire_date = ?`
// run query
XOLog(sqlstr, expireDate)
q, err := db.Query(sqlstr, expireDate)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
} | go | func DjangoSessionsByExpireDate(db XODB, expireDate *time.Time) ([]*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE expire_date = ?`
// run query
XOLog(sqlstr, expireDate)
q, err := db.Query(sqlstr, expireDate)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoSession{}
for q.Next() {
ds := DjangoSession{
_exists: true,
}
// scan
err = q.Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
res = append(res, &ds)
}
return res, nil
} | [
"func",
"DjangoSessionsByExpireDate",
"(",
"db",
"XODB",
",",
"expireDate",
"*",
"time",
".",
"Time",
")",
"(",
"[",
"]",
"*",
"DjangoSession",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`session_key, session_data, expire_date `",
"+",
"`FROM django.django_session `",
"+",
"`WHERE expire_date = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"expireDate",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"expireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"DjangoSession",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"ds",
":=",
"DjangoSession",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"ds",
".",
"SessionKey",
",",
"&",
"ds",
".",
"SessionData",
",",
"&",
"ds",
".",
"ExpireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"ds",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // DjangoSessionsByExpireDate retrieves a row from 'django.django_session' as a DjangoSession.
//
// Generated from index 'django_session_de54fa62'. | [
"DjangoSessionsByExpireDate",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_session",
"as",
"a",
"DjangoSession",
".",
"Generated",
"from",
"index",
"django_session_de54fa62",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangosession.xo.go#L127-L161 | train |
xo/xo | examples/django/mysql/djangosession.xo.go | DjangoSessionBySessionKey | func DjangoSessionBySessionKey(db XODB, sessionKey string) (*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE session_key = ?`
// run query
XOLog(sqlstr, sessionKey)
ds := DjangoSession{
_exists: true,
}
err = db.QueryRow(sqlstr, sessionKey).Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
return &ds, nil
} | go | func DjangoSessionBySessionKey(db XODB, sessionKey string) (*DjangoSession, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`session_key, session_data, expire_date ` +
`FROM django.django_session ` +
`WHERE session_key = ?`
// run query
XOLog(sqlstr, sessionKey)
ds := DjangoSession{
_exists: true,
}
err = db.QueryRow(sqlstr, sessionKey).Scan(&ds.SessionKey, &ds.SessionData, &ds.ExpireDate)
if err != nil {
return nil, err
}
return &ds, nil
} | [
"func",
"DjangoSessionBySessionKey",
"(",
"db",
"XODB",
",",
"sessionKey",
"string",
")",
"(",
"*",
"DjangoSession",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`session_key, session_data, expire_date `",
"+",
"`FROM django.django_session `",
"+",
"`WHERE session_key = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"sessionKey",
")",
"\n",
"ds",
":=",
"DjangoSession",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"sessionKey",
")",
".",
"Scan",
"(",
"&",
"ds",
".",
"SessionKey",
",",
"&",
"ds",
".",
"SessionData",
",",
"&",
"ds",
".",
"ExpireDate",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"ds",
",",
"nil",
"\n",
"}"
] | // DjangoSessionBySessionKey retrieves a row from 'django.django_session' as a DjangoSession.
//
// Generated from index 'django_session_session_key_pkey'. | [
"DjangoSessionBySessionKey",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_session",
"as",
"a",
"DjangoSession",
".",
"Generated",
"from",
"index",
"django_session_session_key_pkey",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/djangosession.xo.go#L166-L187 | train |
xo/xo | examples/django/mysql/authuseruserpermission.xo.go | Update | func (auup *AuthUserUserPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if auup._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.auth_user_user_permissions SET ` +
`user_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
_, err = db.Exec(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
return err
} | go | func (auup *AuthUserUserPermission) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if auup._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.auth_user_user_permissions SET ` +
`user_id = ?, permission_id = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
_, err = db.Exec(sqlstr, auup.UserID, auup.PermissionID, auup.ID)
return err
} | [
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"auup",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"auup",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE django.auth_user_user_permissions SET `",
"+",
"`user_id = ?, permission_id = ?`",
"+",
"` WHERE id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"auup",
".",
"UserID",
",",
"auup",
".",
"PermissionID",
",",
"auup",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"auup",
".",
"UserID",
",",
"auup",
".",
"PermissionID",
",",
"auup",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the AuthUserUserPermission in the database. | [
"Update",
"updates",
"the",
"AuthUserUserPermission",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/mysql/authuseruserpermission.xo.go#L67-L89 | train |
xo/xo | examples/django/oracle/djangomigration.xo.go | Update | func (dm *DjangoMigration) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dm._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.django_migrations SET ` +
`app = :1, name = :2, applied = :3` +
` WHERE id = :4`
// run query
XOLog(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
_, err = db.Exec(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
return err
} | go | func (dm *DjangoMigration) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dm._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE django.django_migrations SET ` +
`app = :1, name = :2, applied = :3` +
` WHERE id = :4`
// run query
XOLog(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
_, err = db.Exec(sqlstr, dm.App, dm.Name, dm.Applied, dm.ID)
return err
} | [
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dm",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dm",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE django.django_migrations SET `",
"+",
"`app = :1, name = :2, applied = :3`",
"+",
"` WHERE id = :4`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dm",
".",
"App",
",",
"dm",
".",
"Name",
",",
"dm",
".",
"Applied",
",",
"dm",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dm",
".",
"App",
",",
"dm",
".",
"Name",
",",
"dm",
".",
"Applied",
",",
"dm",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the DjangoMigration in the database. | [
"Update",
"updates",
"the",
"DjangoMigration",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L70-L92 | train |
xo/xo | examples/django/oracle/djangomigration.xo.go | Delete | func (dm *DjangoMigration) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return nil
}
// if deleted, bail
if dm._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_migrations WHERE id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Exec(sqlstr, dm.ID)
if err != nil {
return err
}
// set deleted
dm._deleted = true
return nil
} | go | func (dm *DjangoMigration) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !dm._exists {
return nil
}
// if deleted, bail
if dm._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.django_migrations WHERE id = :1`
// run query
XOLog(sqlstr, dm.ID)
_, err = db.Exec(sqlstr, dm.ID)
if err != nil {
return err
}
// set deleted
dm._deleted = true
return nil
} | [
"func",
"(",
"dm",
"*",
"DjangoMigration",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dm",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dm",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM django.django_migrations WHERE id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dm",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dm",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"dm",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the DjangoMigration from the database. | [
"Delete",
"deletes",
"the",
"DjangoMigration",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L104-L131 | train |
xo/xo | examples/django/oracle/djangomigration.xo.go | DjangoMigrationByID | func DjangoMigrationByID(db XODB, id float64) (*DjangoMigration, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app, name, applied ` +
`FROM django.django_migrations ` +
`WHERE id = :1`
// run query
XOLog(sqlstr, id)
dm := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dm.ID, &dm.App, &dm.Name, &dm.Applied)
if err != nil {
return nil, err
}
return &dm, nil
} | go | func DjangoMigrationByID(db XODB, id float64) (*DjangoMigration, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app, name, applied ` +
`FROM django.django_migrations ` +
`WHERE id = :1`
// run query
XOLog(sqlstr, id)
dm := DjangoMigration{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dm.ID, &dm.App, &dm.Name, &dm.Applied)
if err != nil {
return nil, err
}
return &dm, nil
} | [
"func",
"DjangoMigrationByID",
"(",
"db",
"XODB",
",",
"id",
"float64",
")",
"(",
"*",
"DjangoMigration",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, app, name, applied `",
"+",
"`FROM django.django_migrations `",
"+",
"`WHERE id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"dm",
":=",
"DjangoMigration",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"dm",
".",
"ID",
",",
"&",
"dm",
".",
"App",
",",
"&",
"dm",
".",
"Name",
",",
"&",
"dm",
".",
"Applied",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"dm",
",",
"nil",
"\n",
"}"
] | // DjangoMigrationByID retrieves a row from 'django.django_migrations' as a DjangoMigration.
//
// Generated from index 'sys_c004953'. | [
"DjangoMigrationByID",
"retrieves",
"a",
"row",
"from",
"django",
".",
"django_migrations",
"as",
"a",
"DjangoMigration",
".",
"Generated",
"from",
"index",
"sys_c004953",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/djangomigration.xo.go#L136-L157 | train |
xo/xo | examples/django/sqlite3/djangocontenttype.xo.go | DjangoContentTypeByID | func DjangoContentTypeByID(db XODB, id int) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django_content_type ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
} | go | func DjangoContentTypeByID(db XODB, id int) (*DjangoContentType, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, app_label, model ` +
`FROM django_content_type ` +
`WHERE id = ?`
// run query
XOLog(sqlstr, id)
dct := DjangoContentType{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&dct.ID, &dct.AppLabel, &dct.Model)
if err != nil {
return nil, err
}
return &dct, nil
} | [
"func",
"DjangoContentTypeByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"DjangoContentType",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, app_label, model `",
"+",
"`FROM django_content_type `",
"+",
"`WHERE id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"dct",
":=",
"DjangoContentType",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"dct",
".",
"ID",
",",
"&",
"dct",
".",
"AppLabel",
",",
"&",
"dct",
".",
"Model",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"dct",
",",
"nil",
"\n",
"}"
] | // DjangoContentTypeByID retrieves a row from 'django_content_type' as a DjangoContentType.
//
// Generated from index 'django_content_type_id_pkey'. | [
"DjangoContentTypeByID",
"retrieves",
"a",
"row",
"from",
"django_content_type",
"as",
"a",
"DjangoContentType",
".",
"Generated",
"from",
"index",
"django_content_type_id_pkey",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/djangocontenttype.xo.go#L159-L180 | train |
xo/xo | examples/django/postgres/djangoadminlog.xo.go | Update | func (dal *DjangoAdminLog) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dal._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_admin_log SET (` +
`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id` +
`) = ( ` +
`$1, $2, $3, $4, $5, $6, $7` +
`) WHERE id = $8`
// run query
XOLog(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
_, err = db.Exec(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
return err
} | go | func (dal *DjangoAdminLog) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !dal._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if dal._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.django_admin_log SET (` +
`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id` +
`) = ( ` +
`$1, $2, $3, $4, $5, $6, $7` +
`) WHERE id = $8`
// run query
XOLog(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
_, err = db.Exec(sqlstr, dal.ActionTime, dal.ObjectID, dal.ObjectRepr, dal.ActionFlag, dal.ChangeMessage, dal.ContentTypeID, dal.UserID, dal.ID)
return err
} | [
"func",
"(",
"dal",
"*",
"DjangoAdminLog",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"dal",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"dal",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE public.django_admin_log SET (`",
"+",
"`action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id`",
"+",
"`) = ( `",
"+",
"`$1, $2, $3, $4, $5, $6, $7`",
"+",
"`) WHERE id = $8`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"dal",
".",
"ActionTime",
",",
"dal",
".",
"ObjectID",
",",
"dal",
".",
"ObjectRepr",
",",
"dal",
".",
"ActionFlag",
",",
"dal",
".",
"ChangeMessage",
",",
"dal",
".",
"ContentTypeID",
",",
"dal",
".",
"UserID",
",",
"dal",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"dal",
".",
"ActionTime",
",",
"dal",
".",
"ObjectID",
",",
"dal",
".",
"ObjectRepr",
",",
"dal",
".",
"ActionFlag",
",",
"dal",
".",
"ChangeMessage",
",",
"dal",
".",
"ContentTypeID",
",",
"dal",
".",
"UserID",
",",
"dal",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the DjangoAdminLog in the database. | [
"Update",
"updates",
"the",
"DjangoAdminLog",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangoadminlog.xo.go#L67-L91 | train |
xo/xo | examples/django/postgres/djangoadminlog.xo.go | DjangoAdminLogsByContentTypeID | func DjangoAdminLogsByContentTypeID(db XODB, contentTypeID sql.NullInt64) ([]*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id ` +
`FROM public.django_admin_log ` +
`WHERE content_type_id = $1`
// run query
XOLog(sqlstr, contentTypeID)
q, err := db.Query(sqlstr, contentTypeID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoAdminLog{}
for q.Next() {
dal := DjangoAdminLog{
_exists: true,
}
// scan
err = q.Scan(&dal.ID, &dal.ActionTime, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID)
if err != nil {
return nil, err
}
res = append(res, &dal)
}
return res, nil
} | go | func DjangoAdminLogsByContentTypeID(db XODB, contentTypeID sql.NullInt64) ([]*DjangoAdminLog, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id ` +
`FROM public.django_admin_log ` +
`WHERE content_type_id = $1`
// run query
XOLog(sqlstr, contentTypeID)
q, err := db.Query(sqlstr, contentTypeID)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*DjangoAdminLog{}
for q.Next() {
dal := DjangoAdminLog{
_exists: true,
}
// scan
err = q.Scan(&dal.ID, &dal.ActionTime, &dal.ObjectID, &dal.ObjectRepr, &dal.ActionFlag, &dal.ChangeMessage, &dal.ContentTypeID, &dal.UserID)
if err != nil {
return nil, err
}
res = append(res, &dal)
}
return res, nil
} | [
"func",
"DjangoAdminLogsByContentTypeID",
"(",
"db",
"XODB",
",",
"contentTypeID",
"sql",
".",
"NullInt64",
")",
"(",
"[",
"]",
"*",
"DjangoAdminLog",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, action_time, object_id, object_repr, action_flag, change_message, content_type_id, user_id `",
"+",
"`FROM public.django_admin_log `",
"+",
"`WHERE content_type_id = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"contentTypeID",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"contentTypeID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"DjangoAdminLog",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"dal",
":=",
"DjangoAdminLog",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"dal",
".",
"ID",
",",
"&",
"dal",
".",
"ActionTime",
",",
"&",
"dal",
".",
"ObjectID",
",",
"&",
"dal",
".",
"ObjectRepr",
",",
"&",
"dal",
".",
"ActionFlag",
",",
"&",
"dal",
".",
"ChangeMessage",
",",
"&",
"dal",
".",
"ContentTypeID",
",",
"&",
"dal",
".",
"UserID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"dal",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // DjangoAdminLogsByContentTypeID retrieves a row from 'public.django_admin_log' as a DjangoAdminLog.
//
// Generated from index 'django_admin_log_417f1b1c'. | [
"DjangoAdminLogsByContentTypeID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"django_admin_log",
"as",
"a",
"DjangoAdminLog",
".",
"Generated",
"from",
"index",
"django_admin_log_417f1b1c",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/djangoadminlog.xo.go#L184-L218 | train |
xo/xo | models/proc.xo.go | PgProcs | func PgProcs(db XODB, schema string) ([]*Proc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`p.proname, ` + // ::varchar AS proc_name
`pg_get_function_result(p.oid) ` + // ::varchar AS return_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Proc{}
for q.Next() {
p := Proc{}
// scan
err = q.Scan(&p.ProcName, &p.ReturnType)
if err != nil {
return nil, err
}
res = append(res, &p)
}
return res, nil
} | go | func PgProcs(db XODB, schema string) ([]*Proc, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`p.proname, ` + // ::varchar AS proc_name
`pg_get_function_result(p.oid) ` + // ::varchar AS return_type
`FROM pg_proc p ` +
`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid ` +
`WHERE n.nspname = $1`
// run query
XOLog(sqlstr, schema)
q, err := db.Query(sqlstr, schema)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Proc{}
for q.Next() {
p := Proc{}
// scan
err = q.Scan(&p.ProcName, &p.ReturnType)
if err != nil {
return nil, err
}
res = append(res, &p)
}
return res, nil
} | [
"func",
"PgProcs",
"(",
"db",
"XODB",
",",
"schema",
"string",
")",
"(",
"[",
"]",
"*",
"Proc",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`p.proname, `",
"+",
"// ::varchar AS proc_name",
"`pg_get_function_result(p.oid) `",
"+",
"// ::varchar AS return_type",
"`FROM pg_proc p `",
"+",
"`JOIN ONLY pg_namespace n ON p.pronamespace = n.oid `",
"+",
"`WHERE n.nspname = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"Proc",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"p",
":=",
"Proc",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"p",
".",
"ProcName",
",",
"&",
"p",
".",
"ReturnType",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"p",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // PgProcs runs a custom query, returning results as Proc. | [
"PgProcs",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Proc",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/proc.xo.go#L13-L47 | train |
xo/xo | examples/django/oracle/authgroup.xo.go | Delete | func (ag *AuthGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return nil
}
// if deleted, bail
if ag._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_group WHERE id = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag.ID)
if err != nil {
return err
}
// set deleted
ag._deleted = true
return nil
} | go | func (ag *AuthGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return nil
}
// if deleted, bail
if ag._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_group WHERE id = :1`
// run query
XOLog(sqlstr, ag.ID)
_, err = db.Exec(sqlstr, ag.ID)
if err != nil {
return err
}
// set deleted
ag._deleted = true
return nil
} | [
"func",
"(",
"ag",
"*",
"AuthGroup",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"ag",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"ag",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_group WHERE id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"ag",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ag",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"ag",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the AuthGroup from the database. | [
"Delete",
"deletes",
"the",
"AuthGroup",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authgroup.xo.go#L101-L128 | train |
xo/xo | examples/django/sqlite3/authgroup.xo.go | Update | func (ag *AuthGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ag._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group SET ` +
`name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ag.Name, ag.ID)
_, err = db.Exec(sqlstr, ag.Name, ag.ID)
return err
} | go | func (ag *AuthGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !ag._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if ag._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE auth_group SET ` +
`name = ?` +
` WHERE id = ?`
// run query
XOLog(sqlstr, ag.Name, ag.ID)
_, err = db.Exec(sqlstr, ag.Name, ag.ID)
return err
} | [
"func",
"(",
"ag",
"*",
"AuthGroup",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"ag",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"ag",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE auth_group SET `",
"+",
"`name = ?`",
"+",
"` WHERE id = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"ag",
".",
"Name",
",",
"ag",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"ag",
".",
"Name",
",",
"ag",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the AuthGroup in the database. | [
"Update",
"updates",
"the",
"AuthGroup",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/sqlite3/authgroup.xo.go#L66-L88 | train |
xo/xo | examples/django/oracle/authuser.xo.go | Delete | func (au *AuthUser) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !au._exists {
return nil
}
// if deleted, bail
if au._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user WHERE id = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.ID)
if err != nil {
return err
}
// set deleted
au._deleted = true
return nil
} | go | func (au *AuthUser) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !au._exists {
return nil
}
// if deleted, bail
if au._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user WHERE id = :1`
// run query
XOLog(sqlstr, au.ID)
_, err = db.Exec(sqlstr, au.ID)
if err != nil {
return err
}
// set deleted
au._deleted = true
return nil
} | [
"func",
"(",
"au",
"*",
"AuthUser",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"au",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"au",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_user WHERE id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"au",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"au",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"au",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the AuthUser from the database. | [
"Delete",
"deletes",
"the",
"AuthUser",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuser.xo.go#L111-L138 | train |
xo/xo | examples/django/oracle/authuser.xo.go | AuthUserByUsername | func AuthUserByUsername(db XODB, username sql.NullString) (*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM django.auth_user ` +
`WHERE username = :1`
// run query
XOLog(sqlstr, username)
au := AuthUser{
_exists: true,
}
err = db.QueryRow(sqlstr, username).Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
return &au, nil
} | go | func AuthUserByUsername(db XODB, username sql.NullString) (*AuthUser, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined ` +
`FROM django.auth_user ` +
`WHERE username = :1`
// run query
XOLog(sqlstr, username)
au := AuthUser{
_exists: true,
}
err = db.QueryRow(sqlstr, username).Scan(&au.ID, &au.Password, &au.LastLogin, &au.IsSuperuser, &au.Username, &au.FirstName, &au.LastName, &au.Email, &au.IsStaff, &au.IsActive, &au.DateJoined)
if err != nil {
return nil, err
}
return &au, nil
} | [
"func",
"AuthUserByUsername",
"(",
"db",
"XODB",
",",
"username",
"sql",
".",
"NullString",
")",
"(",
"*",
"AuthUser",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, password, last_login, is_superuser, username, first_name, last_name, email, is_staff, is_active, date_joined `",
"+",
"`FROM django.auth_user `",
"+",
"`WHERE username = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"username",
")",
"\n",
"au",
":=",
"AuthUser",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"username",
")",
".",
"Scan",
"(",
"&",
"au",
".",
"ID",
",",
"&",
"au",
".",
"Password",
",",
"&",
"au",
".",
"LastLogin",
",",
"&",
"au",
".",
"IsSuperuser",
",",
"&",
"au",
".",
"Username",
",",
"&",
"au",
".",
"FirstName",
",",
"&",
"au",
".",
"LastName",
",",
"&",
"au",
".",
"Email",
",",
"&",
"au",
".",
"IsStaff",
",",
"&",
"au",
".",
"IsActive",
",",
"&",
"au",
".",
"DateJoined",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"au",
",",
"nil",
"\n",
"}"
] | // AuthUserByUsername retrieves a row from 'django.auth_user' as a AuthUser.
//
// Generated from index 'sys_c004977'. | [
"AuthUserByUsername",
"retrieves",
"a",
"row",
"from",
"django",
".",
"auth_user",
"as",
"a",
"AuthUser",
".",
"Generated",
"from",
"index",
"sys_c004977",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authuser.xo.go#L169-L190 | train |
xo/xo | internal/fkmode.go | UnmarshalText | func (f *FkMode) UnmarshalText(text []byte) error {
switch strings.ToLower(string(text)) {
case "smart", "default":
*f = FkModeSmart
case "parent":
*f = FkModeParent
case "field":
*f = FkModeField
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
} | go | func (f *FkMode) UnmarshalText(text []byte) error {
switch strings.ToLower(string(text)) {
case "smart", "default":
*f = FkModeSmart
case "parent":
*f = FkModeParent
case "field":
*f = FkModeField
case "key":
*f = FkModeKey
default:
return errors.New("invalid FkMode")
}
return nil
} | [
"func",
"(",
"f",
"*",
"FkMode",
")",
"UnmarshalText",
"(",
"text",
"[",
"]",
"byte",
")",
"error",
"{",
"switch",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"text",
")",
")",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"*",
"f",
"=",
"FkModeSmart",
"\n",
"case",
"\"",
"\"",
":",
"*",
"f",
"=",
"FkModeParent",
"\n",
"case",
"\"",
"\"",
":",
"*",
"f",
"=",
"FkModeField",
"\n",
"case",
"\"",
"\"",
":",
"*",
"f",
"=",
"FkModeKey",
"\n\n",
"default",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalText unmarshals FkMode from text. | [
"UnmarshalText",
"unmarshals",
"FkMode",
"from",
"text",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L44-L60 | train |
xo/xo | internal/fkmode.go | fkName | func fkName(mode FkMode, fkMap map[string]*ForeignKey, fk *ForeignKey) string {
switch mode {
case FkModeParent:
return fk.RefType.Name
case FkModeField:
return fk.RefType.Name + "By" + fk.Field.Name
case FkModeKey:
return fk.RefType.Name + "By" + snaker.SnakeToCamelIdentifier(fk.ForeignKey.ForeignKeyName)
}
// mode is FkModeSmart
// inspect all foreign keys and use FkModeField if conflict found
for _, f := range fkMap {
if fk != f && fk.Type.Name == f.Type.Name && fk.RefType.Name == f.RefType.Name {
return fkName(FkModeField, fkMap, fk)
}
}
// no conflict, so use FkModeParent
return fkName(FkModeParent, fkMap, fk)
} | go | func fkName(mode FkMode, fkMap map[string]*ForeignKey, fk *ForeignKey) string {
switch mode {
case FkModeParent:
return fk.RefType.Name
case FkModeField:
return fk.RefType.Name + "By" + fk.Field.Name
case FkModeKey:
return fk.RefType.Name + "By" + snaker.SnakeToCamelIdentifier(fk.ForeignKey.ForeignKeyName)
}
// mode is FkModeSmart
// inspect all foreign keys and use FkModeField if conflict found
for _, f := range fkMap {
if fk != f && fk.Type.Name == f.Type.Name && fk.RefType.Name == f.RefType.Name {
return fkName(FkModeField, fkMap, fk)
}
}
// no conflict, so use FkModeParent
return fkName(FkModeParent, fkMap, fk)
} | [
"func",
"fkName",
"(",
"mode",
"FkMode",
",",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"fk",
"*",
"ForeignKey",
")",
"string",
"{",
"switch",
"mode",
"{",
"case",
"FkModeParent",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"\n",
"case",
"FkModeField",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"+",
"\"",
"\"",
"+",
"fk",
".",
"Field",
".",
"Name",
"\n",
"case",
"FkModeKey",
":",
"return",
"fk",
".",
"RefType",
".",
"Name",
"+",
"\"",
"\"",
"+",
"snaker",
".",
"SnakeToCamelIdentifier",
"(",
"fk",
".",
"ForeignKey",
".",
"ForeignKeyName",
")",
"\n",
"}",
"\n\n",
"// mode is FkModeSmart",
"// inspect all foreign keys and use FkModeField if conflict found",
"for",
"_",
",",
"f",
":=",
"range",
"fkMap",
"{",
"if",
"fk",
"!=",
"f",
"&&",
"fk",
".",
"Type",
".",
"Name",
"==",
"f",
".",
"Type",
".",
"Name",
"&&",
"fk",
".",
"RefType",
".",
"Name",
"==",
"f",
".",
"RefType",
".",
"Name",
"{",
"return",
"fkName",
"(",
"FkModeField",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// no conflict, so use FkModeParent",
"return",
"fkName",
"(",
"FkModeParent",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}"
] | // fkName returns the name for the foreign key. | [
"fkName",
"returns",
"the",
"name",
"for",
"the",
"foreign",
"key",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L79-L99 | train |
xo/xo | internal/fkmode.go | ForeignKeyName | func (a *ArgType) ForeignKeyName(fkMap map[string]*ForeignKey, fk *ForeignKey) string {
return fkName(*a.ForeignKeyMode, fkMap, fk)
} | go | func (a *ArgType) ForeignKeyName(fkMap map[string]*ForeignKey, fk *ForeignKey) string {
return fkName(*a.ForeignKeyMode, fkMap, fk)
} | [
"func",
"(",
"a",
"*",
"ArgType",
")",
"ForeignKeyName",
"(",
"fkMap",
"map",
"[",
"string",
"]",
"*",
"ForeignKey",
",",
"fk",
"*",
"ForeignKey",
")",
"string",
"{",
"return",
"fkName",
"(",
"*",
"a",
".",
"ForeignKeyMode",
",",
"fkMap",
",",
"fk",
")",
"\n",
"}"
] | // ForeignKeyName returns the foreign key name for the passed type. | [
"ForeignKeyName",
"returns",
"the",
"foreign",
"key",
"name",
"for",
"the",
"passed",
"type",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/internal/fkmode.go#L102-L104 | train |
xo/xo | examples/django/postgres/authuseruserpermission.xo.go | Delete | func (auup *AuthUserUserPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return nil
}
// if deleted, bail
if auup._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.auth_user_user_permissions WHERE id = $1`
// run query
XOLog(sqlstr, auup.ID)
_, err = db.Exec(sqlstr, auup.ID)
if err != nil {
return err
}
// set deleted
auup._deleted = true
return nil
} | go | func (auup *AuthUserUserPermission) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !auup._exists {
return nil
}
// if deleted, bail
if auup._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM public.auth_user_user_permissions WHERE id = $1`
// run query
XOLog(sqlstr, auup.ID)
_, err = db.Exec(sqlstr, auup.ID)
if err != nil {
return err
}
// set deleted
auup._deleted = true
return nil
} | [
"func",
"(",
"auup",
"*",
"AuthUserUserPermission",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"auup",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"auup",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM public.auth_user_user_permissions WHERE id = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"auup",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"auup",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"auup",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the AuthUserUserPermission from the database. | [
"Delete",
"deletes",
"the",
"AuthUserUserPermission",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authuseruserpermission.xo.go#L131-L158 | train |
xo/xo | examples/django/postgres/authuseruserpermission.xo.go | AuthUserUserPermissionByID | func AuthUserUserPermissionByID(db XODB, id int) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM public.auth_user_user_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | go | func AuthUserUserPermissionByID(db XODB, id int) (*AuthUserUserPermission, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`id, user_id, permission_id ` +
`FROM public.auth_user_user_permissions ` +
`WHERE id = $1`
// run query
XOLog(sqlstr, id)
auup := AuthUserUserPermission{
_exists: true,
}
err = db.QueryRow(sqlstr, id).Scan(&auup.ID, &auup.UserID, &auup.PermissionID)
if err != nil {
return nil, err
}
return &auup, nil
} | [
"func",
"AuthUserUserPermissionByID",
"(",
"db",
"XODB",
",",
"id",
"int",
")",
"(",
"*",
"AuthUserUserPermission",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`id, user_id, permission_id `",
"+",
"`FROM public.auth_user_user_permissions `",
"+",
"`WHERE id = $1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"id",
")",
"\n",
"auup",
":=",
"AuthUserUserPermission",
"{",
"_exists",
":",
"true",
",",
"}",
"\n\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"id",
")",
".",
"Scan",
"(",
"&",
"auup",
".",
"ID",
",",
"&",
"auup",
".",
"UserID",
",",
"&",
"auup",
".",
"PermissionID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"auup",
",",
"nil",
"\n",
"}"
] | // AuthUserUserPermissionByID retrieves a row from 'public.auth_user_user_permissions' as a AuthUserUserPermission.
//
// Generated from index 'auth_user_user_permissions_pkey'. | [
"AuthUserUserPermissionByID",
"retrieves",
"a",
"row",
"from",
"public",
".",
"auth_user_user_permissions",
"as",
"a",
"AuthUserUserPermission",
".",
"Generated",
"from",
"index",
"auth_user_user_permissions_pkey",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authuseruserpermission.xo.go#L255-L276 | train |
xo/xo | examples/django/oracle/authusergroup.xo.go | Delete | func (aug *AuthUserGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return nil
}
// if deleted, bail
if aug._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user_groups WHERE id = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.Exec(sqlstr, aug.ID)
if err != nil {
return err
}
// set deleted
aug._deleted = true
return nil
} | go | func (aug *AuthUserGroup) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return nil
}
// if deleted, bail
if aug._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM django.auth_user_groups WHERE id = :1`
// run query
XOLog(sqlstr, aug.ID)
_, err = db.Exec(sqlstr, aug.ID)
if err != nil {
return err
}
// set deleted
aug._deleted = true
return nil
} | [
"func",
"(",
"aug",
"*",
"AuthUserGroup",
")",
"Delete",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"aug",
".",
"_exists",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"aug",
".",
"_deleted",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`DELETE FROM django.auth_user_groups WHERE id = :1`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"aug",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"aug",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// set deleted",
"aug",
".",
"_deleted",
"=",
"true",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Delete deletes the AuthUserGroup from the database. | [
"Delete",
"deletes",
"the",
"AuthUserGroup",
"from",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/oracle/authusergroup.xo.go#L99-L126 | train |
xo/xo | models/myenumvalue.xo.go | MyEnumValues | func MyEnumValues(db XODB, schema string, enum string) (*MyEnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values ` +
`FROM information_schema.columns ` +
`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`
// run query
XOLog(sqlstr, schema, enum)
var mev MyEnumValue
err = db.QueryRow(sqlstr, schema, enum).Scan(&mev.EnumValues)
if err != nil {
return nil, err
}
return &mev, nil
} | go | func MyEnumValues(db XODB, schema string, enum string) (*MyEnumValue, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values ` +
`FROM information_schema.columns ` +
`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`
// run query
XOLog(sqlstr, schema, enum)
var mev MyEnumValue
err = db.QueryRow(sqlstr, schema, enum).Scan(&mev.EnumValues)
if err != nil {
return nil, err
}
return &mev, nil
} | [
"func",
"MyEnumValues",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"enum",
"string",
")",
"(",
"*",
"MyEnumValue",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`SUBSTRING(column_type, 6, CHAR_LENGTH(column_type) - 6) AS enum_values `",
"+",
"`FROM information_schema.columns `",
"+",
"`WHERE data_type = 'enum' AND table_schema = ? AND column_name = ?`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
"\n",
"var",
"mev",
"MyEnumValue",
"\n",
"err",
"=",
"db",
".",
"QueryRow",
"(",
"sqlstr",
",",
"schema",
",",
"enum",
")",
".",
"Scan",
"(",
"&",
"mev",
".",
"EnumValues",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"mev",
",",
"nil",
"\n",
"}"
] | // MyEnumValues runs a custom query, returning results as MyEnumValue. | [
"MyEnumValues",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"MyEnumValue",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/myenumvalue.xo.go#L12-L30 | train |
xo/xo | examples/django/postgres/authusergroup.xo.go | Update | func (aug *AuthUserGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if aug._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth_user_groups SET (` +
`user_id, group_id` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, aug.UserID, aug.GroupID, aug.ID)
_, err = db.Exec(sqlstr, aug.UserID, aug.GroupID, aug.ID)
return err
} | go | func (aug *AuthUserGroup) Update(db XODB) error {
var err error
// if doesn't exist, bail
if !aug._exists {
return errors.New("update failed: does not exist")
}
// if deleted, bail
if aug._deleted {
return errors.New("update failed: marked for deletion")
}
// sql query
const sqlstr = `UPDATE public.auth_user_groups SET (` +
`user_id, group_id` +
`) = ( ` +
`$1, $2` +
`) WHERE id = $3`
// run query
XOLog(sqlstr, aug.UserID, aug.GroupID, aug.ID)
_, err = db.Exec(sqlstr, aug.UserID, aug.GroupID, aug.ID)
return err
} | [
"func",
"(",
"aug",
"*",
"AuthUserGroup",
")",
"Update",
"(",
"db",
"XODB",
")",
"error",
"{",
"var",
"err",
"error",
"\n\n",
"// if doesn't exist, bail",
"if",
"!",
"aug",
".",
"_exists",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// if deleted, bail",
"if",
"aug",
".",
"_deleted",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`UPDATE public.auth_user_groups SET (`",
"+",
"`user_id, group_id`",
"+",
"`) = ( `",
"+",
"`$1, $2`",
"+",
"`) WHERE id = $3`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"aug",
".",
"UserID",
",",
"aug",
".",
"GroupID",
",",
"aug",
".",
"ID",
")",
"\n",
"_",
",",
"err",
"=",
"db",
".",
"Exec",
"(",
"sqlstr",
",",
"aug",
".",
"UserID",
",",
"aug",
".",
"GroupID",
",",
"aug",
".",
"ID",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Update updates the AuthUserGroup in the database. | [
"Update",
"updates",
"the",
"AuthUserGroup",
"in",
"the",
"database",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/examples/django/postgres/authusergroup.xo.go#L60-L84 | train |
xo/xo | models/column.xo.go | MyTableColumns | func MyTableColumns(db XODB, schema string, table string) ([]*Column, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`ordinal_position AS field_ordinal, ` +
`column_name, ` +
`IF(data_type = 'enum', column_name, column_type) AS data_type, ` +
`IF(is_nullable = 'YES', false, true) AS not_null, ` +
`column_default AS default_value, ` +
`IF(column_key = 'PRI', true, false) AS is_primary_key ` +
`FROM information_schema.columns ` +
`WHERE table_schema = ? AND table_name = ? ` +
`ORDER BY ordinal_position`
// run query
XOLog(sqlstr, schema, table)
q, err := db.Query(sqlstr, schema, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Column{}
for q.Next() {
c := Column{}
// scan
err = q.Scan(&c.FieldOrdinal, &c.ColumnName, &c.DataType, &c.NotNull, &c.DefaultValue, &c.IsPrimaryKey)
if err != nil {
return nil, err
}
res = append(res, &c)
}
return res, nil
} | go | func MyTableColumns(db XODB, schema string, table string) ([]*Column, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`ordinal_position AS field_ordinal, ` +
`column_name, ` +
`IF(data_type = 'enum', column_name, column_type) AS data_type, ` +
`IF(is_nullable = 'YES', false, true) AS not_null, ` +
`column_default AS default_value, ` +
`IF(column_key = 'PRI', true, false) AS is_primary_key ` +
`FROM information_schema.columns ` +
`WHERE table_schema = ? AND table_name = ? ` +
`ORDER BY ordinal_position`
// run query
XOLog(sqlstr, schema, table)
q, err := db.Query(sqlstr, schema, table)
if err != nil {
return nil, err
}
defer q.Close()
// load results
res := []*Column{}
for q.Next() {
c := Column{}
// scan
err = q.Scan(&c.FieldOrdinal, &c.ColumnName, &c.DataType, &c.NotNull, &c.DefaultValue, &c.IsPrimaryKey)
if err != nil {
return nil, err
}
res = append(res, &c)
}
return res, nil
} | [
"func",
"MyTableColumns",
"(",
"db",
"XODB",
",",
"schema",
"string",
",",
"table",
"string",
")",
"(",
"[",
"]",
"*",
"Column",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n\n",
"// sql query",
"const",
"sqlstr",
"=",
"`SELECT `",
"+",
"`ordinal_position AS field_ordinal, `",
"+",
"`column_name, `",
"+",
"`IF(data_type = 'enum', column_name, column_type) AS data_type, `",
"+",
"`IF(is_nullable = 'YES', false, true) AS not_null, `",
"+",
"`column_default AS default_value, `",
"+",
"`IF(column_key = 'PRI', true, false) AS is_primary_key `",
"+",
"`FROM information_schema.columns `",
"+",
"`WHERE table_schema = ? AND table_name = ? `",
"+",
"`ORDER BY ordinal_position`",
"\n\n",
"// run query",
"XOLog",
"(",
"sqlstr",
",",
"schema",
",",
"table",
")",
"\n",
"q",
",",
"err",
":=",
"db",
".",
"Query",
"(",
"sqlstr",
",",
"schema",
",",
"table",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"q",
".",
"Close",
"(",
")",
"\n\n",
"// load results",
"res",
":=",
"[",
"]",
"*",
"Column",
"{",
"}",
"\n",
"for",
"q",
".",
"Next",
"(",
")",
"{",
"c",
":=",
"Column",
"{",
"}",
"\n\n",
"// scan",
"err",
"=",
"q",
".",
"Scan",
"(",
"&",
"c",
".",
"FieldOrdinal",
",",
"&",
"c",
".",
"ColumnName",
",",
"&",
"c",
".",
"DataType",
",",
"&",
"c",
".",
"NotNull",
",",
"&",
"c",
".",
"DefaultValue",
",",
"&",
"c",
".",
"IsPrimaryKey",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
"=",
"append",
"(",
"res",
",",
"&",
"c",
")",
"\n",
"}",
"\n\n",
"return",
"res",
",",
"nil",
"\n",
"}"
] | // MyTableColumns runs a custom query, returning results as Column. | [
"MyTableColumns",
"runs",
"a",
"custom",
"query",
"returning",
"results",
"as",
"Column",
"."
] | 1a94fa516029cb306cce6d379d086e4d5b5bb232 | https://github.com/xo/xo/blob/1a94fa516029cb306cce6d379d086e4d5b5bb232/models/column.xo.go#L66-L104 | train |
gravitational/teleport | lib/auth/methods.go | AuthenticateUser | func (s *AuthServer) AuthenticateUser(req AuthenticateUserRequest) error {
err := s.authenticateUser(req)
if err != nil {
s.EmitAuditEvent(events.UserLocalLoginFailure, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
s.EmitAuditEvent(events.UserLocalLogin, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: true,
})
}
return err
} | go | func (s *AuthServer) AuthenticateUser(req AuthenticateUserRequest) error {
err := s.authenticateUser(req)
if err != nil {
s.EmitAuditEvent(events.UserLocalLoginFailure, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: false,
events.AuthAttemptErr: err.Error(),
})
} else {
s.EmitAuditEvent(events.UserLocalLogin, events.EventFields{
events.EventUser: req.Username,
events.LoginMethod: events.LoginMethodLocal,
events.AuthAttemptSuccess: true,
})
}
return err
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateUser",
"(",
"req",
"AuthenticateUserRequest",
")",
"error",
"{",
"err",
":=",
"s",
".",
"authenticateUser",
"(",
"req",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserLocalLoginFailure",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"req",
".",
"Username",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodLocal",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"false",
",",
"events",
".",
"AuthAttemptErr",
":",
"err",
".",
"Error",
"(",
")",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"s",
".",
"EmitAuditEvent",
"(",
"events",
".",
"UserLocalLogin",
",",
"events",
".",
"EventFields",
"{",
"events",
".",
"EventUser",
":",
"req",
".",
"Username",
",",
"events",
".",
"LoginMethod",
":",
"events",
".",
"LoginMethodLocal",
",",
"events",
".",
"AuthAttemptSuccess",
":",
"true",
",",
"}",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // AuthenticateUser authenticates user based on the request type | [
"AuthenticateUser",
"authenticates",
"user",
"based",
"on",
"the",
"request",
"type"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L85-L102 | train |
gravitational/teleport | lib/auth/methods.go | AuthenticateWebUser | func (s *AuthServer) AuthenticateWebUser(req AuthenticateUserRequest) (services.WebSession, error) {
if req.Session != nil {
session, err := s.GetWebSession(req.Username, req.Session.ID)
if err != nil {
return nil, trace.AccessDenied("session is invalid or has expired")
}
return session, nil
}
if err := s.AuthenticateUser(req); err != nil {
return nil, trace.Wrap(err)
}
sess, err := s.NewWebSession(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(req.Username, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | go | func (s *AuthServer) AuthenticateWebUser(req AuthenticateUserRequest) (services.WebSession, error) {
if req.Session != nil {
session, err := s.GetWebSession(req.Username, req.Session.ID)
if err != nil {
return nil, trace.AccessDenied("session is invalid or has expired")
}
return session, nil
}
if err := s.AuthenticateUser(req); err != nil {
return nil, trace.Wrap(err)
}
sess, err := s.NewWebSession(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.UpsertWebSession(req.Username, sess); err != nil {
return nil, trace.Wrap(err)
}
sess, err = services.GetWebSessionMarshaler().GenerateWebSession(sess)
if err != nil {
return nil, trace.Wrap(err)
}
return sess, nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateWebUser",
"(",
"req",
"AuthenticateUserRequest",
")",
"(",
"services",
".",
"WebSession",
",",
"error",
")",
"{",
"if",
"req",
".",
"Session",
"!=",
"nil",
"{",
"session",
",",
"err",
":=",
"s",
".",
"GetWebSession",
"(",
"req",
".",
"Username",
",",
"req",
".",
"Session",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"AccessDenied",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"session",
",",
"nil",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"AuthenticateUser",
"(",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
":=",
"s",
".",
"NewWebSession",
"(",
"req",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"s",
".",
"UpsertWebSession",
"(",
"req",
".",
"Username",
",",
"sess",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"sess",
",",
"err",
"=",
"services",
".",
"GetWebSessionMarshaler",
"(",
")",
".",
"GenerateWebSession",
"(",
"sess",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"sess",
",",
"nil",
"\n",
"}"
] | // AuthenticateWebUser authenticates web user, creates and returns web session
// in case if authentication is successful. In case if existing session id
// is used to authenticate, returns session associated with the existing session id
// instead of creating the new one | [
"AuthenticateWebUser",
"authenticates",
"web",
"user",
"creates",
"and",
"returns",
"web",
"session",
"in",
"case",
"if",
"authentication",
"is",
"successful",
".",
"In",
"case",
"if",
"existing",
"session",
"id",
"is",
"used",
"to",
"authenticate",
"returns",
"session",
"associated",
"with",
"the",
"existing",
"session",
"id",
"instead",
"of",
"creating",
"the",
"new",
"one"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L165-L188 | train |
gravitational/teleport | lib/auth/methods.go | CheckAndSetDefaults | func (a *AuthenticateSSHRequest) CheckAndSetDefaults() error {
if err := a.AuthenticateUserRequest.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
if len(a.PublicKey) == 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.CompatibilityMode)
if err != nil {
return trace.Wrap(err)
}
a.CompatibilityMode = certificateFormat
return nil
} | go | func (a *AuthenticateSSHRequest) CheckAndSetDefaults() error {
if err := a.AuthenticateUserRequest.CheckAndSetDefaults(); err != nil {
return trace.Wrap(err)
}
if len(a.PublicKey) == 0 {
return trace.BadParameter("missing parameter 'public_key'")
}
certificateFormat, err := utils.CheckCertificateFormatFlag(a.CompatibilityMode)
if err != nil {
return trace.Wrap(err)
}
a.CompatibilityMode = certificateFormat
return nil
} | [
"func",
"(",
"a",
"*",
"AuthenticateSSHRequest",
")",
"CheckAndSetDefaults",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"a",
".",
"AuthenticateUserRequest",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"a",
".",
"PublicKey",
")",
"==",
"0",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"certificateFormat",
",",
"err",
":=",
"utils",
".",
"CheckCertificateFormatFlag",
"(",
"a",
".",
"CompatibilityMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"CompatibilityMode",
"=",
"certificateFormat",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default certificate values | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"certificate",
"values"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L203-L216 | train |
gravitational/teleport | lib/auth/methods.go | SSHCertPublicKeys | func (c *TrustedCerts) SSHCertPublicKeys() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(c.HostCertificates))
for _, keyBytes := range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)
}
return out, nil
} | go | func (c *TrustedCerts) SSHCertPublicKeys() ([]ssh.PublicKey, error) {
out := make([]ssh.PublicKey, 0, len(c.HostCertificates))
for _, keyBytes := range c.HostCertificates {
publicKey, _, _, _, err := ssh.ParseAuthorizedKey(keyBytes)
if err != nil {
return nil, trace.Wrap(err)
}
out = append(out, publicKey)
}
return out, nil
} | [
"func",
"(",
"c",
"*",
"TrustedCerts",
")",
"SSHCertPublicKeys",
"(",
")",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"error",
")",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"ssh",
".",
"PublicKey",
",",
"0",
",",
"len",
"(",
"c",
".",
"HostCertificates",
")",
")",
"\n",
"for",
"_",
",",
"keyBytes",
":=",
"range",
"c",
".",
"HostCertificates",
"{",
"publicKey",
",",
"_",
",",
"_",
",",
"_",
",",
"err",
":=",
"ssh",
".",
"ParseAuthorizedKey",
"(",
"keyBytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"out",
"=",
"append",
"(",
"out",
",",
"publicKey",
")",
"\n",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // SSHCertPublicKeys returns a list of trusted host SSH certificate authority public keys | [
"SSHCertPublicKeys",
"returns",
"a",
"list",
"of",
"trusted",
"host",
"SSH",
"certificate",
"authority",
"public",
"keys"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L247-L257 | train |
gravitational/teleport | lib/auth/methods.go | AuthoritiesToTrustedCerts | func AuthoritiesToTrustedCerts(authorities []services.CertAuthority) []TrustedCerts {
out := make([]TrustedCerts, len(authorities))
for i, ca := range authorities {
out[i] = TrustedCerts{
ClusterName: ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),
}
}
return out
} | go | func AuthoritiesToTrustedCerts(authorities []services.CertAuthority) []TrustedCerts {
out := make([]TrustedCerts, len(authorities))
for i, ca := range authorities {
out[i] = TrustedCerts{
ClusterName: ca.GetClusterName(),
HostCertificates: ca.GetCheckingKeys(),
TLSCertificates: services.TLSCerts(ca),
}
}
return out
} | [
"func",
"AuthoritiesToTrustedCerts",
"(",
"authorities",
"[",
"]",
"services",
".",
"CertAuthority",
")",
"[",
"]",
"TrustedCerts",
"{",
"out",
":=",
"make",
"(",
"[",
"]",
"TrustedCerts",
",",
"len",
"(",
"authorities",
")",
")",
"\n",
"for",
"i",
",",
"ca",
":=",
"range",
"authorities",
"{",
"out",
"[",
"i",
"]",
"=",
"TrustedCerts",
"{",
"ClusterName",
":",
"ca",
".",
"GetClusterName",
"(",
")",
",",
"HostCertificates",
":",
"ca",
".",
"GetCheckingKeys",
"(",
")",
",",
"TLSCertificates",
":",
"services",
".",
"TLSCerts",
"(",
"ca",
")",
",",
"}",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}"
] | // AuthoritiesToTrustedCerts serializes authorities to TrustedCerts data structure | [
"AuthoritiesToTrustedCerts",
"serializes",
"authorities",
"to",
"TrustedCerts",
"data",
"structure"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L260-L270 | train |
gravitational/teleport | lib/auth/methods.go | AuthenticateSSHUser | func (s *AuthServer) AuthenticateSSHUser(req AuthenticateSSHRequest) (*SSHLoginResponse, error) {
clusterName, err := s.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.AuthenticateUser(req.AuthenticateUserRequest); err != nil {
return nil, trace.Wrap(err)
}
user, err := s.GetUser(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), s, user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Return the host CA for this cluster only.
authority, err := s.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
hostCertAuthorities := []services.CertAuthority{
authority,
}
certs, err := s.generateUserCert(certRequest{
user: user,
roles: roles,
ttl: req.TTL,
publicKey: req.PublicKey,
compatibility: req.CompatibilityMode,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &SSHLoginResponse{
Username: req.Username,
Cert: certs.ssh,
TLSCert: certs.tls,
HostSigners: AuthoritiesToTrustedCerts(hostCertAuthorities),
}, nil
} | go | func (s *AuthServer) AuthenticateSSHUser(req AuthenticateSSHRequest) (*SSHLoginResponse, error) {
clusterName, err := s.GetClusterName()
if err != nil {
return nil, trace.Wrap(err)
}
if err := s.AuthenticateUser(req.AuthenticateUserRequest); err != nil {
return nil, trace.Wrap(err)
}
user, err := s.GetUser(req.Username)
if err != nil {
return nil, trace.Wrap(err)
}
roles, err := services.FetchRoles(user.GetRoles(), s, user.GetTraits())
if err != nil {
return nil, trace.Wrap(err)
}
// Return the host CA for this cluster only.
authority, err := s.GetCertAuthority(services.CertAuthID{
Type: services.HostCA,
DomainName: clusterName.GetClusterName(),
}, false)
if err != nil {
return nil, trace.Wrap(err)
}
hostCertAuthorities := []services.CertAuthority{
authority,
}
certs, err := s.generateUserCert(certRequest{
user: user,
roles: roles,
ttl: req.TTL,
publicKey: req.PublicKey,
compatibility: req.CompatibilityMode,
})
if err != nil {
return nil, trace.Wrap(err)
}
return &SSHLoginResponse{
Username: req.Username,
Cert: certs.ssh,
TLSCert: certs.tls,
HostSigners: AuthoritiesToTrustedCerts(hostCertAuthorities),
}, nil
} | [
"func",
"(",
"s",
"*",
"AuthServer",
")",
"AuthenticateSSHUser",
"(",
"req",
"AuthenticateSSHRequest",
")",
"(",
"*",
"SSHLoginResponse",
",",
"error",
")",
"{",
"clusterName",
",",
"err",
":=",
"s",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"s",
".",
"AuthenticateUser",
"(",
"req",
".",
"AuthenticateUserRequest",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"user",
",",
"err",
":=",
"s",
".",
"GetUser",
"(",
"req",
".",
"Username",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"roles",
",",
"err",
":=",
"services",
".",
"FetchRoles",
"(",
"user",
".",
"GetRoles",
"(",
")",
",",
"s",
",",
"user",
".",
"GetTraits",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// Return the host CA for this cluster only.",
"authority",
",",
"err",
":=",
"s",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"services",
".",
"HostCA",
",",
"DomainName",
":",
"clusterName",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"hostCertAuthorities",
":=",
"[",
"]",
"services",
".",
"CertAuthority",
"{",
"authority",
",",
"}",
"\n\n",
"certs",
",",
"err",
":=",
"s",
".",
"generateUserCert",
"(",
"certRequest",
"{",
"user",
":",
"user",
",",
"roles",
":",
"roles",
",",
"ttl",
":",
"req",
".",
"TTL",
",",
"publicKey",
":",
"req",
".",
"PublicKey",
",",
"compatibility",
":",
"req",
".",
"CompatibilityMode",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"&",
"SSHLoginResponse",
"{",
"Username",
":",
"req",
".",
"Username",
",",
"Cert",
":",
"certs",
".",
"ssh",
",",
"TLSCert",
":",
"certs",
".",
"tls",
",",
"HostSigners",
":",
"AuthoritiesToTrustedCerts",
"(",
"hostCertAuthorities",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] | // AuthenticateSSHUser authenticates web user, creates and returns web session
// in case if authentication is successful | [
"AuthenticateSSHUser",
"authenticates",
"web",
"user",
"creates",
"and",
"returns",
"web",
"session",
"in",
"case",
"if",
"authentication",
"is",
"successful"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/methods.go#L274-L320 | train |
gravitational/teleport | lib/pam/pam.go | unregisterHandler | func unregisterHandler(handlerIndex int) {
handlerMu.Lock()
defer handlerMu.Unlock()
delete(handlers, handlerIndex)
} | go | func unregisterHandler(handlerIndex int) {
handlerMu.Lock()
defer handlerMu.Unlock()
delete(handlers, handlerIndex)
} | [
"func",
"unregisterHandler",
"(",
"handlerIndex",
"int",
")",
"{",
"handlerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"handlerMu",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"handlers",
",",
"handlerIndex",
")",
"\n",
"}"
] | // unregisterHandler will remove the PAM handle from the package level map
// once no more C callbacks can come back. | [
"unregisterHandler",
"will",
"remove",
"the",
"PAM",
"handle",
"from",
"the",
"package",
"level",
"map",
"once",
"no",
"more",
"C",
"callbacks",
"can",
"come",
"back",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L140-L145 | train |
gravitational/teleport | lib/pam/pam.go | lookupHandler | func lookupHandler(handlerIndex int) (handler, error) {
handlerMu.Lock()
defer handlerMu.Unlock()
handle, ok := handlers[handlerIndex]
if !ok {
return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
} | go | func lookupHandler(handlerIndex int) (handler, error) {
handlerMu.Lock()
defer handlerMu.Unlock()
handle, ok := handlers[handlerIndex]
if !ok {
return nil, trace.BadParameter("handler with index %v not registered", handlerIndex)
}
return handle, nil
} | [
"func",
"lookupHandler",
"(",
"handlerIndex",
"int",
")",
"(",
"handler",
",",
"error",
")",
"{",
"handlerMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"handlerMu",
".",
"Unlock",
"(",
")",
"\n\n",
"handle",
",",
"ok",
":=",
"handlers",
"[",
"handlerIndex",
"]",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"handlerIndex",
")",
"\n",
"}",
"\n\n",
"return",
"handle",
",",
"nil",
"\n",
"}"
] | // lookupHandler returns a particular handler from the package level map. | [
"lookupHandler",
"returns",
"a",
"particular",
"handler",
"from",
"the",
"package",
"level",
"map",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L148-L158 | train |
gravitational/teleport | lib/pam/pam.go | Open | func Open(config *Config) (*PAM, error) {
if config == nil {
return nil, trace.BadParameter("PAM configuration is required.")
}
err := config.CheckDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
p := &PAM{
pamh: nil,
stdin: config.Stdin,
stdout: config.Stdout,
stderr: config.Stderr,
}
// Both config.ServiceName and config.Username convert between Go strings to
// C strings. Since the C strings are allocated on the heap in Go code, this
// memory must be released (and will be on the call to the Close method).
p.service_name = C.CString(config.ServiceName)
p.user = C.CString(config.Username)
// C code does not know that this PAM context exists. To ensure the
// conversation function can get messages to the right context, a handle
// registry at the package level is created (handlers). Each instance of the
// PAM context has it's own handle which is used to communicate between C
// and a instance of a PAM context.
p.handlerIndex = registerHandler(p)
// Create and initialize a PAM context. The pam_start function will
// allocate pamh if needed and the pam_end function will release any
// allocated memory.
p.retval = C._pam_start(pamHandle, p.service_name, p.user, p.conv, &p.pamh)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
// Check that the *nix account is valid. Checking an account varies based off
// the PAM modules used in the account stack. Typically this consists of
// checking if the account is expired or has access restrictions.
//
// Note: This function does not perform any authentication!
retval := C._pam_acct_mgmt(pamHandle, p.pamh, 0)
if retval != C.PAM_SUCCESS {
return nil, p.codeToError(retval)
}
// Open a user session. Opening a session varies based off the PAM modules
// used in the "session" stack. Opening a session typically consists of
// printing the MOTD, mounting a home directory, updating auth.log.
p.retval = C._pam_open_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
return p, nil
} | go | func Open(config *Config) (*PAM, error) {
if config == nil {
return nil, trace.BadParameter("PAM configuration is required.")
}
err := config.CheckDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
p := &PAM{
pamh: nil,
stdin: config.Stdin,
stdout: config.Stdout,
stderr: config.Stderr,
}
// Both config.ServiceName and config.Username convert between Go strings to
// C strings. Since the C strings are allocated on the heap in Go code, this
// memory must be released (and will be on the call to the Close method).
p.service_name = C.CString(config.ServiceName)
p.user = C.CString(config.Username)
// C code does not know that this PAM context exists. To ensure the
// conversation function can get messages to the right context, a handle
// registry at the package level is created (handlers). Each instance of the
// PAM context has it's own handle which is used to communicate between C
// and a instance of a PAM context.
p.handlerIndex = registerHandler(p)
// Create and initialize a PAM context. The pam_start function will
// allocate pamh if needed and the pam_end function will release any
// allocated memory.
p.retval = C._pam_start(pamHandle, p.service_name, p.user, p.conv, &p.pamh)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
// Check that the *nix account is valid. Checking an account varies based off
// the PAM modules used in the account stack. Typically this consists of
// checking if the account is expired or has access restrictions.
//
// Note: This function does not perform any authentication!
retval := C._pam_acct_mgmt(pamHandle, p.pamh, 0)
if retval != C.PAM_SUCCESS {
return nil, p.codeToError(retval)
}
// Open a user session. Opening a session varies based off the PAM modules
// used in the "session" stack. Opening a session typically consists of
// printing the MOTD, mounting a home directory, updating auth.log.
p.retval = C._pam_open_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return nil, p.codeToError(p.retval)
}
return p, nil
} | [
"func",
"Open",
"(",
"config",
"*",
"Config",
")",
"(",
"*",
"PAM",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"err",
":=",
"config",
".",
"CheckDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"p",
":=",
"&",
"PAM",
"{",
"pamh",
":",
"nil",
",",
"stdin",
":",
"config",
".",
"Stdin",
",",
"stdout",
":",
"config",
".",
"Stdout",
",",
"stderr",
":",
"config",
".",
"Stderr",
",",
"}",
"\n\n",
"// Both config.ServiceName and config.Username convert between Go strings to",
"// C strings. Since the C strings are allocated on the heap in Go code, this",
"// memory must be released (and will be on the call to the Close method).",
"p",
".",
"service_name",
"=",
"C",
".",
"CString",
"(",
"config",
".",
"ServiceName",
")",
"\n",
"p",
".",
"user",
"=",
"C",
".",
"CString",
"(",
"config",
".",
"Username",
")",
"\n\n",
"// C code does not know that this PAM context exists. To ensure the",
"// conversation function can get messages to the right context, a handle",
"// registry at the package level is created (handlers). Each instance of the",
"// PAM context has it's own handle which is used to communicate between C",
"// and a instance of a PAM context.",
"p",
".",
"handlerIndex",
"=",
"registerHandler",
"(",
"p",
")",
"\n\n",
"// Create and initialize a PAM context. The pam_start function will",
"// allocate pamh if needed and the pam_end function will release any",
"// allocated memory.",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_start",
"(",
"pamHandle",
",",
"p",
".",
"service_name",
",",
"p",
".",
"user",
",",
"p",
".",
"conv",
",",
"&",
"p",
".",
"pamh",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n\n",
"// Check that the *nix account is valid. Checking an account varies based off",
"// the PAM modules used in the account stack. Typically this consists of",
"// checking if the account is expired or has access restrictions.",
"//",
"// Note: This function does not perform any authentication!",
"retval",
":=",
"C",
".",
"_pam_acct_mgmt",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"retval",
")",
"\n",
"}",
"\n\n",
"// Open a user session. Opening a session varies based off the PAM modules",
"// used in the \"session\" stack. Opening a session typically consists of",
"// printing the MOTD, mounting a home directory, updating auth.log.",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_open_session",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"nil",
",",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] | // Open creates a PAM context and initiates a PAM transaction to check the
// account and then opens a session. | [
"Open",
"creates",
"a",
"PAM",
"context",
"and",
"initiates",
"a",
"PAM",
"transaction",
"to",
"check",
"the",
"account",
"and",
"then",
"opens",
"a",
"session",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L215-L271 | train |
gravitational/teleport | lib/pam/pam.go | Close | func (p *PAM) Close() error {
// Close the PAM session. Closing a session can entail anything from
// unmounting a home directory and updating auth.log.
p.retval = C._pam_close_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return p.codeToError(p.retval)
}
// Terminate the PAM transaction.
retval := C._pam_end(pamHandle, p.pamh, p.retval)
if retval != C.PAM_SUCCESS {
return p.codeToError(retval)
}
// Unregister handler index at the package level.
unregisterHandler(p.handlerIndex)
// Release the memory allocated for the conversation function.
C.free(unsafe.Pointer(p.conv))
// Release strings that were allocated when opening the PAM context.
C.free(unsafe.Pointer(p.service_name))
C.free(unsafe.Pointer(p.user))
return nil
} | go | func (p *PAM) Close() error {
// Close the PAM session. Closing a session can entail anything from
// unmounting a home directory and updating auth.log.
p.retval = C._pam_close_session(pamHandle, p.pamh, 0)
if p.retval != C.PAM_SUCCESS {
return p.codeToError(p.retval)
}
// Terminate the PAM transaction.
retval := C._pam_end(pamHandle, p.pamh, p.retval)
if retval != C.PAM_SUCCESS {
return p.codeToError(retval)
}
// Unregister handler index at the package level.
unregisterHandler(p.handlerIndex)
// Release the memory allocated for the conversation function.
C.free(unsafe.Pointer(p.conv))
// Release strings that were allocated when opening the PAM context.
C.free(unsafe.Pointer(p.service_name))
C.free(unsafe.Pointer(p.user))
return nil
} | [
"func",
"(",
"p",
"*",
"PAM",
")",
"Close",
"(",
")",
"error",
"{",
"// Close the PAM session. Closing a session can entail anything from",
"// unmounting a home directory and updating auth.log.",
"p",
".",
"retval",
"=",
"C",
".",
"_pam_close_session",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"0",
")",
"\n",
"if",
"p",
".",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"p",
".",
"codeToError",
"(",
"p",
".",
"retval",
")",
"\n",
"}",
"\n\n",
"// Terminate the PAM transaction.",
"retval",
":=",
"C",
".",
"_pam_end",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"p",
".",
"retval",
")",
"\n",
"if",
"retval",
"!=",
"C",
".",
"PAM_SUCCESS",
"{",
"return",
"p",
".",
"codeToError",
"(",
"retval",
")",
"\n",
"}",
"\n\n",
"// Unregister handler index at the package level.",
"unregisterHandler",
"(",
"p",
".",
"handlerIndex",
")",
"\n\n",
"// Release the memory allocated for the conversation function.",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"conv",
")",
")",
"\n\n",
"// Release strings that were allocated when opening the PAM context.",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"service_name",
")",
")",
"\n",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
".",
"user",
")",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close will close the session, the PAM context, and release any allocated
// memory. | [
"Close",
"will",
"close",
"the",
"session",
"the",
"PAM",
"context",
"and",
"release",
"any",
"allocated",
"memory",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L275-L300 | train |
gravitational/teleport | lib/pam/pam.go | codeToError | func (p *PAM) codeToError(returnValue C.int) error {
// Error strings are not allocated on the heap, so memory does not need
// released.
err := C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
} | go | func (p *PAM) codeToError(returnValue C.int) error {
// Error strings are not allocated on the heap, so memory does not need
// released.
err := C._pam_strerror(pamHandle, p.pamh, returnValue)
if err != nil {
return trace.BadParameter(C.GoString(err))
}
return nil
} | [
"func",
"(",
"p",
"*",
"PAM",
")",
"codeToError",
"(",
"returnValue",
"C",
".",
"int",
")",
"error",
"{",
"// Error strings are not allocated on the heap, so memory does not need",
"// released.",
"err",
":=",
"C",
".",
"_pam_strerror",
"(",
"pamHandle",
",",
"p",
".",
"pamh",
",",
"returnValue",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"C",
".",
"GoString",
"(",
"err",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // codeToError returns a human readable string from the PAM error. | [
"codeToError",
"returns",
"a",
"human",
"readable",
"string",
"from",
"the",
"PAM",
"error",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/pam/pam.go#L334-L343 | train |
gravitational/teleport | lib/utils/fakeconn.go | DualPipeNetConn | func DualPipeNetConn(srcAddr net.Addr, dstAddr net.Addr) (*PipeNetConn, *PipeNetConn) {
server, client := net.Pipe()
serverConn := NewPipeNetConn(server, server, server, dstAddr, srcAddr)
clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
} | go | func DualPipeNetConn(srcAddr net.Addr, dstAddr net.Addr) (*PipeNetConn, *PipeNetConn) {
server, client := net.Pipe()
serverConn := NewPipeNetConn(server, server, server, dstAddr, srcAddr)
clientConn := NewPipeNetConn(client, client, client, srcAddr, dstAddr)
return serverConn, clientConn
} | [
"func",
"DualPipeNetConn",
"(",
"srcAddr",
"net",
".",
"Addr",
",",
"dstAddr",
"net",
".",
"Addr",
")",
"(",
"*",
"PipeNetConn",
",",
"*",
"PipeNetConn",
")",
"{",
"server",
",",
"client",
":=",
"net",
".",
"Pipe",
"(",
")",
"\n\n",
"serverConn",
":=",
"NewPipeNetConn",
"(",
"server",
",",
"server",
",",
"server",
",",
"dstAddr",
",",
"srcAddr",
")",
"\n",
"clientConn",
":=",
"NewPipeNetConn",
"(",
"client",
",",
"client",
",",
"client",
",",
"srcAddr",
",",
"dstAddr",
")",
"\n\n",
"return",
"serverConn",
",",
"clientConn",
"\n",
"}"
] | // DualPipeAddrConn creates a net.Pipe to connect a client and a server. The
// two net.Conn instances are wrapped in an addrConn which holds the source and
// destination addresses. | [
"DualPipeAddrConn",
"creates",
"a",
"net",
".",
"Pipe",
"to",
"connect",
"a",
"client",
"and",
"a",
"server",
".",
"The",
"two",
"net",
".",
"Conn",
"instances",
"are",
"wrapped",
"in",
"an",
"addrConn",
"which",
"holds",
"the",
"source",
"and",
"destination",
"addresses",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/fakeconn.go#L89-L96 | train |
gravitational/teleport | lib/services/clustername.go | NewClusterName | func NewClusterName(spec ClusterNameSpecV2) (ClusterName, error) {
cn := ClusterNameV2{
Kind: KindClusterName,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterName,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cn, nil
} | go | func NewClusterName(spec ClusterNameSpecV2) (ClusterName, error) {
cn := ClusterNameV2{
Kind: KindClusterName,
Version: V2,
Metadata: Metadata{
Name: MetaNameClusterName,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := cn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return &cn, nil
} | [
"func",
"NewClusterName",
"(",
"spec",
"ClusterNameSpecV2",
")",
"(",
"ClusterName",
",",
"error",
")",
"{",
"cn",
":=",
"ClusterNameV2",
"{",
"Kind",
":",
"KindClusterName",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"MetaNameClusterName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"err",
":=",
"cn",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"cn",
",",
"nil",
"\n",
"}"
] | // NewClusterName is a convenience wrapper to create a ClusterName resource. | [
"NewClusterName",
"is",
"a",
"convenience",
"wrapper",
"to",
"create",
"a",
"ClusterName",
"resource",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L46-L61 | train |
gravitational/teleport | lib/services/clustername.go | GetClusterNameSchema | func GetClusterNameSchema(extensionSchema string) string {
var clusterNameSchema string
if clusterNameSchema == "" {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, "")
} else {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterNameSchema, DefaultDefinitions)
} | go | func GetClusterNameSchema(extensionSchema string) string {
var clusterNameSchema string
if clusterNameSchema == "" {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, "")
} else {
clusterNameSchema = fmt.Sprintf(ClusterNameSpecSchemaTemplate, ","+extensionSchema)
}
return fmt.Sprintf(V2SchemaTemplate, MetadataSchema, clusterNameSchema, DefaultDefinitions)
} | [
"func",
"GetClusterNameSchema",
"(",
"extensionSchema",
"string",
")",
"string",
"{",
"var",
"clusterNameSchema",
"string",
"\n",
"if",
"clusterNameSchema",
"==",
"\"",
"\"",
"{",
"clusterNameSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"ClusterNameSpecSchemaTemplate",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"clusterNameSchema",
"=",
"fmt",
".",
"Sprintf",
"(",
"ClusterNameSpecSchemaTemplate",
",",
"\"",
"\"",
"+",
"extensionSchema",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"V2SchemaTemplate",
",",
"MetadataSchema",
",",
"clusterNameSchema",
",",
"DefaultDefinitions",
")",
"\n",
"}"
] | // GetClusterNameSchema returns the schema with optionally injected
// schema for extensions. | [
"GetClusterNameSchema",
"returns",
"the",
"schema",
"with",
"optionally",
"injected",
"schema",
"for",
"extensions",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L166-L174 | train |
gravitational/teleport | lib/services/clustername.go | Unmarshal | func (t *TeleportClusterNameMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterName, error) {
var clusterName ClusterNameV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &clusterName); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetClusterNameSchema(""), &clusterName, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = clusterName.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterName.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterName.SetExpiry(cfg.Expires)
}
return &clusterName, nil
} | go | func (t *TeleportClusterNameMarshaler) Unmarshal(bytes []byte, opts ...MarshalOption) (ClusterName, error) {
var clusterName ClusterNameV2
if len(bytes) == 0 {
return nil, trace.BadParameter("missing resource data")
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.SkipValidation {
if err := utils.FastUnmarshal(bytes, &clusterName); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
err = utils.UnmarshalWithSchema(GetClusterNameSchema(""), &clusterName, bytes)
if err != nil {
return nil, trace.BadParameter(err.Error())
}
}
err = clusterName.CheckAndSetDefaults()
if err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
clusterName.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
clusterName.SetExpiry(cfg.Expires)
}
return &clusterName, nil
} | [
"func",
"(",
"t",
"*",
"TeleportClusterNameMarshaler",
")",
"Unmarshal",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ClusterName",
",",
"error",
")",
"{",
"var",
"clusterName",
"ClusterNameV2",
"\n\n",
"if",
"len",
"(",
"bytes",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"bytes",
",",
"&",
"clusterName",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"err",
"=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetClusterNameSchema",
"(",
"\"",
"\"",
")",
",",
"&",
"clusterName",
",",
"bytes",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"err",
"=",
"clusterName",
".",
"CheckAndSetDefaults",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"clusterName",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"clusterName",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"clusterName",
",",
"nil",
"\n",
"}"
] | // Unmarshal unmarshals ClusterName from JSON. | [
"Unmarshal",
"unmarshals",
"ClusterName",
"from",
"JSON",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L203-L239 | train |
gravitational/teleport | lib/services/clustername.go | Marshal | func (t *TeleportClusterNameMarshaler) Marshal(c ClusterName, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterNameV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
} | go | func (t *TeleportClusterNameMarshaler) Marshal(c ClusterName, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch resource := c.(type) {
case *ClusterNameV2:
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *resource
copy.SetResourceID(0)
resource = ©
}
return utils.FastMarshal(resource)
default:
return nil, trace.BadParameter("unrecognized resource version %T", c)
}
} | [
"func",
"(",
"t",
"*",
"TeleportClusterNameMarshaler",
")",
"Marshal",
"(",
"c",
"ClusterName",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"switch",
"resource",
":=",
"c",
".",
"(",
"type",
")",
"{",
"case",
"*",
"ClusterNameV2",
":",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"// avoid modifying the original object",
"// to prevent unexpected data races",
"copy",
":=",
"*",
"resource",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"resource",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"resource",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n",
"}"
] | // Marshal marshals ClusterName to JSON. | [
"Marshal",
"marshals",
"ClusterName",
"to",
"JSON",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/clustername.go#L242-L260 | train |
gravitational/teleport | lib/services/trust.go | Check | func (c CertAuthType) Check() error {
if c != HostCA && c != UserCA {
return trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
} | go | func (c CertAuthType) Check() error {
if c != HostCA && c != UserCA {
return trace.BadParameter("'%v' authority type is not supported", c)
}
return nil
} | [
"func",
"(",
"c",
"CertAuthType",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"c",
"!=",
"HostCA",
"&&",
"c",
"!=",
"UserCA",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"c",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check checks if certificate authority type value is correct | [
"Check",
"checks",
"if",
"certificate",
"authority",
"type",
"value",
"is",
"correct"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trust.go#L81-L86 | train |
gravitational/teleport | lib/services/trust.go | Check | func (c *CertAuthID) Check() error {
if err := c.Type.Check(); err != nil {
return trace.Wrap(err)
}
if strings.TrimSpace(c.DomainName) == "" {
return trace.BadParameter("identity validation error: empty domain name")
}
return nil
} | go | func (c *CertAuthID) Check() error {
if err := c.Type.Check(); err != nil {
return trace.Wrap(err)
}
if strings.TrimSpace(c.DomainName) == "" {
return trace.BadParameter("identity validation error: empty domain name")
}
return nil
} | [
"func",
"(",
"c",
"*",
"CertAuthID",
")",
"Check",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"Type",
".",
"Check",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"strings",
".",
"TrimSpace",
"(",
"c",
".",
"DomainName",
")",
"==",
"\"",
"\"",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Check returns error if any of the id parameters are bad, nil otherwise | [
"Check",
"returns",
"error",
"if",
"any",
"of",
"the",
"id",
"parameters",
"are",
"bad",
"nil",
"otherwise"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/trust.go#L99-L107 | train |
gravitational/teleport | lib/services/tunnel.go | NewReverseTunnel | func NewReverseTunnel(clusterName string, dialAddrs []string) ReverseTunnel {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs,
},
}
} | go | func NewReverseTunnel(clusterName string, dialAddrs []string) ReverseTunnel {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: clusterName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: clusterName,
DialAddrs: dialAddrs,
},
}
} | [
"func",
"NewReverseTunnel",
"(",
"clusterName",
"string",
",",
"dialAddrs",
"[",
"]",
"string",
")",
"ReverseTunnel",
"{",
"return",
"&",
"ReverseTunnelV2",
"{",
"Kind",
":",
"KindReverseTunnel",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"clusterName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"ReverseTunnelSpecV2",
"{",
"ClusterName",
":",
"clusterName",
",",
"DialAddrs",
":",
"dialAddrs",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewReverseTunnel returns new version of reverse tunnel | [
"NewReverseTunnel",
"returns",
"new",
"version",
"of",
"reverse",
"tunnel"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L55-L68 | train |
gravitational/teleport | lib/services/tunnel.go | V2 | func (r *ReverseTunnelV1) V2() *ReverseTunnelV2 {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: r.DomainName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.DialAddrs,
},
}
} | go | func (r *ReverseTunnelV1) V2() *ReverseTunnelV2 {
return &ReverseTunnelV2{
Kind: KindReverseTunnel,
Version: V2,
Metadata: Metadata{
Name: r.DomainName,
Namespace: defaults.Namespace,
},
Spec: ReverseTunnelSpecV2{
ClusterName: r.DomainName,
Type: ProxyTunnel,
DialAddrs: r.DialAddrs,
},
}
} | [
"func",
"(",
"r",
"*",
"ReverseTunnelV1",
")",
"V2",
"(",
")",
"*",
"ReverseTunnelV2",
"{",
"return",
"&",
"ReverseTunnelV2",
"{",
"Kind",
":",
"KindReverseTunnel",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"r",
".",
"DomainName",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"ReverseTunnelSpecV2",
"{",
"ClusterName",
":",
"r",
".",
"DomainName",
",",
"Type",
":",
"ProxyTunnel",
",",
"DialAddrs",
":",
"r",
".",
"DialAddrs",
",",
"}",
",",
"}",
"\n",
"}"
] | // V2 returns V2 version of reverse tunnel | [
"V2",
"returns",
"V2",
"version",
"of",
"reverse",
"tunnel"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L240-L254 | train |
gravitational/teleport | lib/services/tunnel.go | UnmarshalReverseTunnel | func UnmarshalReverseTunnel(data []byte, opts ...MarshalOption) (ReverseTunnel, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel data")
}
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var r ReverseTunnelV1
err := json.Unmarshal(data, &r)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := r.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return r.V2(), nil
case V2:
var r ReverseTunnelV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &r); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetReverseTunnelSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.SetExpiry(cfg.Expires)
}
return &r, nil
}
return nil, trace.BadParameter("reverse tunnel version %v is not supported", h.Version)
} | go | func UnmarshalReverseTunnel(data []byte, opts ...MarshalOption) (ReverseTunnel, error) {
if len(data) == 0 {
return nil, trace.BadParameter("missing tunnel data")
}
var h ResourceHeader
err := json.Unmarshal(data, &h)
if err != nil {
return nil, trace.Wrap(err)
}
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
switch h.Version {
case "":
var r ReverseTunnelV1
err := json.Unmarshal(data, &r)
if err != nil {
return nil, trace.Wrap(err)
}
v2 := r.V2()
if cfg.ID != 0 {
v2.SetResourceID(cfg.ID)
}
return r.V2(), nil
case V2:
var r ReverseTunnelV2
if cfg.SkipValidation {
if err := utils.FastUnmarshal(data, &r); err != nil {
return nil, trace.BadParameter(err.Error())
}
} else {
if err := utils.UnmarshalWithSchema(GetReverseTunnelSchema(), &r, data); err != nil {
return nil, trace.BadParameter(err.Error())
}
}
if err := r.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
if cfg.ID != 0 {
r.SetResourceID(cfg.ID)
}
if !cfg.Expires.IsZero() {
r.SetExpiry(cfg.Expires)
}
return &r, nil
}
return nil, trace.BadParameter("reverse tunnel version %v is not supported", h.Version)
} | [
"func",
"UnmarshalReverseTunnel",
"(",
"data",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ReverseTunnel",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"h",
"ResourceHeader",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"h",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"switch",
"h",
".",
"Version",
"{",
"case",
"\"",
"\"",
":",
"var",
"r",
"ReverseTunnelV1",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"v2",
":=",
"r",
".",
"V2",
"(",
")",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"v2",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"return",
"r",
".",
"V2",
"(",
")",
",",
"nil",
"\n",
"case",
"V2",
":",
"var",
"r",
"ReverseTunnelV2",
"\n",
"if",
"cfg",
".",
"SkipValidation",
"{",
"if",
"err",
":=",
"utils",
".",
"FastUnmarshal",
"(",
"data",
",",
"&",
"r",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"utils",
".",
"UnmarshalWithSchema",
"(",
"GetReverseTunnelSchema",
"(",
")",
",",
"&",
"r",
",",
"data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
":=",
"r",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"cfg",
".",
"ID",
"!=",
"0",
"{",
"r",
".",
"SetResourceID",
"(",
"cfg",
".",
"ID",
")",
"\n",
"}",
"\n",
"if",
"!",
"cfg",
".",
"Expires",
".",
"IsZero",
"(",
")",
"{",
"r",
".",
"SetExpiry",
"(",
"cfg",
".",
"Expires",
")",
"\n",
"}",
"\n",
"return",
"&",
"r",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"h",
".",
"Version",
")",
"\n",
"}"
] | // UnmarshalReverseTunnel unmarshals reverse tunnel from JSON or YAML,
// sets defaults and checks the schema | [
"UnmarshalReverseTunnel",
"unmarshals",
"reverse",
"tunnel",
"from",
"JSON",
"or",
"YAML",
"sets",
"defaults",
"and",
"checks",
"the",
"schema"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L264-L313 | train |
gravitational/teleport | lib/services/tunnel.go | UnmarshalReverseTunnel | func (*TeleportTunnelMarshaler) UnmarshalReverseTunnel(bytes []byte, opts ...MarshalOption) (ReverseTunnel, error) {
return UnmarshalReverseTunnel(bytes, opts...)
} | go | func (*TeleportTunnelMarshaler) UnmarshalReverseTunnel(bytes []byte, opts ...MarshalOption) (ReverseTunnel, error) {
return UnmarshalReverseTunnel(bytes, opts...)
} | [
"func",
"(",
"*",
"TeleportTunnelMarshaler",
")",
"UnmarshalReverseTunnel",
"(",
"bytes",
"[",
"]",
"byte",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"ReverseTunnel",
",",
"error",
")",
"{",
"return",
"UnmarshalReverseTunnel",
"(",
"bytes",
",",
"opts",
"...",
")",
"\n",
"}"
] | // UnmarshalReverseTunnel unmarshals reverse tunnel from JSON or YAML | [
"UnmarshalReverseTunnel",
"unmarshals",
"reverse",
"tunnel",
"from",
"JSON",
"or",
"YAML"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L340-L342 | train |
gravitational/teleport | lib/services/tunnel.go | MarshalReverseTunnel | func (*TeleportTunnelMarshaler) MarshalReverseTunnel(rt ReverseTunnel, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type tunv1 interface {
V1() *ReverseTunnelV1
}
type tunv2 interface {
V2() *ReverseTunnelV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := rt.(tunv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := rt.(tunv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | go | func (*TeleportTunnelMarshaler) MarshalReverseTunnel(rt ReverseTunnel, opts ...MarshalOption) ([]byte, error) {
cfg, err := collectOptions(opts)
if err != nil {
return nil, trace.Wrap(err)
}
type tunv1 interface {
V1() *ReverseTunnelV1
}
type tunv2 interface {
V2() *ReverseTunnelV2
}
version := cfg.GetVersion()
switch version {
case V1:
v, ok := rt.(tunv1)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V1)
}
return json.Marshal(v.V1())
case V2:
v, ok := rt.(tunv2)
if !ok {
return nil, trace.BadParameter("don't know how to marshal %v", V2)
}
v2 := v.V2()
if !cfg.PreserveResourceID {
// avoid modifying the original object
// to prevent unexpected data races
copy := *v2
copy.SetResourceID(0)
v2 = ©
}
return utils.FastMarshal(v2)
default:
return nil, trace.BadParameter("version %v is not supported", version)
}
} | [
"func",
"(",
"*",
"TeleportTunnelMarshaler",
")",
"MarshalReverseTunnel",
"(",
"rt",
"ReverseTunnel",
",",
"opts",
"...",
"MarshalOption",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"cfg",
",",
"err",
":=",
"collectOptions",
"(",
"opts",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"type",
"tunv1",
"interface",
"{",
"V1",
"(",
")",
"*",
"ReverseTunnelV1",
"\n",
"}",
"\n",
"type",
"tunv2",
"interface",
"{",
"V2",
"(",
")",
"*",
"ReverseTunnelV2",
"\n",
"}",
"\n",
"version",
":=",
"cfg",
".",
"GetVersion",
"(",
")",
"\n",
"switch",
"version",
"{",
"case",
"V1",
":",
"v",
",",
"ok",
":=",
"rt",
".",
"(",
"tunv1",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"V1",
")",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"v",
".",
"V1",
"(",
")",
")",
"\n",
"case",
"V2",
":",
"v",
",",
"ok",
":=",
"rt",
".",
"(",
"tunv2",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"V2",
")",
"\n",
"}",
"\n",
"v2",
":=",
"v",
".",
"V2",
"(",
")",
"\n",
"if",
"!",
"cfg",
".",
"PreserveResourceID",
"{",
"// avoid modifying the original object",
"// to prevent unexpected data races",
"copy",
":=",
"*",
"v2",
"\n",
"copy",
".",
"SetResourceID",
"(",
"0",
")",
"\n",
"v2",
"=",
"&",
"copy",
"\n",
"}",
"\n",
"return",
"utils",
".",
"FastMarshal",
"(",
"v2",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"version",
")",
"\n",
"}",
"\n",
"}"
] | // MarshalRole marshalls role into JSON | [
"MarshalRole",
"marshalls",
"role",
"into",
"JSON"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnel.go#L345-L381 | train |
gravitational/teleport | lib/utils/syslog.go | SwitchLoggingtoSyslog | func SwitchLoggingtoSyslog() error {
log.StandardLogger().SetHooks(make(log.LevelHooks))
hook, err := logrusSyslog.NewSyslogHook("", "", syslog.LOG_WARNING, "")
if err != nil {
// syslog is not available
log.SetOutput(os.Stderr)
return trace.Wrap(err)
}
log.AddHook(hook)
// ... and disable stderr:
log.SetOutput(ioutil.Discard)
return nil
} | go | func SwitchLoggingtoSyslog() error {
log.StandardLogger().SetHooks(make(log.LevelHooks))
hook, err := logrusSyslog.NewSyslogHook("", "", syslog.LOG_WARNING, "")
if err != nil {
// syslog is not available
log.SetOutput(os.Stderr)
return trace.Wrap(err)
}
log.AddHook(hook)
// ... and disable stderr:
log.SetOutput(ioutil.Discard)
return nil
} | [
"func",
"SwitchLoggingtoSyslog",
"(",
")",
"error",
"{",
"log",
".",
"StandardLogger",
"(",
")",
".",
"SetHooks",
"(",
"make",
"(",
"log",
".",
"LevelHooks",
")",
")",
"\n",
"hook",
",",
"err",
":=",
"logrusSyslog",
".",
"NewSyslogHook",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"syslog",
".",
"LOG_WARNING",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// syslog is not available",
"log",
".",
"SetOutput",
"(",
"os",
".",
"Stderr",
")",
"\n",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"log",
".",
"AddHook",
"(",
"hook",
")",
"\n",
"// ... and disable stderr:",
"log",
".",
"SetOutput",
"(",
"ioutil",
".",
"Discard",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SwitchLoggingtoSyslog tells the logger to send the output to syslog. This
// code is behind a build flag because Windows does not support syslog. | [
"SwitchLoggingtoSyslog",
"tells",
"the",
"logger",
"to",
"send",
"the",
"output",
"to",
"syslog",
".",
"This",
"code",
"is",
"behind",
"a",
"build",
"flag",
"because",
"Windows",
"does",
"not",
"support",
"syslog",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/syslog.go#L33-L45 | train |
gravitational/teleport | lib/auth/rotate.go | Types | func (r *RotateRequest) Types() []services.CertAuthType {
switch r.Type {
case "":
return []services.CertAuthType{services.HostCA, services.UserCA}
case services.HostCA:
return []services.CertAuthType{services.HostCA}
case services.UserCA:
return []services.CertAuthType{services.UserCA}
}
return nil
} | go | func (r *RotateRequest) Types() []services.CertAuthType {
switch r.Type {
case "":
return []services.CertAuthType{services.HostCA, services.UserCA}
case services.HostCA:
return []services.CertAuthType{services.HostCA}
case services.UserCA:
return []services.CertAuthType{services.UserCA}
}
return nil
} | [
"func",
"(",
"r",
"*",
"RotateRequest",
")",
"Types",
"(",
")",
"[",
"]",
"services",
".",
"CertAuthType",
"{",
"switch",
"r",
".",
"Type",
"{",
"case",
"\"",
"\"",
":",
"return",
"[",
"]",
"services",
".",
"CertAuthType",
"{",
"services",
".",
"HostCA",
",",
"services",
".",
"UserCA",
"}",
"\n",
"case",
"services",
".",
"HostCA",
":",
"return",
"[",
"]",
"services",
".",
"CertAuthType",
"{",
"services",
".",
"HostCA",
"}",
"\n",
"case",
"services",
".",
"UserCA",
":",
"return",
"[",
"]",
"services",
".",
"CertAuthType",
"{",
"services",
".",
"UserCA",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Types returns cert authority types requested to be rotated. | [
"Types",
"returns",
"cert",
"authority",
"types",
"requested",
"to",
"be",
"rotated",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L61-L71 | train |
gravitational/teleport | lib/auth/rotate.go | CheckAndSetDefaults | func (r *RotateRequest) CheckAndSetDefaults(clock clockwork.Clock) error {
if r.TargetPhase == "" {
// if phase if not set, imply that the first meaningful phase
// is set as a target phase
r.TargetPhase = services.RotationPhaseInit
}
// if mode is not set, default to manual (as it's safer)
if r.Mode == "" {
r.Mode = services.RotationModeManual
}
switch r.Type {
case "", services.HostCA, services.UserCA:
default:
return trace.BadParameter("unsupported certificate authority type: %q", r.Type)
}
if r.GracePeriod == nil {
period := defaults.RotationGracePeriod
r.GracePeriod = &period
}
if r.Schedule == nil {
var err error
r.Schedule, err = services.GenerateSchedule(clock, *r.GracePeriod)
if err != nil {
return trace.Wrap(err)
}
} else {
if err := r.Schedule.CheckAndSetDefaults(clock); err != nil {
return trace.Wrap(err)
}
}
return nil
} | go | func (r *RotateRequest) CheckAndSetDefaults(clock clockwork.Clock) error {
if r.TargetPhase == "" {
// if phase if not set, imply that the first meaningful phase
// is set as a target phase
r.TargetPhase = services.RotationPhaseInit
}
// if mode is not set, default to manual (as it's safer)
if r.Mode == "" {
r.Mode = services.RotationModeManual
}
switch r.Type {
case "", services.HostCA, services.UserCA:
default:
return trace.BadParameter("unsupported certificate authority type: %q", r.Type)
}
if r.GracePeriod == nil {
period := defaults.RotationGracePeriod
r.GracePeriod = &period
}
if r.Schedule == nil {
var err error
r.Schedule, err = services.GenerateSchedule(clock, *r.GracePeriod)
if err != nil {
return trace.Wrap(err)
}
} else {
if err := r.Schedule.CheckAndSetDefaults(clock); err != nil {
return trace.Wrap(err)
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"RotateRequest",
")",
"CheckAndSetDefaults",
"(",
"clock",
"clockwork",
".",
"Clock",
")",
"error",
"{",
"if",
"r",
".",
"TargetPhase",
"==",
"\"",
"\"",
"{",
"// if phase if not set, imply that the first meaningful phase",
"// is set as a target phase",
"r",
".",
"TargetPhase",
"=",
"services",
".",
"RotationPhaseInit",
"\n",
"}",
"\n",
"// if mode is not set, default to manual (as it's safer)",
"if",
"r",
".",
"Mode",
"==",
"\"",
"\"",
"{",
"r",
".",
"Mode",
"=",
"services",
".",
"RotationModeManual",
"\n",
"}",
"\n",
"switch",
"r",
".",
"Type",
"{",
"case",
"\"",
"\"",
",",
"services",
".",
"HostCA",
",",
"services",
".",
"UserCA",
":",
"default",
":",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"r",
".",
"Type",
")",
"\n",
"}",
"\n",
"if",
"r",
".",
"GracePeriod",
"==",
"nil",
"{",
"period",
":=",
"defaults",
".",
"RotationGracePeriod",
"\n",
"r",
".",
"GracePeriod",
"=",
"&",
"period",
"\n",
"}",
"\n",
"if",
"r",
".",
"Schedule",
"==",
"nil",
"{",
"var",
"err",
"error",
"\n",
"r",
".",
"Schedule",
",",
"err",
"=",
"services",
".",
"GenerateSchedule",
"(",
"clock",
",",
"*",
"r",
".",
"GracePeriod",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"r",
".",
"Schedule",
".",
"CheckAndSetDefaults",
"(",
"clock",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // CheckAndSetDefaults checks and sets default values. | [
"CheckAndSetDefaults",
"checks",
"and",
"sets",
"default",
"values",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L74-L105 | train |
gravitational/teleport | lib/auth/rotate.go | RotateExternalCertAuthority | func (a *AuthServer) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
// this is just an extra precaution against local admins,
// because this is additionally enforced by RBAC as well
if ca.GetClusterName() == clusterName.GetClusterName() {
return trace.BadParameter("can not rotate local certificate authority")
}
existing, err := a.Trust.GetCertAuthority(services.CertAuthID{
Type: ca.GetType(),
DomainName: ca.GetClusterName(),
}, false)
if err != nil {
return trace.Wrap(err)
}
updated := existing.Clone()
updated.SetCheckingKeys(ca.GetCheckingKeys())
updated.SetTLSKeyPairs(ca.GetTLSKeyPairs())
updated.SetRotation(ca.GetRotation())
// use compare and swap to protect from concurrent updates
// by trusted cluster API
if err := a.CompareAndSwapCertAuthority(updated, existing); err != nil {
return trace.Wrap(err)
}
return nil
} | go | func (a *AuthServer) RotateExternalCertAuthority(ca services.CertAuthority) error {
if ca == nil {
return trace.BadParameter("missing certificate authority")
}
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
// this is just an extra precaution against local admins,
// because this is additionally enforced by RBAC as well
if ca.GetClusterName() == clusterName.GetClusterName() {
return trace.BadParameter("can not rotate local certificate authority")
}
existing, err := a.Trust.GetCertAuthority(services.CertAuthID{
Type: ca.GetType(),
DomainName: ca.GetClusterName(),
}, false)
if err != nil {
return trace.Wrap(err)
}
updated := existing.Clone()
updated.SetCheckingKeys(ca.GetCheckingKeys())
updated.SetTLSKeyPairs(ca.GetTLSKeyPairs())
updated.SetRotation(ca.GetRotation())
// use compare and swap to protect from concurrent updates
// by trusted cluster API
if err := a.CompareAndSwapCertAuthority(updated, existing); err != nil {
return trace.Wrap(err)
}
return nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"RotateExternalCertAuthority",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"if",
"ca",
"==",
"nil",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"clusterName",
",",
"err",
":=",
"a",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"// this is just an extra precaution against local admins,",
"// because this is additionally enforced by RBAC as well",
"if",
"ca",
".",
"GetClusterName",
"(",
")",
"==",
"clusterName",
".",
"GetClusterName",
"(",
")",
"{",
"return",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"existing",
",",
"err",
":=",
"a",
".",
"Trust",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"ca",
".",
"GetType",
"(",
")",
",",
"DomainName",
":",
"ca",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"updated",
":=",
"existing",
".",
"Clone",
"(",
")",
"\n",
"updated",
".",
"SetCheckingKeys",
"(",
"ca",
".",
"GetCheckingKeys",
"(",
")",
")",
"\n",
"updated",
".",
"SetTLSKeyPairs",
"(",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
")",
"\n",
"updated",
".",
"SetRotation",
"(",
"ca",
".",
"GetRotation",
"(",
")",
")",
"\n\n",
"// use compare and swap to protect from concurrent updates",
"// by trusted cluster API",
"if",
"err",
":=",
"a",
".",
"CompareAndSwapCertAuthority",
"(",
"updated",
",",
"existing",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // RotateExternalCertAuthority rotates external certificate authority,
// this method is called by remote trusted cluster and is used to update
// only public keys and certificates of the certificate authority. | [
"RotateExternalCertAuthority",
"rotates",
"external",
"certificate",
"authority",
"this",
"method",
"is",
"called",
"by",
"remote",
"trusted",
"cluster",
"and",
"is",
"used",
"to",
"update",
"only",
"public",
"keys",
"and",
"certificates",
"of",
"the",
"certificate",
"authority",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L245-L280 | train |
gravitational/teleport | lib/auth/rotate.go | autoRotateCertAuthorities | func (a *AuthServer) autoRotateCertAuthorities() error {
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
for _, caType := range []services.CertAuthType{services.HostCA, services.UserCA} {
ca, err := a.Trust.GetCertAuthority(services.CertAuthID{
Type: caType,
DomainName: clusterName.GetClusterName(),
}, true)
if err != nil {
return trace.Wrap(err)
}
if err := a.autoRotate(ca); err != nil {
return trace.Wrap(err)
}
}
return nil
} | go | func (a *AuthServer) autoRotateCertAuthorities() error {
clusterName, err := a.GetClusterName()
if err != nil {
return trace.Wrap(err)
}
for _, caType := range []services.CertAuthType{services.HostCA, services.UserCA} {
ca, err := a.Trust.GetCertAuthority(services.CertAuthID{
Type: caType,
DomainName: clusterName.GetClusterName(),
}, true)
if err != nil {
return trace.Wrap(err)
}
if err := a.autoRotate(ca); err != nil {
return trace.Wrap(err)
}
}
return nil
} | [
"func",
"(",
"a",
"*",
"AuthServer",
")",
"autoRotateCertAuthorities",
"(",
")",
"error",
"{",
"clusterName",
",",
"err",
":=",
"a",
".",
"GetClusterName",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"caType",
":=",
"range",
"[",
"]",
"services",
".",
"CertAuthType",
"{",
"services",
".",
"HostCA",
",",
"services",
".",
"UserCA",
"}",
"{",
"ca",
",",
"err",
":=",
"a",
".",
"Trust",
".",
"GetCertAuthority",
"(",
"services",
".",
"CertAuthID",
"{",
"Type",
":",
"caType",
",",
"DomainName",
":",
"clusterName",
".",
"GetClusterName",
"(",
")",
",",
"}",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"a",
".",
"autoRotate",
"(",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // autoRotateCertAuthorities automatically rotates cert authorities,
// does nothing if no rotation parameters were set up
// or it is too early to rotate per schedule | [
"autoRotateCertAuthorities",
"automatically",
"rotates",
"cert",
"authorities",
"does",
"nothing",
"if",
"no",
"rotation",
"parameters",
"were",
"set",
"up",
"or",
"it",
"is",
"too",
"early",
"to",
"rotate",
"per",
"schedule"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L285-L303 | train |
gravitational/teleport | lib/auth/rotate.go | processRotationRequest | func processRotationRequest(req rotationReq) (services.CertAuthority, error) {
rotation := req.ca.GetRotation()
ca := req.ca.Clone()
switch req.targetPhase {
case services.RotationPhaseInit:
// This is the first stage of the rotation - new certificate authorities
// are being generated, but no components are using them yet
switch rotation.State {
case services.RotationStateStandby, "":
default:
return nil, trace.BadParameter("can not initate rotation while another is in progress")
}
if err := startNewRotation(req, ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
case services.RotationPhaseUpdateClients:
// Update client phase clients will start using new credentials
// and servers will use the existing credentials, but will trust clients
// with both old and new credentials.
if rotation.Phase != services.RotationPhaseInit {
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateClients,
services.RotationPhaseInit,
rotation.Phase)
}
if err := updateClients(ca, req.mode); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
case services.RotationPhaseUpdateServers:
// Update server phase uses the new credentials both for servers
// and clients, but still trusts clients with old credentials.
if rotation.Phase != services.RotationPhaseUpdateClients {
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateServers,
services.RotationPhaseUpdateClients,
rotation.Phase)
}
// Signal nodes to restart and start serving new signatures
// by updating the phase.
rotation.Phase = req.targetPhase
rotation.Mode = req.mode
ca.SetRotation(rotation)
return ca, nil
case services.RotationPhaseRollback:
// Rollback moves back both clients and servers to use the old credentials
// but will trust new credentials.
switch rotation.Phase {
case services.RotationPhaseInit, services.RotationPhaseUpdateClients, services.RotationPhaseUpdateServers:
if err := startRollingBackRotation(ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
default:
return nil, trace.BadParameter("can not transition to phase %q from %q phase.", req.targetPhase, rotation.Phase)
}
case services.RotationPhaseStandby:
// Transition to the standby phase moves rotation process
// to standby, servers will only trust one certificate authority.
switch rotation.Phase {
case services.RotationPhaseUpdateServers, services.RotationPhaseRollback:
if err := completeRotation(req.clock, ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
default:
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateServers,
services.RotationPhaseUpdateClients,
rotation.Phase)
}
default:
return nil, trace.BadParameter("unsupported phase: %q", req.targetPhase)
}
} | go | func processRotationRequest(req rotationReq) (services.CertAuthority, error) {
rotation := req.ca.GetRotation()
ca := req.ca.Clone()
switch req.targetPhase {
case services.RotationPhaseInit:
// This is the first stage of the rotation - new certificate authorities
// are being generated, but no components are using them yet
switch rotation.State {
case services.RotationStateStandby, "":
default:
return nil, trace.BadParameter("can not initate rotation while another is in progress")
}
if err := startNewRotation(req, ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
case services.RotationPhaseUpdateClients:
// Update client phase clients will start using new credentials
// and servers will use the existing credentials, but will trust clients
// with both old and new credentials.
if rotation.Phase != services.RotationPhaseInit {
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateClients,
services.RotationPhaseInit,
rotation.Phase)
}
if err := updateClients(ca, req.mode); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
case services.RotationPhaseUpdateServers:
// Update server phase uses the new credentials both for servers
// and clients, but still trusts clients with old credentials.
if rotation.Phase != services.RotationPhaseUpdateClients {
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateServers,
services.RotationPhaseUpdateClients,
rotation.Phase)
}
// Signal nodes to restart and start serving new signatures
// by updating the phase.
rotation.Phase = req.targetPhase
rotation.Mode = req.mode
ca.SetRotation(rotation)
return ca, nil
case services.RotationPhaseRollback:
// Rollback moves back both clients and servers to use the old credentials
// but will trust new credentials.
switch rotation.Phase {
case services.RotationPhaseInit, services.RotationPhaseUpdateClients, services.RotationPhaseUpdateServers:
if err := startRollingBackRotation(ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
default:
return nil, trace.BadParameter("can not transition to phase %q from %q phase.", req.targetPhase, rotation.Phase)
}
case services.RotationPhaseStandby:
// Transition to the standby phase moves rotation process
// to standby, servers will only trust one certificate authority.
switch rotation.Phase {
case services.RotationPhaseUpdateServers, services.RotationPhaseRollback:
if err := completeRotation(req.clock, ca); err != nil {
return nil, trace.Wrap(err)
}
return ca, nil
default:
return nil, trace.BadParameter(
"can only switch to phase %v from %v, current phase is %v",
services.RotationPhaseUpdateServers,
services.RotationPhaseUpdateClients,
rotation.Phase)
}
default:
return nil, trace.BadParameter("unsupported phase: %q", req.targetPhase)
}
} | [
"func",
"processRotationRequest",
"(",
"req",
"rotationReq",
")",
"(",
"services",
".",
"CertAuthority",
",",
"error",
")",
"{",
"rotation",
":=",
"req",
".",
"ca",
".",
"GetRotation",
"(",
")",
"\n",
"ca",
":=",
"req",
".",
"ca",
".",
"Clone",
"(",
")",
"\n\n",
"switch",
"req",
".",
"targetPhase",
"{",
"case",
"services",
".",
"RotationPhaseInit",
":",
"// This is the first stage of the rotation - new certificate authorities",
"// are being generated, but no components are using them yet",
"switch",
"rotation",
".",
"State",
"{",
"case",
"services",
".",
"RotationStateStandby",
",",
"\"",
"\"",
":",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"startNewRotation",
"(",
"req",
",",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ca",
",",
"nil",
"\n",
"case",
"services",
".",
"RotationPhaseUpdateClients",
":",
"// Update client phase clients will start using new credentials",
"// and servers will use the existing credentials, but will trust clients",
"// with both old and new credentials.",
"if",
"rotation",
".",
"Phase",
"!=",
"services",
".",
"RotationPhaseInit",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"services",
".",
"RotationPhaseUpdateClients",
",",
"services",
".",
"RotationPhaseInit",
",",
"rotation",
".",
"Phase",
")",
"\n",
"}",
"\n",
"if",
"err",
":=",
"updateClients",
"(",
"ca",
",",
"req",
".",
"mode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ca",
",",
"nil",
"\n",
"case",
"services",
".",
"RotationPhaseUpdateServers",
":",
"// Update server phase uses the new credentials both for servers",
"// and clients, but still trusts clients with old credentials.",
"if",
"rotation",
".",
"Phase",
"!=",
"services",
".",
"RotationPhaseUpdateClients",
"{",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"services",
".",
"RotationPhaseUpdateServers",
",",
"services",
".",
"RotationPhaseUpdateClients",
",",
"rotation",
".",
"Phase",
")",
"\n",
"}",
"\n",
"// Signal nodes to restart and start serving new signatures",
"// by updating the phase.",
"rotation",
".",
"Phase",
"=",
"req",
".",
"targetPhase",
"\n",
"rotation",
".",
"Mode",
"=",
"req",
".",
"mode",
"\n",
"ca",
".",
"SetRotation",
"(",
"rotation",
")",
"\n",
"return",
"ca",
",",
"nil",
"\n",
"case",
"services",
".",
"RotationPhaseRollback",
":",
"// Rollback moves back both clients and servers to use the old credentials",
"// but will trust new credentials.",
"switch",
"rotation",
".",
"Phase",
"{",
"case",
"services",
".",
"RotationPhaseInit",
",",
"services",
".",
"RotationPhaseUpdateClients",
",",
"services",
".",
"RotationPhaseUpdateServers",
":",
"if",
"err",
":=",
"startRollingBackRotation",
"(",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ca",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"req",
".",
"targetPhase",
",",
"rotation",
".",
"Phase",
")",
"\n",
"}",
"\n",
"case",
"services",
".",
"RotationPhaseStandby",
":",
"// Transition to the standby phase moves rotation process",
"// to standby, servers will only trust one certificate authority.",
"switch",
"rotation",
".",
"Phase",
"{",
"case",
"services",
".",
"RotationPhaseUpdateServers",
",",
"services",
".",
"RotationPhaseRollback",
":",
"if",
"err",
":=",
"completeRotation",
"(",
"req",
".",
"clock",
",",
"ca",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"ca",
",",
"nil",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"services",
".",
"RotationPhaseUpdateServers",
",",
"services",
".",
"RotationPhaseUpdateClients",
",",
"rotation",
".",
"Phase",
")",
"\n",
"}",
"\n",
"default",
":",
"return",
"nil",
",",
"trace",
".",
"BadParameter",
"(",
"\"",
"\"",
",",
"req",
".",
"targetPhase",
")",
"\n",
"}",
"\n",
"}"
] | // processRotationRequest processes rotation request based on the target and
// current phase and state. | [
"processRotationRequest",
"processes",
"rotation",
"request",
"based",
"on",
"the",
"target",
"and",
"current",
"phase",
"and",
"state",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L371-L450 | train |
gravitational/teleport | lib/auth/rotate.go | startRollingBackRotation | func startRollingBackRotation(ca services.CertAuthority) error {
rotation := ca.GetRotation()
// Rollback always sets rotation to manual mode.
rotation.Mode = services.RotationModeManual
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
// Rotation sets the first key to be the new key
// and keep only public keys/certs for the new CA.
signingKeys = [][]byte{signingKeys[1]}
checkingKeys = [][]byte{checkingKeys[1]}
// Keep the new certificate as trusted
// as during the rollback phase, both types of clients may be present in the cluster.
keyPairs = []services.TLSKeyPair{keyPairs[1], services.TLSKeyPair{Cert: keyPairs[0].Cert}}
rotation.State = services.RotationStateInProgress
rotation.Phase = services.RotationPhaseRollback
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | go | func startRollingBackRotation(ca services.CertAuthority) error {
rotation := ca.GetRotation()
// Rollback always sets rotation to manual mode.
rotation.Mode = services.RotationModeManual
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
// Rotation sets the first key to be the new key
// and keep only public keys/certs for the new CA.
signingKeys = [][]byte{signingKeys[1]}
checkingKeys = [][]byte{checkingKeys[1]}
// Keep the new certificate as trusted
// as during the rollback phase, both types of clients may be present in the cluster.
keyPairs = []services.TLSKeyPair{keyPairs[1], services.TLSKeyPair{Cert: keyPairs[0].Cert}}
rotation.State = services.RotationStateInProgress
rotation.Phase = services.RotationPhaseRollback
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | [
"func",
"startRollingBackRotation",
"(",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"rotation",
":=",
"ca",
".",
"GetRotation",
"(",
")",
"\n\n",
"// Rollback always sets rotation to manual mode.",
"rotation",
".",
"Mode",
"=",
"services",
".",
"RotationModeManual",
"\n\n",
"signingKeys",
":=",
"ca",
".",
"GetSigningKeys",
"(",
")",
"\n",
"checkingKeys",
":=",
"ca",
".",
"GetCheckingKeys",
"(",
")",
"\n",
"keyPairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n\n",
"// Rotation sets the first key to be the new key",
"// and keep only public keys/certs for the new CA.",
"signingKeys",
"=",
"[",
"]",
"[",
"]",
"byte",
"{",
"signingKeys",
"[",
"1",
"]",
"}",
"\n",
"checkingKeys",
"=",
"[",
"]",
"[",
"]",
"byte",
"{",
"checkingKeys",
"[",
"1",
"]",
"}",
"\n\n",
"// Keep the new certificate as trusted",
"// as during the rollback phase, both types of clients may be present in the cluster.",
"keyPairs",
"=",
"[",
"]",
"services",
".",
"TLSKeyPair",
"{",
"keyPairs",
"[",
"1",
"]",
",",
"services",
".",
"TLSKeyPair",
"{",
"Cert",
":",
"keyPairs",
"[",
"0",
"]",
".",
"Cert",
"}",
"}",
"\n",
"rotation",
".",
"State",
"=",
"services",
".",
"RotationStateInProgress",
"\n",
"rotation",
".",
"Phase",
"=",
"services",
".",
"RotationPhaseRollback",
"\n\n",
"ca",
".",
"SetSigningKeys",
"(",
"signingKeys",
")",
"\n",
"ca",
".",
"SetCheckingKeys",
"(",
"checkingKeys",
")",
"\n",
"ca",
".",
"SetTLSKeyPairs",
"(",
"keyPairs",
")",
"\n",
"ca",
".",
"SetRotation",
"(",
"rotation",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // startRollingBackRotation starts roll back to the original state. | [
"startRollingBackRotation",
"starts",
"roll",
"back",
"to",
"the",
"original",
"state",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L575-L601 | train |
gravitational/teleport | lib/auth/rotate.go | completeRollingBackRotation | func completeRollingBackRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
// clean up the state
rotation.Started = time.Time{}
rotation.State = services.RotationStateStandby
rotation.Phase = services.RotationPhaseStandby
rotation.Mode = ""
rotation.Schedule = services.RotationSchedule{}
keyPairs := ca.GetTLSKeyPairs()
// only keep the original certificate authority as trusted
// and remove everything else.
keyPairs = []services.TLSKeyPair{keyPairs[0]}
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | go | func completeRollingBackRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
// clean up the state
rotation.Started = time.Time{}
rotation.State = services.RotationStateStandby
rotation.Phase = services.RotationPhaseStandby
rotation.Mode = ""
rotation.Schedule = services.RotationSchedule{}
keyPairs := ca.GetTLSKeyPairs()
// only keep the original certificate authority as trusted
// and remove everything else.
keyPairs = []services.TLSKeyPair{keyPairs[0]}
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | [
"func",
"completeRollingBackRotation",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"rotation",
":=",
"ca",
".",
"GetRotation",
"(",
")",
"\n\n",
"// clean up the state",
"rotation",
".",
"Started",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"rotation",
".",
"State",
"=",
"services",
".",
"RotationStateStandby",
"\n",
"rotation",
".",
"Phase",
"=",
"services",
".",
"RotationPhaseStandby",
"\n",
"rotation",
".",
"Mode",
"=",
"\"",
"\"",
"\n",
"rotation",
".",
"Schedule",
"=",
"services",
".",
"RotationSchedule",
"{",
"}",
"\n\n",
"keyPairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n",
"// only keep the original certificate authority as trusted",
"// and remove everything else.",
"keyPairs",
"=",
"[",
"]",
"services",
".",
"TLSKeyPair",
"{",
"keyPairs",
"[",
"0",
"]",
"}",
"\n\n",
"ca",
".",
"SetTLSKeyPairs",
"(",
"keyPairs",
")",
"\n",
"ca",
".",
"SetRotation",
"(",
"rotation",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // completeRollingBackRotation completes rollback of the rotation and sets it to the standby state | [
"completeRollingBackRotation",
"completes",
"rollback",
"of",
"the",
"rotation",
"and",
"sets",
"it",
"to",
"the",
"standby",
"state"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L604-L622 | train |
gravitational/teleport | lib/auth/rotate.go | completeRotation | func completeRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
signingKeys = signingKeys[:1]
checkingKeys = checkingKeys[:1]
keyPairs = keyPairs[:1]
rotation.Started = time.Time{}
rotation.State = services.RotationStateStandby
rotation.Phase = services.RotationPhaseStandby
rotation.LastRotated = clock.Now()
rotation.Mode = ""
rotation.Schedule = services.RotationSchedule{}
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | go | func completeRotation(clock clockwork.Clock, ca services.CertAuthority) error {
rotation := ca.GetRotation()
signingKeys := ca.GetSigningKeys()
checkingKeys := ca.GetCheckingKeys()
keyPairs := ca.GetTLSKeyPairs()
signingKeys = signingKeys[:1]
checkingKeys = checkingKeys[:1]
keyPairs = keyPairs[:1]
rotation.Started = time.Time{}
rotation.State = services.RotationStateStandby
rotation.Phase = services.RotationPhaseStandby
rotation.LastRotated = clock.Now()
rotation.Mode = ""
rotation.Schedule = services.RotationSchedule{}
ca.SetSigningKeys(signingKeys)
ca.SetCheckingKeys(checkingKeys)
ca.SetTLSKeyPairs(keyPairs)
ca.SetRotation(rotation)
return nil
} | [
"func",
"completeRotation",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"ca",
"services",
".",
"CertAuthority",
")",
"error",
"{",
"rotation",
":=",
"ca",
".",
"GetRotation",
"(",
")",
"\n",
"signingKeys",
":=",
"ca",
".",
"GetSigningKeys",
"(",
")",
"\n",
"checkingKeys",
":=",
"ca",
".",
"GetCheckingKeys",
"(",
")",
"\n",
"keyPairs",
":=",
"ca",
".",
"GetTLSKeyPairs",
"(",
")",
"\n\n",
"signingKeys",
"=",
"signingKeys",
"[",
":",
"1",
"]",
"\n",
"checkingKeys",
"=",
"checkingKeys",
"[",
":",
"1",
"]",
"\n",
"keyPairs",
"=",
"keyPairs",
"[",
":",
"1",
"]",
"\n\n",
"rotation",
".",
"Started",
"=",
"time",
".",
"Time",
"{",
"}",
"\n",
"rotation",
".",
"State",
"=",
"services",
".",
"RotationStateStandby",
"\n",
"rotation",
".",
"Phase",
"=",
"services",
".",
"RotationPhaseStandby",
"\n",
"rotation",
".",
"LastRotated",
"=",
"clock",
".",
"Now",
"(",
")",
"\n",
"rotation",
".",
"Mode",
"=",
"\"",
"\"",
"\n",
"rotation",
".",
"Schedule",
"=",
"services",
".",
"RotationSchedule",
"{",
"}",
"\n\n",
"ca",
".",
"SetSigningKeys",
"(",
"signingKeys",
")",
"\n",
"ca",
".",
"SetCheckingKeys",
"(",
"checkingKeys",
")",
"\n",
"ca",
".",
"SetTLSKeyPairs",
"(",
"keyPairs",
")",
"\n",
"ca",
".",
"SetRotation",
"(",
"rotation",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // completeRotation completes the certificate authority rotation. | [
"completeRotation",
"completes",
"the",
"certificate",
"authority",
"rotation",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/auth/rotate.go#L625-L647 | train |
gravitational/teleport | lib/utils/unpack.go | Extract | func Extract(r io.Reader, dir string) error {
tarball := tar.NewReader(r)
for {
header, err := tarball.Next()
if err == io.EOF {
break
} else if err != nil {
return trace.Wrap(err)
}
if err := extractFile(tarball, header, dir); err != nil {
return trace.Wrap(err)
}
}
return nil
} | go | func Extract(r io.Reader, dir string) error {
tarball := tar.NewReader(r)
for {
header, err := tarball.Next()
if err == io.EOF {
break
} else if err != nil {
return trace.Wrap(err)
}
if err := extractFile(tarball, header, dir); err != nil {
return trace.Wrap(err)
}
}
return nil
} | [
"func",
"Extract",
"(",
"r",
"io",
".",
"Reader",
",",
"dir",
"string",
")",
"error",
"{",
"tarball",
":=",
"tar",
".",
"NewReader",
"(",
"r",
")",
"\n\n",
"for",
"{",
"header",
",",
"err",
":=",
"tarball",
".",
"Next",
"(",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"{",
"break",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"extractFile",
"(",
"tarball",
",",
"header",
",",
"dir",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Extract extracts the contents of the specified tarball under dir.
// The resulting files and directories are created using the current user context. | [
"Extract",
"extracts",
"the",
"contents",
"of",
"the",
"specified",
"tarball",
"under",
"dir",
".",
"The",
"resulting",
"files",
"and",
"directories",
"are",
"created",
"using",
"the",
"current",
"user",
"context",
"."
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/unpack.go#L33-L49 | train |
gravitational/teleport | lib/utils/rand.go | CryptoRandomHex | func CryptoRandomHex(len int) (string, error) {
randomBytes := make([]byte, len)
if _, err := rand.Reader.Read(randomBytes); err != nil {
return "", trace.Wrap(err)
}
return hex.EncodeToString(randomBytes), nil
} | go | func CryptoRandomHex(len int) (string, error) {
randomBytes := make([]byte, len)
if _, err := rand.Reader.Read(randomBytes); err != nil {
return "", trace.Wrap(err)
}
return hex.EncodeToString(randomBytes), nil
} | [
"func",
"CryptoRandomHex",
"(",
"len",
"int",
")",
"(",
"string",
",",
"error",
")",
"{",
"randomBytes",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"rand",
".",
"Reader",
".",
"Read",
"(",
"randomBytes",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"hex",
".",
"EncodeToString",
"(",
"randomBytes",
")",
",",
"nil",
"\n",
"}"
] | // CryptoRandomHex returns hex encoded random string generated with crypto-strong
// pseudo random generator of the given bytes | [
"CryptoRandomHex",
"returns",
"hex",
"encoded",
"random",
"string",
"generated",
"with",
"crypto",
"-",
"strong",
"pseudo",
"random",
"generator",
"of",
"the",
"given",
"bytes"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/rand.go#L30-L36 | train |
gravitational/teleport | lib/utils/rand.go | RandomDuration | func RandomDuration(max time.Duration) time.Duration {
randomVal, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
if err != nil {
return max / 2
}
return time.Duration(randomVal.Int64())
} | go | func RandomDuration(max time.Duration) time.Duration {
randomVal, err := rand.Int(rand.Reader, big.NewInt(int64(max)))
if err != nil {
return max / 2
}
return time.Duration(randomVal.Int64())
} | [
"func",
"RandomDuration",
"(",
"max",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"randomVal",
",",
"err",
":=",
"rand",
".",
"Int",
"(",
"rand",
".",
"Reader",
",",
"big",
".",
"NewInt",
"(",
"int64",
"(",
"max",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"max",
"/",
"2",
"\n",
"}",
"\n",
"return",
"time",
".",
"Duration",
"(",
"randomVal",
".",
"Int64",
"(",
")",
")",
"\n",
"}"
] | // RandomDuration returns a duration in a range [0, max) | [
"RandomDuration",
"returns",
"a",
"duration",
"in",
"a",
"range",
"[",
"0",
"max",
")"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/utils/rand.go#L39-L45 | train |
gravitational/teleport | lib/services/suite/suite.go | NewServer | func NewServer(kind, name, addr, namespace string) *services.ServerV2 {
return &services.ServerV2{
Kind: kind,
Version: services.V2,
Metadata: services.Metadata{
Name: name,
Namespace: namespace,
},
Spec: services.ServerSpecV2{
Addr: addr,
PublicAddr: addr,
},
}
} | go | func NewServer(kind, name, addr, namespace string) *services.ServerV2 {
return &services.ServerV2{
Kind: kind,
Version: services.V2,
Metadata: services.Metadata{
Name: name,
Namespace: namespace,
},
Spec: services.ServerSpecV2{
Addr: addr,
PublicAddr: addr,
},
}
} | [
"func",
"NewServer",
"(",
"kind",
",",
"name",
",",
"addr",
",",
"namespace",
"string",
")",
"*",
"services",
".",
"ServerV2",
"{",
"return",
"&",
"services",
".",
"ServerV2",
"{",
"Kind",
":",
"kind",
",",
"Version",
":",
"services",
".",
"V2",
",",
"Metadata",
":",
"services",
".",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"namespace",
",",
"}",
",",
"Spec",
":",
"services",
".",
"ServerSpecV2",
"{",
"Addr",
":",
"addr",
",",
"PublicAddr",
":",
"addr",
",",
"}",
",",
"}",
"\n",
"}"
] | // NewServer creates a new server resource | [
"NewServer",
"creates",
"a",
"new",
"server",
"resource"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/suite/suite.go#L302-L315 | train |
gravitational/teleport | lib/services/suite/suite.go | AuthPreference | func (s *ServicesTestSuite) AuthPreference(c *check.C) {
ap, err := services.NewAuthPreference(services.AuthPreferenceSpecV2{
Type: "local",
SecondFactor: "otp",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetAuthPreference(ap)
c.Assert(err, check.IsNil)
gotAP, err := s.ConfigS.GetAuthPreference()
c.Assert(err, check.IsNil)
c.Assert(gotAP.GetType(), check.Equals, "local")
c.Assert(gotAP.GetSecondFactor(), check.Equals, "otp")
} | go | func (s *ServicesTestSuite) AuthPreference(c *check.C) {
ap, err := services.NewAuthPreference(services.AuthPreferenceSpecV2{
Type: "local",
SecondFactor: "otp",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetAuthPreference(ap)
c.Assert(err, check.IsNil)
gotAP, err := s.ConfigS.GetAuthPreference()
c.Assert(err, check.IsNil)
c.Assert(gotAP.GetType(), check.Equals, "local")
c.Assert(gotAP.GetSecondFactor(), check.Equals, "otp")
} | [
"func",
"(",
"s",
"*",
"ServicesTestSuite",
")",
"AuthPreference",
"(",
"c",
"*",
"check",
".",
"C",
")",
"{",
"ap",
",",
"err",
":=",
"services",
".",
"NewAuthPreference",
"(",
"services",
".",
"AuthPreferenceSpecV2",
"{",
"Type",
":",
"\"",
"\"",
",",
"SecondFactor",
":",
"\"",
"\"",
",",
"}",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"SetAuthPreference",
"(",
"ap",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"gotAP",
",",
"err",
":=",
"s",
".",
"ConfigS",
".",
"GetAuthPreference",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"c",
".",
"Assert",
"(",
"gotAP",
".",
"GetType",
"(",
")",
",",
"check",
".",
"Equals",
",",
"\"",
"\"",
")",
"\n",
"c",
".",
"Assert",
"(",
"gotAP",
".",
"GetSecondFactor",
"(",
")",
",",
"check",
".",
"Equals",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // AuthPreference tests authentication preference service | [
"AuthPreference",
"tests",
"authentication",
"preference",
"service"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/suite/suite.go#L890-L905 | train |
gravitational/teleport | lib/services/suite/suite.go | CollectOptions | func CollectOptions(opts ...SuiteOption) SuiteOptions {
var suiteOpts SuiteOptions
for _, o := range opts {
o(&suiteOpts)
}
return suiteOpts
} | go | func CollectOptions(opts ...SuiteOption) SuiteOptions {
var suiteOpts SuiteOptions
for _, o := range opts {
o(&suiteOpts)
}
return suiteOpts
} | [
"func",
"CollectOptions",
"(",
"opts",
"...",
"SuiteOption",
")",
"SuiteOptions",
"{",
"var",
"suiteOpts",
"SuiteOptions",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"&",
"suiteOpts",
")",
"\n",
"}",
"\n",
"return",
"suiteOpts",
"\n",
"}"
] | // CollectOptions collects suite options | [
"CollectOptions",
"collects",
"suite",
"options"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/suite/suite.go#L953-L959 | train |
gravitational/teleport | lib/services/suite/suite.go | ClusterConfig | func (s *ServicesTestSuite) ClusterConfig(c *check.C, opts ...SuiteOption) {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{
ClientIdleTimeout: services.NewDuration(17 * time.Second),
DisconnectExpiredCert: services.NewBool(true),
ClusterID: "27",
SessionRecording: services.RecordAtProxy,
Audit: services.AuditConfig{
Region: "us-west-1",
Type: "dynamodb",
AuditSessionsURI: "file:///home/log",
AuditTableName: "audit_table_name",
AuditEventsURI: []string{"dynamodb://audit_table_name", "file:///home/log"},
},
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterConfig(config)
c.Assert(err, check.IsNil)
gotConfig, err := s.ConfigS.GetClusterConfig()
c.Assert(err, check.IsNil)
config.SetResourceID(gotConfig.GetResourceID())
fixtures.DeepCompare(c, config, gotConfig)
// Some parts (e.g. auth server) will not function
// without cluster name or cluster config
if CollectOptions(opts...).SkipDelete {
return
}
err = s.ConfigS.DeleteClusterConfig()
c.Assert(err, check.IsNil)
_, err = s.ConfigS.GetClusterConfig()
fixtures.ExpectNotFound(c, err)
clusterName, err := services.NewClusterName(services.ClusterNameSpecV2{
ClusterName: "example.com",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterName(clusterName)
c.Assert(err, check.IsNil)
gotName, err := s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
clusterName.SetResourceID(gotName.GetResourceID())
fixtures.DeepCompare(c, clusterName, gotName)
err = s.ConfigS.DeleteClusterName()
c.Assert(err, check.IsNil)
_, err = s.ConfigS.GetClusterName()
fixtures.ExpectNotFound(c, err)
err = s.ConfigS.UpsertClusterName(clusterName)
c.Assert(err, check.IsNil)
gotName, err = s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
clusterName.SetResourceID(gotName.GetResourceID())
fixtures.DeepCompare(c, clusterName, gotName)
} | go | func (s *ServicesTestSuite) ClusterConfig(c *check.C, opts ...SuiteOption) {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{
ClientIdleTimeout: services.NewDuration(17 * time.Second),
DisconnectExpiredCert: services.NewBool(true),
ClusterID: "27",
SessionRecording: services.RecordAtProxy,
Audit: services.AuditConfig{
Region: "us-west-1",
Type: "dynamodb",
AuditSessionsURI: "file:///home/log",
AuditTableName: "audit_table_name",
AuditEventsURI: []string{"dynamodb://audit_table_name", "file:///home/log"},
},
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterConfig(config)
c.Assert(err, check.IsNil)
gotConfig, err := s.ConfigS.GetClusterConfig()
c.Assert(err, check.IsNil)
config.SetResourceID(gotConfig.GetResourceID())
fixtures.DeepCompare(c, config, gotConfig)
// Some parts (e.g. auth server) will not function
// without cluster name or cluster config
if CollectOptions(opts...).SkipDelete {
return
}
err = s.ConfigS.DeleteClusterConfig()
c.Assert(err, check.IsNil)
_, err = s.ConfigS.GetClusterConfig()
fixtures.ExpectNotFound(c, err)
clusterName, err := services.NewClusterName(services.ClusterNameSpecV2{
ClusterName: "example.com",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterName(clusterName)
c.Assert(err, check.IsNil)
gotName, err := s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
clusterName.SetResourceID(gotName.GetResourceID())
fixtures.DeepCompare(c, clusterName, gotName)
err = s.ConfigS.DeleteClusterName()
c.Assert(err, check.IsNil)
_, err = s.ConfigS.GetClusterName()
fixtures.ExpectNotFound(c, err)
err = s.ConfigS.UpsertClusterName(clusterName)
c.Assert(err, check.IsNil)
gotName, err = s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
clusterName.SetResourceID(gotName.GetResourceID())
fixtures.DeepCompare(c, clusterName, gotName)
} | [
"func",
"(",
"s",
"*",
"ServicesTestSuite",
")",
"ClusterConfig",
"(",
"c",
"*",
"check",
".",
"C",
",",
"opts",
"...",
"SuiteOption",
")",
"{",
"config",
",",
"err",
":=",
"services",
".",
"NewClusterConfig",
"(",
"services",
".",
"ClusterConfigSpecV3",
"{",
"ClientIdleTimeout",
":",
"services",
".",
"NewDuration",
"(",
"17",
"*",
"time",
".",
"Second",
")",
",",
"DisconnectExpiredCert",
":",
"services",
".",
"NewBool",
"(",
"true",
")",
",",
"ClusterID",
":",
"\"",
"\"",
",",
"SessionRecording",
":",
"services",
".",
"RecordAtProxy",
",",
"Audit",
":",
"services",
".",
"AuditConfig",
"{",
"Region",
":",
"\"",
"\"",
",",
"Type",
":",
"\"",
"\"",
",",
"AuditSessionsURI",
":",
"\"",
"\"",
",",
"AuditTableName",
":",
"\"",
"\"",
",",
"AuditEventsURI",
":",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"}",
",",
"}",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"SetClusterConfig",
"(",
"config",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"gotConfig",
",",
"err",
":=",
"s",
".",
"ConfigS",
".",
"GetClusterConfig",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n",
"config",
".",
"SetResourceID",
"(",
"gotConfig",
".",
"GetResourceID",
"(",
")",
")",
"\n",
"fixtures",
".",
"DeepCompare",
"(",
"c",
",",
"config",
",",
"gotConfig",
")",
"\n\n",
"// Some parts (e.g. auth server) will not function",
"// without cluster name or cluster config",
"if",
"CollectOptions",
"(",
"opts",
"...",
")",
".",
"SkipDelete",
"{",
"return",
"\n",
"}",
"\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"DeleteClusterConfig",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"_",
",",
"err",
"=",
"s",
".",
"ConfigS",
".",
"GetClusterConfig",
"(",
")",
"\n",
"fixtures",
".",
"ExpectNotFound",
"(",
"c",
",",
"err",
")",
"\n\n",
"clusterName",
",",
"err",
":=",
"services",
".",
"NewClusterName",
"(",
"services",
".",
"ClusterNameSpecV2",
"{",
"ClusterName",
":",
"\"",
"\"",
",",
"}",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"SetClusterName",
"(",
"clusterName",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"gotName",
",",
"err",
":=",
"s",
".",
"ConfigS",
".",
"GetClusterName",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n",
"clusterName",
".",
"SetResourceID",
"(",
"gotName",
".",
"GetResourceID",
"(",
")",
")",
"\n",
"fixtures",
".",
"DeepCompare",
"(",
"c",
",",
"clusterName",
",",
"gotName",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"DeleteClusterName",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"_",
",",
"err",
"=",
"s",
".",
"ConfigS",
".",
"GetClusterName",
"(",
")",
"\n",
"fixtures",
".",
"ExpectNotFound",
"(",
"c",
",",
"err",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"UpsertClusterName",
"(",
"clusterName",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"gotName",
",",
"err",
"=",
"s",
".",
"ConfigS",
".",
"GetClusterName",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n",
"clusterName",
".",
"SetResourceID",
"(",
"gotName",
".",
"GetResourceID",
"(",
")",
")",
"\n",
"fixtures",
".",
"DeepCompare",
"(",
"c",
",",
"clusterName",
",",
"gotName",
")",
"\n",
"}"
] | // ClusterConfig tests cluster configuration | [
"ClusterConfig",
"tests",
"cluster",
"configuration"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/suite/suite.go#L962-L1023 | train |
gravitational/teleport | lib/services/suite/suite.go | EventsClusterConfig | func (s *ServicesTestSuite) EventsClusterConfig(c *check.C) {
testCases := []eventTest{
{
name: "Cluster config",
kind: services.WatchKind{
Kind: services.KindClusterConfig,
},
crud: func() services.Resource {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterConfig(config)
c.Assert(err, check.IsNil)
out, err := s.ConfigS.GetClusterConfig()
c.Assert(err, check.IsNil)
err = s.ConfigS.DeleteClusterConfig()
c.Assert(err, check.IsNil)
return out
},
},
{
name: "Cluster name",
kind: services.WatchKind{
Kind: services.KindClusterName,
},
crud: func() services.Resource {
clusterName, err := services.NewClusterName(services.ClusterNameSpecV2{
ClusterName: "example.com",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterName(clusterName)
c.Assert(err, check.IsNil)
out, err := s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
err = s.ConfigS.DeleteClusterName()
c.Assert(err, check.IsNil)
return out
},
},
}
s.runEventsTests(c, testCases)
} | go | func (s *ServicesTestSuite) EventsClusterConfig(c *check.C) {
testCases := []eventTest{
{
name: "Cluster config",
kind: services.WatchKind{
Kind: services.KindClusterConfig,
},
crud: func() services.Resource {
config, err := services.NewClusterConfig(services.ClusterConfigSpecV3{})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterConfig(config)
c.Assert(err, check.IsNil)
out, err := s.ConfigS.GetClusterConfig()
c.Assert(err, check.IsNil)
err = s.ConfigS.DeleteClusterConfig()
c.Assert(err, check.IsNil)
return out
},
},
{
name: "Cluster name",
kind: services.WatchKind{
Kind: services.KindClusterName,
},
crud: func() services.Resource {
clusterName, err := services.NewClusterName(services.ClusterNameSpecV2{
ClusterName: "example.com",
})
c.Assert(err, check.IsNil)
err = s.ConfigS.SetClusterName(clusterName)
c.Assert(err, check.IsNil)
out, err := s.ConfigS.GetClusterName()
c.Assert(err, check.IsNil)
err = s.ConfigS.DeleteClusterName()
c.Assert(err, check.IsNil)
return out
},
},
}
s.runEventsTests(c, testCases)
} | [
"func",
"(",
"s",
"*",
"ServicesTestSuite",
")",
"EventsClusterConfig",
"(",
"c",
"*",
"check",
".",
"C",
")",
"{",
"testCases",
":=",
"[",
"]",
"eventTest",
"{",
"{",
"name",
":",
"\"",
"\"",
",",
"kind",
":",
"services",
".",
"WatchKind",
"{",
"Kind",
":",
"services",
".",
"KindClusterConfig",
",",
"}",
",",
"crud",
":",
"func",
"(",
")",
"services",
".",
"Resource",
"{",
"config",
",",
"err",
":=",
"services",
".",
"NewClusterConfig",
"(",
"services",
".",
"ClusterConfigSpecV3",
"{",
"}",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"SetClusterConfig",
"(",
"config",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"out",
",",
"err",
":=",
"s",
".",
"ConfigS",
".",
"GetClusterConfig",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"DeleteClusterConfig",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"return",
"out",
"\n",
"}",
",",
"}",
",",
"{",
"name",
":",
"\"",
"\"",
",",
"kind",
":",
"services",
".",
"WatchKind",
"{",
"Kind",
":",
"services",
".",
"KindClusterName",
",",
"}",
",",
"crud",
":",
"func",
"(",
")",
"services",
".",
"Resource",
"{",
"clusterName",
",",
"err",
":=",
"services",
".",
"NewClusterName",
"(",
"services",
".",
"ClusterNameSpecV2",
"{",
"ClusterName",
":",
"\"",
"\"",
",",
"}",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"SetClusterName",
"(",
"clusterName",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"out",
",",
"err",
":=",
"s",
".",
"ConfigS",
".",
"GetClusterName",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n\n",
"err",
"=",
"s",
".",
"ConfigS",
".",
"DeleteClusterName",
"(",
")",
"\n",
"c",
".",
"Assert",
"(",
"err",
",",
"check",
".",
"IsNil",
")",
"\n",
"return",
"out",
"\n",
"}",
",",
"}",
",",
"}",
"\n",
"s",
".",
"runEventsTests",
"(",
"c",
",",
"testCases",
")",
"\n",
"}"
] | // EventsClusterConfig tests cluster config resource events | [
"EventsClusterConfig",
"tests",
"cluster",
"config",
"resource",
"events"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/suite/suite.go#L1310-L1357 | train |
gravitational/teleport | lib/services/tunnelconn.go | TunnelConnectionStatus | func TunnelConnectionStatus(clock clockwork.Clock, conn TunnelConnection) string {
diff := clock.Now().Sub(conn.GetLastHeartbeat())
if diff < defaults.ReverseTunnelOfflineThreshold {
return teleport.RemoteClusterStatusOnline
}
return teleport.RemoteClusterStatusOffline
} | go | func TunnelConnectionStatus(clock clockwork.Clock, conn TunnelConnection) string {
diff := clock.Now().Sub(conn.GetLastHeartbeat())
if diff < defaults.ReverseTunnelOfflineThreshold {
return teleport.RemoteClusterStatusOnline
}
return teleport.RemoteClusterStatusOffline
} | [
"func",
"TunnelConnectionStatus",
"(",
"clock",
"clockwork",
".",
"Clock",
",",
"conn",
"TunnelConnection",
")",
"string",
"{",
"diff",
":=",
"clock",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"conn",
".",
"GetLastHeartbeat",
"(",
")",
")",
"\n",
"if",
"diff",
"<",
"defaults",
".",
"ReverseTunnelOfflineThreshold",
"{",
"return",
"teleport",
".",
"RemoteClusterStatusOnline",
"\n",
"}",
"\n",
"return",
"teleport",
".",
"RemoteClusterStatusOffline",
"\n",
"}"
] | // IsTunnelConnectionStatus returns tunnel connection status based on the last
// heartbeat time recorded for a connection | [
"IsTunnelConnectionStatus",
"returns",
"tunnel",
"connection",
"status",
"based",
"on",
"the",
"last",
"heartbeat",
"time",
"recorded",
"for",
"a",
"connection"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnelconn.go#L78-L84 | train |
gravitational/teleport | lib/services/tunnelconn.go | MustCreateTunnelConnection | func MustCreateTunnelConnection(name string, spec TunnelConnectionSpecV2) TunnelConnection {
conn, err := NewTunnelConnection(name, spec)
if err != nil {
panic(err)
}
return conn
} | go | func MustCreateTunnelConnection(name string, spec TunnelConnectionSpecV2) TunnelConnection {
conn, err := NewTunnelConnection(name, spec)
if err != nil {
panic(err)
}
return conn
} | [
"func",
"MustCreateTunnelConnection",
"(",
"name",
"string",
",",
"spec",
"TunnelConnectionSpecV2",
")",
"TunnelConnection",
"{",
"conn",
",",
"err",
":=",
"NewTunnelConnection",
"(",
"name",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
"\n",
"}"
] | // MustCreateTunnelConnection returns new connection from V2 spec or panics if
// parameters are incorrect | [
"MustCreateTunnelConnection",
"returns",
"new",
"connection",
"from",
"V2",
"spec",
"or",
"panics",
"if",
"parameters",
"are",
"incorrect"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnelconn.go#L88-L94 | train |
gravitational/teleport | lib/services/tunnelconn.go | NewTunnelConnection | func NewTunnelConnection(name string, spec TunnelConnectionSpecV2) (TunnelConnection, error) {
conn := &TunnelConnectionV2{
Kind: KindTunnelConnection,
SubKind: spec.ClusterName,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := conn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | go | func NewTunnelConnection(name string, spec TunnelConnectionSpecV2) (TunnelConnection, error) {
conn := &TunnelConnectionV2{
Kind: KindTunnelConnection,
SubKind: spec.ClusterName,
Version: V2,
Metadata: Metadata{
Name: name,
Namespace: defaults.Namespace,
},
Spec: spec,
}
if err := conn.CheckAndSetDefaults(); err != nil {
return nil, trace.Wrap(err)
}
return conn, nil
} | [
"func",
"NewTunnelConnection",
"(",
"name",
"string",
",",
"spec",
"TunnelConnectionSpecV2",
")",
"(",
"TunnelConnection",
",",
"error",
")",
"{",
"conn",
":=",
"&",
"TunnelConnectionV2",
"{",
"Kind",
":",
"KindTunnelConnection",
",",
"SubKind",
":",
"spec",
".",
"ClusterName",
",",
"Version",
":",
"V2",
",",
"Metadata",
":",
"Metadata",
"{",
"Name",
":",
"name",
",",
"Namespace",
":",
"defaults",
".",
"Namespace",
",",
"}",
",",
"Spec",
":",
"spec",
",",
"}",
"\n",
"if",
"err",
":=",
"conn",
".",
"CheckAndSetDefaults",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"trace",
".",
"Wrap",
"(",
"err",
")",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // NewTunnelConnection returns new connection from V2 spec | [
"NewTunnelConnection",
"returns",
"new",
"connection",
"from",
"V2",
"spec"
] | d5243dbe8d36bba44bf640c08f1c49185ed2c8a4 | https://github.com/gravitational/teleport/blob/d5243dbe8d36bba44bf640c08f1c49185ed2c8a4/lib/services/tunnelconn.go#L97-L112 | train |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.