_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q181200 | ReleaseIPBlock | test | func (c *Client) ReleaseIPBlock(ipblockid string) (*http.Header, error) {
url := ipblockPath(ipblockid)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181201 | ListVolumes | test | func (c *Client) ListVolumes(dcid string) (*Volumes, error) {
url := volumeColPath(dcid) + `?depth=` + c.client.depth
ret := &Volumes{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181202 | GetVolume | test | func (c *Client) GetVolume(dcid string, volumeID string) (*Volume, error) {
url := volumePath(dcid, volumeID) + `?depth=` + c.client.depth
ret := &Volume{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181203 | UpdateVolume | test | func (c *Client) UpdateVolume(dcid string, volid string, request VolumeProperties) (*Volume, error) {
url := volumePath(dcid, volid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Volume{}
err := c.client.Patch(url, request, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181204 | CreateVolume | test | func (c *Client) CreateVolume(dcid string, request Volume) (*Volume, error) {
url := volumeColPath(dcid) + `?depth=` + c.client.depth
ret := &Volume{}
err := c.client.Post(url, request, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181205 | DeleteVolume | test | func (c *Client) DeleteVolume(dcid, volid string) (*http.Header, error) {
url := volumePath(dcid, volid)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181206 | CreateSnapshot | test | func (c *Client) CreateSnapshot(dcid string, volid string, name string, description string) (*Snapshot, error) {
path := volumePath(dcid, volid) + "/create-snapshot"
data := url.Values{}
data.Set("name", name)
data.Add("description", description)
ret := &Snapshot{}
err := c.client.Post(path, data, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181207 | RestoreSnapshot | test | func (c *Client) RestoreSnapshot(dcid string, volid string, snapshotID string) (*http.Header, error) {
path := volumePath(dcid, volid) + "/restore-snapshot"
data := url.Values{}
data.Set("snapshotId", snapshotID)
ret := &http.Header{}
err := c.client.Post(path, data, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181208 | ListServers | test | func (c *Client) ListServers(dcid string) (*Servers, error) {
url := serverColPath(dcid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Servers{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181209 | GetServer | test | func (c *Client) GetServer(dcid, srvid string) (*Server, error) {
url := serverPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Server{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181210 | DeleteServer | test | func (c *Client) DeleteServer(dcid, srvid string) (*http.Header, error) {
ret := &http.Header{}
err := c.client.Delete(serverPath(dcid, srvid), ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181211 | ListAttachedCdroms | test | func (c *Client) ListAttachedCdroms(dcid, srvid string) (*Images, error) {
url := serverCdromColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Images{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181212 | AttachCdrom | test | func (c *Client) AttachCdrom(dcid string, srvid string, cdid string) (*Image, error) {
data := struct {
ID string `json:"id,omitempty"`
}{
cdid,
}
url := serverCdromColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Image{}
err := c.client.Post(url, data, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181213 | GetAttachedCdrom | test | func (c *Client) GetAttachedCdrom(dcid, srvid, cdid string) (*Image, error) {
url := serverCdromPath(dcid, srvid, cdid) // + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Image{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181214 | DetachCdrom | test | func (c *Client) DetachCdrom(dcid, srvid, cdid string) (*http.Header, error) {
url := serverCdromPath(dcid, srvid, cdid) + `?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": ""
} |
q181215 | ListAttachedVolumes | test | func (c *Client) ListAttachedVolumes(dcid, srvid string) (*Volumes, error) {
url := serverVolumeColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Volumes{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181216 | AttachVolume | test | func (c *Client) AttachVolume(dcid string, srvid string, volid string) (*Volume, error) {
data := struct {
ID string `json:"id,omitempty"`
}{
volid,
}
url := serverVolumeColPath(dcid, srvid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Volume{}
err := c.client.Post(url, data, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181217 | GetAttachedVolume | test | func (c *Client) GetAttachedVolume(dcid, srvid, volid string) (*Volume, error) {
url := serverVolumePath(dcid, srvid, volid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Volume{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181218 | DetachVolume | test | func (c *Client) DetachVolume(dcid, srvid, volid string) (*http.Header, error) {
url := serverVolumePath(dcid, srvid, volid)
ret := &http.Header{}
err := c.client.Delete(url, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181219 | StartServer | test | func (c *Client) StartServer(dcid, srvid string) (*http.Header, error) {
url := serverPath(dcid, srvid) + "/start"
ret := &http.Header{}
err := c.client.Post(url, nil, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181220 | ListLocations | test | func (c *Client) ListLocations() (*Locations, error) {
url := locationColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Locations{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181221 | GetRegionalLocations | test | func (c *Client) GetRegionalLocations(regid string) (*Locations, error) {
url := locationRegPath(regid) + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Locations{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181222 | GetLocation | test | func (c *Client) GetLocation(locid string) (*Location, error) {
url := locationPath(locid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Location{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181223 | GetContractResources | test | func (c *Client) GetContractResources() (*ContractResources, error) {
url := contractResourcePath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &ContractResources{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181224 | ListImages | test | func (c *Client) ListImages() (*Images, error) {
url := imageColPath() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Images{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181225 | GetImage | test | func (c *Client) GetImage(imageid string) (*Image, error) {
url := imagePath(imageid)
ret := &Image{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181226 | PrintHeaders | test | func (r *Resp) PrintHeaders() {
for key, value := range r.Headers {
fmt.Println(key, " : ", value[0])
}
} | go | {
"resource": ""
} |
q181227 | ListGroups | test | func (c *Client) ListGroups() (*Groups, error) {
url := umGroups() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Groups{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181228 | GetGroup | test | func (c *Client) GetGroup(groupid string) (*Group, error) {
url := umGroupPath(groupid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Group{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181229 | CreateGroup | test | func (c *Client) CreateGroup(grp Group) (*Group, error) {
url := umGroups() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Group{}
err := c.client.Post(url, grp, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181230 | UpdateGroup | test | func (c *Client) UpdateGroup(groupid string, obj Group) (*Group, error) {
url := umGroupPath(groupid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Group{}
err := c.client.Put(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181231 | DeleteGroup | test | func (c *Client) DeleteGroup(groupid string) (*http.Header, error) {
url := umGroupPath(groupid) + `?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": ""
} |
q181232 | ListShares | test | func (c *Client) ListShares(grpid string) (*Shares, error) {
url := umGroupShares(grpid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Shares{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181233 | GetShare | test | func (c *Client) GetShare(groupid string, resourceid string) (*Share, error) {
url := umGroupSharePath(groupid, resourceid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Share{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181234 | AddShare | test | func (c *Client) AddShare(groupid string, resourceid string, share Share) (*Share, error) {
url := umGroupSharePath(groupid, resourceid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Share{}
err := c.client.Post(url, share, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181235 | UpdateShare | test | func (c *Client) UpdateShare(groupid string, resourceid string, obj Share) (*Share, error) {
url := umGroupSharePath(groupid, resourceid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Share{}
err := c.client.Put(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181236 | DeleteShare | test | func (c *Client) DeleteShare(groupid string, resourceid string) (*http.Header, error) {
url := umGroupSharePath(groupid, resourceid) + `?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": ""
} |
q181237 | ListGroupUsers | test | func (c *Client) ListGroupUsers(groupid string) (*Users, error) {
url := umGroupUsers(groupid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Users{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181238 | AddUserToGroup | test | func (c *Client) AddUserToGroup(groupid string, userid string) (*User, error) {
var usr User
usr.ID = userid
url := umGroupUsers(groupid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &User{}
err := c.client.Post(url, usr, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181239 | DeleteUserFromGroup | test | func (c *Client) DeleteUserFromGroup(groupid string, userid string) (*http.Header, error) {
url := umGroupUsersPath(groupid, userid) + `?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": ""
} |
q181240 | ListUsers | test | func (c *Client) ListUsers() (*Users, error) {
url := umUsers() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Users{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181241 | GetUser | test | func (c *Client) GetUser(usrid string) (*User, error) {
url := umUsersPath(usrid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &User{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181242 | CreateUser | test | func (c *Client) CreateUser(usr User) (*User, error) {
url := umUsers() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &User{}
err := c.client.Post(url, usr, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181243 | UpdateUser | test | func (c *Client) UpdateUser(userid string, obj User) (*User, error) {
url := umUsersPath(userid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &User{}
err := c.client.Put(url, obj, ret, http.StatusAccepted)
return ret, err
} | go | {
"resource": ""
} |
q181244 | DeleteUser | test | func (c *Client) DeleteUser(userid string) (*http.Header, error) {
url := umUsersPath(userid) + `?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": ""
} |
q181245 | ListResources | test | func (c *Client) ListResources() (*Resources, error) {
url := umResources() + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Resources{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181246 | GetResourceByType | test | func (c *Client) GetResourceByType(resourcetype string, resourceid string) (*Resource, error) {
url := umResourcesTypePath(resourcetype, resourceid) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Resource{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181247 | ListResourcesByType | test | func (c *Client) ListResourcesByType(resourcetype string) (*Resources, error) {
url := umResourcesType(resourcetype) + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Resources{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181248 | ListRequests | test | func (c *Client) ListRequests() (*Requests, error) {
url := "/requests" + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Requests{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181249 | GetRequest | test | func (c *Client) GetRequest(reqID string) (*Request, error) {
url := "/requests/" + reqID + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &Request{}
err := c.client.Get(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181250 | GetRequestStatus | test | func (c *Client) GetRequestStatus(path string) (*RequestStatus, error) {
url := path + `?depth=` + c.client.depth + `&pretty=` + strconv.FormatBool(c.client.pretty)
ret := &RequestStatus{}
err := c.client.GetRequestStatus(url, ret, http.StatusOK)
return ret, err
} | go | {
"resource": ""
} |
q181251 | Close | test | func (l *Writer) Close() error {
l.mutex.Lock()
defer l.mutex.Unlock()
return l.file.Close()
} | go | {
"resource": ""
} |
q181252 | GetSerializableArgument | test | func (serialize *SerializableMeta) GetSerializableArgument(serializableMetaInterface SerializableMetaInterface) interface{} {
if serialize.Value.OriginalValue != nil {
return serialize.Value.OriginalValue
}
if res := serializableMetaInterface.GetSerializableArgumentResource(); res != nil {
value := res.NewStruct()
json.Unmarshal([]byte(serialize.Value.SerializedValue), value)
return value
}
return nil
} | go | {
"resource": ""
} |
q181253 | BoolVar | test | func BoolVar(p *bool, name string, value bool, usage string) {
EnvironmentFlags.BoolVar(p, name, value, usage)
} | go | {
"resource": ""
} |
q181254 | Bool | test | func Bool(name string, value bool, usage string) *bool {
return EnvironmentFlags.Bool(name, value, usage)
} | go | {
"resource": ""
} |
q181255 | IntVar | test | func IntVar(p *int, name string, value int, usage string) {
EnvironmentFlags.IntVar(p, name, value, usage)
} | go | {
"resource": ""
} |
q181256 | Int | test | func Int(name string, value int, usage string) *int {
return EnvironmentFlags.Int(name, value, usage)
} | go | {
"resource": ""
} |
q181257 | Int64Var | test | func Int64Var(p *int64, name string, value int64, usage string) {
EnvironmentFlags.Int64Var(p, name, value, usage)
} | go | {
"resource": ""
} |
q181258 | Int64 | test | func Int64(name string, value int64, usage string) *int64 {
return EnvironmentFlags.Int64(name, value, usage)
} | go | {
"resource": ""
} |
q181259 | UintVar | test | func UintVar(p *uint, name string, value uint, usage string) {
EnvironmentFlags.UintVar(p, name, value, usage)
} | go | {
"resource": ""
} |
q181260 | Uint | test | func Uint(name string, value uint, usage string) *uint {
return EnvironmentFlags.Uint(name, value, usage)
} | go | {
"resource": ""
} |
q181261 | Uint64Var | test | func Uint64Var(p *uint64, name string, value uint64, usage string) {
EnvironmentFlags.Uint64Var(p, name, value, usage)
} | go | {
"resource": ""
} |
q181262 | Uint64 | test | func Uint64(name string, value uint64, usage string) *uint64 {
return EnvironmentFlags.Uint64(name, value, usage)
} | go | {
"resource": ""
} |
q181263 | StringVar | test | func StringVar(p *string, name string, value string, usage string) {
EnvironmentFlags.StringVar(p, name, value, usage)
} | go | {
"resource": ""
} |
q181264 | String | test | func String(name string, value string, usage string) *string {
return EnvironmentFlags.String(name, value, usage)
} | go | {
"resource": ""
} |
q181265 | Float64Var | test | func Float64Var(p *float64, name string, value float64, usage string) {
EnvironmentFlags.Float64Var(p, name, value, usage)
} | go | {
"resource": ""
} |
q181266 | Float64 | test | func Float64(name string, value float64, usage string) *float64 {
return EnvironmentFlags.Float64(name, value, usage)
} | go | {
"resource": ""
} |
q181267 | DurationVar | test | func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
EnvironmentFlags.DurationVar(p, name, value, usage)
} | go | {
"resource": ""
} |
q181268 | Duration | test | func Duration(name string, value time.Duration, usage string) *time.Duration {
return EnvironmentFlags.Duration(name, value, usage)
} | go | {
"resource": ""
} |
q181269 | Parse | test | func Parse() {
env := os.Environ()
// Clean up and "fake" some flag k/v pairs.
args := make([]string, 0, len(env))
for _, value := range env {
if Lookup(value[:strings.Index(value, "=")]) == nil {
continue
}
args = append(args, fmt.Sprintf("-%s", value))
}
EnvironmentFlags.Parse(args)
} | go | {
"resource": ""
} |
q181270 | WriteStringToFile | test | func WriteStringToFile(text, path string) error {
f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0644)
defer f.Close()
if err != nil {
return err
}
f.WriteString(text)
return nil
} | go | {
"resource": ""
} |
q181271 | ReadFileToString | test | func ReadFileToString(path string) (string, error) {
f, err := os.Open(path)
if err != nil {
return "", err
}
defer f.Close()
scanner := bufio.NewScanner(f)
scanner.Scan()
return scanner.Text(), nil
} | go | {
"resource": ""
} |
q181272 | LineReader | test | func LineReader(r io.Reader) (<-chan string, error) {
return lineReader(func() (io.Reader, func(), error) { return r, nil, nil })
} | go | {
"resource": ""
} |
q181273 | LineReaderFrom | test | func LineReaderFrom(path string) (<-chan string, error) {
return lineReader(func() (io.Reader, func(), error) {
if !FileExists(path) {
return nil, nil, nil
}
f, err := os.Open(path)
if err != nil {
return nil, nil, err
}
return f, func() { f.Close() }, nil
})
} | go | {
"resource": ""
} |
q181274 | FileExists | test | func FileExists(filePath string) bool {
if _, err := os.Stat(filePath); !os.IsNotExist(err) {
return true
}
return false
} | go | {
"resource": ""
} |
q181275 | FileExistsInPath | test | func FileExistsInPath(fileName string) bool {
_, err := exec.LookPath(fileName)
return err == nil
} | go | {
"resource": ""
} |
q181276 | GetPathParts | test | func GetPathParts(path string) (dirPath, fileName, absPath string) {
lookup, lookupErr := exec.LookPath(path)
if lookupErr == nil {
path = lookup
}
absPath, _ = filepath.Abs(path)
dirPath = filepath.Dir(absPath)
fileName = filepath.Base(absPath)
return
} | go | {
"resource": ""
} |
q181277 | GetThisPathParts | test | func GetThisPathParts() (dirPath, fileName, absPath string) {
exeFile, _ := osext.Executable()
return GetPathParts(exeFile)
} | go | {
"resource": ""
} |
q181278 | RandomString | test | func RandomString(length int) string {
src := rand.NewSource(time.Now().UnixNano())
b := make([]byte, length)
for i, cache, remain := length-1, src.Int63(), letterIndexMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIndexMax
}
if idx := int(cache & letterIndexMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIndexBits
remain--
}
return string(b)
} | go | {
"resource": ""
} |
q181279 | ParseAddress | test | func ParseAddress(addr string) (proto string, path string, err error) {
m := netAddrRx.FindStringSubmatch(addr)
if m == nil {
return "", "", goof.WithField("address", addr, "invalid address")
}
return m[1], m[2], nil
} | go | {
"resource": ""
} |
q181280 | HomeDir | test | func HomeDir() string {
if homeDirSet {
return homeDir
}
if user, err := user.Current(); err == nil {
homeDir = user.HomeDir
}
homeDirSet = true
return homeDir
} | go | {
"resource": ""
} |
q181281 | IsTCPPortAvailable | test | func IsTCPPortAvailable(port int) bool {
if port < minTCPPort || port > maxTCPPort {
return false
}
conn, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
return false
}
conn.Close()
return true
} | go | {
"resource": ""
} |
q181282 | RandomTCPPort | test | func RandomTCPPort() int {
for i := maxReservedTCPPort; i < maxTCPPort; i++ {
p := tcpPortRand.Intn(maxRandTCPPort) + maxReservedTCPPort + 1
if IsTCPPortAvailable(p) {
return p
}
}
return -1
} | go | {
"resource": ""
} |
q181283 | HashString | test | func HashString(key string, numBuckets int) int32 {
// jump.Hash returns values from 0.
k := Hash(Sum64(key), numBuckets)
return k
} | go | {
"resource": ""
} |
q181284 | Context | test | func (sm *sessionManager) Context(ctx context.Context, req *empty.Empty) (*mnemosynerpc.ContextResponse, error) {
md, ok := metadata.FromIncomingContext(ctx)
if !ok {
return nil, status.Errorf(codes.InvalidArgument, "missing metadata in context, access token cannot be retrieved")
}
if len(md[mnemosyne.AccessTokenMetadataKey]) == 0 {
return nil, status.Errorf(codes.InvalidArgument, "missing access token in metadata")
}
at := md[mnemosyne.AccessTokenMetadataKey][0]
res, err := sm.Get(ctx, &mnemosynerpc.GetRequest{AccessToken: at})
if err != nil {
return nil, err
}
return &mnemosynerpc.ContextResponse{
Session: res.Session,
}, nil
} | go | {
"resource": ""
} |
q181285 | Token | test | func (s *Session) Token() (*oauth2.Token, error) {
var (
err error
expireAt time.Time
)
if s.ExpireAt != nil {
expireAt, err = ptypes.Timestamp(s.ExpireAt)
if err != nil {
return nil, err
}
}
token := &oauth2.Token{
AccessToken: string(s.AccessToken),
Expiry: expireAt,
}
if s.Bag != nil && len(s.Bag) > 0 {
token = token.WithExtra(bagToURLValues(s.Bag))
}
return token, nil
} | go | {
"resource": ""
} |
q181286 | NewDaemon | test | func NewDaemon(opts *DaemonOpts) (*Daemon, error) {
d := &Daemon{
done: make(chan struct{}),
opts: opts,
logger: opts.Logger,
serverOptions: opts.RPCOptions,
rpcListener: opts.RPCListener,
debugListener: opts.DebugListener,
}
if err := d.setPostgresConnectionParameters(); err != nil {
return nil, err
}
if d.opts.SessionTTL == 0 {
d.opts.SessionTTL = storage.DefaultTTL
}
if d.opts.SessionTTC == 0 {
d.opts.SessionTTC = storage.DefaultTTC
}
if d.opts.Storage == "" {
d.opts.Storage = storage.EnginePostgres
}
if d.opts.PostgresTable == "" {
d.opts.PostgresTable = "session"
}
if d.opts.PostgresSchema == "" {
d.opts.PostgresSchema = "mnemosyne"
}
return d, nil
} | go | {
"resource": ""
} |
q181287 | Close | test | func (d *Daemon) Close() (err error) {
d.done <- struct{}{}
d.server.GracefulStop()
if d.postgres != nil {
if err = d.postgres.Close(); err != nil {
return
}
}
if d.debugListener != nil {
if err = d.debugListener.Close(); err != nil {
return
}
}
if d.tracerCloser != nil {
if err = d.tracerCloser.Close(); err != nil {
return
}
}
return nil
} | go | {
"resource": ""
} |
q181288 | NewAccessTokenContext | test | func NewAccessTokenContext(ctx context.Context, at string) context.Context {
return context.WithValue(ctx, accessTokenContextKey, at)
} | go | {
"resource": ""
} |
q181289 | AccessTokenFromContext | test | func AccessTokenFromContext(ctx context.Context) (string, bool) {
at, ok := ctx.Value(accessTokenContextKey).(string)
return at, ok
} | go | {
"resource": ""
} |
q181290 | RandomAccessToken | test | func RandomAccessToken() (string, error) {
buf, err := generateRandomBytes(128)
if err != nil {
return "", err
}
// A hash needs to be 64 bytes long to have 256-bit collision resistance.
hash := make([]byte, 64)
// Compute a 64-byte hash of buf and put it in h.
sha3.ShakeSum256(hash, buf)
hash2 := make([]byte, hex.EncodedLen(len(hash)))
hex.Encode(hash2, hash)
return string(hash2), nil
} | go | {
"resource": ""
} |
q181291 | Init | test | func Init(opts Opts) (logger *zap.Logger, err error) {
var (
cfg zap.Config
options []zap.Option
lvl zapcore.Level
)
switch opts.Environment {
case "production":
cfg = zap.NewProductionConfig()
case "stackdriver":
cfg = NewStackdriverConfig()
options = append(options, zap.Fields(zap.Object("serviceContext", &ServiceContext{
Service: "mnemosyned",
Version: opts.Version,
})))
case "development":
cfg = zap.NewDevelopmentConfig()
default:
cfg = zap.NewProductionConfig()
}
if err = lvl.Set(opts.Level); err != nil {
return nil, err
}
cfg.Level.SetLevel(lvl)
logger, err = cfg.Build(options...)
if err != nil {
return nil, err
}
logger.Info("logger has been initialized", zap.String("environment", opts.Environment))
return logger, nil
} | go | {
"resource": ""
} |
q181292 | Load | test | func Load(path string) (d *Dic, err error) {
d = new(Dic)
r, err := zip.OpenReader(path)
if err != nil {
return d, err
}
defer r.Close()
for _, f := range r.File {
if err = func() error {
rc, e := f.Open()
if e != nil {
return e
}
defer rc.Close()
switch f.Name {
case "morph.dic":
if e = d.loadMorphDicPart(rc); e != nil {
return e
}
case "pos.dic":
if e = d.loadPOSDicPart(rc); e != nil {
return e
}
case "content.dic":
if e = d.loadContentDicPart(rc); e != nil {
return e
}
case "index.dic":
if e = d.loadIndexDicPart(rc); e != nil {
return e
}
case "connection.dic":
if e = d.loadConnectionDicPart(rc); e != nil {
return e
}
case "chardef.dic":
if e = d.loadCharDefDicPart(rc); e != nil {
return e
}
case "unk.dic":
if e = d.loadUnkDicPart(rc); e != nil {
return e
}
}
return nil
}(); err != nil {
return
}
}
return
} | go | {
"resource": ""
} |
q181293 | Start | test | func (s *Storage) Start(ctx context.Context, accessToken, refreshToken, sid, sc string, b map[string]string) (*mnemosynerpc.Session, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.start")
defer span.Finish()
ent := &sessionEntity{
AccessToken: accessToken,
RefreshToken: refreshToken,
SubjectID: sid,
SubjectClient: sc,
Bag: model.Bag(b),
}
if err := s.save(ctx, ent); err != nil {
return nil, err
}
return ent.session()
} | go | {
"resource": ""
} |
q181294 | Get | test | func (s *Storage) Get(ctx context.Context, accessToken string) (*mnemosynerpc.Session, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.get")
defer span.Finish()
var entity sessionEntity
start := time.Now()
labels := prometheus.Labels{"query": "get"}
err := s.db.QueryRowContext(ctx, s.queryGet, accessToken).Scan(
&entity.RefreshToken,
&entity.SubjectID,
&entity.SubjectClient,
&entity.Bag,
&entity.ExpireAt,
)
s.incQueries(labels, start)
if err != nil {
s.incError(labels)
if err == sql.ErrNoRows {
return nil, storage.ErrSessionNotFound
}
return nil, err
}
expireAt, err := ptypes.TimestampProto(entity.ExpireAt)
if err != nil {
return nil, err
}
return &mnemosynerpc.Session{
AccessToken: accessToken,
RefreshToken: entity.RefreshToken,
SubjectId: entity.SubjectID,
SubjectClient: entity.SubjectClient,
Bag: entity.Bag,
ExpireAt: expireAt,
}, nil
} | go | {
"resource": ""
} |
q181295 | List | test | func (s *Storage) List(ctx context.Context, offset, limit int64, expiredAtFrom, expiredAtTo *time.Time) ([]*mnemosynerpc.Session, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.list")
defer span.Finish()
if limit == 0 {
return nil, errors.New("cannot retrieve list of sessions, limit needs to be higher than 0")
}
args := []interface{}{offset, limit}
query := "SELECT access_token, refresh_token, subject_id, subject_client, bag, expire_at FROM " + s.schema + "." + s.table + " "
if expiredAtFrom != nil || expiredAtTo != nil {
query += " WHERE "
}
switch {
case expiredAtFrom != nil && expiredAtTo == nil:
query += "expire_at > $3"
args = append(args, expiredAtFrom)
case expiredAtFrom == nil && expiredAtTo != nil:
query += "expire_at < $3"
args = append(args, expiredAtTo)
case expiredAtFrom != nil && expiredAtTo != nil:
query += "expire_at > $3 AND expire_at < $4"
args = append(args, expiredAtFrom, expiredAtTo)
}
query += " OFFSET $1 LIMIT $2"
labels := prometheus.Labels{"query": "list"}
start := time.Now()
rows, err := s.db.QueryContext(ctx, query, args...)
s.incQueries(labels, start)
if err != nil {
s.incError(labels)
return nil, err
}
defer rows.Close()
sessions := make([]*mnemosynerpc.Session, 0, limit)
for rows.Next() {
var ent sessionEntity
err = rows.Scan(
&ent.AccessToken,
&ent.RefreshToken,
&ent.SubjectID,
&ent.SubjectClient,
&ent.Bag,
&ent.ExpireAt,
)
if err != nil {
s.incError(labels)
return nil, err
}
expireAt, err := ptypes.TimestampProto(ent.ExpireAt)
if err != nil {
return nil, err
}
sessions = append(sessions, &mnemosynerpc.Session{
AccessToken: ent.AccessToken,
RefreshToken: ent.RefreshToken,
SubjectId: ent.SubjectID,
SubjectClient: ent.SubjectClient,
Bag: ent.Bag,
ExpireAt: expireAt,
})
}
if rows.Err() != nil {
s.incError(labels)
return nil, rows.Err()
}
return sessions, nil
} | go | {
"resource": ""
} |
q181296 | Exists | test | func (s *Storage) Exists(ctx context.Context, accessToken string) (exists bool, err error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.exists")
defer span.Finish()
start := time.Now()
labels := prometheus.Labels{"query": "exists"}
err = s.db.QueryRowContext(ctx, s.queryExists, accessToken).Scan(
&exists,
)
s.incQueries(labels, start)
if err != nil {
s.incError(labels)
}
return
} | go | {
"resource": ""
} |
q181297 | Abandon | test | func (s *Storage) Abandon(ctx context.Context, accessToken string) (bool, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.abandon")
defer span.Finish()
start := time.Now()
labels := prometheus.Labels{"query": "abandon"}
result, err := s.db.ExecContext(ctx, s.queryAbandon, accessToken)
s.incQueries(labels, start)
if err != nil {
s.incError(labels)
return false, err
}
affected, err := result.RowsAffected()
if err != nil {
return false, err
}
if affected == 0 {
return false, storage.ErrSessionNotFound
}
return true, nil
} | go | {
"resource": ""
} |
q181298 | SetValue | test | func (s *Storage) SetValue(ctx context.Context, accessToken string, key, value string) (map[string]string, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.set-value")
defer span.Finish()
var err error
if accessToken == "" {
return nil, storage.ErrMissingAccessToken
}
entity := &sessionEntity{
AccessToken: accessToken,
}
selectQuery := `
SELECT bag
FROM ` + s.schema + `.` + s.table + `
WHERE access_token = $1
FOR UPDATE
`
updateQuery := `
UPDATE ` + s.schema + `.` + s.table + `
SET
bag = $2
WHERE access_token = $1
`
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
tx.Rollback()
return nil, err
}
startSelect := time.Now()
err = tx.QueryRowContext(ctx, selectQuery, accessToken).Scan(
&entity.Bag,
)
s.incQueries(prometheus.Labels{"query": "set_value_select"}, startSelect)
if err != nil {
s.incError(prometheus.Labels{"query": "set_value_select"})
tx.Rollback()
if err == sql.ErrNoRows {
return nil, storage.ErrSessionNotFound
}
return nil, err
}
entity.Bag.Set(key, value)
startUpdate := time.Now()
_, err = tx.ExecContext(ctx, updateQuery, accessToken, entity.Bag)
s.incQueries(prometheus.Labels{"query": "set_value_update"}, startUpdate)
if err != nil {
s.incError(prometheus.Labels{"query": "set_value_update"})
tx.Rollback()
return nil, err
}
tx.Commit()
return entity.Bag, nil
} | go | {
"resource": ""
} |
q181299 | Delete | test | func (s *Storage) Delete(ctx context.Context, subjectID, accessToken, refreshToken string, expiredAtFrom, expiredAtTo *time.Time) (int64, error) {
span, ctx := opentracing.StartSpanFromContext(ctx, "postgres.storage.delete")
defer span.Finish()
where, args := s.where(subjectID, accessToken, refreshToken, expiredAtFrom, expiredAtTo)
if where.Len() == 0 {
return 0, fmt.Errorf("session cannot be deleted, no where parameter provided: %s", where.String())
}
query := "DELETE FROM " + s.schema + "." + s.table + " WHERE " + where.String()
labels := prometheus.Labels{"query": "delete"}
start := time.Now()
result, err := s.db.Exec(query, args...)
s.incQueries(labels, start)
if err != nil {
s.incError(labels)
return 0, err
}
return result.RowsAffected()
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.