_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8500 | Rotate | train | func (gp *GoPdf) Rotate(angle, x, y float64) {
gp.UnitsToPointsVar(&x, &y)
gp.getContent().appendRotate(angle, x, y)
} | go | {
"resource": ""
} |
q8501 | UnitsToPoints | train | func (gp *GoPdf) UnitsToPoints(u float64) float64 {
return UnitsToPoints(gp.config.Unit, u)
} | go | {
"resource": ""
} |
q8502 | UnitsToPointsVar | train | func (gp *GoPdf) UnitsToPointsVar(u ...*float64) {
UnitsToPointsVar(gp.config.Unit, u...)
} | go | {
"resource": ""
} |
q8503 | PointsToUnits | train | func (gp *GoPdf) PointsToUnits(u float64) float64 {
return PointsToUnits(gp.config.Unit, u)
} | go | {
"resource": ""
} |
q8504 | PointsToUnitsVar | train | func (gp *GoPdf) PointsToUnitsVar(u ...*float64) {
PointsToUnitsVar(gp.config.Unit, u...)
} | go | {
"resource": ""
} |
q8505 | PointsToUnits | train | func (rect *Rect) PointsToUnits(t int) (r *Rect) {
if rect == nil {
return
}
if rect.unitOverride != Unit_Unset {
t = rect.unitOverride
}
r = &Rect{W: rect.W, H: rect.H}
PointsToUnitsVar(t, &r.W, &r.H)
return
} | go | {
"resource": ""
} |
q8506 | UnitsToPoints | train | func (rect *Rect) UnitsToPoints(t int) (r *Rect) {
if rect == nil {
return
}
if rect.unitOverride != Unit_Unset {
t = rect.unitOverride
}
r = &Rect{W: rect.W, H: rect.H}
UnitsToPointsVar(t, &r.W, &r.H)
return
} | go | {
"resource": ""
} |
q8507 | ImgReactagleToWH | train | func ImgReactagleToWH(imageRect image.Rectangle) (float64, float64) {
k := 1
w := -128 //init
h := -128 //init
if w < 0 {
w = -imageRect.Dx() * 72 / w / k
}
if h < 0 {
h = -imageRect.Dy() * 72 / h / k
}
if w == 0 {
w = h * imageRect.Dx() / imageRect.Dy()
}
if h == 0 {
h = w * imageRect.Dy() / imageRect.Dx()
}
return float64(w), float64(h)
} | go | {
"resource": ""
} |
q8508 | URL | train | func (i *item) URL() *url.URL {
str, err := i.bucket.FileURL(i.name)
if err != nil {
return nil
}
url, _ := url.Parse(str)
url.Scheme = Kind
return url
} | go | {
"resource": ""
} |
q8509 | Metadata | train | func (i *item) Metadata() (map[string]interface{}, error) {
if err := i.ensureInfo(); err != nil {
return nil, errors.Wrap(err, "retrieving item metadata")
}
return i.metadata, nil
} | go | {
"resource": ""
} |
q8510 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
_, r, err := i.bucket.DownloadFileByName(i.name)
return r, err
} | go | {
"resource": ""
} |
q8511 | ETag | train | func (i *item) ETag() (string, error) {
if err := i.ensureInfo(); err != nil {
return "", errors.Wrap(err, "retreiving etag")
}
return i.lastModified.String(), nil
} | go | {
"resource": ""
} |
q8512 | CreateContainer | train | func (l *location) CreateContainer(name string) (stow.Container, error) {
err := l.client.ContainerCreate(name, nil)
if err != nil {
return nil, err
}
container := &container{
id: name,
client: l.client,
}
return container, nil
} | go | {
"resource": ""
} |
q8513 | Containers | train | func (l *location) Containers(prefix, cursor string, count int) ([]stow.Container, string, error) {
params := &swift.ContainersOpts{
Limit: count,
Prefix: prefix,
Marker: cursor,
}
response, err := l.client.Containers(params)
if err != nil {
return nil, "", err
}
containers := make([]stow.Container, len(response))
for i, cont := range response {
containers[i] = &container{
id: cont.Name,
client: l.client,
// count: cont.Count,
// bytes: cont.Bytes,
}
}
marker := ""
if len(response) == count {
marker = response[len(response)-1].Name
}
return containers, marker, nil
} | go | {
"resource": ""
} |
q8514 | Container | train | func (l *location) Container(id string) (stow.Container, error) {
_, _, err := l.client.Container(id)
// TODO: grab info + headers
if err != nil {
return nil, stow.ErrNotFound
}
c := &container{
id: id,
client: l.client,
}
return c, nil
} | go | {
"resource": ""
} |
q8515 | RemoveContainer | train | func (l *location) RemoveContainer(id string) error {
return l.client.ContainerDelete(id)
} | go | {
"resource": ""
} |
q8516 | Register | train | func Register(kind string, makefn func(Config) (Location, error), kindmatchfn func(*url.URL) bool, validatefn func(Config) error) {
lock.Lock()
defer lock.Unlock()
// if already registered, leave
if _, ok := locations[kind]; ok {
return
}
locations[kind] = makefn
configurations[kind] = validatefn
kinds = append(kinds, kind)
kindmatches = append(kindmatches, func(u *url.URL) string {
if kindmatchfn(u) {
return kind // match
}
return "" // empty string means no match
})
} | go | {
"resource": ""
} |
q8517 | Dial | train | func Dial(kind string, config Config) (Location, error) {
fn, ok := locations[kind]
if !ok {
return nil, errUnknownKind(kind)
}
return fn(config)
} | go | {
"resource": ""
} |
q8518 | Validate | train | func Validate(kind string, config Config) error {
fn, ok := configurations[kind]
if !ok {
return errUnknownKind(kind)
}
return fn(config)
} | go | {
"resource": ""
} |
q8519 | KindByURL | train | func KindByURL(u *url.URL) (string, error) {
lock.RLock()
defer lock.RUnlock()
for _, fn := range kindmatches {
kind := fn(u)
if kind == "" {
continue
}
return kind, nil
}
return "", errUnknownKind("")
} | go | {
"resource": ""
} |
q8520 | Config | train | func (c ConfigMap) Config(name string) (string, bool) {
val, ok := c[name]
return val, ok
} | go | {
"resource": ""
} |
q8521 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
return os.Open(i.path)
} | go | {
"resource": ""
} |
q8522 | URL | train | func (i *item) URL() *url.URL {
if i.container.customEndpoint == "" {
genericURL := fmt.Sprintf("https://s3-%s.amazonaws.com/%s/%s", i.container.Region(), i.container.Name(), i.Name())
return &url.URL{
Scheme: "s3",
Path: genericURL,
}
}
genericURL := fmt.Sprintf("%s/%s", i.container.Name(), i.Name())
return &url.URL{
Scheme: "s3",
Path: genericURL,
}
} | go | {
"resource": ""
} |
q8523 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
params := &s3.GetObjectInput{
Bucket: aws.String(i.container.Name()),
Key: aws.String(i.ID()),
}
response, err := i.client.GetObject(params)
if err != nil {
return nil, errors.Wrap(err, "Open, getting the object")
}
return response.Body, nil
} | go | {
"resource": ""
} |
q8524 | Tags | train | func (i *item) Tags() (map[string]interface{}, error) {
i.tagsOnce.Do(func() {
params := &s3.GetObjectTaggingInput{
Bucket: aws.String(i.container.name),
Key: aws.String(i.ID()),
}
res, err := i.client.GetObjectTagging(params)
if err != nil {
if strings.Contains(err.Error(), "NoSuchKey") {
i.tagsErr = stow.ErrNotFound
return
}
i.tagsErr = errors.Wrap(err, "getObjectTagging")
return
}
i.tags = make(map[string]interface{})
for _, t := range res.TagSet {
i.tags[*t.Key] = *t.Value
}
})
return i.tags, i.tagsErr
} | go | {
"resource": ""
} |
q8525 | ensureInfo | train | func (i *item) ensureInfo() error {
// If lastModified is empty, so is hash. get info on the Item and
// update the necessary fields at the same time.
if i.lastModified.IsZero() || i.hash == "" || i.metadata == nil {
i.infoOnce.Do(func() {
itemInfo, infoErr := i.getInfo()
if infoErr != nil {
i.infoErr = infoErr
return
}
i.hash, i.infoErr = itemInfo.ETag()
if infoErr != nil {
i.infoErr = infoErr
return
}
i.lastModified, i.infoErr = itemInfo.LastMod()
if infoErr != nil {
i.infoErr = infoErr
return
}
i.metadata, i.infoErr = itemInfo.Metadata()
if infoErr != nil {
i.infoErr = infoErr
return
}
})
}
return i.infoErr
} | go | {
"resource": ""
} |
q8526 | Open | train | func (i *item) Open() (io.ReadCloser, error) {
r, _, err := i.client.ObjectOpen(i.container.id, i.id, false, nil)
var res io.ReadCloser = r
// FIXME: this is a workaround to issue https://github.com/graymeta/stow/issues/120
if s, ok := res.(readSeekCloser); ok {
res = &fixReadSeekCloser{readSeekCloser: s, item: i}
}
return res, err
} | go | {
"resource": ""
} |
q8527 | LastMod | train | func (i *item) LastMod() (time.Time, error) {
// If an object is PUT, certain information is missing. Detect
// if the lastModified field is missing, send a request to retrieve
// it, and save both this and other missing information so that a
// request doesn't have to be sent again.
err := i.ensureInfo()
if err != nil {
return time.Time{}, err
}
return i.lastModified, nil
} | go | {
"resource": ""
} |
q8528 | parseMetadata | train | func parseMetadata(md swift.Headers) (map[string]interface{}, error) {
m := make(map[string]interface{}, len(md))
for key, value := range md.ObjectMetadata() {
m[key] = value
}
return m, nil
} | go | {
"resource": ""
} |
q8529 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
params := &swift.ObjectsOpts{
Limit: count,
Marker: cursor,
Prefix: prefix,
}
objects, err := c.client.Objects(c.id, params)
if err != nil {
return nil, "", err
}
items := make([]stow.Item, len(objects))
for i, obj := range objects {
items[i] = &item{
id: obj.Name,
container: c,
client: c.client,
hash: obj.Hash,
size: obj.Bytes,
lastModified: obj.LastModified,
}
}
marker := ""
if len(objects) == count {
marker = objects[len(objects)-1].Name
}
return items, marker, nil
} | go | {
"resource": ""
} |
q8530 | Put | train | func (c *container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, errors.Wrap(err, "unable to create or update Item, preparing metadata")
}
_, err = c.client.ObjectPut(c.id, name, r, false, "", "", nil)
if err != nil {
return nil, errors.Wrap(err, "unable to create or update Item")
}
err = c.client.ObjectUpdate(c.id, name, mdPrepped)
if err != nil {
return nil, errors.Wrap(err, "unable to update Item metadata")
}
item := &item{
id: name,
container: c,
client: c.client,
size: size,
// not setting metadata here, the refined version isn't available
// unless an explicit getItem() is done. Possible to write a func to facilitate
// this.
}
return item, nil
} | go | {
"resource": ""
} |
q8531 | prepUrl | train | func prepUrl(str string) (*url.URL, error) {
u, err := url.Parse(str)
if err != nil {
return nil, err
}
u.Scheme = "google"
// Discard the query string
u.RawQuery = ""
return u, nil
} | go | {
"resource": ""
} |
q8532 | Containers | train | func (l *location) Containers(prefix string, cursor string, count int) ([]stow.Container, string, error) {
response, err := l.client.ListBuckets()
if err != nil {
return nil, "", err
}
containers := make([]stow.Container, 0, len(response))
for _, cont := range response {
// api and/or library don't seem to support prefixes, so do it ourself
if strings.HasPrefix(cont.Name, prefix) {
containers = append(containers, &container{
bucket: cont,
})
}
}
return containers, "", nil
} | go | {
"resource": ""
} |
q8533 | Container | train | func (l *location) Container(id string) (stow.Container, error) {
bucket, err := l.client.Bucket(id)
if err != nil || bucket == nil {
return nil, stow.ErrNotFound
}
return &container{
bucket: bucket,
}, nil
} | go | {
"resource": ""
} |
q8534 | ItemByURL | train | func (l *location) ItemByURL(u *url.URL) (stow.Item, error) {
if u.Scheme != Kind {
return nil, errors.New("not valid b2 URL")
}
// b2://f001.backblaze.com/file/<container_name>/<path_to_object>
pieces := strings.SplitN(u.Path, "/", 4)
c, err := l.Container(pieces[2])
if err != nil {
return nil, err
}
filename, err := url.QueryUnescape(pieces[3])
if err != nil {
return nil, err
}
response, err := c.(*container).bucket.ListFileNames(filename, 1)
if err != nil {
return nil, stow.ErrNotFound
}
if len(response.Files) != 1 {
return nil, errors.New("unexpected number of responses from ListFileNames")
}
return c.Item(response.Files[0].ID)
} | go | {
"resource": ""
} |
q8535 | RemoveContainer | train | func (l *location) RemoveContainer(id string) error {
stowCont, err := l.Container(id)
if err != nil {
return err
}
return stowCont.(*container).bucket.Delete()
} | go | {
"resource": ""
} |
q8536 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
itemLimit := int64(count)
params := &s3.ListObjectsV2Input{
Bucket: aws.String(c.Name()),
StartAfter: &cursor,
MaxKeys: &itemLimit,
Prefix: &prefix,
}
response, err := c.client.ListObjectsV2(params)
if err != nil {
return nil, "", errors.Wrap(err, "Items, listing objects")
}
var containerItems []stow.Item
for _, object := range response.Contents {
if *object.StorageClass == "GLACIER" {
continue
}
etag := cleanEtag(*object.ETag) // Copy etag value and remove the strings.
object.ETag = &etag // Assign the value to the object field representing the item.
newItem := &item{
container: c,
client: c.client,
properties: properties{
ETag: object.ETag,
Key: object.Key,
LastModified: object.LastModified,
Owner: object.Owner,
Size: object.Size,
StorageClass: object.StorageClass,
},
}
containerItems = append(containerItems, newItem)
}
// Create a marker and determine if the list of items to retrieve is complete.
// If not, the last file is the input to the value of after which item to start
startAfter := ""
if *response.IsTruncated {
startAfter = containerItems[len(containerItems)-1].Name()
}
return containerItems, startAfter, nil
} | go | {
"resource": ""
} |
q8537 | getItem | train | func (c *container) getItem(id string) (*item, error) {
params := &s3.HeadObjectInput{
Bucket: aws.String(c.name),
Key: aws.String(id),
}
res, err := c.client.HeadObject(params)
if err != nil {
// stow needs ErrNotFound to pass the test but amazon returns an opaque error
if aerr, ok := err.(awserr.Error); ok && aerr.Code() == "NotFound" {
return nil, stow.ErrNotFound
}
return nil, errors.Wrap(err, "getItem, getting the object")
}
etag := cleanEtag(*res.ETag) // etag string value contains quotations. Remove them.
md, err := parseMetadata(res.Metadata)
if err != nil {
return nil, errors.Wrap(err, "unable to retrieve Item information, parsing metadata")
}
i := &item{
container: c,
client: c.client,
properties: properties{
ETag: &etag,
Key: &id,
LastModified: res.LastModified,
Owner: nil, // not returned in the response.
Size: res.ContentLength,
StorageClass: res.StorageClass,
Metadata: md,
},
}
return i, nil
} | go | {
"resource": ""
} |
q8538 | parseMetadata | train | func parseMetadata(md map[string]*string) (map[string]interface{}, error) {
m := make(map[string]interface{}, len(md))
for key, value := range md {
k := strings.ToLower(key)
m[k] = *value
}
return m, nil
} | go | {
"resource": ""
} |
q8539 | flatdirs | train | func flatdirs(path string) ([]os.FileInfo, error) {
var list []os.FileInfo
err := filepath.Walk(path, func(p string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
flatname, err := filepath.Rel(path, p)
if err != nil {
return err
}
list = append(list, fileinfo{
FileInfo: info,
name: flatname,
})
return nil
})
if err != nil {
return nil, err
}
return list, nil
} | go | {
"resource": ""
} |
q8540 | determineChunkSize | train | func determineChunkSize(size int64) (int64, error) {
var chunkSize = int64(startChunkSize)
for {
parts := size / chunkSize
rem := size % chunkSize
if rem != 0 {
parts++
}
if parts <= maxParts {
break
}
if chunkSize == maxChunkSize {
return 0, errMultiPartUploadTooBig
}
chunkSize *= 2
if chunkSize > maxChunkSize {
chunkSize = maxChunkSize
}
}
return chunkSize, nil
} | go | {
"resource": ""
} |
q8541 | multipartUpload | train | func (c *container) multipartUpload(name string, r io.Reader, size int64) error {
chunkSize, err := determineChunkSize(size)
if err != nil {
return err
}
var buf = make([]byte, chunkSize)
var blocks []az.Block
var rawID uint64
blob := c.client.GetContainerReference(c.id).GetBlobReference(name)
// TODO: upload the parts in parallel
for {
n, err := r.Read(buf)
if err != nil {
if err == io.EOF {
break
}
return err
}
blockID := encodedBlockID(rawID)
chunk := buf[:n]
if err := blob.PutBlock(blockID, chunk, nil); err != nil {
return err
}
blocks = append(blocks, az.Block{
ID: blockID,
Status: az.BlockStatusLatest,
})
rawID++
}
return blob.PutBlockList(blocks, nil)
} | go | {
"resource": ""
} |
q8542 | CreateContainer | train | func (l *location) CreateContainer(containerName string) (stow.Container, error) {
createBucketParams := &s3.CreateBucketInput{
Bucket: aws.String(containerName), // required
}
_, err := l.client.CreateBucket(createBucketParams)
if err != nil {
return nil, errors.Wrap(err, "CreateContainer, creating the bucket")
}
region, _ := l.config.Config("region")
newContainer := &container{
name: containerName,
client: l.client,
region: region,
customEndpoint: l.customEndpoint,
}
return newContainer, nil
} | go | {
"resource": ""
} |
q8543 | Containers | train | func (l *location) Containers(prefix, cursor string, count int) ([]stow.Container, string, error) {
// Response returns exported Owner(*s3.Owner) and Bucket(*s3.[]Bucket)
var params *s3.ListBucketsInput
bucketList, err := l.client.ListBuckets(params)
if err != nil {
return nil, "", errors.Wrap(err, "Containers, listing the buckets")
}
// Seek to the current bucket, according to cursor.
if cursor != stow.CursorStart {
ok := false
for i, b := range bucketList.Buckets {
if *b.Name == cursor {
ok = true
bucketList.Buckets = bucketList.Buckets[i:]
break
}
}
if !ok {
return nil, "", stow.ErrBadCursor
}
}
cursor = ""
// Region is pulled from stow.Config. If Region is specified, only add
// Bucket to Container list if it is located in configured Region.
region, regionSet := l.config.Config(ConfigRegion)
// Endpoint would indicate that we are using s3-compatible storage, which
// does not support s3session.GetBucketRegion().
endpoint, endpointSet := l.config.Config(ConfigEndpoint)
// Iterate through the slice of pointers to buckets
var containers []stow.Container
for _, bucket := range bucketList.Buckets {
if len(containers) == count {
cursor = *bucket.Name
break
}
if !strings.HasPrefix(*bucket.Name, prefix) {
continue
}
var err error
client := l.client
bucketRegion := region
if !endpointSet && endpoint == "" {
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
bucketRegion, err = s3manager.GetBucketRegionWithClient(ctx, l.client, *bucket.Name)
cancel()
if err != nil {
return nil, "", errors.Wrapf(err, "Containers, getting bucket region for: %s", *bucket.Name)
}
if regionSet && region != "" && bucketRegion != region {
continue
}
client, _, err = newS3Client(l.config, bucketRegion)
if err != nil {
return nil, "", errors.Wrapf(err, "Containers, creating new client for region: %s", bucketRegion)
}
}
newContainer := &container{
name: *(bucket.Name),
client: client,
region: bucketRegion,
customEndpoint: l.customEndpoint,
}
containers = append(containers, newContainer)
}
return containers, cursor, nil
} | go | {
"resource": ""
} |
q8544 | Walk | train | func Walk(container Container, prefix string, pageSize int, fn WalkFunc) error {
var (
err error
items []Item
cursor = CursorStart
)
for {
items, cursor, err = container.Items(prefix, cursor, pageSize)
if err != nil {
err = fn(nil, err)
if err != nil {
return err
}
}
for _, item := range items {
err = fn(item, nil)
if err != nil {
return err
}
}
if IsCursorEnd(cursor) {
break
}
}
return nil
} | go | {
"resource": ""
} |
q8545 | WalkContainers | train | func WalkContainers(location Location, prefix string, pageSize int, fn WalkContainersFunc) error {
var (
err error
containers []Container
cursor = CursorStart
)
for {
containers, cursor, err = location.Containers(prefix, cursor, pageSize)
if err != nil {
err = fn(nil, err)
if err != nil {
return err
}
}
for _, container := range containers {
err = fn(container, nil)
if err != nil {
return err
}
}
if IsCursorEnd(cursor) {
break
}
}
return nil
} | go | {
"resource": ""
} |
q8546 | Item | train | func (c *Container) Item(id string) (stow.Item, error) {
res, err := c.client.Objects.Get(c.name, id).Do()
if err != nil {
return nil, stow.ErrNotFound
}
t, err := time.Parse(time.RFC3339, res.Updated)
if err != nil {
return nil, err
}
u, err := prepUrl(res.MediaLink)
if err != nil {
return nil, err
}
mdParsed, err := parseMetadata(res.Metadata)
if err != nil {
return nil, err
}
i := &Item{
name: id,
container: c,
client: c.client,
size: int64(res.Size),
etag: res.Etag,
hash: res.Md5Hash,
lastModified: t,
url: u,
metadata: mdParsed,
object: res,
}
return i, nil
} | go | {
"resource": ""
} |
q8547 | Items | train | func (c *Container) Items(prefix string, cursor string, count int) ([]stow.Item, string, error) {
// List all objects in a bucket using pagination
call := c.client.Objects.List(c.name).MaxResults(int64(count))
if prefix != "" {
call.Prefix(prefix)
}
if cursor != "" {
call = call.PageToken(cursor)
}
res, err := call.Do()
if err != nil {
return nil, "", err
}
containerItems := make([]stow.Item, len(res.Items))
for i, o := range res.Items {
t, err := time.Parse(time.RFC3339, o.Updated)
if err != nil {
return nil, "", err
}
u, err := prepUrl(o.MediaLink)
if err != nil {
return nil, "", err
}
mdParsed, err := parseMetadata(o.Metadata)
if err != nil {
return nil, "", err
}
containerItems[i] = &Item{
name: o.Name,
container: c,
client: c.client,
size: int64(o.Size),
etag: o.Etag,
hash: o.Md5Hash,
lastModified: t,
url: u,
metadata: mdParsed,
object: o,
}
}
return containerItems, res.NextPageToken, nil
} | go | {
"resource": ""
} |
q8548 | Put | train | func (c *Container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, err
}
object := &storage.Object{
Name: name,
Metadata: mdPrepped,
}
res, err := c.client.Objects.Insert(c.name, object).Media(r).Do()
if err != nil {
return nil, err
}
t, err := time.Parse(time.RFC3339, res.Updated)
if err != nil {
return nil, err
}
u, err := prepUrl(res.MediaLink)
if err != nil {
return nil, err
}
mdParsed, err := parseMetadata(res.Metadata)
if err != nil {
return nil, err
}
newItem := &Item{
name: name,
container: c,
client: c.client,
size: size,
etag: res.Etag,
hash: res.Md5Hash,
lastModified: t,
url: u,
metadata: mdParsed,
object: res,
}
return newItem, nil
} | go | {
"resource": ""
} |
q8549 | Items | train | func (c *container) Items(prefix, cursor string, count int) ([]stow.Item, string, error) {
items := make([]stow.Item, 0, count)
for {
response, err := c.bucket.ListFileNames(cursor, count)
if err != nil {
return nil, "", err
}
for _, obj := range response.Files {
if prefix != stow.NoPrefix && !strings.HasPrefix(obj.Name, prefix) {
continue
}
items = append(items, &item{
id: obj.ID,
name: obj.Name,
size: int64(obj.Size),
lastModified: time.Unix(obj.UploadTimestamp/1000, 0),
bucket: c.bucket,
})
if len(items) == count {
break
}
}
cursor = response.NextFileName
if prefix == "" || cursor == "" {
return items, cursor, nil
}
if len(items) == count {
break
}
if !strings.HasPrefix(cursor, prefix) {
return items, "", nil
}
}
if cursor != "" && cursor != items[len(items)-1].Name() {
// append a space because that's a funny quirk of backblaze's implementation
cursor = items[len(items)-1].Name() + " "
}
return items, cursor, nil
} | go | {
"resource": ""
} |
q8550 | Put | train | func (c *container) Put(name string, r io.Reader, size int64, metadata map[string]interface{}) (stow.Item, error) {
// Convert map[string]interface{} to map[string]string
mdPrepped, err := prepMetadata(metadata)
if err != nil {
return nil, errors.Wrap(err, "unable to create or update item, preparing metadata")
}
file, err := c.bucket.UploadFile(name, mdPrepped, r)
if err != nil {
return nil, err
}
return &item{
id: file.ID,
name: file.Name,
size: file.ContentLength,
bucket: c.bucket,
}, nil
} | go | {
"resource": ""
} |
q8551 | RemoveItem | train | func (c *container) RemoveItem(id string) error {
item, err := c.getItem(id)
if err != nil {
return err
}
// files can have multiple versions in backblaze. You have to delete
// files one version at a time.
for {
response, err := item.bucket.ListFileNames(item.Name(), 1)
if err != nil {
return err
}
var fileStatus *backblaze.FileStatus
for i := range response.Files {
if response.Files[i].Name == item.Name() {
fileStatus = &response.Files[i]
break
}
}
if fileStatus == nil {
// we've deleted all versions of the file
return nil
}
if _, err := c.bucket.DeleteFileVersion(item.name, response.Files[0].ID); err != nil {
return err
}
}
} | go | {
"resource": ""
} |
q8552 | filesToContainers | train | func (l *location) filesToContainers(root string, files ...string) ([]stow.Container, error) {
cs := make([]stow.Container, 0, len(files))
for _, f := range files {
info, err := os.Stat(f)
if err != nil {
return nil, err
}
if !info.IsDir() {
continue
}
absroot, err := filepath.Abs(root)
if err != nil {
return nil, err
}
path, err := filepath.Abs(f)
if err != nil {
return nil, err
}
name, err := filepath.Rel(absroot, path)
if err != nil {
return nil, err
}
cs = append(cs, &container{
name: name,
path: path,
})
}
return cs, nil
} | go | {
"resource": ""
} |
q8553 | CreateContainer | train | func (l *Location) CreateContainer(containerName string) (stow.Container, error) {
projId, _ := l.config.Config(ConfigProjectId)
// Create a bucket.
_, err := l.client.Buckets.Insert(projId, &storage.Bucket{Name: containerName}).Do()
//res, err := l.client.Buckets.Insert(projId, &storage.Bucket{Name: containerName}).Do()
if err != nil {
return nil, err
}
newContainer := &Container{
name: containerName,
client: l.client,
}
return newContainer, nil
} | go | {
"resource": ""
} |
q8554 | Containers | train | func (l *Location) Containers(prefix string, cursor string, count int) ([]stow.Container, string, error) {
projId, _ := l.config.Config(ConfigProjectId)
// List all objects in a bucket using pagination
call := l.client.Buckets.List(projId).MaxResults(int64(count))
if prefix != "" {
call.Prefix(prefix)
}
if cursor != "" {
call = call.PageToken(cursor)
}
res, err := call.Do()
if err != nil {
return nil, "", err
}
containers := make([]stow.Container, len(res.Items))
for i, o := range res.Items {
containers[i] = &Container{
name: o.Name,
client: l.client,
}
}
return containers, res.NextPageToken, nil
} | go | {
"resource": ""
} |
q8555 | Register | train | func Register(mock Mock) {
if Exists(mock) {
return
}
// Make ops thread safe
mutex.Lock()
defer mutex.Unlock()
// Expose mock in request/response for delegation
mock.Request().Mock = mock
mock.Response().Mock = mock
// Registers the mock in the global store
mocks = append(mocks, mock)
} | go | {
"resource": ""
} |
q8556 | Exists | train | func Exists(m Mock) bool {
storeMutex.RLock()
defer storeMutex.RUnlock()
for _, mock := range mocks {
if mock == m {
return true
}
}
return false
} | go | {
"resource": ""
} |
q8557 | Remove | train | func Remove(m Mock) {
for i, mock := range mocks {
if mock == m {
storeMutex.Lock()
mocks = append(mocks[:i], mocks[i+1:]...)
storeMutex.Unlock()
}
}
} | go | {
"resource": ""
} |
q8558 | Clean | train | func Clean() {
storeMutex.Lock()
defer storeMutex.Unlock()
buf := []Mock{}
for _, mock := range mocks {
if mock.Done() {
continue
}
buf = append(buf, mock)
}
mocks = buf
} | go | {
"resource": ""
} |
q8559 | Add | train | func (m *MockMatcher) Add(fn MatchFunc) {
m.Matchers = append(m.Matchers, fn)
} | go | {
"resource": ""
} |
q8560 | Match | train | func (m *MockMatcher) Match(req *http.Request, ereq *Request) (bool, error) {
for _, matcher := range m.Matchers {
matches, err := matcher(req, ereq)
if err != nil {
return false, err
}
if !matches {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8561 | MatchMock | train | func MatchMock(req *http.Request) (Mock, error) {
for _, mock := range GetAll() {
matches, err := mock.Match(req)
if err != nil {
return nil, err
}
if matches {
return mock, nil
}
}
return nil, nil
} | go | {
"resource": ""
} |
q8562 | NewRequest | train | func NewRequest() *Request {
return &Request{
Counter: 1,
URLStruct: &url.URL{},
Header: make(http.Header),
PathParams: make(map[string]string),
}
} | go | {
"resource": ""
} |
q8563 | URL | train | func (r *Request) URL(uri string) *Request {
r.URLStruct, r.Error = url.Parse(uri)
return r
} | go | {
"resource": ""
} |
q8564 | SetURL | train | func (r *Request) SetURL(u *url.URL) *Request {
r.URLStruct = u
return r
} | go | {
"resource": ""
} |
q8565 | method | train | func (r *Request) method(method, path string) *Request {
if path != "/" {
r.URLStruct.Path = path
}
r.Method = strings.ToUpper(method)
return r
} | go | {
"resource": ""
} |
q8566 | BodyString | train | func (r *Request) BodyString(body string) *Request {
r.BodyBuffer = []byte(body)
return r
} | go | {
"resource": ""
} |
q8567 | File | train | func (r *Request) File(path string) *Request {
r.BodyBuffer, r.Error = ioutil.ReadFile(path)
return r
} | go | {
"resource": ""
} |
q8568 | Compression | train | func (r *Request) Compression(scheme string) *Request {
r.Header.Set("Content-Encoding", scheme)
r.CompressionScheme = scheme
return r
} | go | {
"resource": ""
} |
q8569 | JSON | train | func (r *Request) JSON(data interface{}) *Request {
if r.Header.Get("Content-Type") == "" {
r.Header.Set("Content-Type", "application/json")
}
r.BodyBuffer, r.Error = readAndDecode(data, "json")
return r
} | go | {
"resource": ""
} |
q8570 | BasicAuth | train | func (r *Request) BasicAuth(username, password string) *Request {
r.Header.Set("Authorization", "Basic "+basicAuth(username, password))
return r
} | go | {
"resource": ""
} |
q8571 | MatchHeader | train | func (r *Request) MatchHeader(key, value string) *Request {
r.Header.Set(key, value)
return r
} | go | {
"resource": ""
} |
q8572 | HeaderPresent | train | func (r *Request) HeaderPresent(key string) *Request {
r.Header.Set(key, ".*")
return r
} | go | {
"resource": ""
} |
q8573 | MatchHeaders | train | func (r *Request) MatchHeaders(headers map[string]string) *Request {
for key, value := range headers {
r.Header.Set(key, value)
}
return r
} | go | {
"resource": ""
} |
q8574 | MatchParam | train | func (r *Request) MatchParam(key, value string) *Request {
query := r.URLStruct.Query()
query.Set(key, value)
r.URLStruct.RawQuery = query.Encode()
return r
} | go | {
"resource": ""
} |
q8575 | MatchParams | train | func (r *Request) MatchParams(params map[string]string) *Request {
query := r.URLStruct.Query()
for key, value := range params {
query.Set(key, value)
}
r.URLStruct.RawQuery = query.Encode()
return r
} | go | {
"resource": ""
} |
q8576 | ParamPresent | train | func (r *Request) ParamPresent(key string) *Request {
r.MatchParam(key, ".*")
return r
} | go | {
"resource": ""
} |
q8577 | Times | train | func (r *Request) Times(num int) *Request {
r.Counter = num
return r
} | go | {
"resource": ""
} |
q8578 | AddMatcher | train | func (r *Request) AddMatcher(fn MatchFunc) *Request {
r.Mock.AddMatcher(fn)
return r
} | go | {
"resource": ""
} |
q8579 | SetMatcher | train | func (r *Request) SetMatcher(matcher Matcher) *Request {
r.Mock.SetMatcher(matcher)
return r
} | go | {
"resource": ""
} |
q8580 | Map | train | func (r *Request) Map(fn MapRequestFunc) *Request {
r.Mappers = append(r.Mappers, fn)
return r
} | go | {
"resource": ""
} |
q8581 | EnableNetworking | train | func (r *Request) EnableNetworking() *Request {
if r.Response != nil {
r.Response.UseNetwork = true
}
return r
} | go | {
"resource": ""
} |
q8582 | Reply | train | func (r *Request) Reply(status int) *Response {
return r.Response.Status(status)
} | go | {
"resource": ""
} |
q8583 | ReplyError | train | func (r *Request) ReplyError(err error) *Response {
return r.Response.SetError(err)
} | go | {
"resource": ""
} |
q8584 | ReplyFunc | train | func (r *Request) ReplyFunc(replier func(*Response)) *Response {
replier(r.Response)
return r.Response
} | go | {
"resource": ""
} |
q8585 | Responder | train | func Responder(req *http.Request, mock *Response, res *http.Response) (*http.Response, error) {
// If error present, reply it
err := mock.Error
if err != nil {
return nil, err
}
if res == nil {
res = createResponse(req)
}
// Apply response filter
for _, filter := range mock.Filters {
if !filter(res) {
return res, nil
}
}
// Define mock status code
if mock.StatusCode != 0 {
res.Status = strconv.Itoa(mock.StatusCode) + " " + http.StatusText(mock.StatusCode)
res.StatusCode = mock.StatusCode
}
// Define headers by merging fields
res.Header = mergeHeaders(res, mock)
// Define mock body, if present
if len(mock.BodyBuffer) > 0 {
res.ContentLength = int64(len(mock.BodyBuffer))
res.Body = createReadCloser(mock.BodyBuffer)
}
// Apply response mappers
for _, mapper := range mock.Mappers {
if tres := mapper(res); tres != nil {
res = tres
}
}
// Sleep to simulate delay, if necessary
if mock.ResponseDelay > 0 {
time.Sleep(mock.ResponseDelay)
}
return res, err
} | go | {
"resource": ""
} |
q8586 | createResponse | train | func createResponse(req *http.Request) *http.Response {
return &http.Response{
ProtoMajor: 1,
ProtoMinor: 1,
Proto: "HTTP/1.1",
Request: req,
Header: make(http.Header),
Body: createReadCloser([]byte{}),
}
} | go | {
"resource": ""
} |
q8587 | mergeHeaders | train | func mergeHeaders(res *http.Response, mres *Response) http.Header {
for key, values := range mres.Header {
for _, value := range values {
res.Header.Add(key, value)
}
}
return res.Header
} | go | {
"resource": ""
} |
q8588 | createReadCloser | train | func createReadCloser(body []byte) io.ReadCloser {
return ioutil.NopCloser(bytes.NewReader(body))
} | go | {
"resource": ""
} |
q8589 | startHTTPServer | train | func startHTTPServer() *httptest.Server {
return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
fmt.Println("Local server received a GET request")
res, err := http.Get("http://httpbin.org/nope")
if err != nil {
msg := fmt.Sprintf("Error from request to httpbin: %s", err)
http.Error(w, msg, http.StatusInternalServerError)
return
}
body, _ := ioutil.ReadAll(res.Body)
// MUST NOT get original body since the networking
// wasn't enabled for this request
fmt.Printf("Body From httpbin: %s\n", string(body))
fmt.Printf("Status From httpbin: %s\n", res.Status)
io.WriteString(w, "Local Response="+res.Header.Get("Server"))
}))
} | go | {
"resource": ""
} |
q8590 | MatchMethod | train | func MatchMethod(req *http.Request, ereq *Request) (bool, error) {
return ereq.Method == "" || req.Method == ereq.Method, nil
} | go | {
"resource": ""
} |
q8591 | MatchScheme | train | func MatchScheme(req *http.Request, ereq *Request) (bool, error) {
return ereq.URLStruct.Scheme == "" || req.URL.Scheme == "" || ereq.URLStruct.Scheme == req.URL.Scheme, nil
} | go | {
"resource": ""
} |
q8592 | MatchHost | train | func MatchHost(req *http.Request, ereq *Request) (bool, error) {
url := ereq.URLStruct
if strings.EqualFold(url.Host, req.URL.Host) {
return true, nil
}
return regexp.MatchString(url.Host, req.URL.Host)
} | go | {
"resource": ""
} |
q8593 | MatchPath | train | func MatchPath(req *http.Request, ereq *Request) (bool, error) {
if req.URL.Path == ereq.URLStruct.Path {
return true, nil
}
return regexp.MatchString(ereq.URLStruct.Path, req.URL.Path)
} | go | {
"resource": ""
} |
q8594 | MatchHeaders | train | func MatchHeaders(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.Header {
var err error
var match bool
for _, field := range req.Header[key] {
match, err = regexp.MatchString(value[0], field)
if err != nil {
return false, err
}
if match {
break
}
}
if !match {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8595 | MatchQueryParams | train | func MatchQueryParams(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.URLStruct.Query() {
var err error
var match bool
for _, field := range req.URL.Query()[key] {
match, err = regexp.MatchString(value[0], field)
if err != nil {
return false, err
}
if match {
break
}
}
if !match {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8596 | MatchPathParams | train | func MatchPathParams(req *http.Request, ereq *Request) (bool, error) {
for key, value := range ereq.PathParams {
var s string
if err := parth.Sequent(req.URL.Path, key, &s); err != nil {
return false, nil
}
if s != value {
return false, nil
}
}
return true, nil
} | go | {
"resource": ""
} |
q8597 | Status | train | func (r *Response) Status(code int) *Response {
r.StatusCode = code
return r
} | go | {
"resource": ""
} |
q8598 | SetHeader | train | func (r *Response) SetHeader(key, value string) *Response {
r.Header.Set(key, value)
return r
} | go | {
"resource": ""
} |
q8599 | AddHeader | train | func (r *Response) AddHeader(key, value string) *Response {
r.Header.Add(key, value)
return r
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.