package clientv3

import pb "github.com/coreos/etcd/etcdserver/etcdserverpb"

type opType int

const (
    // A default Op has opType 0, which is invalid.
    tRange opType = iota + 1
    tPut
    tDeleteRange
)

var (
    noPrefixEnd = []byte{0}
)

// Op represents an Operation that kv can execute.
type Op struct {
    t   opType
    key []byte
    end []byte

    // for range
    limit        int64
    sort         *SortOption
    serializable bool
    keysOnly     bool
    countOnly    bool
    minModRev    int64
    maxModRev    int64
    minCreateRev int64
    maxCreateRev int64

    // for range, watch
    rev int64

    // for watch, put, delete
    prevKV bool

    // progressNotify is for progress updates.
    progressNotify bool
    // createdNotify is for created event
    createdNotify bool
    // filters for watchers
    filterPut    bool
    filterDelete bool

    // for put
    val     []byte
    leaseID LeaseID
}

func (op Op) toRangeRequest() *pb.RangeRequest {
    if op.t != tRange {
        panic("op.t != tRange")
    }
    r := &pb.RangeRequest{
        Key:               op.key,
        RangeEnd:          op.end,
        Limit:             op.limit,
        Revision:          op.rev,
        Serializable:      op.serializable,
        KeysOnly:          op.keysOnly,
        CountOnly:         op.countOnly,
        MinModRevision:    op.minModRev,
        MaxModRevision:    op.maxModRev,
        MinCreateRevision: op.minCreateRev,
        MaxCreateRevision: op.maxCreateRev,
    }
    if op.sort != nil {
        r.SortOrder = pb.RangeRequest_SortOrder(op.sort.Order)
        r.SortTarget = pb.RangeRequest_SortTarget(op.sort.Target)
    }
    return r
}

func (op Op) toRequestOp() *pb.RequestOp {
    switch op.t {
    case tRange:
        return &pb.RequestOp{Request: &pb.RequestOp_RequestRange{RequestRange: op.toRangeRequest()}}
    case tPut:
        r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID), PrevKv: op.prevKV}
        return &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: r}}
    case tDeleteRange:
        r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV}
        return &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{RequestDeleteRange: r}}
    default:
        panic("Unknown Op")
    }
}

func (op Op) isWrite() bool {
    return op.t != tRange
}

func OpGet(key string, opts ...OpOption) Op {
    ret := Op{t: tRange, key: []byte(key)}
    ret.applyOpts(opts)
    return ret
}

func OpDelete(key string, opts ...OpOption) Op {
    ret := Op{t: tDeleteRange, key: []byte(key)}
    ret.applyOpts(opts)
    switch {
    case ret.leaseID != 0:
        panic("unexpected lease in delete")
    case ret.limit != 0:
        panic("unexpected limit in delete")
    case ret.rev != 0:
        panic("unexpected revision in delete")
    case ret.sort != nil:
        panic("unexpected sort in delete")
    case ret.serializable:
        panic("unexpected serializable in delete")
    case ret.countOnly:
        panic("unexpected countOnly in delete")
    case ret.minModRev != 0, ret.maxModRev != 0:
        panic("unexpected mod revision filter in delete")
    case ret.minCreateRev != 0, ret.maxCreateRev != 0:
        panic("unexpected create revision filter in delete")
    case ret.filterDelete, ret.filterPut:
        panic("unexpected filter in delete")
    case ret.createdNotify:
        panic("unexpected createdNotify in delete")
    }
    return ret
}

func OpPut(key, val string, opts ...OpOption) Op {
    ret := Op{t: tPut, key: []byte(key), val: []byte(val)}
    ret.applyOpts(opts)
    switch {
    case ret.end != nil:
        panic("unexpected range in put")
    case ret.limit != 0:
        panic("unexpected limit in put")
    case ret.rev != 0:
        panic("unexpected revision in put")
    case ret.sort != nil:
        panic("unexpected sort in put")
    case ret.serializable:
        panic("unexpected serializable in put")
    case ret.countOnly:
        panic("unexpected countOnly in put")
    case ret.minModRev != 0, ret.maxModRev != 0:
        panic("unexpected mod revision filter in put")
    case ret.minCreateRev != 0, ret.maxCreateRev != 0:
        panic("unexpected create revision filter in put")
    case ret.filterDelete, ret.filterPut:
        panic("unexpected filter in put")
    case ret.createdNotify:
        panic("unexpected createdNotify in put")
    }
    return ret
}

func opWatch(key string, opts ...OpOption) Op {
    ret := Op{t: tRange, key: []byte(key)}
    ret.applyOpts(opts)
    switch {
    case ret.leaseID != 0:
        panic("unexpected lease in watch")
    case ret.limit != 0:
        panic("unexpected limit in watch")
    case ret.sort != nil:
        panic("unexpected sort in watch")
    case ret.serializable:
        panic("unexpected serializable in watch")
    case ret.countOnly:
        panic("unexpected countOnly in watch")
    case ret.minModRev != 0, ret.maxModRev != 0:
        panic("unexpected mod revision filter in watch")
    case ret.minCreateRev != 0, ret.maxCreateRev != 0:
        panic("unexpected create revision filter in watch")
    }
    return ret
}

func (op *Op) applyOpts(opts []OpOption) {
    for _, opt := range opts {
        opt(op)
    }
}

// OpOption configures Operations like Get, Put, Delete.
type OpOption func(*Op)

// WithLease attaches a lease ID to a key in 'Put' request.
func WithLease(leaseID LeaseID) OpOption {
    return func(op *Op) { op.leaseID = leaseID }
}

// WithLimit limits the number of results to return from 'Get' request.
func WithLimit(n int64) OpOption { return func(op *Op) { op.limit = n } }

// WithRev specifies the store revision for 'Get' request.
// Or the start revision of 'Watch' request.
func WithRev(rev int64) OpOption { return func(op *Op) { op.rev = rev } }

// WithSort specifies the ordering in 'Get' request. It requires
// 'WithRange' and/or 'WithPrefix' to be specified too.
// 'target' specifies the target to sort by: key, version, revisions, value.
// 'order' can be either 'SortNone', 'SortAscend', 'SortDescend'.
func WithSort(target SortTarget, order SortOrder) OpOption {
    return func(op *Op) {
        if target == SortByKey && order == SortAscend {
            // If order != SortNone, server fetches the entire key-space,
            // and then applies the sort and limit, if provided.
            // Since current mvcc.Range implementation returns results
            // sorted by keys in lexicographically ascending order,
            // client should ignore SortOrder if the target is SortByKey.
            order = SortNone
        }
        op.sort = &SortOption{target, order}
    }
}

// GetPrefixRangeEnd gets the range end of the prefix.
// 'Get(foo, WithPrefix())' is equal to 'Get(foo, WithRange(GetPrefixRangeEnd(foo))'.
func GetPrefixRangeEnd(prefix string) string {
    return string(getPrefix([]byte(prefix)))
}

func getPrefix(key []byte) []byte {
    end := make([]byte, len(key))
    copy(end, key)
    for i := len(end) - 1; i >= 0; i-- {
        if end[i] < 0xff {
            end[i] = end[i] + 1
            end = end[:i+1]
            return end
        }
    }
    // next prefix does not exist (e.g., 0xffff);
    // default to WithFromKey policy
    return noPrefixEnd
}

// WithPrefix enables 'Get', 'Delete', or 'Watch' requests to operate
// on the keys with matching prefix. For example, 'Get(foo, WithPrefix())'
// can return 'foo1', 'foo2', and so on.
func WithPrefix() OpOption {
    return func(op *Op) {
        op.end = getPrefix(op.key)
    }
}

// WithRange specifies the range of 'Get', 'Delete', 'Watch' requests.
// For example, 'Get' requests with 'WithRange(end)' returns
// the keys in the range [key, end).
// endKey must be lexicographically greater than start key.
func WithRange(endKey string) OpOption {
    return func(op *Op) { op.end = []byte(endKey) }
}

// WithFromKey specifies the range of 'Get', 'Delete', 'Watch' requests
// to be equal or greater than the key in the argument.
func WithFromKey() OpOption { return WithRange("\x00") }

// WithSerializable makes 'Get' request serializable. By default,
// it's linearizable. Serializable requests are better for lower latency
// requirement.
func WithSerializable() OpOption {
    return func(op *Op) { op.serializable = true }
}

// WithKeysOnly makes the 'Get' request return only the keys and the corresponding
// values will be omitted.
func WithKeysOnly() OpOption {
    return func(op *Op) { op.keysOnly = true }
}

// WithCountOnly makes the 'Get' request return only the count of keys.
func WithCountOnly() OpOption {
    return func(op *Op) { op.countOnly = true }
}

// WithMinModRev filters out keys for Get with modification revisions less than the given revision.
func WithMinModRev(rev int64) OpOption { return func(op *Op) { op.minModRev = rev } }

// WithMaxModRev filters out keys for Get with modification revisions greater than the given revision.
func WithMaxModRev(rev int64) OpOption { return func(op *Op) { op.maxModRev = rev } }

// WithMinCreateRev filters out keys for Get with creation revisions less than the given revision.
func WithMinCreateRev(rev int64) OpOption { return func(op *Op) { op.minCreateRev = rev } }

// WithMaxCreateRev filters out keys for Get with creation revisions greater than the given revision.
func WithMaxCreateRev(rev int64) OpOption { return func(op *Op) { op.maxCreateRev = rev } }

// WithFirstCreate gets the key with the oldest creation revision in the request range.
func WithFirstCreate() []OpOption { return withTop(SortByCreateRevision, SortAscend) }

// WithLastCreate gets the key with the latest creation revision in the request range.
func WithLastCreate() []OpOption { return withTop(SortByCreateRevision, SortDescend) }

// WithFirstKey gets the lexically first key in the request range.
func WithFirstKey() []OpOption { return withTop(SortByKey, SortAscend) }

// WithLastKey gets the lexically last key in the request range.
func WithLastKey() []OpOption { return withTop(SortByKey, SortDescend) }

// WithFirstRev gets the key with the oldest modification revision in the request range.
func WithFirstRev() []OpOption { return withTop(SortByModRevision, SortAscend) }

// WithLastRev gets the key with the latest modification revision in the request range.
func WithLastRev() []OpOption { return withTop(SortByModRevision, SortDescend) }

// withTop gets the first key over the get's prefix given a sort order
func withTop(target SortTarget, order SortOrder) []OpOption {
    return []OpOption{WithPrefix(), WithSort(target, order), WithLimit(1)}
}

// WithProgressNotify makes watch server send periodic progress updates
// every 10 minutes when there is no incoming events.
// Progress updates have zero events in WatchResponse.
func WithProgressNotify() OpOption {
    return func(op *Op) {
        op.progressNotify = true
    }
}

// WithCreatedNotify makes watch server sends the created event.
func WithCreatedNotify() OpOption {
    return func(op *Op) {
        op.createdNotify = true
    }
}

// WithFilterPut discards PUT events from the watcher.
func WithFilterPut() OpOption {
    return func(op *Op) { op.filterPut = true }
}

// WithFilterDelete discards DELETE events from the watcher.
func WithFilterDelete() OpOption {
    return func(op *Op) { op.filterDelete = true }
}

// WithPrevKV gets the previous key-value pair before the event happens. If the previous KV is already compacted,
// nothing will be returned.
func WithPrevKV() OpOption {
    return func(op *Op) {
        op.prevKV = true
    }
}

// LeaseOp represents an Operation that lease can execute.
type LeaseOp struct {
    id LeaseID

    // for TimeToLive
    attachedKeys bool
}

// LeaseOption configures lease operations.
type LeaseOption func(*LeaseOp)

func (op *LeaseOp) applyOpts(opts []LeaseOption) {
    for _, opt := range opts {
        opt(op)
    }
}

// WithAttachedKeys requests lease timetolive API to return
// attached keys of given lease ID.
func WithAttachedKeys() LeaseOption {
    return func(op *LeaseOp) { op.attachedKeys = true }
}

func toLeaseTimeToLiveRequest(id LeaseID, opts ...LeaseOption) *pb.LeaseTimeToLiveRequest {
    ret := &LeaseOp{id: id}
    ret.applyOpts(opts)
    return &pb.LeaseTimeToLiveRequest{ID: int64(id), Keys: ret.attachedKeys}
}

op.go的更多相关文章

  1. IE、FF、Safari、OP不同浏览器兼容报告

    IE.FF.Safari.OP不同浏览器兼容报告 1         浏览器内核简介 Trident IE浏览器(GreenBrowser绿色浏览器, 遨游浏览器....都是IE) Geckos Fi ...

  2. ERROR<53761> - Plugins - conn=-1 op=-1 msgId=-1 - Connection Bind through PTA failed (91). Retrying...

    LDAP6.3在DSCC控制台启动实例完成,但是操作状态显示“意外错误”,查看日志如下: 04/May/2016:21:10:39 +0800] - Sun-Java(tm)-System-Direc ...

  3. 兼容ie6/ff/ch/op的div+css实现的圆角框

    <!DOCTYPE html> <html> <head> <title>青春不迷茫:寻梦时代的“蚁族”逆袭之旅- 职场管理专题-中国人力资源开发网-中 ...

  4. read op case $op in

     read op case $op in

  5. OP（Over-provisioning）预留空间

    SSD上的OP指的是用户不可操作的容量,大小为实际容量减去用户可用容量,OP区域一般被用于优化操作如:WL,GC和坏块映射等.       OP一般分三层(见下图).第一层容量固定为SSD标称容量的7 ...

  6. Python 实现的下载op海贼王网的图片（网络爬虫）

    没得事就爬一下我喜欢的海贼王上的图片 须要在d盘下建立一个imgcache目录 # -*- coding: utf-8 -*- import urllib import urllib2 import ...

  7. Microsoft Dynamics CRM 9.0 OP 版本 安装 的那些 雷

    天天讲安装过程好无聊了,还是搞点有营养的东西来,那么后面来说说刚出来的MSCRM OP 9.0 版本安装的那些雷: 雷1:操作系统要求Windows 2016 Server 这点还好,因为之前安装MS ...

  8. op 和 oo 的区别

    本是之前一位前辈留下的问题,因为我不是程序出身,略懂一些代码,后又查了很多人的博客,问了周围搞开发的朋友,得出以下结论: 有人这么形容OP和OO的不同:用面向过程的方法写出来的程序是一份蛋炒饭,而用面 ...

  9. tensorflow 升级到1.9-rc0,生成静态图frozen graph.pb本地测试正常， 在其他版本（eg1.4版本）或者android下运行出错NodeDef mentions attr 'dilations' not in Op<name=Conv2D; signature=input:T, filter:T -> output:T; attr=T:type,allowed=[DT_

    这时节点定义找不到NodeDef attr 'dilations' not in,说明执行版本的NodeDef不在节点定义上,两个不一致,分别是执行inference的代码和生成静态图节点不一致(当然 ...

随机推荐

  1. Oracle 报错ORA-00904:标示符无效

    写select查询,报错:ORA-00904 标示符无效 这个错误通常是因为 字段名写错了,或者是在创建表的时候,创建最后一个字段的时候也加了逗号 . 我遇到的情况时,之前的同事创建表的时候,将小写的 ...

  2. 关于js对象添加属性

    字符串类型的(注意要加引号): var obj={}; for(var i=0;i<10;i++){ eval("obj.key"+i+"='"+&quo ...

  3. Python-Web框架之 - 利用SQLALchemy创建与数据库MySQL的连接, 详解用Flask时会遇到的一些大坑 !

    经过这个小项目算是对Django与Flask这两个web框架有了新的认识 , Django本身的轮子非常齐全 , 套路也很固定 , 新手在接触Django框架时 , 不会陷入到处找轮子的大坑 ; 那么 ...

  4. C++堆栈问题

    编写C++中的两个类 一个只能在栈中分配空间 一个只能在堆中分配. 解答: (1)代码如下 (2)堆栈分配内存的介绍 一.一个经过编译的C/C++的程序占用的内存分成以下几个部分:1.栈区(stack ...

  5. Colossus: Successor to the Google File System (GFS)

    Colossus is the successor to the Google File System (GFS) as mentioned in the recent paper on Spanne ...

  6. 浅谈这个时代的SEO与网络营销

    1.大网站对分享内容的审核越来越严,高质量借道外链越来越难做. 2.大搜索引擎入口的权威性将会不断受各种方面的的削弱:比如自媒体.垂直服务网站等 3.旧路还没有短,但是新路要积极挖掘. 这也说的太少了 ...

  7. 清理out的浏览器收藏夹发现的

    刚才清理了一下自己的浏览器书签,其实好几年不做收藏了,常用的直接放到书签栏里就行了. 发现不少之前的技术内容域名都被色情病毒经营者续费利用,相关技术内容都是VB.SQL.XMAPP这些过期的玩意,其中 ...

  8. java线程之线程通信

    前面提到多线程操作会有一个资源共享问题. 日常生活中,对于一个超市,有供货商往超市运货,有消费者从超市取货,供货商和消费者都与超市 建立了某种连接,超市就相当于公共资源,而他们的这种行为放到线程上说就 ...

  9. 【原创】整合Spring4+Hibernate4+Struts2时NullPointerException问题解决

    1.开场白 相信SSH初学者肯定遇到过这个问题,但是又是百思不得其解,明白了之后就恍然大悟. 2.问题描述 程序实现过程是UserAction中调用UserService,UserService的实现 ...

  10. centos下网络的配置

    1.网络模式要进行使用NAT,要连网的话,要配置好设置:网络要进行一下共享到虚拟机 进入vi /etc/sysconfig/network-scripts/ifcfg-eth0   把里面的onboo ...