本文整理汇总了Golang中github.com/bioothod/backrunner/errors.NewKeyError函数的典型用法代码示例。如果您正苦于以下问题:Golang NewKeyError函数的具体用法?Golang NewKeyError怎么用?Golang NewKeyError使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了NewKeyError函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: Delete
func (bctl *BucketCtl) Delete(bname, key string, req *http.Request) (err error) {
bucket, err := bctl.FindBucket(bname)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, err.Error())
return
}
err = bucket.check_auth(req, BucketAuthWrite)
if err != nil {
err = errors.NewKeyError(req.URL.String(), errors.ErrorStatus(err),
fmt.Sprintf("upload: %s", errors.ErrorData(err)))
return
}
s, err := bctl.e.DataSession(req)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("delete: could not create data session: %v", err))
return
}
defer s.Delete()
s.SetNamespace(bucket.Name)
s.SetGroups(bucket.Meta.Groups)
s.SetIOflags(elliptics.IOflag(bctl.Conf.Proxy.WriterIOFlags))
log.Printf("delete-trace-id: %x: url: %s, bucket: %s, key: %s, id: %s\n",
s.GetTraceID(), req.URL.String(), bucket.Name, key, s.Transform(key))
for r := range s.Remove(key) {
err = r.Error()
}
return
}
示例2: Lookup
func (bctl *BucketCtl) Lookup(bname, key string, req *http.Request) (reply *reply.LookupResult, err error) {
bucket, err := bctl.FindBucket(bname)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, err.Error())
return
}
err = bucket.check_auth(req, BucketAuthEmpty)
if err != nil {
err = errors.NewKeyError(req.URL.String(), errors.ErrorStatus(err),
fmt.Sprintf("upload: %s", errors.ErrorData(err)))
return
}
s, err := bctl.e.DataSession(req)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("lookup: could not create data session: %v", err))
return
}
defer s.Delete()
s.SetNamespace(bucket.Name)
s.SetGroups(bucket.Meta.Groups)
s.SetIOflags(elliptics.IOflag(bctl.Conf.Proxy.ReaderIOFlags))
log.Printf("lookup-trace-id: %x: url: %s, bucket: %s, key: %s, id: %s\n",
s.GetTraceID(), req.URL.String(), bucket.Name, key, s.Transform(key))
reply, err = bucket.lookup_serialize(false, s.ParallelLookup(key))
return
}
示例3: check_auth
func (b *Bucket) check_auth(r *http.Request, required_flags uint64) (err error) {
if len(b.Meta.Acl) == 0 {
err = nil
return
}
user, recv_auth, err := auth.GetAuthInfo(r)
if err != nil {
return
}
acl, ok := b.Meta.Acl[user]
if !ok {
err = errors.NewKeyError(r.URL.String(), http.StatusForbidden,
fmt.Sprintf("auth: header: '%v': there is no user '%s' in ACL",
r.Header[auth.AuthHeaderStr], user))
return
}
log.Printf("check-auth: url: %s, user: %s, token: %s, flags: %x, required: %x\n",
r.URL.String(), acl.User, acl.Token, acl.Flags, required_flags)
// only require required_flags check if its not @BucketAuthEmpty
// @BucketAuthEmpty required_flags is set by reader, non BucketAuthEmpty required_flags are supposed to mean modifications
if required_flags != BucketAuthEmpty {
// there are no required flags in ACL
if (acl.Flags & required_flags) == 0 {
err = errors.NewKeyError(r.URL.String(), http.StatusForbidden,
fmt.Sprintf("auth: header: '%v': user '%s' is not allowed to do action: acl-flags: 0x%x, required-flags: 0x%x",
r.Header[auth.AuthHeaderStr], user, acl.Flags, required_flags))
return
}
}
// skip authorization if special ACL flag is set
if (acl.Flags & BucketAuthNoToken) != 0 {
return
}
calc_auth, err := auth.GenerateSignature(acl.Token, r.Method, r.URL, r.Header)
if err != nil {
err = errors.NewKeyError(r.URL.String(), http.StatusForbidden,
fmt.Sprintf("auth: header: '%v': hmac generation failed: %s",
r.Header[auth.AuthHeaderStr], user))
return
}
if recv_auth != calc_auth {
err = errors.NewKeyError(r.URL.String(), http.StatusForbidden,
fmt.Sprintf("auth: header: '%v': user: %s, hmac mismatch: recv: '%s', calc: '%s'",
r.Header[auth.AuthHeaderStr], user, recv_auth, calc_auth))
return
}
return
}
示例4: Stream
func (bctl *BucketCtl) Stream(bname, key string, w http.ResponseWriter, req *http.Request) (err error) {
bucket, err := bctl.FindBucket(bname)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, err.Error())
return
}
err = bucket.check_auth(req, BucketAuthEmpty)
if err != nil {
err = errors.NewKeyError(req.URL.String(), errors.ErrorStatus(err),
fmt.Sprintf("stream: %s", errors.ErrorData(err)))
return
}
s, err := bctl.e.DataSession(req)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("stream: could not create data session: %v", err))
return
}
defer s.Delete()
s.SetFilter(elliptics.SessionFilterAll)
s.SetNamespace(bucket.Name)
bctl.SetGroupsTimeout(s, bucket, key)
log.Printf("stream-trace-id: %x: url: %s, bucket: %s, key: %s, id: %s\n",
s.GetTraceID(), req.URL.String(), bucket.Name, key, s.Transform(key))
offset, size, err := URIOffsetSize(req)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, fmt.Sprintf("stream: %v", err))
return
}
if offset != 0 || size != 0 {
if size == 0 {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-", offset))
} else {
req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", offset, offset+size-1))
}
}
rs, err := elliptics.NewReadSeekerOffsetSize(s, key, offset, size)
if err != nil {
err = errors.NewKeyErrorFromEllipticsError(err, req.URL.String(), "stream: could not create read-seeker")
return
}
defer rs.Free()
bctl.SetContentType(key, w)
http.ServeContent(w, req, key, rs.Mtime, rs)
return
}
示例5: lookup_handler
func lookup_handler(w http.ResponseWriter, req *http.Request, strings ...string) Reply {
bucket := strings[0]
key := strings[1]
reply, err := proxy.bctl.Lookup(bucket, key, req)
if err != nil {
return Reply{
err: err,
status: errors.ErrorStatus(err),
}
}
reply_json, err := json.Marshal(reply)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("lookup: json marshal failed: %q", err))
return Reply{
err: err,
status: http.StatusServiceUnavailable,
}
}
w.WriteHeader(http.StatusOK)
w.Write(reply_json)
return GoodReply()
}
示例6: stat_handler
func stat_handler(w http.ResponseWriter, req *http.Request, str ...string) Reply {
bnames := make([]string, 0)
bnames_combined := strings.SplitN(str[0], "/", 2)
if len(bnames_combined[0]) != 0 {
bnames = strings.Split(bnames_combined[0], ",")
if len(bnames[0]) == 0 {
bnames = []string{}
}
}
reply, err := proxy.bctl.Stat(req, bnames)
if err != nil {
return Reply{
err: err,
status: errors.ErrorStatus(err),
}
}
reply_json, err := json.Marshal(reply)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("stat: json marshal failed: %q", err))
return Reply{
err: err,
status: http.StatusBadRequest,
}
}
w.WriteHeader(http.StatusOK)
w.Write(reply_json)
return GoodReply()
}
示例7: update_local_config_handler
func update_local_config_handler(w http.ResponseWriter, req *http.Request, strings ...string) Reply {
conf := &config.ProxyConfig{}
err := conf.LoadIO(req.Body)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest,
fmt.Sprintf("conf: could not parse config: %q", err))
return Reply{
err: err,
status: http.StatusBadRequest,
}
}
conf.Proxy.RedirectToken = proxy.bctl.Conf.Proxy.RedirectToken
diff := pretty.Diff(proxy.bctl.Conf, conf)
for _, d := range diff {
log.Printf("update_local_config_handler: diff: %s\n", d)
}
proxy.bctl.Lock()
proxy.bctl.Conf = conf
proxy.bctl.DisableConfigUpdateUntil = time.Now().Add(time.Second * time.Duration(conf.Proxy.DisableConfigUpdateForSeconds))
proxy.bctl.Unlock()
log.Printf("update_local_config_handler: next automatic config update is only allowed in %d seconds at %s\n",
conf.Proxy.DisableConfigUpdateForSeconds,
proxy.bctl.DisableConfigUpdateUntil.String())
return GoodReply()
}
示例8: common_handler
func common_handler(w http.ResponseWriter, req *http.Request, strings ...string) Reply {
if len(proxy.bctl.Conf.Proxy.Root) == 0 {
err := errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("common: root option is not configured, reading files is being denied"))
return Reply{
err: err,
status: http.StatusServiceUnavailable,
}
}
if len(strings) == 0 {
w.WriteHeader(http.StatusOK)
return GoodReply()
}
object := path.Clean(strings[0])
if object == bucket.ProfilePath || object == "." {
err := errors.NewKeyError(req.URL.String(), http.StatusNotFound,
fmt.Sprintf("common: could not read file '%s'", object))
return Reply{
err: err,
status: http.StatusNotFound,
}
}
key := proxy.bctl.Conf.Proxy.Root + "/" + object
data, err := ioutil.ReadFile(key)
if err != nil {
log.Printf("common: url: %s, object: '%s', error: %s\n", req.URL.String(), object, err)
err = errors.NewKeyError(req.URL.String(), http.StatusNotFound,
fmt.Sprintf("common: could not read file '%s'", object))
return Reply{
err: err,
status: http.StatusNotFound,
}
}
w.WriteHeader(http.StatusOK)
w.Write(data)
return GoodReplyLength(uint64(len(data)))
}
示例9: BucketUpload
func (bctl *BucketCtl) BucketUpload(bucket_name, key string, req *http.Request) (reply *reply.LookupResult, bucket *Bucket, err error) {
bucket, err = bctl.FindBucket(bucket_name)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, err.Error())
return
}
reply, err = bctl.bucket_upload(bucket, key, req)
return
}
示例10: BulkDelete
func (bctl *BucketCtl) BulkDelete(bname string, keys []string, req *http.Request) (reply map[string]interface{}, err error) {
reply = make(map[string]interface{})
bucket, err := bctl.FindBucket(bname)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusBadRequest, err.Error())
return
}
err = bucket.check_auth(req, BucketAuthWrite)
if err != nil {
err = errors.NewKeyError(req.URL.String(), errors.ErrorStatus(err),
fmt.Sprintf("upload: %s", errors.ErrorData(err)))
return
}
s, err := bctl.e.DataSession(req)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("bulk_delete: could not create data session: %v", err))
return
}
defer s.Delete()
s.SetNamespace(bucket.Name)
s.SetGroups(bucket.Meta.Groups)
s.SetIOflags(elliptics.IOflag(bctl.Conf.Proxy.WriterIOFlags))
log.Printf("bulk-delete-trace-id: %x: url: %s, bucket: %s, keys: %v\n",
s.GetTraceID(), req.URL.String(), bucket.Name, keys)
for r := range s.BulkRemove(keys) {
err = r.Error()
if err != nil {
reply[r.Key()] = err.Error()
}
}
err = nil
return
}
示例11: Upload
func (bctl *BucketCtl) Upload(key string, req *http.Request) (reply *reply.LookupResult, bucket *Bucket, err error) {
bucket = bctl.GetBucket(key, req)
if bucket == nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("there are no buckets with free space available"))
return
}
reply, err = bctl.bucket_upload(bucket, key, req)
return
}
示例12: ReadBucket
func ReadBucket(ell *etransport.Elliptics, name string) (bucket *Bucket, err error) {
ms, err := ell.MetadataSession()
if err != nil {
log.Printf("read-bucket: %s: could not create metadata session: %v", name, err)
return
}
defer ms.Delete()
ms.SetNamespace(BucketNamespace)
b := NewBucket(name)
for rd := range ms.ReadData(name, 0, 0) {
if rd.Error() != nil {
err = rd.Error()
log.Printf("read-bucket: %s: could not read bucket metadata: %v", name, err)
return
}
var out []interface{}
err = msgpack.Unmarshal([]byte(rd.Data()), &out)
if err != nil {
log.Printf("read-bucket: %s: could not parse bucket metadata: %v", name, err)
return
}
err = b.Meta.ExtractMsgpack(out)
if err != nil {
log.Printf("read-bucket: %s: unsupported msgpack data: %v", name, err)
return
}
bucket = b
return
}
bucket = nil
err = errors.NewKeyError(name, http.StatusNotFound,
"read-bucket: could not read bucket data: ReadData() returned nothing")
return
}
示例13: WriteBucket
func WriteBucket(ell *etransport.Elliptics, meta *BucketMsgpack) (bucket *Bucket, err error) {
ms, err := ell.MetadataSession()
if err != nil {
log.Printf("%s: could not create metadata session: %v", meta.Name, err)
return
}
defer ms.Delete()
ms.SetNamespace(BucketNamespace)
out, err := meta.PackMsgpack()
if err != nil {
log.Printf("%s: could not pack bucket: %v", meta.Name, err)
return
}
data, err := msgpack.Marshal(&out)
if err != nil {
log.Printf("%s: could not parse bucket metadata: %v", meta.Name, err)
return
}
for wr := range ms.WriteData(meta.Name, bytes.NewReader(data), 0, 0) {
if wr.Error() != nil {
err = wr.Error()
log.Printf("%s: could not write bucket metadata: %v", meta.Name, err)
return
}
bucket = NewBucket(meta.Name)
bucket.Meta = *meta
return
}
err = errors.NewKeyError(meta.Name, http.StatusNotFound,
"could not write bucket metadata: WriteData() returned nothing")
return
}
示例14: proxy_stat_handler
func proxy_stat_handler(w http.ResponseWriter, req *http.Request, strings ...string) Reply {
start_idx := proxy.error_index
l := uint64(len(proxy.last_errors))
if start_idx < uint64(len(proxy.last_errors)) {
l = start_idx
}
res := proxy_stat_reply{
BucketCtlStat: proxy.bctl.NewBucketCtlStat(),
Handlers: estimator_scan_handlers,
Errors: make([]ErrorInfo, l),
}
if start_idx <= uint64(len(proxy.last_errors)) {
copy(res.Errors, proxy.last_errors)
} else {
var i uint64
for i = 0; i < uint64(len(proxy.last_errors)); i++ {
idx := (i + start_idx + 1) % uint64(len(proxy.last_errors))
res.Errors[i] = proxy.last_errors[idx]
}
}
reply_json, err := json.Marshal(&res)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("stat: json marshal failed: %q", err))
return Reply{
err: err,
status: http.StatusServiceUnavailable,
}
}
w.WriteHeader(http.StatusOK)
w.Write(reply_json)
return GoodReply()
}
示例15: send_upload_reply
func (p *bproxy) send_upload_reply(w http.ResponseWriter, req *http.Request,
bucket *bucket.Bucket, key string, resp *reply.LookupResult) Reply {
reply := reply.Upload{
Bucket: bucket.Name,
Key: key,
Reply: resp,
}
reply_json, err := json.Marshal(reply)
if err != nil {
err = errors.NewKeyError(req.URL.String(), http.StatusServiceUnavailable,
fmt.Sprintf("upload: json marshal failed: %q", err))
return Reply{
err: err,
status: http.StatusServiceUnavailable,
}
}
w.WriteHeader(http.StatusOK)
w.Write(reply_json)
return GoodReply()
}