_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q182300 | IsLeader | test | func (c *Candidate) IsLeader() bool {
c.lock.Lock()
defer c.lock.Unlock()
return c.leader
} | go | {
"resource": ""
} |
q182301 | NewResponse | test | func NewResponse(clientID, redirectURI, userID, exp, code string) Response {
return Response{ClientID: clientID, RedirectURI: redirectURI, UserID: userID, Exp: exp, Code: code}
} | go | {
"resource": ""
} |
q182302 | GetRequestID | test | func GetRequestID(ctx context.Context) (string, error) {
if ctx == nil {
return "", errors.New("nil context")
}
reqID, ok := ctx.Value(contextRequestID).(string)
if !ok {
return "", errors.New("unexpected type")
}
if len(reqID) == 0 {
return "", errors.New("empty value in context")
}
return reqID, nil
... | go | {
"resource": ""
} |
q182303 | Log | test | func (m *monitorableWriter) Log() {
duration := time.Now().Sub(m.t0)
if m.Code == 0 {
m.Code = 200
}
if m.opts.Filter != nil && !m.opts.Filter(m.r, m.Code, duration, m.Size) {
return //skip
}
cc := m.colorCode()
size := ""
if m.Size > 0 {
size = sizestr.ToString(m.Size)
}
buff := bytes.Buffer{}
m.opts.... | go | {
"resource": ""
} |
q182304 | SendMailSSL | test | func SendMailSSL(addr string, a smtp.Auth, from string, to []string, msg []byte) error {
conn, err := tls.Dial("tcp", addr, &tls.Config{InsecureSkipVerify: true}) //TODO: Not secure
if err != nil {
log.Println("Error Dialing", err)
return err
}
h, _, _ := net.SplitHostPort(addr)
c, err := smtp.NewClient(conn, ... | go | {
"resource": ""
} |
q182305 | Send | test | func (m *MailService) Send(message string, subject string, from string, to string) (err error) {
t := []string{to}
msg := []byte("From: " + from + "\r\n" +
"To: " + to + "\r\n" +
"Subject: " + subject + "\r\n" +
"\r\n" +
message + "\r\n")
err = m.SMTP.SendMail(from, t, msg)
return
} | go | {
"resource": ""
} |
q182306 | WaitForIt | test | func WaitForIt(fullConn, host string, port, timeout int) error {
// fullConn := flag.String("full-connection", "", "full connection")
// host := flag.String("host", "", "host to connect")
// port := flag.Int("port", 80, "port to connect")
// timeout := flag.Int("timeout", 10, "time to wait until port become availab... | go | {
"resource": ""
} |
q182307 | Get | test | func Get(source interface{}, environment string, configEnv Environment) (conf interface{}, err error) {
if filename, ok := source.(string); ok {
source, err = ioutil.ReadFile(filename)
if err != nil {
log.Printf("Fatal: %v", err)
return
}
}
err = yaml.Unmarshal(source.([]byte), configEnv)
if err != nil... | go | {
"resource": ""
} |
q182308 | initConfig | test | func initConfig() {
if cfgFile != "" { // enable ability to specify config file via flag
Viper.SetConfigFile(cfgFile)
}
Viper.SetConfigName("config") // name of config file (without extension)
Viper.AddConfigPath("$HOME") // adding home directory as first search path
Viper.AddConfigPath("./") // adding loc... | go | {
"resource": ""
} |
q182309 | WritePluginResultsToDatabase | test | func WritePluginResultsToDatabase(results map[string]interface{}) {
// connect to RethinkDB
session, err := r.Connect(r.ConnectOpts{
Address: fmt.Sprintf("%s:28015", utils.Getopt("MALICE_RETHINKDB", "rethink")),
Timeout: 5 * time.Second,
Database: "malice",
})
if err != nil {
log.Debug(err)
return
}
... | go | {
"resource": ""
} |
q182310 | NewAuthController | test | func NewAuthController(um UserManager, cnf web.Config) *AuthController {
authController := AuthController{UserManager: um, cnf: cnf}
return &authController
} | go | {
"resource": ""
} |
q182311 | Authenticate | test | func (c *AuthController) Authenticate(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
var user User
var data map[string]string
err := decoder.Decode(&user)
if err != nil {
http.Error(w, fmt.Sprintf("%v", err), 400)
return
}
user, _ = c.UserManager.Get(user.Username, user.Password... | go | {
"resource": ""
} |
q182312 | NewOAuth2Controller | test | func NewOAuth2Controller(am ApplicationManager, cnf web.Config) *OAuth2Controller {
oAuth2Controller := OAuth2Controller{cnf: cnf, ApplicationManager: am}
return &oAuth2Controller
} | go | {
"resource": ""
} |
q182313 | Refresh | test | func (c *OAuth2Controller) Refresh(w http.ResponseWriter, r *http.Request) {
grantType := r.URL.Query().Get("grant_type")
refreshToken := r.URL.Query().Get("refresh_token")
if strings.Compare(grantType, "refresh_token") != 0 {
http.Error(w, errors.New("Parameter grant_type is required").Error(), http.StatusBadRequ... | go | {
"resource": ""
} |
q182314 | Token | test | func (c *OAuth2Controller) Token(w http.ResponseWriter, r *http.Request) {
grantType := r.URL.Query().Get("grant_type")
code := r.URL.Query().Get("code")
if strings.Compare(grantType, "authorization_code") != 0 {
http.Error(w, errors.New("Parameter grant_type is required").Error(), http.StatusBadRequest)
return
... | go | {
"resource": ""
} |
q182315 | Logging | test | func Logging(next http.Handler, log *logrus.Logger) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
srw := StatusResponseWriter{w, 0, 0}
start := time.Now()
next.ServeHTTP(&srw, r)
end := time.Now()
latency := end.Sub(start)
log.WithField("client", r.RemoteAddr).WithF... | go | {
"resource": ""
} |
q182316 | SingleFile | test | func SingleFile(filename string) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, filename)
})
} | go | {
"resource": ""
} |
q182317 | Write | test | func (w *StatusResponseWriter) Write(data []byte) (int, error) {
w.length = len(data)
return w.ResponseWriter.Write(data)
} | go | {
"resource": ""
} |
q182318 | Hijack | test | func (w *StatusResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
if hj, ok := w.ResponseWriter.(http.Hijacker); ok {
return hj.Hijack()
}
return nil, nil, errors.New("Not a Hijacker")
} | go | {
"resource": ""
} |
q182319 | NewMongo | test | func NewMongo(filename string, environment string) (*Mongo, error) {
ctx := context.Background()
cnf, err := GetMongo(filename, environment)
if err != nil {
return nil, err
}
var uri string
if len(cnf.Username) > 0 && len(cnf.Password) > 0 {
uri = fmt.Sprintf(`mongodb://%s:%s@%s:%d/%s`,
cnf.Username,
cn... | go | {
"resource": ""
} |
q182320 | Disconnect | test | func (m *Mongo) Disconnect() error {
err := m.Client.Disconnect(m.context)
if err != nil {
log.Printf("Impossible de fermer la connexion")
return err
}
return nil
} | go | {
"resource": ""
} |
q182321 | New | test | func New(fields []string) *Table {
return &Table{
Fields: fields,
Rows: make([]map[string]string, 0),
fieldSizes: make(map[string]int),
}
} | go | {
"resource": ""
} |
q182322 | PrintTable | test | func PrintTable(fields []string, rows []map[string]interface{}) {
table := New(fields)
for _, r := range rows {
table.AddRow(r)
}
table.Print()
} | go | {
"resource": ""
} |
q182323 | PrintHorizontal | test | func PrintHorizontal(m map[string]interface{}) {
table := New([]string{"Key", "Value"})
rows := mapToRows(m)
for _, row := range rows {
table.AddRow(row)
}
table.HideHead = true
table.Print()
} | go | {
"resource": ""
} |
q182324 | PrintRow | test | func PrintRow(fields []string, row map[string]interface{}) {
table := New(fields)
table.AddRow(row)
table.Print()
} | go | {
"resource": ""
} |
q182325 | AddRow | test | func (t *Table) AddRow(row map[string]interface{}) {
newRow := make(map[string]string)
for _, k := range t.Fields {
v := row[k]
// If is not nil format
// else value is empty string
var val string
if v == nil {
val = ""
} else {
val = fmt.Sprintf("%v", v)
}
newRow[k] = val
}
t.calculateSizes... | go | {
"resource": ""
} |
q182326 | Print | test | func (t *Table) Print() {
if len(t.Rows) == 0 && t.Footer == nil {
return
}
t.calculateSizes(t.Footer)
if !t.Markdown {
t.printDash()
}
if !t.HideHead {
fmt.Println(t.getHead())
t.printTableDash()
}
for _, r := range t.Rows {
fmt.Println(t.rowString(r))
if !t.Markdown {
t.printDash()
}
}
... | go | {
"resource": ""
} |
q182327 | String | test | func (t *Table) String(title string) string {
tableString := []string{}
if len(t.Rows) == 0 && t.Footer == nil {
return ""
}
tableString = append(tableString, "### "+title)
t.calculateSizes(t.Footer)
if !t.Markdown {
// t.printDash()
tableString = append(tableString, t.stringDash())
}
if !t.HideHead... | go | {
"resource": ""
} |
q182328 | getHead | test | func (t *Table) getHead() string {
s := "|"
for _, name := range t.Fields {
s += t.fieldString(name, strings.Title(name)) + "|"
}
return s
} | go | {
"resource": ""
} |
q182329 | rowString | test | func (t *Table) rowString(row map[string]string) string {
s := "|"
for _, name := range t.Fields {
value := row[name]
s += t.fieldString(name, value) + "|"
}
return s
} | go | {
"resource": ""
} |
q182330 | fieldString | test | func (t *Table) fieldString(name, value string) string {
value = fmt.Sprintf(" %s ", value)
spacesLeft := t.fieldSizes[name] - runewidth.StringWidth(value)
if spacesLeft > 0 {
for i := 0; i < spacesLeft; i++ {
value += " "
}
}
return value
} | go | {
"resource": ""
} |
q182331 | stringTableDash | test | func (t *Table) stringTableDash() string {
if t.Markdown {
return t.stringMarkdownDash()
}
return t.stringDash()
} | go | {
"resource": ""
} |
q182332 | printMarkdownDash | test | func (t *Table) printMarkdownDash() {
r := make(map[string]string)
for _, name := range t.Fields {
r[name] = strings.Repeat("-", t.fieldSizes[name]-2)
}
fmt.Println(t.rowString(r))
} | go | {
"resource": ""
} |
q182333 | stringMarkdownDash | test | func (t *Table) stringMarkdownDash() string {
r := make(map[string]string)
for _, name := range t.Fields {
r[name] = strings.Repeat("-", t.fieldSizes[name]-2)
}
return t.rowString(r)
} | go | {
"resource": ""
} |
q182334 | HashPassword | test | func HashPassword(password []byte, salt []byte) (hash []byte, err error) {
hash, err = scrypt.Key(password, salt, N, R, P, KEYLENGTH)
if err != nil {
return nil, err
}
return
} | go | {
"resource": ""
} |
q182335 | EncodeOAuth2Code | test | func EncodeOAuth2Code(clientID, redirectURI, userID, sharedKey string) (code string, err error) {
rand := RandStringBytesMaskImprSrc(20)
exp := time.Now().Add(time.Minute * 10).String()
response := NewResponse(clientID, redirectURI, userID, exp, rand)
jresponse, err := json.Marshal(response)
if err != nil {
log.... | go | {
"resource": ""
} |
q182336 | DecodeOAuth2Code | test | func DecodeOAuth2Code(code, sharedKey string) (response Response, err error) {
object, err := jose.ParseSigned(code)
if err != nil {
return
}
output, err := object.Verify([]byte(sharedKey))
if err != nil {
return
}
base64Text := make([]byte, base64.StdEncoding.DecodedLen(len(output)))
l, err := base64.StdEn... | go | {
"resource": ""
} |
q182337 | NewServer | test | func NewServer(filename string, environment string) (server *Server, err error) {
conf, err := GetConfig(filename, environment)
logFile, err := os.OpenFile(conf.Log.File+logFilename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.SetOutput(os.Stderr)
log.Warningf("Can't open logfile: %v", err)
... | go | {
"resource": ""
} |
q182338 | Start | test | func (s *Server) Start() (err error) {
log.Infof("Lunarc is starting on port :%d", s.Config.Port)
var l net.Listener
go func() {
l, err = net.Listen("tcp", fmt.Sprintf(":%d", s.Config.Port))
if err != nil {
log.Errorf("Error: %v", err)
s.Error <- err
return
}
s.isStarted = true
if len(s.Config.SSL... | go | {
"resource": ""
} |
q182339 | Stop | test | func (s *Server) Stop() {
if s.isStarted && s.quit != nil {
log.Info("Lunarc is stopping...")
s.quit <- true
} else {
log.Info("Lunarc is not running")
s.Error <- errors.New("Lunarc is not running")
s.Done <- false
}
} | go | {
"resource": ""
} |
q182340 | NewLoggingServeMux | test | func NewLoggingServeMux(conf Config) *LoggingServeMux {
serveMux := http.NewServeMux()
return &LoggingServeMux{serveMux, conf}
} | go | {
"resource": ""
} |
q182341 | Handler | test | func (mux *LoggingServeMux) Handler(r *http.Request) (h http.Handler, pattern string) {
return mux.serveMux.Handler(r)
} | go | {
"resource": ""
} |
q182342 | Handle | test | func (mux *LoggingServeMux) Handle(pattern string, handler http.Handler) {
var log = logrus.New()
logFile, err := os.OpenFile(mux.conf.Log.File+aFilename, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Out = os.Stderr
log.Warningf("Can't open logfile: %v", err)
} else {
log.Out = logFile
}
... | go | {
"resource": ""
} |
q182343 | HandleFunc | test | func (mux *LoggingServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) {
mux.serveMux.Handle(pattern, http.HandlerFunc(handler))
} | go | {
"resource": ""
} |
q182344 | Init | test | func (db *Database) Init() error {
// Create URL from host/port
db.getURL()
// Test connection to ElasticSearch
err := db.TestConnection()
if err != nil {
return errors.Wrap(err, "failed to connect to database")
}
client, err := elastic.NewSimpleClient(
elastic.SetURL(db.URL),
elastic.SetBasicAuth(
u... | go | {
"resource": ""
} |
q182345 | WaitForConnection | test | func (db *Database) WaitForConnection(ctx context.Context, timeout int) error {
var err error
secondsWaited := 0
connCtx, cancel := context.WithTimeout(ctx, time.Duration(timeout)*time.Second)
defer cancel()
log.Debug("===> trying to connect to elasticsearch")
for {
// Try to connect to Elasticsearch
sele... | go | {
"resource": ""
} |
q182346 | StoreFileInfo | test | func (db *Database) StoreFileInfo(sample map[string]interface{}) (elastic.IndexResponse, error) {
if len(db.Plugins) == 0 {
return elastic.IndexResponse{}, errors.New("Database.Plugins is empty (you must set this field to use this function)")
}
// Test connection to ElasticSearch
err := db.TestConnection()
if ... | go | {
"resource": ""
} |
q182347 | StorePluginResults | test | func (db *Database) StorePluginResults(results database.PluginResults) error {
// Test connection to ElasticSearch
err := db.TestConnection()
if err != nil {
return errors.Wrap(err, "failed to connect to database")
}
client, err := elastic.NewSimpleClient(
elastic.SetURL(db.URL),
elastic.SetBasicAuth(
u... | go | {
"resource": ""
} |
q182348 | CamelCase | test | func CamelCase(src string) string {
byteSrc := []byte(src)
chunks := camelingRegex.FindAll(byteSrc, -1)
for idx, val := range chunks {
if idx > 0 {
chunks[idx] = bytes.Title(val)
}
}
return string(bytes.Join(chunks, nil))
} | go | {
"resource": ""
} |
q182349 | Getopt | test | func Getopt(name, dfault string) string {
value := os.Getenv(name)
if value == "" {
value = dfault
}
return value
} | go | {
"resource": ""
} |
q182350 | Getopts | test | func Getopts(userInput, envVar, dfault string) string {
if len(strings.TrimSpace(userInput)) > 0 {
return userInput
}
value := os.Getenv(envVar)
if value == "" {
value = dfault
}
return value
} | go | {
"resource": ""
} |
q182351 | GetSHA256 | test | func GetSHA256(name string) string {
dat, err := ioutil.ReadFile(name)
Assert(err)
h256 := sha256.New()
_, err = h256.Write(dat)
Assert(err)
return fmt.Sprintf("%x", h256.Sum(nil))
} | go | {
"resource": ""
} |
q182352 | RunCommand | test | func RunCommand(ctx context.Context, cmd string, args ...string) (string, error) {
var c *exec.Cmd
if ctx != nil {
c = exec.CommandContext(ctx, cmd, args...)
} else {
c = exec.Command(cmd, args...)
}
output, err := c.Output()
if err != nil {
return string(output), err
}
// check for exec context timeo... | go | {
"resource": ""
} |
q182353 | RemoveDuplicates | test | func RemoveDuplicates(elements []string) []string {
// Use map to record duplicates as we find them.
encountered := map[string]bool{}
result := []string{}
for v := range elements {
if encountered[elements[v]] == true {
// Do not add duplicate.
} else {
// Record this element as an encountered element.
... | go | {
"resource": ""
} |
q182354 | Unzip | test | func Unzip(archive, target string) error {
// fmt.Println("Unzip archive ", target)
reader, err := zip.OpenReader(archive)
if err != nil {
return err
}
defer reader.Close()
for _, file := range reader.File {
filePath := filepath.Join(target, file.Name)
if file.FileInfo().IsDir() {
os.MkdirAll(filePat... | go | {
"resource": ""
} |
q182355 | SliceContainsString | test | func SliceContainsString(a string, list []string) bool {
for _, b := range list {
if strings.Contains(b, a) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q182356 | NewSMTP | test | func NewSMTP(filename string, environment string) (s *SMTP, err error) {
conf, err := GetSMTP(filename, environment)
if err != nil {
return
}
auth := smtp.PlainAuth("", conf.Auth.User, conf.Auth.Password, conf.Host)
f := smtp.SendMail
if conf.SSL {
f = SendMailSSL
}
s = &SMTP{auth: auth, send: f, addr: fmt.... | go | {
"resource": ""
} |
q182357 | SendMail | test | func (s *SMTP) SendMail(from string, to []string, msg []byte) (err error) {
err = s.send(s.addr, s.auth, from, to, msg)
return
} | go | {
"resource": ""
} |
q182358 | GetEnvironment | test | func (se *SMTPEnvironment) GetEnvironment(environment string) interface{} {
for env, conf := range se.Env {
if strings.Compare(environment, env) == 0 {
return conf
}
}
return nil
} | go | {
"resource": ""
} |
q182359 | GetSMTP | test | func GetSMTP(source interface{}, environment string) (smtp Config, err error) {
var smtpEnvironment SMTPEnvironment
i, err := config.Get(source, environment, &smtpEnvironment)
smtp = i.(Config)
return
} | go | {
"resource": ""
} |
q182360 | GetConfig | test | func GetConfig(source interface{}, environment string) (server Config, err error) {
var serverEnvironment ServerEnvironment
i, err := config.Get(source, environment, &serverEnvironment)
server = i.(Config)
return
} | go | {
"resource": ""
} |
q182361 | GetEnvironment | test | func (m *Environment) GetEnvironment(environment string) interface{} {
for env, conf := range m.Env {
if strings.Compare(environment, env) == 0 {
return conf
}
}
return nil
} | go | {
"resource": ""
} |
q182362 | GetMongo | test | func GetMongo(source interface{}, environment string) (mongo Config, err error) {
var env Environment
i, err := config.Get(source, environment, &env)
mongo = i.(Config)
return
} | go | {
"resource": ""
} |
q182363 | TokenHandler | test | func TokenHandler(next http.Handler, cnf web.Config) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
token, err := request.ParseFromRequest(r, request.AuthorizationHeaderExtractor, func(token *jwt.Token) (interface{}, error) {
if _, ok := token.Method.(*jwt.SigningMethodHMAC)... | go | {
"resource": ""
} |
q182364 | Receive | test | func (c *Conn) Receive() (*InMsg, error) {
stanza, err := c.xmppConn.Recv()
if err != nil {
return nil, err
}
if c.debug {
log.Printf("Incoming raw CCS stanza: %+v\n", stanza)
}
chat, ok := stanza.(xmpp.Chat)
if !ok {
return nil, nil
}
if chat.Type == "error" {
// todo: once go-xmpp can parse XMPP e... | go | {
"resource": ""
} |
q182365 | Send | test | func (c *Conn) Send(m *OutMsg) (n int, err error) {
if m.ID == "" {
if m.ID, err = getMsgID(); err != nil {
return 0, err
}
}
mb, err := json.Marshal(m)
if err != nil {
return 0, err
}
ms := string(mb)
res := fmt.Sprintf(gcmMessageStanza, ms)
return c.xmppConn.SendOrg(res)
} | go | {
"resource": ""
} |
q182366 | allBoshReleaseNames | test | func (d pivnetReleaseDiffer) allBoshReleaseNames() []string {
boshReleaseNamesMap := make(map[string]string)
var addReleaseNames = func(br map[string]*release.BoshRelease) {
for brname := range br {
boshReleaseNamesMap[brname] = brname
}
}
addReleaseNames(d.release1.BoshRelease)
addReleaseNames(d.release2.B... | go | {
"resource": ""
} |
q182367 | AddedProperty | test | func (dj *DeltaJob) AddedProperty(name string, p *enaml.JobManifestProperty) {
dj.AddedProperties[name] = *p
} | go | {
"resource": ""
} |
q182368 | RemovedProperty | test | func (dj *DeltaJob) RemovedProperty(name string, p *enaml.JobManifestProperty) {
dj.RemovedProperties[name] = *p
} | go | {
"resource": ""
} |
q182369 | AddDeltaJob | test | func (r *Result) AddDeltaJob(dj *DeltaJob) {
r.DeltaJob = append(r.DeltaJob, *dj)
} | go | {
"resource": ""
} |
q182370 | Concat | test | func (r *Result) Concat(other *Result) {
for _, dj := range other.DeltaJob {
r.DeltaJob = append(r.DeltaJob, dj)
}
} | go | {
"resource": ""
} |
q182371 | Read | test | func (r *Release) Read(releaseLocation string) (io.ReadCloser, error) {
local, err := r.Pull(releaseLocation)
if err != nil {
return nil, err
}
rr, err := os.Open(local)
if err != nil {
return nil, err
}
return rr, nil
} | go | {
"resource": ""
} |
q182372 | Pull | test | func (r *Release) Pull(releaseLocation string) (filename string, err error) {
u, uerr := url.Parse(releaseLocation)
if uerr != nil || !(u.Scheme == "http" || u.Scheme == "https") {
// assume a local file, ensure it exists
if _, ferr := os.Stat(releaseLocation); os.IsNotExist(ferr) {
err = fmt.Errorf("Could not... | go | {
"resource": ""
} |
q182373 | BuildJob | test | func BuildJob(jobMeta BoshJobMeta, dest string) error {
b, err := json.Marshal(jobMeta)
if err != nil {
return err
}
fmt.Println("building job: ", string(b))
monitFile, specFile, err := createJobFiles(dest, jobMeta.Name)
if err != nil {
return err
}
defer monitFile.Close()
defer specFile.Close()
err = w... | go | {
"resource": ""
} |
q182374 | LoadBoshRelease | test | func LoadBoshRelease(releaseRepo pull.Release, path string) (release *BoshRelease, err error) {
var rr io.ReadCloser
rr, err = releaseRepo.Read(path)
if err != nil {
return
}
defer func() {
if cerr := rr.Close(); cerr != nil {
err = cerr
}
}()
release, err = readBoshRelease(rr)
return
} | go | {
"resource": ""
} |
q182375 | readBoshRelease | test | func readBoshRelease(rr io.Reader) (*BoshRelease, error) {
release := &BoshRelease{
JobManifests: make(map[string]enaml.JobManifest),
}
err := release.readBoshRelease(rr)
return release, err
} | go | {
"resource": ""
} |
q182376 | readBoshRelease | test | func (r *BoshRelease) readBoshRelease(rr io.Reader) error {
w := pkg.NewTgzWalker(rr)
w.OnMatch("release.MF", func(file pkg.FileEntry) error {
return decodeYaml(file.Reader, &r.ReleaseManifest)
})
w.OnMatch("/jobs/", func(file pkg.FileEntry) error {
job, jerr := r.readBoshJob(file.Reader)
if jerr == nil {
... | go | {
"resource": ""
} |
q182377 | readBoshJob | test | func (r *BoshRelease) readBoshJob(jr io.Reader) (enaml.JobManifest, error) {
var job enaml.JobManifest
jw := pkg.NewTgzWalker(jr)
jw.OnMatch("job.MF", func(file pkg.FileEntry) error {
return decodeYaml(file.Reader, &job)
})
err := jw.Walk()
return job, err
} | go | {
"resource": ""
} |
q182378 | NewRequest | test | func (s *Client) NewRequest(method, url string, body io.Reader) (*http.Request, error) {
req, err := http.NewRequest(method, url, body)
if err != nil {
return nil, err
}
setAuth(s, req)
return req, nil
} | go | {
"resource": ""
} |
q182379 | PushCloudConfig | test | func (s *Client) PushCloudConfig(manifest []byte) error {
ccm := enaml.NewCloudConfigManifest(manifest)
req, err := s.newCloudConfigRequest(*ccm)
if err != nil {
return err
}
res, err := s.http.Do(req)
if err != nil {
return err
}
defer res.Body.Close()
if res.StatusCode >= 400 {
body, err := ioutil.Read... | go | {
"resource": ""
} |
q182380 | Generate | test | func Generate(packagename string, fileBytes []byte, outputDir string) {
b := preprocessJobManifest(fileBytes)
objects := make(map[string]map[string]ObjectField)
var properties []string
for _, v := range b.recs {
properties = append(properties, v.Orig)
}
for i := 0; i < b.max; i++ {
for _, v := range b.recs {... | go | {
"resource": ""
} |
q182381 | CreateNewRecord | test | func CreateNewRecord(property string, yaml enaml.JobManifestProperty) (record Record) {
elementArray := strings.Split(property, ".")
record = Record{
Length: len(elementArray),
Orig: property,
Slice: elementArray,
Yaml: yaml,
}
return
} | go | {
"resource": ""
} |
q182382 | NewShowCmd | test | func NewShowCmd(releaseRepo pull.Release, release string) *ShowCmd {
return &ShowCmd{
releaseRepo: releaseRepo,
release: release,
}
} | go | {
"resource": ""
} |
q182383 | All | test | func (s *ShowCmd) All(w io.Writer) error {
if filepath.Ext(s.release) == ".pivotal" {
pivnetRelease, err := release.LoadPivnetRelease(s.releaseRepo, s.release)
if err != nil {
return err
}
for _, br := range pivnetRelease.BoshRelease {
s.printBoshRelease(w, br)
}
return nil
}
boshRelease, err := re... | go | {
"resource": ""
} |
q182384 | GetDefaultTaskImageResource | test | func (s *ConcoursePipeline) GetDefaultTaskImageResource() atc.ImageResource {
return atc.ImageResource{
Type: s.defaultImageType,
Source: atc.Source{
"repository": s.defaultImageRepository,
},
}
} | go | {
"resource": ""
} |
q182385 | AddRawJob | test | func (s *ConcoursePipeline) AddRawJob(job atc.JobConfig) {
s.Jobs = append(s.Jobs, job)
} | go | {
"resource": ""
} |
q182386 | AddGroup | test | func (s *ConcoursePipeline) AddGroup(name string, jobs ...string) {
s.Groups = append(s.Groups, atc.GroupConfig{
Name: name,
Jobs: jobs,
})
} | go | {
"resource": ""
} |
q182387 | GetResourceByName | test | func (s *ConcoursePipeline) GetResourceByName(name string) *atc.ResourceConfig {
for i, v := range s.Resources {
if v.Name == name {
return &s.Resources[i]
}
}
return nil
} | go | {
"resource": ""
} |
q182388 | AddRawResource | test | func (s *ConcoursePipeline) AddRawResource(rawResource atc.ResourceConfig) {
s.Resources = append(s.Resources, rawResource)
} | go | {
"resource": ""
} |
q182389 | AddResource | test | func (s *ConcoursePipeline) AddResource(name string, typename string, source map[string]interface{}) {
s.Resources = append(s.Resources, atc.ResourceConfig{
Name: name,
Type: typename,
Source: source,
})
} | go | {
"resource": ""
} |
q182390 | AddGithubResource | test | func (s *ConcoursePipeline) AddGithubResource(name string, source map[string]interface{}) {
s.AddResource(name, GithubResourceName, source)
} | go | {
"resource": ""
} |
q182391 | AddBoshIOResource | test | func (s *ConcoursePipeline) AddBoshIOResource(name string, source map[string]interface{}) {
s.AddResource(name, BoshIOResourceName, source)
} | go | {
"resource": ""
} |
q182392 | AddBoshDeploymentResource | test | func (s *ConcoursePipeline) AddBoshDeploymentResource(name string, source map[string]interface{}) {
s.AddResource(name, BoshDeploymentResourceName, source)
} | go | {
"resource": ""
} |
q182393 | AddGitResource | test | func (s *ConcoursePipeline) AddGitResource(name string, source map[string]interface{}) {
s.AddResource(name, GitResourceName, source)
} | go | {
"resource": ""
} |
q182394 | allJobNames | test | func (d boshReleaseDiffer) allJobNames() []string {
jobNamesMap := make(map[string]string)
var addJobNames = func(br *release.BoshRelease) {
if br != nil {
for jbname := range br.JobManifests {
jobNamesMap[jbname] = jbname
}
}
}
addJobNames(d.release1)
addJobNames(d.release2)
var jobNames []string
... | go | {
"resource": ""
} |
q182395 | NewDeploymentManifestFromFile | test | func NewDeploymentManifestFromFile(f *os.File) *DeploymentManifest {
var b []byte
fi, _ := f.Stat()
if fi.Size() > 0 {
b, _ = ioutil.ReadAll(f)
}
return NewDeploymentManifest(b)
} | go | {
"resource": ""
} |
q182396 | NewDeploymentManifest | test | func NewDeploymentManifest(b []byte) *DeploymentManifest {
dm := new(DeploymentManifest)
yaml.Unmarshal(b, dm)
return dm
} | go | {
"resource": ""
} |
q182397 | AddRemoteRelease | test | func (s *DeploymentManifest) AddRemoteRelease(releaseName, ver, url, sha1 string) (err error) {
s.Releases = append(s.Releases, Release{
Name: releaseName,
URL: url,
SHA1: sha1,
Version: ver,
})
return
} | go | {
"resource": ""
} |
q182398 | AddRemoteStemcell | test | func (s *DeploymentManifest) AddRemoteStemcell(os, alias, ver, url, sha1 string) {
s.Stemcells = append(s.Stemcells, Stemcell{
OS: os,
Alias: alias,
Version: ver,
URL: url,
SHA1: sha1,
})
} | go | {
"resource": ""
} |
q182399 | Tag | test | func (s *DeploymentManifest) Tag(key string) string {
if s.Tags == nil {
return ""
}
return s.Tags[key]
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.