id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c173900 | 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))
} | |
c173901 | io.Reader {
return &throttledReader{
ctx: ctx,
wrapped: r,
throttle: throttle,
}
} | |
c173902 | {
b = &throttledBucket{
opThrottle: opThrottle,
egressThrottle: egressThrottle,
wrapped: wrapped,
}
return
} | |
c173903 | return nil, errors.Errorf("cmdName cannot contain whitespace: %q", cmdName)
}
}
return &CmdWithRunner{
cmdName: cmdName,
runner: runner,
}, nil
} | |
c173904 | runner)
if err != nil {
panic(err)
}
return cmdWithRunner
} | |
c173905 | // if group has changed, add path to the output
output = append(output, importPath(gen.Specs[srcIndex]))
}
}
}
// assume that only one import token block exists
break
}
}
return output
} | |
c173906 | }
return CmderWithPrependedArgs(selfCmder, proxyCmd(cmd).Name()), nil
}
} | |
c173907 |
return nil, err
}
return CmderWithPrependedArgs(r, argsFunc(cmd)...), nil
}
} | |
c173908 | path for current executable")
}
return PathCmder(pathToSelf), nil
} | |
c173909 | r,
prependedArgs: prependedArgs,
}
} | |
c173910 |
c4.befores = make([]Before, 0)
c4.roots = make(map[string]*rootNode)
c4.HandleMethodNotAllowed = true
return c4
} | |
c173911 | c4.handleAfterMiddlewares(handler, w, req, params)
c4.timer.Get(route).Accumulate(started, beforeEnd, after, time.Now())
} else {
c4.handleAfterMiddlewares(handler, w, req, params)
}
return
}
}
c4.Router.handleMissing(w, req)
}), w, req)
} | |
c173912 | append(c4.befores, middleware...)
} | |
c173913 | append(c4.afters, middleware...)
} | |
c173914 | c4.timer != nil {
return c4.timer
}
timer = NewTimer()
}
c4.timer = timer
return c4.timer
} | |
c173915 | = make(map[string]*rootNode)
r.HandleMethodNotAllowed = true
return r
} | |
c173916 | handler.ServeHTTP(w, req, params)
//log.Println(time.Now().Sub(now))
return
}
}
r.handleMissing(w, req)
} | |
c173917 | := NewGroupRouter(r, path)
fn(gr)
} | |
c173918 | == nn.path {
// same node
return c
}
}
return nil
} | |
c173919 | name must be same for")
}
return n.paramChild
}
if nn.paramNode {
n.paramChild = nn
} else {
n.children = append(n.children, nn)
}
return nn
} | |
c173920 | if c, exist := t.routes[name]; exist {
return c
}
t.routes[name] = &Counter{}
t.routes[name].Min = 1<<63 - 1
return t.routes[name]
} | |
c173921 | v.Count)
stat.AvgAfter = time.Duration(int64(v.AfterTot) / v.Count)
stat.AvgBefore = time.Duration(int64(v.BeforeTot) / v.Count)
stat.Max = v.Max
stat.Min = v.Min
stats.Result = append(stats.Result, stat)
}
sort.Sort(sort.Reverse(stats))
jsonData, _ := json.Marshal(stats)
w.Write(jsonData)
} | |
c173922 | p r2router.Params) {
w.Write([]byte( p.Get("name")))
})
http.ListenAndServe("127.0.0.1:8080", router)
} | |
c173923 | gr := &GroupRouter{}
gr.router = r
gr.path = strings.TrimRight(path, "/")
return gr
} | |
c173924 | p r2router.Params) {
p.AppSet("say", "Hello")
next(w, r, p)
}
} | |
c173925 | http.ResponseWriter, r *http.Request, _ r2router.Params) {
next(w, r)
}
} | |
c173926 | c[1]-r, c[2]-r, 2*r, 2*r, 2*r)
} | |
c173927 | r1.Max.Assign(r.Max)
return r1
} | |
c173928 | r.Max[0] - r.Min[0],
r.Max[1] - r.Min[1],
r.Max[2] - r.Min[2],
}
} | |
c173929 | r.Min[1] < s.Max[1] && s.Min[1] < r.Max[1] &&
r.Min[2] < s.Max[2] && s.Min[2] < r.Max[2]
} | |
c173930 | fmt.Sprintf("(Min:%v,Max:%v)", r.Min, r.Max)
} | |
c173931 | {
return r.Max.X - r.Min.X
} | |
c173932 | {
return r.Max.Y - r.Min.Y
} | |
c173933 | 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]
} | |
c173934 | math.Abs(x-y) < eps*(1.0+math.Max(math.Abs(x), math.Abs(y)))
} | |
c173935 | < eps*(1.0+math.Max(math.Abs(x), math.Abs(y)))
} | |
c173936 | = x
v[1] = y
v[2] = z
} | |
c173937 | dx := v1[0] - v2[0]
dz := v1[2] - v2[2]
return dx*dx + dz*dz
} | |
c173938 |
dst[1] = v[1]
dst[2] = v[2]
} | |
c173939 |
v[1] = v1[1]
v[2] = v1[2]
} | |
c173940 |
return math32.Sqrt(dx*dx + dz*dz)
} | |
c173941 | v1[2] - v[2]
return dx*dx + dz*dz
} | |
c173942 | v[2]*v1[0] - v[0]*v1[2],
v[0]*v1[1] - v[1]*v1[0],
}
} | |
c173943 | v[0]*u[0] + v[2]*u[2]
} | |
c173944 | invv: Vec{1.0 / v.X, 1.0 / v.Y},
}
} | |
c173945 | = (b.Max.X - r.o.X) * r.invv.X
tmin = math.Max(tmin, math.Min(t1, t2))
tmax = math.Min(tmax, math.Max(t1, t2))
// y
t1 = (b.Min.Y - r.o.Y) * r.invv.Y
t2 = (b.Max.Y - r.o.Y) * r.invv.Y
tmin = math.Max(tmin, math.Min(t1, t2))
tmax = math.Min(tmax, math.Max(t1, t2))
return tmax >= math.Max(tmin, 0.0)
} | |
c173946 | {
return ErrUnsupportedRequestType(req.SubjectRequestType)
}
for _, identity := range req.SubjectIdentities {
if _, ok := identityMap[string(identity.Type)+string(identity.Format)]; !ok {
return ErrUnsupportedIdentity(identity)
}
}
return nil
}
} | |
c173947 | blockBytes = b
}
parsed, err := x509.ParsePKCS8PrivateKey(blockBytes)
if err != nil {
return nil, err
}
privKey, ok := parsed.(*rsa.PrivateKey)
if !ok {
return nil, fmt.Errorf("unsupported private key")
}
return &rsaSigner{privKey: privKey}, nil
} | |
c173948 | cert.PublicKeyAlgorithm != x509.RSA {
return nil, fmt.Errorf("unsupported public key type")
}
return &rsaVerifier{publicKey: cert.PublicKey.(*rsa.PublicKey), cert: cert}, nil
} | |
c173949 | resp, err := c.caller.Call("POST", c.endpoint+"/opengdpr_requests", buf)
return reqResp, c.json(resp, err, true, reqResp)
} | |
c173950 | c.caller.Call("GET", c.endpoint+"/opengdpr_requests/"+id, nil)
return statResp, c.json(resp, err, true, statResp)
} | |
c173951 | c.caller.Call("DELETE", c.endpoint+"/opengdpr_requests/"+id, nil)
return cancelResp, c.json(resp, err, true, cancelResp)
} | |
c173952 | c.caller.Call("GET", c.endpoint+"/discovery", nil)
return discResp, c.json(resp, err, false, discResp)
} | |
c173953 | "Content-Type": "Application/JSON",
},
},
endpoint: opts.Endpoint,
verifier: opts.Verifier,
}
return client
} | |
c173954 | &item{value, s.top}
s.size++
} | |
c173955 | {
value, s.top = s.top.value, s.top.next
s.size--
return
}
return nil
} | |
c173956 | lastElem != nil {
return lastElem.value
}
return nil
} | |
c173957 |
value = s.top.value
exists = true
}
return
} | |
c173958 | {
break
}
N = append(N, cur.value)
cur = cur.next
}
return N
} | |
c173959 | {
return Vec{float64(x), float64(y)}
} | |
c173960 | Vec{float64(x), float64(y)}
} | |
c173961 | + v2.X, v.Y + v2.Y}
} | |
c173962 | - v2.X, v.Y - v2.Y}
} | |
c173963 | <= v.X && v.X < r.Max.X &&
r.Min.Y <= v.Y && v.Y < r.Max.Y
} | |
c173964 | float64(math.Hypot(float64(v.X), float64(v.Y)))
} | |
c173965 | return false
}
if !eq(v.Y, v2.Y) {
return false
}
return true
} | |
c173966 | hm[key]; !ok {
hm[key] = map[string]Builder{}
}
for method, builder := range methods {
hm[key][method] = builder
}
}
} | |
c173967 | "/opengdpr_requests" && r.Method == "POST" {
return http.StatusCreated
}
return http.StatusOK
} | |
c173968 |
hm := buildHandlerMap(opts)
for path, methods := range hm {
for method, builder := range methods {
router.Handle(method, path, server.handle(builder(opts)))
}
}
server.handlerFn = router.ServeHTTP
return server
} | |
c173969 | http.NewRequest("POST", cbReq.StatusCallbackUrl, buf)
if err != nil {
return err
}
req.Header.Set("X-OpenGDPR-Processor-Domain", opts.ProcessorDomain)
req.Header.Set("X-OpenGDPR-Signature", signature)
// Attempt to make callback
for i := 0; i < opts.MaxAttempts; i++ {
resp, err := client.Do(req)
if err != nil || resp.StatusCode != 200 {
time.Sleep(opts.Backoff)
continue
}
// Success
return nil
}
return fmt.Errorf("callback timed out for %s", cbReq.StatusCallbackUrl)
} | |
c173970 | Message: fmt.Sprintf("request %s not found", id),
}
} | |
c173971 | Message: fmt.Sprintf("unsupported request type: %s", st),
}
} | |
c173972 | http.StatusNotImplemented,
Message: fmt.Sprintf("unsupported identity: %s/%s", id.Type, id.Format),
}
} | |
c173973 | Message: fmt.Sprintf("missing required field: %s", field),
}
} | |
c173974 | http.StatusForbidden,
Message: fmt.Sprintf("could not validate request signature: %s", signature),
Errors: []Error{Error{Message: err.Error()}},
}
} | |
c173975 | c.MakeApiRequest("GET", "/1.0/database_servers", nil, &dbs)
if err != nil {
return nil, err
}
return dbs, err
} | |
c173976 | getLinkRel(res.Header.Get("Link"), "dbi", "snapshot")
if snapID != nil {
snap := new(DatabaseSnapshot)
snap.Id = *snapID
return snap, nil
}
return nil, nil
} | |
c173977 | c.MakeApiRequest("POST", "/1.0/database_servers/"+identifier+"/reset_password", nil, &dbs)
if err != nil {
return nil, err
}
return dbs, nil
} | |
c173978 |
if err != nil {
return nil, err
}
return servers, err
} | |
c173979 | nil, server)
if err != nil {
return nil, err
}
return server, err
} | |
c173980 | "/1.0/servers/"+identifier, nil, nil)
if err != nil {
return err
}
return nil
} | |
c173981 | c.LockResource(Server{Id: identifier})
} | |
c173982 | c.UnLockResource(Server{Id: identifier})
} | |
c173983 | getLinkRel(res.Header.Get("Link"), "img", "snapshot")
if imageID != nil {
img := new(Image)
img.Id = *imageID
return img, nil
}
return nil, nil
} | |
c173984 | := u.Query()
if values.Get("password") != "" {
return s.ConsoleUrl
}
values.Set("password", s.ConsoleToken)
u.RawQuery = values.Encode()
return u.String()
} | |
c173985 | c.MakeApiRequest("GET", "/1.0/firewall_rules/"+identifier, nil, rule)
if err != nil {
return nil, err
}
return rule, err
} | |
c173986 | nil, &groups)
if err != nil {
return nil, err
}
return groups, err
} | |
c173987 | c.MakeApiRequest("GET", "/1.0/server_groups/"+identifier, nil, group)
if err != nil {
return nil, err
}
return group, err
} | |
c173988 | := c.MakeApiRequest("POST", "/1.0/server_groups/"+identifier+"/add_servers", opts, &group)
if err != nil {
return nil, err
}
return group, nil
} | |
c173989 |
_, err := c.MakeApiRequest("POST", "/1.0/server_groups/"+src+"/move_servers", opts, &group)
if err != nil {
return nil, err
}
return group, nil
} | |
c173990 | "/1.0/load_balancers", nil, &lbs)
if err != nil {
return nil, err
}
return lbs, err
} | |
c173991 | c.MakeApiRequest("GET", "/1.0/load_balancers/"+identifier, nil, lb)
if err != nil {
return nil, err
}
return lb, err
} | |
c173992 | := new(LoadBalancer)
_, err := c.MakeApiRequest("POST", "/1.0/load_balancers/"+loadBalancerID+"/add_nodes", nodes, &lb)
if err != nil {
return nil, err
}
return lb, nil
} | |
c173993 | c.MakeApiRequest("POST", "/1.0/load_balancers/"+loadBalancerID+"/remove_listeners", listeners, &lb)
if err != nil {
return nil, err
}
return lb, nil
} | |
c173994 | _, err = c.MakeApiRequest("PUT", fmt.Sprintf("/1.0/%s/lock_resource", rpath), nil, nil)
if err != nil {
return err
}
return nil
} | |
c173995 |
_, err := c.MakeApiRequest("GET", "/1.0/firewall_policies", nil, &policies)
if err != nil {
return nil, err
}
return policies, err
} | |
c173996 | c.MakeApiRequest("GET", "/1.0/firewall_policies/"+identifier, nil, policy)
if err != nil {
return nil, err
}
return policy, err
} | |
c173997 |
map[string]string{"server_group": serverGroupId}, &policy)
if err != nil {
return nil, err
}
return policy, nil
} | |
c173998 | error) {
var s *AuthResult
err := r.ExtractInto(&s)
return s, err
} | |
c173999 | &apiClients)
if err != nil {
return nil, err
}
return apiClients, err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.