_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q181100 | SliceFilter | test | func SliceFilter(filter Filter) Filter {
return FilterFunc(func(k string, v interface{}) interface{} {
r := reflect.ValueOf(v)
if r.Kind() == reflect.Slice {
res := make([]interface{}, 0, r.Len())
for i := 0; i < r.Len(); i++ {
el := r.Index(i).Interface()
res = append(res, filter.Filter(k, el))
}
return res
}
return filter.Filter(k, v)
})
} | go | {
"resource": ""
} |
q181101 | MapFilter | test | func MapFilter(filter Filter) Filter {
return FilterFunc(func(k string, v interface{}) interface{} {
r := reflect.ValueOf(v)
if r.Kind() == reflect.Map {
// res will be the filtered map
res := make(map[string]interface{}, r.Len())
for _, key := range r.MapKeys() {
str := key.String()
val := r.MapIndex(key).Interface()
res[str] = filter.Filter(str, val)
}
return res
}
return v
})
} | go | {
"resource": ""
} |
q181102 | RestrictFilter | test | func RestrictFilter(fieldName string, filter Filter) Filter {
return FilterFunc(func(k string, v interface{}) interface{} {
if fieldName == k {
return filter.Filter(k, v)
}
return v
})
} | go | {
"resource": ""
} |
q181103 | LowerCaseFilter | test | func LowerCaseFilter(filter Filter) Filter {
return FilterFunc(func(k string, v interface{}) interface{} {
return filter.Filter(strings.ToLower(k), v)
})
} | go | {
"resource": ""
} |
q181104 | newBatchPoints | test | func newBatchPoints(bpConf influxdb.BatchPointsConfig) influxdb.BatchPoints {
bp, err := influxdb.NewBatchPoints(bpConf)
if err != nil {
// Can only happen if there's an error in the code
panic(fmt.Errorf("Invalid batch point configuration: %s", err))
}
return bp
} | go | {
"resource": ""
} |
q181105 | NewSinglePointWriter | test | func NewSinglePointWriter(log ttnlog.Interface, w BatchPointsWriter) *SinglePointWriter {
return &SinglePointWriter{
log: log,
writer: w,
}
} | go | {
"resource": ""
} |
q181106 | Write | test | func (w *SinglePointWriter) Write(bpConf influxdb.BatchPointsConfig, p *influxdb.Point) error {
bp := newBatchPoints(bpConf)
bp.AddPoint(p)
return w.writer.Write(bp)
} | go | {
"resource": ""
} |
q181107 | WithScalingInterval | test | func WithScalingInterval(v time.Duration) BatchingWriterOption {
return func(w *BatchingWriter) {
w.scalingInterval = v
}
} | go | {
"resource": ""
} |
q181108 | NewBatchingWriter | test | func NewBatchingWriter(log ttnlog.Interface, w BatchPointsWriter, opts ...BatchingWriterOption) *BatchingWriter {
bw := &BatchingWriter{
log: log,
writer: w,
scalingInterval: DefaultScalingInterval,
limit: DefaultInstanceLimit,
pointChans: make(map[influxdb.BatchPointsConfig]chan *batchPoint),
}
for _, opt := range opts {
opt(bw)
}
bw.log = bw.log.WithFields(ttnlog.Fields{
"limit": bw.limit,
"scalingInterval": bw.scalingInterval,
})
return bw
} | go | {
"resource": ""
} |
q181109 | Write | test | func (w *BatchingWriter) Write(bpConf influxdb.BatchPointsConfig, p *influxdb.Point) error {
log := w.log.WithField("config", bpConf)
w.pointChanMutex.RLock()
ch, ok := w.pointChans[bpConf]
w.pointChanMutex.RUnlock()
if !ok {
w.pointChanMutex.Lock()
ch, ok = w.pointChans[bpConf]
if !ok {
w.mutex.Lock()
w.active++
w.limit++
w.mutex.Unlock()
ch = make(chan *batchPoint)
w.pointChans[bpConf] = ch
go writeInBatches(log, w.writer, bpConf, w.scalingInterval, ch, true)
}
w.pointChanMutex.Unlock()
}
point := &batchPoint{
Point: p,
errch: make(chan error, 1),
}
select {
case ch <- point:
case <-time.After(w.scalingInterval):
w.mutex.Lock()
if w.active < w.limit {
w.active++
go writeInBatches(w.log, w.writer, bpConf, w.scalingInterval, ch, false)
}
w.mutex.Unlock()
ch <- point
}
return <-point.errch
} | go | {
"resource": ""
} |
q181110 | MustParseLevel | test | func (w *apexInterfaceWrapper) MustParseLevel(s string) {
level, err := ParseLevel(s)
if err != nil {
w.WithError(err).WithField("level", s).Fatal("Could not parse log level")
}
w.Level = level
} | go | {
"resource": ""
} |
q181111 | New | test | func New(bufferSize int, setup func() (grpc.ClientStream, error)) *Stream {
return &Stream{
setupFunc: setup,
sendBuffer: make(chan interface{}, bufferSize),
log: ttnlog.Get(),
}
} | go | {
"resource": ""
} |
q181112 | SetLogger | test | func (s *Stream) SetLogger(log ttnlog.Interface) {
s.mu.Lock()
s.log = log
s.mu.Unlock()
} | go | {
"resource": ""
} |
q181113 | CloseRecv | test | func (s *Stream) CloseRecv() {
s.mu.Lock()
if s.recvBuffer != nil {
close(s.recvBuffer)
s.recvBuffer = nil
}
s.mu.Unlock()
} | go | {
"resource": ""
} |
q181114 | Stats | test | func (s *Stream) Stats() (sent, dropped uint64) {
return atomic.LoadUint64(&s.sent), atomic.LoadUint64(&s.dropped)
} | go | {
"resource": ""
} |
q181115 | Run | test | func (s *Stream) Run() (err error) {
s.mu.RLock()
defer s.mu.RUnlock()
defer func() {
if err != nil {
if grpc.Code(err) == codes.Canceled {
s.log.Debug("streambuffer: context canceled")
err = context.Canceled
return
}
if grpc.Code(err) == codes.DeadlineExceeded {
s.log.Debug("streambuffer: context deadline exceeded")
err = context.DeadlineExceeded
return
}
}
}()
stream, err := s.setupFunc()
if err != nil {
s.log.WithError(err).Debug("streambuffer: setup returned error")
return err
}
recvErr := make(chan error)
defer func() {
go func() { // empty the recvErr channel on return
<-recvErr
}()
}()
go func() {
for {
var r interface{}
if s.recvFunc != nil {
r = s.recvFunc()
} else {
r = new(empty.Empty) // Generic proto message if not interested in received values
}
err := stream.RecvMsg(r)
if err != nil {
s.log.WithError(err).Debug("streambuffer: error from stream.RecvMsg")
recvErr <- err
close(recvErr)
return
}
if s.recvFunc != nil {
s.recvMsg(r)
}
}
}()
defer stream.CloseSend()
for {
select {
case err := <-recvErr:
return err
case <-stream.Context().Done():
s.log.WithError(stream.Context().Err()).Debug("streambuffer: context done")
return stream.Context().Err()
case msg := <-s.sendBuffer:
if err = stream.SendMsg(msg); err != nil {
s.log.WithError(err).Debug("streambuffer: error from stream.SendMsg")
return err
}
atomic.AddUint64(&s.sent, 1)
}
}
} | go | {
"resource": ""
} |
q181116 | ServerOptions | test | func ServerOptions(log ttnlog.Interface) []grpc.ServerOption {
return []grpc.ServerOption{
grpc.UnaryInterceptor(UnaryServerInterceptor(log)),
grpc.StreamInterceptor(StreamServerInterceptor(log)),
}
} | go | {
"resource": ""
} |
q181117 | ClientOptions | test | func ClientOptions(log ttnlog.Interface) []grpc.DialOption {
return []grpc.DialOption{
grpc.WithUnaryInterceptor(UnaryClientInterceptor(log)),
grpc.WithStreamInterceptor(StreamClientInterceptor(log)),
}
} | go | {
"resource": ""
} |
q181118 | UnaryServerInterceptor | test | func UnaryServerInterceptor(log ttnlog.Interface) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
log := getLog(log).WithField("method", info.FullMethod)
log = log.WithFields(FieldsFromIncomingContext(ctx))
start := time.Now()
resp, err = handler(ctx, req)
log = log.WithField("duration", time.Since(start))
if err != nil {
log.WithError(err).Debug("rpc-server: call failed")
return
}
log.Debug("rpc-server: call done")
return
}
} | go | {
"resource": ""
} |
q181119 | StreamServerInterceptor | test | func StreamServerInterceptor(log ttnlog.Interface) grpc.StreamServerInterceptor {
return func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo, handler grpc.StreamHandler) (err error) {
log := getLog(log).WithField("method", info.FullMethod)
log = log.WithFields(FieldsFromIncomingContext(ss.Context()))
start := time.Now()
log.Debug("rpc-server: stream starting")
err = handler(srv, ss)
log = log.WithField("duration", time.Since(start))
if err != nil {
if err == context.Canceled || grpc.Code(err) == codes.Canceled {
log.Debug("rpc-server: stream canceled")
return
}
log.WithError(err).Debug("rpc-server: stream failed")
return
}
log.Debug("rpc-server: stream done")
return
}
} | go | {
"resource": ""
} |
q181120 | UnaryClientInterceptor | test | func UnaryClientInterceptor(log ttnlog.Interface) grpc.UnaryClientInterceptor {
return func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) (err error) {
log := getLog(log).WithField("method", method)
log = log.WithFields(FieldsFromOutgoingContext(ctx))
start := time.Now()
err = invoker(ctx, method, req, reply, cc, opts...)
log = log.WithField("duration", time.Since(start))
if err != nil {
log.WithError(err).Debug("rpc-client: call failed")
return
}
log.Debug("rpc-client: call done")
return
}
} | go | {
"resource": ""
} |
q181121 | StreamClientInterceptor | test | func StreamClientInterceptor(log ttnlog.Interface) grpc.StreamClientInterceptor {
return func(ctx context.Context, desc *grpc.StreamDesc, cc *grpc.ClientConn, method string, streamer grpc.Streamer, opts ...grpc.CallOption) (stream grpc.ClientStream, err error) {
log := getLog(log).WithField("method", method)
log = log.WithFields(FieldsFromOutgoingContext(ctx))
log.Debug("rpc-client: stream starting")
stream, err = streamer(ctx, desc, cc, method, opts...)
if err != nil {
if err == context.Canceled || grpc.Code(err) == codes.Canceled {
log.Debug("rpc-client: stream canceled")
return
}
log.WithError(err).Debug("rpc-client: stream failed")
return
}
go func() {
<-stream.Context().Done()
if err := stream.Context().Err(); err != nil {
log = log.WithError(err)
}
log.Debug("rpc-client: stream done")
}()
return
}
} | go | {
"resource": ""
} |
q181122 | defaults | test | func (c *Config) defaults() {
if c.BufferSize == 0 {
c.BufferSize = 100
}
if c.Prefix == "" {
c.Prefix = "logs"
}
} | go | {
"resource": ""
} |
q181123 | Flush | test | func (h *Handler) Flush() {
h.mu.Lock()
defer h.mu.Unlock()
if h.batch != nil {
go h.flush(h.batch)
h.batch = nil
}
} | go | {
"resource": ""
} |
q181124 | New | test | func New(w io.Writer) *Handler {
var useColor bool
if os.Getenv("COLORTERM") != "" {
useColor = true
}
if term := os.Getenv("TERM"); term != "" {
for _, substring := range colorTermSubstrings {
if strings.Contains(term, substring) {
useColor = true
break
}
}
}
return &Handler{
Writer: w,
UseColor: useColor,
}
} | go | {
"resource": ""
} |
q181125 | HandleLog | test | func (h *Handler) HandleLog(e *log.Entry) error {
color := Colors[e.Level]
level := Strings[e.Level]
var fields []field
for k, v := range e.Fields {
fields = append(fields, field{k, v})
}
sort.Sort(byName(fields))
h.mu.Lock()
defer h.mu.Unlock()
if h.UseColor {
fmt.Fprintf(h.Writer, "\033[%dm%6s\033[0m %-40s", color, level, e.Message)
} else {
fmt.Fprintf(h.Writer, "%6s %-40s", level, e.Message)
}
for _, f := range fields {
var value interface{}
switch t := f.Value.(type) {
case []byte: // addresses and EUIs are []byte
value = fmt.Sprintf("%X", t)
case [21]byte: // bundle IDs [21]byte
value = fmt.Sprintf("%X-%X-%X-%X", t[0], t[1:9], t[9:17], t[17:])
default:
value = f.Value
}
if h.UseColor {
fmt.Fprintf(h.Writer, " \033[%dm%s\033[0m=%v", color, f.Name, value)
} else {
fmt.Fprintf(h.Writer, " %s=%v", f.Name, value)
}
}
fmt.Fprintln(h.Writer)
return nil
} | go | {
"resource": ""
} |
q181126 | New | test | func New(seed int64) random.Interface {
return &TTNRandom{
Interface: &random.TTNRandom{
Source: rand.New(rand.NewSource(seed)),
},
}
} | go | {
"resource": ""
} |
q181127 | Names | test | func (self *UriTemplate) Names() []string {
names := make([]string, 0, len(self.parts))
for _, p := range self.parts {
if len(p.raw) > 0 || len(p.terms) == 0 {
continue
}
for _, term := range p.terms {
names = append(names, term.name)
}
}
return names
} | go | {
"resource": ""
} |
q181128 | String | test | func (p PerfDatum) String() string {
val := fmtPerfFloat(p.value)
value := fmt.Sprintf("%s=%s%s", p.label, val, p.unit)
value += fmt.Sprintf(";%s;%s", fmtThreshold(p.warn), fmtThreshold(p.crit))
value += fmt.Sprintf(";%s;%s", fmtThreshold(p.min), fmtThreshold(p.max))
return value
} | go | {
"resource": ""
} |
q181129 | RenderPerfdata | test | func RenderPerfdata(perfdata []PerfDatum) string {
value := ""
if len(perfdata) == 0 {
return value
}
// Demarcate start of perfdata in check output.
value += " |"
for _, datum := range perfdata {
value += fmt.Sprintf(" %v", datum)
}
return value
} | go | {
"resource": ""
} |
q181130 | Exit | test | func Exit(status Status, message string) {
fmt.Printf("%v: %s\n", status, message)
os.Exit(int(status))
} | go | {
"resource": ""
} |
q181131 | NewCheckWithOptions | test | func NewCheckWithOptions(options CheckOptions) *Check {
c := NewCheck()
if options.StatusPolicy != nil {
c.statusPolicy = options.StatusPolicy
}
return c
} | go | {
"resource": ""
} |
q181132 | AddResult | test | func (c *Check) AddResult(status Status, message string) {
var result Result
result.status = status
result.message = message
c.results = append(c.results, result)
if (*c.statusPolicy)[result.status] > (*c.statusPolicy)[c.status] {
c.status = result.status
}
} | go | {
"resource": ""
} |
q181133 | AddResultf | test | func (c *Check) AddResultf(status Status, format string, v ...interface{}) {
msg := fmt.Sprintf(format, v...)
c.AddResult(status, msg)
} | go | {
"resource": ""
} |
q181134 | String | test | func (c Check) String() string {
value := fmt.Sprintf("%v: %s", c.status, c.exitInfoText())
value += RenderPerfdata(c.perfdata)
return value
} | go | {
"resource": ""
} |
q181135 | Exitf | test | func (c *Check) Exitf(status Status, format string, v ...interface{}) {
info := fmt.Sprintf(format, v...)
c.AddResult(status, info)
c.Finish()
} | go | {
"resource": ""
} |
q181136 | Criticalf | test | func (c *Check) Criticalf(format string, v ...interface{}) {
c.Exitf(CRITICAL, format, v...)
} | go | {
"resource": ""
} |
q181137 | Unknownf | test | func (c *Check) Unknownf(format string, v ...interface{}) {
c.Exitf(UNKNOWN, format, v...)
} | go | {
"resource": ""
} |
q181138 | NewDefaultStatusPolicy | test | func NewDefaultStatusPolicy() *statusPolicy {
return &statusPolicy{
OK: statusSeverity(OK),
WARNING: statusSeverity(WARNING),
CRITICAL: statusSeverity(CRITICAL),
UNKNOWN: statusSeverity(UNKNOWN),
}
} | go | {
"resource": ""
} |
q181139 | NewStatusPolicy | test | func NewStatusPolicy(statuses []Status) (*statusPolicy, error) {
newPol := make(statusPolicy)
for i, status := range statuses {
newPol[status] = statusSeverity(i)
}
// Ensure all statuses are covered by the new policy.
defaultPol := NewDefaultStatusPolicy()
for status := range *defaultPol {
_, ok := newPol[status]
if !ok {
return nil, fmt.Errorf("missing status: %v", status)
}
}
return &newPol, nil
} | go | {
"resource": ""
} |
q181140 | ParseRange | test | func ParseRange(rangeStr string) (*Range, error) {
// Set defaults
t := &Range{
Start: 0,
End: math.Inf(1),
AlertOnInside: false,
}
// Remove leading and trailing whitespace
rangeStr = strings.Trim(rangeStr, " \n\r")
// Check for inverted semantics
if rangeStr[0] == '@' {
t.AlertOnInside = true
rangeStr = rangeStr[1:]
}
// Parse lower limit
endPos := strings.Index(rangeStr, ":")
if endPos > -1 {
if rangeStr[0] == '~' {
t.Start = math.Inf(-1)
} else {
min, err := strconv.ParseFloat(rangeStr[0:endPos], 64)
if err != nil {
return nil, fmt.Errorf("failed to parse lower limit: %v", err)
}
t.Start = min
}
rangeStr = rangeStr[endPos+1:]
}
// Parse upper limit
if len(rangeStr) > 0 {
max, err := strconv.ParseFloat(rangeStr, 64)
if err != nil {
return nil, fmt.Errorf("failed to parse upper limit: %v", err)
}
t.End = max
}
if t.End < t.Start {
return nil, errors.New("Invalid range definition. min <= max violated!")
}
// OK
return t, nil
} | go | {
"resource": ""
} |
q181141 | Check | test | func (r *Range) Check(value float64) bool {
// Ranges are treated as a closed interval.
if r.Start <= value && value <= r.End {
return r.AlertOnInside
}
return !r.AlertOnInside
} | go | {
"resource": ""
} |
q181142 | CheckInt | test | func (r *Range) CheckInt(val int) bool {
return r.Check(float64(val))
} | go | {
"resource": ""
} |
q181143 | CheckUint64 | test | func (r *Range) CheckUint64(val uint64) bool {
return r.Check(float64(val))
} | go | {
"resource": ""
} |
q181144 | NewClient | test | func NewClient(config *ClientConfig) (*Client, error) {
t := &http.Transport{
TLSClientConfig: &tls.Config{
InsecureSkipVerify: config.AllowUnverifiedSSL,
},
}
httpClient := &http.Client{
Transport: t,
}
apiPath, _ := url.Parse("api/13/")
baseURL, err := url.Parse(config.BaseURL)
if err != nil {
return nil, fmt.Errorf("invalid base URL: %s", err.Error())
}
apiURL := baseURL.ResolveReference(apiPath)
return &Client{
httpClient: httpClient,
apiURL: apiURL,
authToken: config.AuthToken,
}, nil
} | go | {
"resource": ""
} |
q181145 | GetKeyMeta | test | func (c *Client) GetKeyMeta(path string) (*KeyMeta, error) {
k := &KeyMeta{}
err := c.get([]string{"storage", "keys", path}, nil, k)
return k, err
} | go | {
"resource": ""
} |
q181146 | GetKeysInDirMeta | test | func (c *Client) GetKeysInDirMeta(path string) ([]KeyMeta, error) {
r := &keyMetaListContents{}
err := c.get([]string{"storage", "keys", path}, nil, r)
if err != nil {
return nil, err
}
return r.Keys, nil
} | go | {
"resource": ""
} |
q181147 | GetKeyContent | test | func (c *Client) GetKeyContent(path string) (string, error) {
return c.rawGet([]string{"storage", "keys", path}, nil, "application/pgp-keys")
} | go | {
"resource": ""
} |
q181148 | GetJobSummariesForProject | test | func (c *Client) GetJobSummariesForProject(projectName string) ([]JobSummary, error) {
jobList := &jobSummaryList{}
err := c.get([]string{"project", projectName, "jobs"}, nil, jobList)
return jobList.Jobs, err
} | go | {
"resource": ""
} |
q181149 | GetJobsForProject | test | func (c *Client) GetJobsForProject(projectName string) ([]JobDetail, error) {
jobList := &jobDetailList{}
err := c.get([]string{"jobs", "export"}, map[string]string{"project": projectName}, jobList)
if err != nil {
return nil, err
}
return jobList.Jobs, nil
} | go | {
"resource": ""
} |
q181150 | GetJob | test | func (c *Client) GetJob(id string) (*JobDetail, error) {
jobList := &jobDetailList{}
err := c.get([]string{"job", id}, nil, jobList)
if err != nil {
return nil, err
}
return &jobList.Jobs[0], nil
} | go | {
"resource": ""
} |
q181151 | CreateJob | test | func (c *Client) CreateJob(job *JobDetail) (*JobSummary, error) {
return c.importJob(job, "create")
} | go | {
"resource": ""
} |
q181152 | CreateOrUpdateJob | test | func (c *Client) CreateOrUpdateJob(job *JobDetail) (*JobSummary, error) {
return c.importJob(job, "update")
} | go | {
"resource": ""
} |
q181153 | DeleteJob | test | func (c *Client) DeleteJob(id string) error {
return c.delete([]string{"job", id})
} | go | {
"resource": ""
} |
q181154 | JobSummary | test | func (r *jobImportResult) JobSummary() *JobSummary {
return &JobSummary{
ID: r.ID,
Name: r.Name,
GroupName: r.GroupName,
ProjectName: r.ProjectName,
}
} | go | {
"resource": ""
} |
q181155 | GetSystemInfo | test | func (c *Client) GetSystemInfo() (*SystemInfo, error) {
sysInfo := &SystemInfo{}
err := c.get([]string{"system", "info"}, nil, sysInfo)
return sysInfo, err
} | go | {
"resource": ""
} |
q181156 | DateTime | test | func (ts *SystemTimestamp) DateTime() time.Time {
// Assume the server will always give us a valid timestamp,
// so we don't need to handle the error case.
// (Famous last words?)
t, _ := time.Parse(time.RFC3339, ts.DateTimeStr)
return t
} | go | {
"resource": ""
} |
q181157 | GetAllProjects | test | func (c *Client) GetAllProjects() ([]ProjectSummary, error) {
p := &projects{}
err := c.get([]string{"projects"}, nil, p)
return p.Projects, err
} | go | {
"resource": ""
} |
q181158 | GetProject | test | func (c *Client) GetProject(name string) (*Project, error) {
p := &Project{}
err := c.get([]string{"project", name}, nil, p)
return p, err
} | go | {
"resource": ""
} |
q181159 | CreateProject | test | func (c *Client) CreateProject(project *Project) (*Project, error) {
p := &Project{}
err := c.post([]string{"projects"}, nil, project, p)
return p, err
} | go | {
"resource": ""
} |
q181160 | DeleteProject | test | func (c *Client) DeleteProject(name string) error {
return c.delete([]string{"project", name})
} | go | {
"resource": ""
} |
q181161 | SetProjectConfig | test | func (c *Client) SetProjectConfig(projectName string, config ProjectConfig) error {
return c.put(
[]string{"project", projectName, "config"},
config,
nil,
)
} | go | {
"resource": ""
} |
q181162 | NewClient | test | func NewClient(username, password string) *Client {
c := newPBRestClient(username, password, "", "", true)
return &Client{
userName: c.username,
password: c.password,
client: c,
}
} | go | {
"resource": ""
} |
q181163 | NewClientbyToken | test | func NewClientbyToken(token string) *Client {
c := newPBRestClientbyToken(token, "", "", true)
return &Client{
token: c.token,
client: c,
}
} | go | {
"resource": ""
} |
q181164 | SetDepth | test | func (c *Client) SetDepth(depth int) {
c.client.depth = strconv.Itoa(depth)
} | go | {
"resource": ""
} |
q181165 | ListDatacenters | test | func (c *Client) ListDatacenters() (*Datacenters, error) {
url := dcColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenters{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181166 | CreateDatacenter | test | func (c *Client) CreateDatacenter(dc Datacenter) (*Datacenter, error) {
url := dcColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenter{}
err := c.client.Post(url, dc, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181167 | GetDatacenter | test | func (c *Client) GetDatacenter(dcid string) (*Datacenter, error) {
url := dcPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenter{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181168 | UpdateDataCenter | test | func (c *Client) UpdateDataCenter(dcid string, obj DatacenterProperties) (*Datacenter, error) {
url := dcPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Datacenter{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181169 | DeleteDatacenter | test | func (c *Client) DeleteDatacenter(dcid string) (*http.Header, error) {
url := dcPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
return ret, c.client.Delete(url, ret, http.StatusAccepted)
} | go | {
"resource": ""
} |
q181170 | WaitTillProvisioned | test | func (c *Client) WaitTillProvisioned(path string) error {
waitCount := 300
for i := 0; i < waitCount; i++ {
request, err := c.GetRequestStatus(path)
if err != nil {
return err
}
if request.Metadata.Status == "DONE" {
return nil
}
time.Sleep(1 * time.Second)
i++
}
return fmt.Errorf("timeout expired while waiting for request to complete")
} | go | {
"resource": ""
} |
q181171 | ListFirewallRules | test | func (c *Client) ListFirewallRules(dcID string, serverID string, nicID string) (*FirewallRules, error) {
url := fwruleColPath(dcID, serverID, nicID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &FirewallRules{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181172 | GetFirewallRule | test | func (c *Client) GetFirewallRule(dcID string, serverID string, nicID string, fwID string) (*FirewallRule, error) {
url := fwrulePath(dcID, serverID, nicID, fwID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181173 | CreateFirewallRule | test | func (c *Client) CreateFirewallRule(dcID string, serverID string, nicID string, fw FirewallRule) (*FirewallRule, error) {
url := fwruleColPath(dcID, serverID, nicID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Post(url, fw, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181174 | UpdateFirewallRule | test | func (c *Client) UpdateFirewallRule(dcID string, serverID string, nicID string, fwID string, obj FirewallruleProperties) (*FirewallRule, error) {
url := fwrulePath(dcID, serverID, nicID, fwID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &FirewallRule{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181175 | DeleteFirewallRule | test | func (c *Client) DeleteFirewallRule(dcID string, serverID string, nicID string, fwID string) (*http.Header, error) {
url := fwrulePath(dcID, serverID, nicID, fwID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181176 | ListLoadbalancers | test | func (c *Client) ListLoadbalancers(dcid string) (*Loadbalancers, error) {
url := lbalColPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Loadbalancers{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181177 | GetLoadbalancer | test | func (c *Client) GetLoadbalancer(dcid, lbalid string) (*Loadbalancer, error) {
url := lbalPath(dcid, lbalid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Loadbalancer{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181178 | UpdateLoadbalancer | test | func (c *Client) UpdateLoadbalancer(dcid string, lbalid string, obj LoadbalancerProperties) (*Loadbalancer, error) {
url := lbalPath(dcid, lbalid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Loadbalancer{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181179 | DeleteLoadbalancer | test | func (c *Client) DeleteLoadbalancer(dcid, lbalid string) (*http.Header, error) {
url := lbalPath(dcid, lbalid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181180 | ListBalancedNics | test | func (c *Client) ListBalancedNics(dcid, lbalid string) (*Nics, error) {
url := balnicColPath(dcid, lbalid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nics{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181181 | AssociateNic | test | func (c *Client) AssociateNic(dcid string, lbalid string, nicid string) (*Nic, error) {
sm := map[string]string{"id": nicid}
url := balnicColPath(dcid, lbalid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Post(url, sm, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181182 | GetBalancedNic | test | func (c *Client) GetBalancedNic(dcid, lbalid, balnicid string) (*Nic, error) {
url := balnicPath(dcid, lbalid, balnicid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181183 | DeleteBalancedNic | test | func (c *Client) DeleteBalancedNic(dcid, lbalid, balnicid string) (*http.Header, error) {
url := balnicPath(dcid, lbalid, balnicid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181184 | ListLans | test | func (c *Client) ListLans(dcid string) (*Lans, error) {
url := lanColPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Lans{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181185 | GetLan | test | func (c *Client) GetLan(dcid, lanid string) (*Lan, error) {
url := lanPath(dcid, lanid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Lan{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181186 | DeleteLan | test | func (c *Client) DeleteLan(dcid, lanid string) (*http.Header, error) {
url := lanPath(dcid, lanid)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181187 | ListNics | test | func (c *Client) ListNics(dcid, srvid string) (*Nics, error) {
url := nicColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nics{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181188 | CreateNic | test | func (c *Client) CreateNic(dcid string, srvid string, nic Nic) (*Nic, error) {
url := nicColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Post(url, nic, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181189 | GetNic | test | func (c *Client) GetNic(dcid, srvid, nicid string) (*Nic, error) {
url := nicPath(dcid, srvid, nicid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181190 | UpdateNic | test | func (c *Client) UpdateNic(dcid string, srvid string, nicid string, obj NicProperties) (*Nic, error) {
url := nicPath(dcid, srvid, nicid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Nic{}
err := c.client.Patch(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181191 | DeleteNic | test | func (c *Client) DeleteNic(dcid, srvid, nicid string) (*http.Header, error) {
url := nicPath(dcid, srvid, nicid)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181192 | ListSnapshots | test | func (c *Client) ListSnapshots() (*Snapshots, error) {
url := snapshotColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Snapshots{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181193 | GetSnapshot | test | func (c *Client) GetSnapshot(snapshotID string) (*Snapshot, error) {
url := snapshotColPath() + slash(snapshotID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Snapshot{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181194 | DeleteSnapshot | test | func (c *Client) DeleteSnapshot(snapshotID string) (*http.Header, error) {
url := snapshotColPath() + slash(snapshotID) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181195 | UpdateSnapshot | test | func (c *Client) UpdateSnapshot(snapshotID string, request SnapshotProperties) (*Snapshot, error) {
url := snapshotColPath() + slash(snapshotID)
ret := &Snapshot{}
err := c.client.Patch(url, request, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181196 | ListIPBlocks | test | func (c *Client) ListIPBlocks() (*IPBlocks, error) {
url := ipblockColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlocks{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181197 | ReserveIPBlock | test | func (c *Client) ReserveIPBlock(request IPBlock) (*IPBlock, error) {
url := ipblockColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlock{}
err := c.client.Post(url, request, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181198 | GetIPBlock | test | func (c *Client) GetIPBlock(ipblockid string) (*IPBlock, error) {
url := ipblockPath(ipblockid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlock{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181199 | UpdateIPBlock | test | func (c *Client) UpdateIPBlock(ipblockid string, props IPBlockProperties) (*IPBlock, error) {
url := ipblockPath(ipblockid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &IPBlock{}
err := c.client.Patch(url, props, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.