_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173900 | Contains | validation | func (b *AddressBlock) Contains(address HardwareAddr) bool {
//fmt.Println("%v %v %v %v", b.Oui, len(b.Oui), address.Mask(CIDRMask(b.Mask, len(b.Oui)*8)), CIDRMask(b.Mask, len(b.Oui)*8))
return (bytes.Equal(address.Mask(CIDRMask(b.Mask, len(b.Oui)*8)), b.Oui))
} | go | {
"resource": ""
} |
q173901 | ThrottledReader | validation | func ThrottledReader(
ctx context.Context,
r io.Reader,
throttle Throttle) io.Reader {
return &throttledReader{
ctx: ctx,
wrapped: r,
throttle: throttle,
}
} | go | {
"resource": ""
} |
q173902 | NewThrottledBucket | validation | func NewThrottledBucket(
opThrottle Throttle,
egressThrottle Throttle,
wrapped gcs.Bucket) (b gcs.Bucket) {
b = &throttledBucket{
opThrottle: opThrottle,
egressThrottle: egressThrottle,
wrapped: wrapped,
}
return
} | go | {
"resource": ""
} |
q173903 | NewCmdWithRunner | validation | func NewCmdWithRunner(cmdName string, runner func()) (*CmdWithRunner, error) {
if cmdName == "" {
return nil, errors.New("cmdName cannot be blank")
}
for _, r := range cmdName {
if unicode.IsSpace(r) {
return nil, errors.Errorf("cmdName cannot contain whitespace: %q", cmdName)
}
}
return &CmdWithRunner{... | go | {
"resource": ""
} |
q173904 | MustNewCmdWithRunner | validation | func MustNewCmdWithRunner(cmdName string, runner func()) *CmdWithRunner {
cmdWithRunner, err := NewCmdWithRunner(cmdName, runner)
if err != nil {
panic(err)
}
return cmdWithRunner
} | go | {
"resource": ""
} |
q173905 | importBreakPaths | validation | func importBreakPaths(file *ast.File) []string {
var output []string
for _, decl := range file.Decls {
if gen, ok := decl.(*ast.GenDecl); ok && gen.Tok == token.IMPORT {
for srcIndex, currSpec := range gen.Specs {
if srcIndex > 0 {
// if there was a previous element, check if the group has changed
... | go | {
"resource": ""
} |
q173906 | SelfProxyCmderSupplier | validation | func SelfProxyCmderSupplier() CmderSupplier {
return func(cmd Cmd) (Cmder, error) {
selfCmder, err := selfCmder()
if err != nil {
return nil, err
}
return CmderWithPrependedArgs(selfCmder, proxyCmd(cmd).Name()), nil
}
} | go | {
"resource": ""
} |
q173907 | SupplierWithPrependedArgs | validation | func SupplierWithPrependedArgs(s CmderSupplier, argsFunc func(cmd Cmd) []string) CmderSupplier {
return func(cmd Cmd) (Cmder, error) {
r, err := s(cmd)
if err != nil {
return nil, err
}
return CmderWithPrependedArgs(r, argsFunc(cmd)...), nil
}
} | go | {
"resource": ""
} |
q173908 | selfCmder | validation | func selfCmder() (Cmder, error) {
pathToSelf, err := osext.Executable()
if err != nil {
return nil, errors.Wrapf(err, "failed to determine path for current executable")
}
return PathCmder(pathToSelf), nil
} | go | {
"resource": ""
} |
q173909 | CmderWithPrependedArgs | validation | func CmderWithPrependedArgs(r Cmder, prependedArgs ...string) Cmder {
return &wrappedCmder{
inner: r,
prependedArgs: prependedArgs,
}
} | go | {
"resource": ""
} |
q173910 | NewSeeforRouter | validation | func NewSeeforRouter() *Seefor {
c4 := &Seefor{}
c4.afters = make([]After, 0)
c4.befores = make([]Before, 0)
c4.roots = make(map[string]*rootNode)
c4.HandleMethodNotAllowed = true
return c4
} | go | {
"resource": ""
} |
q173911 | ServeHTTP | validation | func (c4 *Seefor) ServeHTTP(w http.ResponseWriter, req *http.Request) {
started := time.Now()
c4.handleBeforeMiddlewares(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
beforeEnd := time.Now()
if root, exist := c4.roots[req.Method]; exist {
handler, params, route := root.match(req.URL.Path)
... | go | {
"resource": ""
} |
q173912 | Before | validation | func (c4 *Seefor) Before(middleware ...Before) {
c4.befores = append(c4.befores, middleware...)
} | go | {
"resource": ""
} |
q173913 | After | validation | func (c4 *Seefor) After(middleware ...After) {
c4.afters = append(c4.afters, middleware...)
} | go | {
"resource": ""
} |
q173914 | UseTimer | validation | func (c4 *Seefor) UseTimer(timer *Timer) *Timer {
if timer == nil {
if c4.timer != nil {
return c4.timer
}
timer = NewTimer()
}
c4.timer = timer
return c4.timer
} | go | {
"resource": ""
} |
q173915 | NewRouter | validation | func NewRouter() *Router {
r := &Router{}
r.roots = make(map[string]*rootNode)
r.HandleMethodNotAllowed = true
return r
} | go | {
"resource": ""
} |
q173916 | ServeHTTP | validation | func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
//now := time.Now()
if root, exist := r.roots[req.Method]; exist {
handler, params, _ := root.match(req.URL.Path)
if handler != nil {
handler.ServeHTTP(w, req, params)
//log.Println(time.Now().Sub(now))
return
}
}
r.handleMissing(... | go | {
"resource": ""
} |
q173917 | Group | validation | func (r *Router) Group(path string, fn func(r *GroupRouter)) {
gr := NewGroupRouter(r, path)
fn(gr)
} | go | {
"resource": ""
} |
q173918 | findChild | validation | func (n *routeNode) findChild(nn *routeNode) *routeNode {
for _, c := range n.children {
if c.path == nn.path {
// same node
return c
}
}
return nil
} | go | {
"resource": ""
} |
q173919 | insertChild | validation | func (n *routeNode) insertChild(nn *routeNode) *routeNode {
if child := n.findChild(nn); child != nil {
return child
}
if n.paramChild != nil && nn.paramNode {
// only allow one param child, unique param name
if n.paramChild.paramName != nn.paramName {
panic("Param name must be same for")
}
return n.pa... | go | {
"resource": ""
} |
q173920 | Get | validation | func (t *Timer) Get(name string) *Counter {
if c, exist := t.routes[name]; exist {
return c
}
t.mux.Lock()
defer t.mux.Unlock()
// could be a race so check again
// could loose som small data but good not to
if c, exist := t.routes[name]; exist {
return c
}
t.routes[name] = &Counter{}
t.routes[name].Min =... | go | {
"resource": ""
} |
q173921 | ServeHTTP | validation | func (t *Timer) ServeHTTP(w http.ResponseWriter, req *http.Request) {
req.ParseForm()
sortBy := req.Form.Get("sort")
stats := &Stats{}
stats.SortBy = strings.ToLower(sortBy)
stats.Generated = time.Now()
stats.UpTime = fmt.Sprintf("%s", stats.Generated.Sub(t.Since))
// Read access OK for map?
stats.Result = ma... | go | {
"resource": ""
} |
q173922 | main | validation | func main() {
router := r2router.NewSeeforRouter()
// basic auth for entire router
router.Before(httpauth.SimpleBasicAuth("testuser", "testpw"))
router.Get("/hello/:name", func(w http.ResponseWriter, r *http.Request, p r2router.Params) {
w.Write([]byte( p.Get("name")))
})
http.ListenAndServe("127.0.0.1:808... | go | {
"resource": ""
} |
q173923 | NewGroupRouter | validation | func NewGroupRouter(r *Router, path string) *GroupRouter {
gr := &GroupRouter{}
gr.router = r
gr.path = strings.TrimRight(path, "/")
return gr
} | go | {
"resource": ""
} |
q173924 | RouteMiddleware | validation | func RouteMiddleware(next r2router.HandlerFunc) r2router.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request, p r2router.Params) {
p.AppSet("say", "Hello")
next(w, r, p)
}
} | go | {
"resource": ""
} |
q173925 | RouteHandlerFunc | validation | func RouteHandlerFunc(next http.HandlerFunc) r2router.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request, _ r2router.Params) {
next(w, r)
}
} | go | {
"resource": ""
} |
q173926 | RectFromSphere | validation | func RectFromSphere(c Vec3, r float32) Rectangle {
return RectWHD(c[0]-r, c[1]-r, c[2]-r, 2*r, 2*r, 2*r)
} | go | {
"resource": ""
} |
q173927 | CopyRect | validation | func CopyRect(r Rectangle) Rectangle {
r1 := NewRect()
r1.Min.Assign(r.Min)
r1.Max.Assign(r.Max)
return r1
} | go | {
"resource": ""
} |
q173928 | Size | validation | func (r Rectangle) Size() Vec3 {
return Vec3{
r.Max[0] - r.Min[0],
r.Max[1] - r.Min[1],
r.Max[2] - r.Min[2],
}
} | go | {
"resource": ""
} |
q173929 | Overlaps | validation | func (r Rectangle) Overlaps(s Rectangle) bool {
return !r.Empty() && !s.Empty() &&
r.Min[0] < s.Max[0] && s.Min[0] < r.Max[0] &&
r.Min[1] < s.Max[1] && s.Min[1] < r.Max[1] &&
r.Min[2] < s.Max[2] && s.Min[2] < r.Max[2]
} | go | {
"resource": ""
} |
q173930 | String | validation | func (r Rectangle) String() string {
return fmt.Sprintf("(Min:%v,Max:%v)", r.Min, r.Max)
} | go | {
"resource": ""
} |
q173931 | Dx | validation | func (r Rectangle) Dx() float64 {
return r.Max.X - r.Min.X
} | go | {
"resource": ""
} |
q173932 | Dy | validation | func (r Rectangle) Dy() float64 {
return r.Max.Y - r.Min.Y
} | go | {
"resource": ""
} |
q173933 | In | validation | func (r Rectangle) In(s Rectangle) bool {
if r.Empty() {
return true
}
// Note that r.Max is an exclusive bound for r, so that r.In(s)
// does not require that r.Max.In(s).
return s.Min[0] <= r.Min[0] && r.Max[0] <= s.Max[0] &&
s.Min[1] <= r.Min[1] && r.Max[1] <= s.Max[1]
} | go | {
"resource": ""
} |
q173934 | Approx | validation | func Approx(x, y float64) bool {
eps := epsilon64 * 100
return math.Abs(x-y) < eps*(1.0+math.Max(math.Abs(x), math.Abs(y)))
} | go | {
"resource": ""
} |
q173935 | ApproxEpsilon | validation | func ApproxEpsilon(x, y float64, eps float64) bool {
return math.Abs(x-y) < eps*(1.0+math.Max(math.Abs(x), math.Abs(y)))
} | go | {
"resource": ""
} |
q173936 | SetXYZ | validation | func (v Vec3) SetXYZ(x, y, z float32) {
v[0] = x
v[1] = y
v[2] = z
} | go | {
"resource": ""
} |
q173937 | Vec3Dist2DSqr | validation | func Vec3Dist2DSqr(v1, v2 Vec3) float32 {
dx := v1[0] - v2[0]
dz := v1[2] - v2[2]
return dx*dx + dz*dz
} | go | {
"resource": ""
} |
q173938 | Copy | validation | func (v Vec3) Copy(dst Vec3) {
dst[0] = v[0]
dst[1] = v[1]
dst[2] = v[2]
} | go | {
"resource": ""
} |
q173939 | Assign | validation | func (v Vec3) Assign(v1 Vec3) {
v[0] = v1[0]
v[1] = v1[1]
v[2] = v1[2]
} | go | {
"resource": ""
} |
q173940 | Dist2D | validation | func (v Vec3) Dist2D(v1 Vec3) float32 {
dx := v1[0] - v[0]
dz := v1[2] - v[2]
return math32.Sqrt(dx*dx + dz*dz)
} | go | {
"resource": ""
} |
q173941 | Dist2DSqr | validation | func (v Vec3) Dist2DSqr(v1 Vec3) float32 {
dx := v1[0] - v[0]
dz := v1[2] - v[2]
return dx*dx + dz*dz
} | go | {
"resource": ""
} |
q173942 | Cross | validation | func (v Vec3) Cross(v1 Vec3) Vec3 {
return Vec3{
v[1]*v1[2] - v[2]*v1[1],
v[2]*v1[0] - v[0]*v1[2],
v[0]*v1[1] - v[1]*v1[0],
}
} | go | {
"resource": ""
} |
q173943 | Dot2D | validation | func (v Vec3) Dot2D(u Vec3) float32 {
return v[0]*u[0] + v[2]*u[2]
} | go | {
"resource": ""
} |
q173944 | NewRay | validation | func NewRay(o, v Vec) Ray {
//v = v.Normalize()
return Ray{
o: o,
v: v,
invv: Vec{1.0 / v.X, 1.0 / v.Y},
}
} | go | {
"resource": ""
} |
q173945 | IntersectRect | validation | func (r Ray) IntersectRect(b Rectangle) bool {
t1 := (b.Min.X - r.o.X) * r.invv.X
t2 := (b.Max.X - r.o.X) * r.invv.X
tmin := math.Min(t1, t2)
tmax := math.Max(t1, t2)
// x
t1 = (b.Min.X - r.o.X) * r.invv.X
t2 = (b.Max.X - r.o.X) * r.invv.X
tmin = math.Max(tmin, math.Min(t1, t2))
tmax = math.Min(tmax, math.Ma... | go | {
"resource": ""
} |
q173946 | SupportedFunc | validation | func SupportedFunc(opts *ServerOptions) func(*Request) error {
subjectMap := map[SubjectType]bool{}
for _, subjectType := range opts.SubjectTypes {
subjectMap[subjectType] = true
}
identityMap := map[string]bool{}
for _, identity := range opts.Identities {
identityMap[string(identity.Type)+string(identity.Form... | go | {
"resource": ""
} |
q173947 | NewSigner | validation | func NewSigner(opts *KeyOptions) (Signer, error) {
privateKey := opts.KeyBytes
if opts.KeyPath != "" {
raw, err := ioutil.ReadFile(opts.KeyPath)
if err != nil {
return nil, err
}
privateKey = raw
}
block, _ := pem.Decode(privateKey)
blockBytes := block.Bytes
// Decode the PEM key if a password is set
... | go | {
"resource": ""
} |
q173948 | NewVerifier | validation | func NewVerifier(opts *KeyOptions) (Verifier, error) {
publicKey := opts.KeyBytes
if opts.KeyPath != "" {
raw, err := ioutil.ReadFile(opts.KeyPath)
if err != nil {
return nil, err
}
publicKey = raw
}
block, _ := pem.Decode(publicKey)
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
ret... | go | {
"resource": ""
} |
q173949 | Request | validation | func (c *Client) Request(req *Request) (*Response, error) {
buf := bytes.NewBuffer(nil)
err := json.NewEncoder(buf).Encode(req)
if err != nil {
return nil, err
}
reqResp := &Response{}
resp, err := c.caller.Call("POST", c.endpoint+"/opengdpr_requests", buf)
return reqResp, c.json(resp, err, true, reqResp)
} | go | {
"resource": ""
} |
q173950 | Status | validation | func (c *Client) Status(id string) (*StatusResponse, error) {
statResp := &StatusResponse{}
resp, err := c.caller.Call("GET", c.endpoint+"/opengdpr_requests/"+id, nil)
return statResp, c.json(resp, err, true, statResp)
} | go | {
"resource": ""
} |
q173951 | Cancel | validation | func (c *Client) Cancel(id string) (*CancellationResponse, error) {
cancelResp := &CancellationResponse{}
resp, err := c.caller.Call("DELETE", c.endpoint+"/opengdpr_requests/"+id, nil)
return cancelResp, c.json(resp, err, true, cancelResp)
} | go | {
"resource": ""
} |
q173952 | Discovery | validation | func (c *Client) Discovery() (*DiscoveryResponse, error) {
discResp := &DiscoveryResponse{}
resp, err := c.caller.Call("GET", c.endpoint+"/discovery", nil)
return discResp, c.json(resp, err, false, discResp)
} | go | {
"resource": ""
} |
q173953 | NewClient | validation | func NewClient(opts *ClientOptions) *Client {
cli := opts.Client
if cli == nil {
cli = http.DefaultClient
}
client := &Client{
caller: &defaultCaller{
client: cli,
headers: map[string]string{
"GDPR-Version": ApiVersion,
"Content-Type": "Application/JSON",
},
},
endpoint: opts.Endpoint,
ve... | go | {
"resource": ""
} |
q173954 | Push | validation | func (s *VecStack) Push(value *Vec) {
s.top = &item{value, s.top}
s.size++
} | go | {
"resource": ""
} |
q173955 | Pop | validation | func (s *VecStack) Pop() (value *Vec) {
if s.size > 0 {
value, s.top = s.top.value, s.top.next
s.size--
return
}
return nil
} | go | {
"resource": ""
} |
q173956 | PopLast | validation | func (s *VecStack) PopLast() (value *Vec) {
if lastElem := s.popLast(s.top); s.size >= 2 && lastElem != nil {
return lastElem.value
}
return nil
} | go | {
"resource": ""
} |
q173957 | Peek | validation | func (s *VecStack) Peek() (value *Vec, exists bool) {
exists = false
if s.size > 0 {
value = s.top.value
exists = true
}
return
} | go | {
"resource": ""
} |
q173958 | PeekN | validation | func (s *VecStack) PeekN(n int) []*Vec {
var (
N []*Vec
cur *item
)
N = make([]*Vec, 0, n)
cur = s.top
for len(N) < n {
if cur == nil {
break
}
N = append(N, cur.value)
cur = cur.next
}
return N
} | go | {
"resource": ""
} |
q173959 | Vecf32 | validation | func Vecf32(x, y float32) Vec {
return Vec{float64(x), float64(y)}
} | go | {
"resource": ""
} |
q173960 | Veci | validation | func Veci(x, y int) Vec {
return Vec{float64(x), float64(y)}
} | go | {
"resource": ""
} |
q173961 | Add | validation | func (v Vec) Add(v2 Vec) Vec {
return Vec{v.X + v2.X, v.Y + v2.Y}
} | go | {
"resource": ""
} |
q173962 | Sub | validation | func (v Vec) Sub(v2 Vec) Vec {
return Vec{v.X - v2.X, v.Y - v2.Y}
} | go | {
"resource": ""
} |
q173963 | In | validation | func (v Vec) In(r Rectangle) bool {
return r.Min.X <= v.X && v.X < r.Max.X &&
r.Min.Y <= v.Y && v.Y < r.Max.Y
} | go | {
"resource": ""
} |
q173964 | Len | validation | func (v Vec) Len() float64 {
return float64(math.Hypot(float64(v.X), float64(v.Y)))
} | go | {
"resource": ""
} |
q173965 | ApproxFuncEqual | validation | func (v Vec) ApproxFuncEqual(v2 Vec, eq func(float64, float64) bool) bool {
if !eq(v.X, v2.X) {
return false
}
if !eq(v.Y, v2.Y) {
return false
}
return true
} | go | {
"resource": ""
} |
q173966 | Merge | validation | func (hm HandlerMap) Merge(other HandlerMap) {
for key, methods := range other {
if _, ok := hm[key]; !ok {
hm[key] = map[string]Builder{}
}
for method, builder := range methods {
hm[key][method] = builder
}
}
} | go | {
"resource": ""
} |
q173967 | respCode | validation | func (s *Server) respCode(r *http.Request) int {
if r.URL.Path == "/opengdpr_requests" && r.Method == "POST" {
return http.StatusCreated
}
return http.StatusOK
} | go | {
"resource": ""
} |
q173968 | NewServer | validation | func NewServer(opts *ServerOptions) *Server {
server := &Server{
signer: opts.Signer,
verifier: opts.Verifier,
isProcessor: hasProcessor(opts),
isController: hasController(opts),
headers: http.Header{},
processorDomain: opts.ProcessorDomain,
}
server.headers.Set("Accept", "... | go | {
"resource": ""
} |
q173969 | Callback | validation | func Callback(cbReq *CallbackRequest, opts *CallbackOptions) error {
client := opts.Client
if client == nil {
client = http.DefaultClient
}
buf := bytes.NewBuffer(nil)
err := json.NewEncoder(buf).Encode(cbReq)
if err != nil {
return err
}
signature, err := opts.Signer.Sign(buf.Bytes())
if err != nil {
re... | go | {
"resource": ""
} |
q173970 | ErrNotFound | validation | func ErrNotFound(id string) error {
return ErrorResponse{
Code: http.StatusNotFound,
Message: fmt.Sprintf("request %s not found", id),
}
} | go | {
"resource": ""
} |
q173971 | ErrUnsupportedRequestType | validation | func ErrUnsupportedRequestType(st SubjectType) error {
return ErrorResponse{
Code: http.StatusNotImplemented,
Message: fmt.Sprintf("unsupported request type: %s", st),
}
} | go | {
"resource": ""
} |
q173972 | ErrUnsupportedIdentity | validation | func ErrUnsupportedIdentity(id Identity) error {
return ErrorResponse{
Code: http.StatusNotImplemented,
Message: fmt.Sprintf("unsupported identity: %s/%s", id.Type, id.Format),
}
} | go | {
"resource": ""
} |
q173973 | ErrMissingRequiredField | validation | func ErrMissingRequiredField(field string) error {
return ErrorResponse{
Code: http.StatusBadRequest,
Message: fmt.Sprintf("missing required field: %s", field),
}
} | go | {
"resource": ""
} |
q173974 | ErrInvalidRequestSignature | validation | func ErrInvalidRequestSignature(signature string, err error) error {
return ErrorResponse{
Code: http.StatusForbidden,
Message: fmt.Sprintf("could not validate request signature: %s", signature),
Errors: []Error{Error{Message: err.Error()}},
}
} | go | {
"resource": ""
} |
q173975 | DatabaseServers | validation | func (c *Client) DatabaseServers() ([]DatabaseServer, error) {
var dbs []DatabaseServer
_, err := c.MakeApiRequest("GET", "/1.0/database_servers", nil, &dbs)
if err != nil {
return nil, err
}
return dbs, err
} | go | {
"resource": ""
} |
q173976 | SnapshotDatabaseServer | validation | func (c *Client) SnapshotDatabaseServer(identifier string) (*DatabaseSnapshot, error) {
dbs := new(DatabaseServer)
res, err := c.MakeApiRequest("POST", "/1.0/database_servers/"+identifier+"/snapshot", nil, &dbs)
if err != nil {
return nil, err
}
snapID := getLinkRel(res.Header.Get("Link"), "dbi", "snapshot")
if... | go | {
"resource": ""
} |
q173977 | ResetPasswordForDatabaseServer | validation | func (c *Client) ResetPasswordForDatabaseServer(identifier string) (*DatabaseServer, error) {
dbs := new(DatabaseServer)
_, err := c.MakeApiRequest("POST", "/1.0/database_servers/"+identifier+"/reset_password", nil, &dbs)
if err != nil {
return nil, err
}
return dbs, nil
} | go | {
"resource": ""
} |
q173978 | Servers | validation | func (c *Client) Servers() ([]Server, error) {
var servers []Server
_, err := c.MakeApiRequest("GET", "/1.0/servers", nil, &servers)
if err != nil {
return nil, err
}
return servers, err
} | go | {
"resource": ""
} |
q173979 | Server | validation | func (c *Client) Server(identifier string) (*Server, error) {
server := new(Server)
_, err := c.MakeApiRequest("GET", "/1.0/servers/"+identifier, nil, server)
if err != nil {
return nil, err
}
return server, err
} | go | {
"resource": ""
} |
q173980 | DestroyServer | validation | func (c *Client) DestroyServer(identifier string) error {
_, err := c.MakeApiRequest("DELETE", "/1.0/servers/"+identifier, nil, nil)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q173981 | LockServer | validation | func (c *Client) LockServer(identifier string) error {
return c.LockResource(Server{Id: identifier})
} | go | {
"resource": ""
} |
q173982 | UnlockServer | validation | func (c *Client) UnlockServer(identifier string) error {
return c.UnLockResource(Server{Id: identifier})
} | go | {
"resource": ""
} |
q173983 | SnapshotServer | validation | func (c *Client) SnapshotServer(identifier string) (*Image, error) {
res, err := c.MakeApiRequest("POST", "/1.0/servers/"+identifier+"/snapshot", nil, nil)
if err != nil {
return nil, err
}
imageID := getLinkRel(res.Header.Get("Link"), "img", "snapshot")
if imageID != nil {
img := new(Image)
img.Id = *imageI... | go | {
"resource": ""
} |
q173984 | FullConsoleUrl | validation | func (s *Server) FullConsoleUrl() string {
if s.ConsoleUrl == "" || s.ConsoleToken == "" {
return s.ConsoleUrl
}
u, err := url.Parse(s.ConsoleUrl)
if u == nil || err != nil {
return s.ConsoleUrl
}
values := u.Query()
if values.Get("password") != "" {
return s.ConsoleUrl
}
values.Set("password", s.Console... | go | {
"resource": ""
} |
q173985 | FirewallRule | validation | func (c *Client) FirewallRule(identifier string) (*FirewallRule, error) {
rule := new(FirewallRule)
_, err := c.MakeApiRequest("GET", "/1.0/firewall_rules/"+identifier, nil, rule)
if err != nil {
return nil, err
}
return rule, err
} | go | {
"resource": ""
} |
q173986 | ServerGroups | validation | func (c *Client) ServerGroups() ([]ServerGroup, error) {
var groups []ServerGroup
_, err := c.MakeApiRequest("GET", "/1.0/server_groups", nil, &groups)
if err != nil {
return nil, err
}
return groups, err
} | go | {
"resource": ""
} |
q173987 | ServerGroup | validation | func (c *Client) ServerGroup(identifier string) (*ServerGroup, error) {
group := new(ServerGroup)
_, err := c.MakeApiRequest("GET", "/1.0/server_groups/"+identifier, nil, group)
if err != nil {
return nil, err
}
return group, err
} | go | {
"resource": ""
} |
q173988 | AddServersToServerGroup | validation | func (c *Client) AddServersToServerGroup(identifier string, serverIds []string) (*ServerGroup, error) {
group := new(ServerGroup)
opts := new(serverGroupMemberOptions)
for _, id := range serverIds {
opts.Servers = append(opts.Servers, serverGroupMember{Server: id})
}
_, err := c.MakeApiRequest("POST", "/1.0/serv... | go | {
"resource": ""
} |
q173989 | MoveServersToServerGroup | validation | func (c *Client) MoveServersToServerGroup(src string, dst string, serverIds []string) (*ServerGroup, error) {
group := new(ServerGroup)
opts := serverGroupMemberOptions{Destination: dst}
for _, id := range serverIds {
opts.Servers = append(opts.Servers, serverGroupMember{Server: id})
}
_, err := c.MakeApiRequest... | go | {
"resource": ""
} |
q173990 | LoadBalancers | validation | func (c *Client) LoadBalancers() ([]LoadBalancer, error) {
var lbs []LoadBalancer
_, err := c.MakeApiRequest("GET", "/1.0/load_balancers", nil, &lbs)
if err != nil {
return nil, err
}
return lbs, err
} | go | {
"resource": ""
} |
q173991 | LoadBalancer | validation | func (c *Client) LoadBalancer(identifier string) (*LoadBalancer, error) {
lb := new(LoadBalancer)
_, err := c.MakeApiRequest("GET", "/1.0/load_balancers/"+identifier, nil, lb)
if err != nil {
return nil, err
}
return lb, err
} | go | {
"resource": ""
} |
q173992 | AddNodesToLoadBalancer | validation | func (c *Client) AddNodesToLoadBalancer(loadBalancerID string, nodes []LoadBalancerNode) (*LoadBalancer, error) {
lb := new(LoadBalancer)
_, err := c.MakeApiRequest("POST", "/1.0/load_balancers/"+loadBalancerID+"/add_nodes", nodes, &lb)
if err != nil {
return nil, err
}
return lb, nil
} | go | {
"resource": ""
} |
q173993 | RemoveListenersFromLoadBalancer | validation | func (c *Client) RemoveListenersFromLoadBalancer(loadBalancerID string, listeners []LoadBalancerListener) (*LoadBalancer, error) {
lb := new(LoadBalancer)
_, err := c.MakeApiRequest("POST", "/1.0/load_balancers/"+loadBalancerID+"/remove_listeners", listeners, &lb)
if err != nil {
return nil, err
}
return lb, nil... | go | {
"resource": ""
} |
q173994 | LockResource | validation | func (c *Client) LockResource(resource interface{}) error {
rpath, err := resourcePath(resource)
if err != nil {
return err
}
_, err = c.MakeApiRequest("PUT", fmt.Sprintf("/1.0/%s/lock_resource", rpath), nil, nil)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q173995 | FirewallPolicies | validation | func (c *Client) FirewallPolicies() ([]FirewallPolicy, error) {
var policies []FirewallPolicy
_, err := c.MakeApiRequest("GET", "/1.0/firewall_policies", nil, &policies)
if err != nil {
return nil, err
}
return policies, err
} | go | {
"resource": ""
} |
q173996 | FirewallPolicy | validation | func (c *Client) FirewallPolicy(identifier string) (*FirewallPolicy, error) {
policy := new(FirewallPolicy)
_, err := c.MakeApiRequest("GET", "/1.0/firewall_policies/"+identifier, nil, policy)
if err != nil {
return nil, err
}
return policy, err
} | go | {
"resource": ""
} |
q173997 | ApplyFirewallPolicy | validation | func (c *Client) ApplyFirewallPolicy(policyId string, serverGroupId string) (*FirewallPolicy, error) {
policy := new(FirewallPolicy)
_, err := c.MakeApiRequest("POST", "/1.0/firewall_policies/"+policyId+"/apply_to",
map[string]string{"server_group": serverGroupId}, &policy)
if err != nil {
return nil, err
}
re... | go | {
"resource": ""
} |
q173998 | Extract | validation | func (r GetAuthResult) Extract() (*AuthResult, error) {
var s *AuthResult
err := r.ExtractInto(&s)
return s, err
} | go | {
"resource": ""
} |
q173999 | ApiClients | validation | func (c *Client) ApiClients() ([]ApiClient, error) {
var apiClients []ApiClient
_, err := c.MakeApiRequest("GET", "/1.0/api_clients", nil, &apiClients)
if err != nil {
return nil, err
}
return apiClients, err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.