id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c182400 | s.Tags != nil {
delete(s.Tags, key)
}
} | |
c182401 | release = &PivnetRelease{
BoshRelease: make(map[string]*BoshRelease),
}
err = release.readPivnetRelease(localPath)
return
} | |
c182402 | nil {
br = emptyBoshRelease
}
return br
} | |
c182403 | return berr
}
r.BoshRelease[br.ReleaseManifest.Name] = br
return nil
})
return walker.Walk()
} | |
c182404 |
yaml.Unmarshal(bytes, v)
}
return err
} | |
c182405 |
zipPath: zipFile,
callbacks: make(map[*regexp.Regexp]WalkFunc),
}
} | |
c182406 | {
return &DiffCmd{
releaseRepo: releaseRepo,
release1: release1,
release2: release2,
}
} | |
c182407 |
if err != nil {
return err
}
s.printDiffResult(w, d)
return nil
} | |
c182408 |
if err != nil {
return err
}
d, err := differ.DiffJob(job)
if err != nil {
return err
}
s.printDiffResult(w, d)
return nil
} | |
c182409 | = release.LoadPivnetRelease(releaseRepo, r1Path); err == nil {
if r2, err = release.LoadPivnetRelease(releaseRepo, r2Path); err == nil {
differ = pivnetReleaseDiffer{
release1: r1,
release2: r2,
}
}
}
} else {
var r1, r2 *release.BoshRelease
if r1, err = release.LoadBoshRelease(releaseRepo, r1Path); err == nil {
if r2, err = release.LoadBoshRelease(releaseRepo, r2Path); err == nil {
differ = boshReleaseDiffer{
release1: r1,
release2: r2,
}
}
}
}
return
} | |
c182410 | len(parentNames) > 1 {
structname = FormatName(v.Slice[i-2] + "_" + currentNode)
}
}
} else {
structname = FormatName(packagename + "_job")
}
return
} | |
c182411 | len(parentNames) > 1 {
typename = "*" + FormatName(v.Slice[i-1]+"_"+currentNode)
}
}
} else {
typename = "interface{}"
}
return
} | |
c182412 |
callbacks: make(map[*regexp.Regexp]WalkFunc),
}
} | |
c182413 | *Backoff {
backoff := Backoff{strategy: strategy, start: start, limit: limit}
backoff.Reset()
return &backoff
} | |
c182414 |
b.NextDuration = b.getNextDuration()
} | |
c182415 | NewBackoff(exponential{}, start, limit)
} | |
c182416 | NewBackoff(exponentialFullJitter{limit: limit}, start, limit)
} | |
c182417 | NewBackoff(linear{}, start, limit)
} | |
c182418 | {
return 1 + line*2 + floor*4 + int(floor/2*2)*int((floor+1)/2)
} | |
c182419 | {
return s.GetLineSize(s.Size-1, s.Size+3)
} | |
c182420 | s.putchar("\n")
}
}
// the trunc
for i := 0; i < s.Size; i++ {
lineSize := s.Size + (s.Size+1)%2
// pad left with spaces
for i := (maxSize-lineSize)/2 - 1; i > 0; i-- {
s.putchar(" ")
}
// draw the body
for i := 0; i < lineSize; i++ {
s.putchar("|")
}
// new line
s.putchar("\n")
}
} | |
c182421 | o.SetTimeout(timeout)
return o
} | |
c182422 | *PostAppsParams {
o.SetContext(ctx)
return o
} | |
c182423 | o.SetHTTPClient(client)
return o
} | |
c182424 | *PostAppsParams {
o.SetBody(body)
return o
} | |
c182425 | time.Duration) *GetAppsAppParams {
o.SetTimeout(timeout)
return o
} | |
c182426 | *GetAppsAppParams {
o.SetContext(ctx)
return o
} | |
c182427 | o.SetHTTPClient(client)
return o
} | |
c182428 | {
o.SetApp(app)
return o
} | |
c182429 | swag.ReadJSON(b, &res); err != nil {
return err
}
*m = res
return nil
} | |
c182430 | *GetAppsParams {
o.SetTimeout(timeout)
return o
} | |
c182431 | *GetAppsParams {
o.SetContext(ctx)
return o
} | |
c182432 | o.SetHTTPClient(client)
return o
} | |
c182433 | {
o.SetTimeout(timeout)
return o
} | |
c182434 | *DeleteAppsAppParams {
o.SetContext(ctx)
return o
} | |
c182435 | {
o.SetHTTPClient(client)
return o
} | |
c182436 | string) *DeleteAppsAppParams {
o.SetApp(app)
return o
} | |
c182437 | time.Duration) *PatchAppsAppRoutesRouteParams {
o.SetTimeout(timeout)
return o
} | |
c182438 | context.Context) *PatchAppsAppRoutesRouteParams {
o.SetContext(ctx)
return o
} | |
c182439 | *http.Client) *PatchAppsAppRoutesRouteParams {
o.SetHTTPClient(client)
return o
} | |
c182440 | string) *PatchAppsAppRoutesRouteParams {
o.SetApp(app)
return o
} | |
c182441 | *PatchAppsAppRoutesRouteParams {
o.SetBody(body)
return o
} | |
c182442 | string) *PatchAppsAppRoutesRouteParams {
o.SetRoute(route)
return o
} | |
c182443 | time.Duration) *PostAppsAppRoutesParams {
o.SetTimeout(timeout)
return o
} | |
c182444 | context.Context) *PostAppsAppRoutesParams {
o.SetContext(ctx)
return o
} | |
c182445 | *http.Client) *PostAppsAppRoutesParams {
o.SetHTTPClient(client)
return o
} | |
c182446 | string) *PostAppsAppRoutesParams {
o.SetApp(app)
return o
} | |
c182447 | *PostAppsAppRoutesParams {
o.SetBody(body)
return o
} | |
c182448 | time.Duration) *PutAppsAppRoutesRouteParams {
o.SetTimeout(timeout)
return o
} | |
c182449 | context.Context) *PutAppsAppRoutesRouteParams {
o.SetContext(ctx)
return o
} | |
c182450 | string) *PutAppsAppRoutesRouteParams {
o.SetApp(app)
return o
} | |
c182451 | *PutAppsAppRoutesRouteParams {
o.SetBody(body)
return o
} | |
c182452 | string) *PutAppsAppRoutesRouteParams {
o.SetRoute(route)
return o
} | |
c182453 | time.Duration) *GetAppsAppRoutesParams {
o.SetTimeout(timeout)
return o
} | |
c182454 | context.Context) *GetAppsAppRoutesParams {
o.SetContext(ctx)
return o
} | |
c182455 | *http.Client) *GetAppsAppRoutesParams {
o.SetHTTPClient(client)
return o
} | |
c182456 | string) *GetAppsAppRoutesParams {
o.SetApp(app)
return o
} | |
c182457 | {
o.SetTimeout(timeout)
return o
} | |
c182458 | *PatchAppsAppParams {
o.SetContext(ctx)
return o
} | |
c182459 | *http.Client) *PatchAppsAppParams {
o.SetHTTPClient(client)
return o
} | |
c182460 | string) *PatchAppsAppParams {
o.SetApp(app)
return o
} | |
c182461 | *PatchAppsAppParams {
o.SetBody(body)
return o
} | |
c182462 | time.Duration) *PutAppsAppParams {
o.SetTimeout(timeout)
return o
} | |
c182463 | *PutAppsAppParams {
o.SetContext(ctx)
return o
} | |
c182464 | {
o.SetApp(app)
return o
} | |
c182465 | *PutAppsAppParams {
o.SetBody(body)
return o
} | |
c182466 | if err := swag.ReadJSON(raw, &aO1); err != nil {
return err
}
m.TaskAllOf1 = aO1
return nil
} | |
c182467 | != nil {
return nil, err
}
_parts = append(_parts, aO1)
return swag.ConcatJSON(_parts...), nil
} | |
c182468 | = append(res, err)
}
if len(res) > 0 {
return errors.CompositeValidationError(res...)
}
return nil
} | |
c182469 | nil || c < 0 || c > 32 {
return nil, &PermError{"Invalid IPv4 CIDR length: " + cidr}
}
}
ip += "/" + cidr
_, ipnet, err := net.ParseCIDR(ip)
if err != nil {
return nil, err
}
net_out = append(net_out, *ipnet)
}
return net_out, nil
} | |
c182470 | time.Duration) *GetAppsAppRoutesRouteParams {
o.SetTimeout(timeout)
return o
} | |
c182471 | context.Context) *GetAppsAppRoutesRouteParams {
o.SetContext(ctx)
return o
} | |
c182472 | *http.Client) *GetAppsAppRoutesRouteParams {
o.SetHTTPClient(client)
return o
} | |
c182473 | string) *GetAppsAppRoutesRouteParams {
o.SetApp(app)
return o
} | |
c182474 | string) *GetAppsAppRoutesRouteParams {
o.SetRoute(route)
return o
} | |
c182475 | = routes.New(transport, formats)
cli.Tasks = tasks.New(transport, formats)
cli.Version = version.New(transport, formats)
return cli
} | |
c182476 |
c.Apps.SetTransport(transport)
c.Routes.SetTransport(transport)
c.Tasks.SetTransport(transport)
c.Version.SetTransport(transport)
} | |
c182477 | time.Duration) *DeleteAppsAppRoutesRouteParams {
o.SetTimeout(timeout)
return o
} | |
c182478 | context.Context) *DeleteAppsAppRoutesRouteParams {
o.SetContext(ctx)
return o
} | |
c182479 | *http.Client) *DeleteAppsAppRoutesRouteParams {
o.SetHTTPClient(client)
return o
} | |
c182480 | string) *DeleteAppsAppRoutesRouteParams {
o.SetApp(app)
return o
} | |
c182481 | string) *DeleteAppsAppRoutesRouteParams {
o.SetRoute(route)
return o
} | |
c182482 | o.SetTimeout(timeout)
return o
} | |
c182483 | *GetTasksParams {
o.SetContext(ctx)
return o
} | |
c182484 | o.SetHTTPClient(client)
return o
} | |
c182485 | i++ {
stor.freeWriteReqChan <- &asyncValueWriteRequest{resChan: make(chan *asyncValueWriteResponse, 1)}
}
for i := 0; i < cap(stor.freeWriteResChan); i++ {
stor.freeWriteResChan <- &asyncValueWriteResponse{}
}
go stor.handleWriteStream()
stor.pendingDeleteReqChan = make(chan *asyncValueDeleteRequest, concurrency)
stor.freeDeleteReqChan = make(chan *asyncValueDeleteRequest, concurrency)
stor.freeDeleteResChan = make(chan *asyncValueDeleteResponse, concurrency)
for i := 0; i < cap(stor.freeDeleteReqChan); i++ {
stor.freeDeleteReqChan <- &asyncValueDeleteRequest{resChan: make(chan *asyncValueDeleteResponse, 1)}
}
for i := 0; i < cap(stor.freeDeleteResChan); i++ {
stor.freeDeleteResChan <- &asyncValueDeleteResponse{}
}
go stor.handleDeleteStream()
return stor, nil
} | |
c182486 |
stor.shutdown()
close(stor.handlersDoneChan)
stor.lock.Unlock()
} | |
c182487 | o.backend = backend
o.Unlock()
} | |
c182488 | defer o.RUnlock()
return o.ring
} | |
c182489 | defer o.RUnlock()
return o.localID
} | |
c182490 | return o.ring.LocalNode().Address(2)
} | |
c182491 |
go rs.ringServerConnector(rs.ringServerExitChan)
}
rs.ringLock.Unlock()
return nil
} | |
c182492 | * time.Millisecond)
close(o.ShutdownComplete)
} | |
c182493 | fmt.Errorf("Service already stopped")
}
close(o.ch)
o.backend.StopListenAndServe()
o.backend.Wait()
o.backend.Stop()
o.stopped = true
return nil
} | |
c182494 |
o.backend.StopListenAndServe()
o.backend.Wait()
o.backend.Stop()
o.stopped = true
defer o.shutdownFinished()
return nil
} | |
c182495 | err := o.binaryUpgrade.Upgrade(version)
if err != nil {
return false, err.Error()
}
return true, ""
} | |
c182496 | return o.binaryUpgrade.GetCurrentVersion()
} | |
c182497 | err := stor.shutdown()
stor.lock.Unlock()
return err
} | |
c182498 | if !data.Success && data.Error != "" {
return RantModel{}, nil, errors.New(data.Error)
}
return data.Rant, data.Comments, nil
} | |
c182499 |
}
var data UserResponse
json.NewDecoder(res.Body).Decode(&data)
if !data.Success && data.Error != "" {
return UserModel{}, ContentModel{}, errors.New(data.Error)
}
return data.Profile, data.Profile.Content.Content, nil
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.