1curl -fsSL https://raw.githubusercontent.com/dapr/cli/master/install/install.sh | /bin/bash

1$ dapr init
2⌛  Making the jump to hyperspace...
3Downloading binaries and setting up components
4✅  Success! Dapr is up and running
5
6$ docker ps
7CONTAINER ID        IMAGE                COMMAND                  CREATED             STATUS              PORTS                        NAMES
8b3a5600e672f        redis                "docker-entrypoint.s…"   44 hours ago        Up 44 hours         0.0.0.0:6379->6379/tcp       xenodochial_hofstadter
9e5010ba0c33f        daprio/dapr          "./placement"            44 hours ago        Up 44 hours         0.0.0.0:50005->50005/tcp     dapr_placement

1git clone https://github.com/dapr/samples.git
2cd samples/1.hello-world

 1// $ cat app.js 
 2// ------------------------------------------------------------
 3// Copyright (c) Microsoft Corporation.
 4// Licensed under the MIT License.
 5// ------------------------------------------------------------
 6
 7const express = require('express');
 8const bodyParser = require('body-parser');
 9require('isomorphic-fetch');
10
11const app = express();
12app.use(bodyParser.json());
13
14const daprPort = process.env.DAPR_HTTP_PORT || 3500;
15const stateUrl = `http://localhost:${daprPort}/v1.0/state`;
16const port = 3000;
17
18app.get('/order', (_req, res) => {
19    fetch(`${stateUrl}/order`)
20        .then((response) => {
21            return response.json();
22        }).then((orders) => {
23            res.send(orders);
24        });
25});
26
27app.post('/neworder', (req, res) => {
28    const data = req.body.data;
29    const orderId = data.orderId;
30    console.log("Got a new order! Order ID: " + orderId);
31
32    const state = [{
33        key: "order",
34        value: data
35    }];
36
37    fetch(stateUrl, {
38        method: "POST",
39        body: JSON.stringify(state),
40        headers: {
41            "Content-Type": "application/json"
42        }
43    }).then((response) => {
44        console.log((response.ok) ? "Successfully persisted state" : "Failed to persist state");
45    });
46
47    res.status(200).send();
48});
49
50app.listen(port, () => console.log(`Node App listening on port ${port}!`));

1const daprPort = process.env.DAPR_HTTP_PORT || 3500;
2const stateUrl = `http://localhost:${daprPort}/v1.0/state`;
3const port = 3000;

 1app.post('/neworder', (req, res) => {
 2    const data = req.body.data;
 3    const orderId = data.orderId;
 4    console.log("Got a new order! Order ID: " + orderId);
 5
 6    const state = [{
 7        key: "order",
 8        value: data
 9    }];
10
11    fetch(stateUrl, {
12        method: "POST",
13        body: JSON.stringify(state),
14        headers: {
15            "Content-Type": "application/json"
16        }
17    }).then((response) => {
18        console.log((response.ok) ? "Successfully persisted state" : "Failed to persist state");
19    });
20
21    res.status(200).send();
22});

1app.get('/order', (_req, res) => {
2    fetch(`${stateUrl}/order`)
3        .then((response) => {
4            return response.json();
5        }).then((orders) => {
6            res.send(orders);
7        });
8});

1$ dapr run --app-id mynode --app-port 3000 --port 3500 node app.js
2ℹ️  Starting Dapr with id mynode. HTTP Port: 3500. gRPC Port: 55099
3✅  You're up and running! Both Dapr and your app logs will appear here.

 1== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="starting Dapr Runtime -- version 0.1.0 -- commit 4358565-dirty"
 2== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="log level set to: info"
 3== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="standalone mode configured"
 4== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="dapr id: mynode"
 5== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="loaded component messagebus (pubsub.redis)"
 6== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="loaded component statestore (state.redis)"
 7== DAPR == time="2019-11-06T10:37:41+08:00" level=info msg="application protocol: http. waiting on port 3000"
 8== APP == Node App listening on port 3000!
 9== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="application discovered on port 3000"
10== DAPR == 2019/11/06 10:37:42 redis: connecting to localhost:6379
11== DAPR == 2019/11/06 10:37:42 redis: connected to localhost:6379 (localAddr: [::1]:55130, remAddr: [::1]:6379)
12== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actor runtime started. actor idle timeout: 1h0m0s. actor scan interval: 30s"
13== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: starting connection attempt to placement service at localhost:50005"
14== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="http server is running on port 3500"
15== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="gRPC server is running on port 55099"
16== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="local service entry announced"
17== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="dapr initialized. Status: Running. Init Elapsed 945.8297490000001ms"
18== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: established connection to placement service at localhost:50005"
19== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: placement order received: lock"
20== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: placement order received: update"
21== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: placement tables updated"
22== DAPR == time="2019-11-06T10:37:42+08:00" level=info msg="actors: placement order received: unlock"

1curl -XPOST -d @sample.json http://localhost:3500/v1.0/invoke/mynode/method/neworder

1POST http://localhost:3500/v1.0/invoke/mynode/method/neworder
2{
3  "data": {
4    "orderId": "42"
5  } 
6}

1== APP == Got a new order! Order ID: 42
2== APP == Successfully persisted state

1curl http://localhost:3500/v1.0/invoke/mynode/method/order

1GET http://localhost:3500/v1.0/invoke/mynode/method/order

1^C
2ℹ️  terminated signal received: shutting down
3✅  Exited Dapr successfully
4✅  Exited App successfully

1# 安装工具
2$ npm install iceworks -g
3# 启动工作台
4$ iceworks

1"predeploy": "npm run build", 
2"deploy": "gh-pages -d build"

1git init
2git add README.md
3git commit -m "first commit"
4git remote add origin git@github.com:{yourName}/{yourProjectName}.git
5git push -u origin master

1npm install gh-pages --save-dev

1npm run deploy

 1// A Buffer is a variable-sized buffer of bytes with Read and Write methods.
 2// The zero value for Buffer is an empty buffer ready to use.
 3// 注意 buffer 的零值是空的 buf
 4type Buffer struct {
 5    buf       []byte   // contents are the bytes buf[off : len(buf)]
 6    off       int      // read at &buf[off], write at &buf[len(buf)]
 7    bootstrap [64]byte // memory to hold first slice; helps small buffers avoid allocation.
 8    lastRead  readOp   // last read operation, so that Unread* can work correctly.
 9
10    // FIXME: it would be advisable to align Buffer to cachelines to avoid false
11    // sharing.
12}

 1// Grow grows the buffer's capacity, if necessary, to guarantee space for
 2// another n bytes. After Grow(n), at least n bytes can be written to the
 3// buffer without another allocation.
 4// If n is negative, Grow will panic.
 5// If the buffer can't grow it will panic with ErrTooLarge.
 6// 增加容量 n byte
 7func (b *Buffer) Grow(n int) {
 8    if n < 0 {
 9        panic("bytes.Buffer.Grow: negative count")
10    }
11    m := b.grow(n)
12    b.buf = b.buf[:m]
13}

 1// WriteString appends the contents of s to the buffer, growing the buffer as
 2// needed. The return value n is the length of s; err is always nil. If the
 3// buffer becomes too large, WriteString will panic with ErrTooLarge.
 4// 直接写 string 也行，同时自动扩展
 5func (b *Buffer) WriteString(s string) (n int, err error) {
 6    b.lastRead = opInvalid
 7    //先尝试不用扩展容量的写法
 8    m, ok := b.tryGrowByReslice(len(s))
 9    if !ok {
10        m = b.grow(len(s))
11    }
12    // copy 可以直接把 string 类型作为 字节切片拷贝过去
13    return copy(b.buf[m:], s), nil
14}

 1// ReadFrom reads data from r until EOF and appends it to the buffer, growing
 2// the buffer as needed. The return value n is the number of bytes read. Any
 3// error except io.EOF encountered during the read is also returned. If the
 4// buffer becomes too large, ReadFrom will panic with ErrTooLarge.
 5// 从实现了 io.Reader 接口的 r 中读取到 EOF 为止，如果超出了 maxInt 那么大就会返回太
 6// 大不能通过一个 [maxInt]byte 字节切片来存储了
 7func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
 8    b.lastRead = opInvalid
 9    for {
10        i := b.grow(MinRead)
11        // grow 申请了 n 个空间之后，会将 buffer 中的字节切片延长长度到 n 个字节之后
12        // 所以需要重新赋值一下长度，避免一些误解，保证长度都是有效数据提供的
13        b.buf = b.buf[:i]
14        // 将 r 中的数据读到 buffer 中去
15        m, e := r.Read(b.buf[i:cap(b.buf)])
16        if m < 0 {
17            panic(errNegativeRead)
18        }
19
20        // 手动更改长度
21        b.buf = b.buf[:i+m]
22        n += int64(m)
23        if e == io.EOF {
24            return n, nil // e is EOF, so return nil explicitly
25        }
26        if e != nil {
27            return n, e
28        }
29    }
30}

 1// WriteTo writes data to w until the buffer is drained or an error occurs.
 2// The return value n is the number of bytes written; it always fits into an
 3// int, but it is int64 to match the io.WriterTo interface. Any error
 4// encountered during the write is also returned.
 5func (b *Buffer) WriteTo(w io.Writer) (n int64, err error) {
 6    b.lastRead = opInvalid
 7    if nBytes := b.Len(); nBytes > 0 {
 8        //从 off 开始读的地方算起，全部写到 io.Writer 中去
 9        m, e := w.Write(b.buf[b.off:])
10        //写的多了就报错
11        if m > nBytes {
12            panic("bytes.Buffer.WriteTo: invalid Write count")
13        }
14        //记录写过了多少，位移 offset 指针
15        b.off += m
16
17        n = int64(m)
18        if e != nil {
19            return n, e
20        }
21        // all bytes should have been written, by definition of
22        // Write method in io.Writer
23        // 因为刚才判断过写多了的情况，所以这里是写少了
24        if m != nBytes {
25            return n, io.ErrShortWrite
26        }
27    }
28    // Buffer is now empty; reset.
29    // 写完之后重置
30    b.Reset()
31    return n, nil
32}

 1// ReadBytes reads until the first occurrence of delim in the input,
 2// returning a slice containing the data up to and including the delimiter.
 3// If ReadBytes encounters an error before finding a delimiter,
 4// it returns the data read before the error and the error itself (often io.EOF).
 5// ReadBytes returns err != nil if and only if the returned data does not end in
 6// delim.
 7// 读取到终止符为止，就结束
 8func (b *Buffer) ReadBytes(delim byte) (line []byte, err error) {
 9    slice, err := b.readSlice(delim)
10    // return a copy of slice. The buffer's backing array may
11    // be overwritten by later calls.
12    line = append(line, slice...)
13    return line, err
14}

 1// NewBuffer creates and initializes a new Buffer using buf as its
 2// initial contents. The new Buffer takes ownership of buf, and the
 3// caller should not use buf after this call. NewBuffer is intended to
 4// prepare a Buffer to read existing data. It can also be used to size
 5// the internal buffer for writing. To do that, buf should have the
 6// desired capacity but a length of zero.
 7//
 8// In most cases, new(Buffer) (or just declaring a Buffer variable) is
 9// sufficient to initialize a Buffer.
10// 通过字节切片创建一个 buffer ，字节切片会保留初始值
11// 在渴望容量但是长度为 0？的情况下
12// 也可以当作内核的 buffer 来写入
13func NewBuffer(buf []byte) *Buffer { return &Buffer{buf: buf} }

 1// A Reader implements the io.Reader, io.ReaderAt, io.WriterTo, io.Seeker,
 2// io.ByteScanner, and io.RuneScanner interfaces by reading from
 3// a byte slice.
 4// Unlike a Buffer, a Reader is read-only and supports seeking.
 5// 实现了读取的各种方法，与 buffer 不同的是，只读同时支持位置
 6type Reader struct {
 7    s        []byte
 8    i        int64 // current reading index
 9    prevRune int   // index of previous rune; or < 0
10}

 1// Generic split: splits after each instance of sep,
 2// including sepSave bytes of sep in the subslices.
 3// 将含有 sep 的字节切片全部单独切开，最多切 n 个，同时 匹配到时候多切 sepSave 个字节一起切进同一个切片
 4func genSplit(s, sep []byte, sepSave, n int) [][]byte {
 5    if n == 0 {
 6        return nil
 7    }
 8    if len(sep) == 0 {
 9        return explode(s, n)
10    }
11    if n < 0 {
12        n = Count(s, sep) + 1
13    }
14
15    a := make([][]byte, n)
16    n--
17    i := 0
18    for i < n {
19        m := Index(s, sep)
20        if m < 0 {
21            break
22        }
23        a[i] = s[: m+sepSave : m+sepSave]
24        s = s[m+len(sep):]
25        i++
26    }
27    a[i] = s
28    return a[:i+1]
29}

 1var asciiSpace = [256]uint8{'\t': 1, '\n': 1, '\v': 1, '\f': 1, '\r': 1, ' ': 1}
 2
 3// Fields interprets s as a sequence of UTF-8-encoded code points.
 4// It splits the slice s around each instance of one or more consecutive white space
 5// characters, as defined by unicode.IsSpace, returning a slice of subslices of s or an
 6// empty slice if s contains only white space.
 7func Fields(s []byte) [][]byte {
 8    // First count the fields.
 9    // This is an exact count if s is ASCII, otherwise it is an approximation.
10    n := 0
11    wasSpace := 1
12    // setBits is used to track which bits are set in the bytes of s.
13  // 意思就是通过位来判断是否所有的都可以通过字节来表示而不是需要utf-8编码
14    setBits := uint8(0)
15  // 这里实现了如果连续出现空格不会多次计数的除噪，通过 wasSpace
16    for i := 0; i < len(s); i++ {
17        r := s[i]
18        setBits |= r
19        isSpace := int(asciiSpace[r])
20        n += wasSpace & ^isSpace
21        wasSpace = isSpace
22    }
23    //不能通过ASCII码了就用utf-8
24    if setBits >= utf8.RuneSelf {
25        // Some runes in the input slice are not ASCII.
26        return FieldsFunc(s, unicode.IsSpace)
27    }
28
29    // ASCII fast path 更快
30    a := make([][]byte, n)
31    na := 0
32    fieldStart := 0
33    i := 0
34    // Skip spaces in the front of the input.
35  // 跳过开头的空格
36    for i < len(s) && asciiSpace[s[i]] != 0 {
37        i++
38    }
39    fieldStart = i
40    for i < len(s) {
41        if asciiSpace[s[i]] == 0 {
42            i++
43            continue
44        }
45        a[na] = s[fieldStart:i:i]
46        na++
47        i++
48        // Skip spaces in between fields.
49        for i < len(s) && asciiSpace[s[i]] != 0 {
50            i++
51        }
52        fieldStart = i
53    }
54  // 弥补上面的判断可能最后的EOF会忽略
55    if fieldStart < len(s) { // Last field might end at EOF.
56        a[na] = s[fieldStart:len(s):len(s)]
57    }
58    return a
59}

 1// Join concatenates the elements of s to create a new byte slice. The separator
 2// sep is placed between elements in the resulting slice.
 3func Join(s [][]byte, sep []byte) []byte {
 4    if len(s) == 0 {
 5        return []byte{}
 6    }
 7    if len(s) == 1 {
 8        // Just return a copy.
 9        return append([]byte(nil), s[0]...)
10    }
11  //判断需要多长的切片
12    n := len(sep) * (len(s) - 1)
13    for _, v := range s {
14        n += len(v)
15    }
16
17    b := make([]byte, n)
18    bp := copy(b, s[0])
19    for _, v := range s[1:] {
20        bp += copy(b[bp:], sep)
21        bp += copy(b[bp:], v)
22    }
23    return b
24}

 1// Map returns a copy of the byte slice s with all its characters modified
 2// according to the mapping function. If mapping returns a negative value, the character is
 3// dropped from the byte slice with no replacement. The characters in s and the
 4// output are interpreted as UTF-8-encoded code points.
 5
 6func Map(mapping func(r rune) rune, s []byte) []byte {
 7    // In the worst case, the slice can grow when mapped, making
 8    // things unpleasant. But it's so rare we barge in assuming it's
 9    // fine. It could also shrink but that falls out naturally.
10    maxbytes := len(s) // length of b
11    nbytes := 0        // number of bytes encoded in b
12    b := make([]byte, maxbytes)
13    for i := 0; i < len(s); {
14        wid := 1
15        r := rune(s[i])
16        if r >= utf8.RuneSelf {
17            r, wid = utf8.DecodeRune(s[i:])
18        }
19        r = mapping(r)
20        if r >= 0 {
21            rl := utf8.RuneLen(r)
22            if rl < 0 {
23                rl = len(string(utf8.RuneError))
24            }
25            if nbytes+rl > maxbytes {
26                // Grow the buffer.
27                maxbytes = maxbytes*2 + utf8.UTFMax
28                nb := make([]byte, maxbytes)
29                copy(nb, b[0:nbytes])
30                b = nb
31            }
32            nbytes += utf8.EncodeRune(b[nbytes:maxbytes], r)
33        }
34        i += wid
35    }
36    return b[0:nbytes]
37}

 1// indexFunc is the same as IndexFunc except that if
 2// truth==false, the sense of the predicate function is
 3// inverted.
 4func indexFunc(s []byte, f func(r rune) bool, truth bool) int {
 5    start := 0
 6    for start < len(s) {
 7        wid := 1
 8        r := rune(s[start])
 9    //如果是utf-8编码才能识别，则调用utf-8.DecodeRune(s[start:])
10        if r >= utf8.RuneSelf {
11            r, wid = utf8.DecodeRune(s[start:])
12        }
13        if f(r) == truth {
14            return start
15        }
16        start += wid
17    }
18    return -1
19}

 1func makeCutsetFunc(cutset string) func(r rune) bool {
 2    if len(cutset) == 1 && cutset[0] < utf8.RuneSelf {
 3        return func(r rune) bool {
 4            return r == rune(cutset[0])
 5        }
 6    }
 7    if as, isASCII := makeASCIISet(cutset); isASCII {
 8        return func(r rune) bool {
 9            return r < utf8.RuneSelf && as.contains(byte(r))
10        }
11    }
12    return func(r rune) bool {
13        for _, c := range cutset {
14            if c == r {
15                return true
16            }
17        }
18        return false
19    }
20}

 1// DecodeRune unpacks the first UTF-8 encoding in p and returns the rune and
 2// its width in bytes. If p is empty it returns (RuneError, 0). Otherwise, if
 3// the encoding is invalid, it returns (RuneError, 1). Both are impossible
 4// results for correct, non-empty UTF-8.
 5//
 6// An encoding is invalid if it is incorrect UTF-8, encodes a rune that is
 7// out of range, or is not the shortest possible UTF-8 encoding for the
 8// value. No other validation is performed.
 9func DecodeRune(p []byte) (r rune, size int) {
10    n := len(p)
11    if n < 1 {
12        return RuneError, 0
13    }
14    p0 := p[0]
15    x := first[p0]
16    if x >= as {
17        // The following code simulates an additional check for x == xx and
18        // handling the ASCII and invalid cases accordingly. This mask-and-or
19        // approach prevents an additional branch.
20        mask := rune(x) << 31 >> 31 // Create 0x0000 or 0xFFFF.
21        return rune(p[0])&^mask | RuneError&mask, 1
22    }
23    sz := x & 7
24    accept := acceptRanges[x>>4]
25    if n < int(sz) {
26        return RuneError, 1
27    }
28    b1 := p[1]
29    if b1 < accept.lo || accept.hi < b1 {
30        return RuneError, 1
31    }
32    if sz == 2 {
33        return rune(p0&mask2)<<6 | rune(b1&maskx), 2
34    }
35    b2 := p[2]
36    if b2 < locb || hicb < b2 {
37        return RuneError, 1
38    }
39    if sz == 3 {
40        return rune(p0&mask3)<<12 | rune(b1&maskx)<<6 | rune(b2&maskx), 3
41    }
42    b3 := p[3]
43    if b3 < locb || hicb < b3 {
44        return RuneError, 1
45    }
46    return rune(p0&mask4)<<18 | rune(b1&maskx)<<12 | rune(b2&maskx)<<6 | rune(b3&maskx), 4
47}

1//go:noescape
2
3// Equal returns a boolean reporting whether a and b
4// are the same length and contain the same bytes.
5// A nil argument is equivalent to an empty slice.
6func Equal(a, b []byte) bool // in internal/bytealg

 1// dialOptions configure a Dial call. dialOptions are set by the DialOption
 2// values passed to Dial.
 3type dialOptions struct {
 4    unaryInt  UnaryClientInterceptor
 5    streamInt StreamClientInterceptor
 6
 7    chainUnaryInts  []UnaryClientInterceptor
 8    chainStreamInts []StreamClientInterceptor
 9
10    cp          Compressor
11    dc          Decompressor
12    bs          backoff.Strategy
13    block       bool
14    insecure    bool
15    timeout     time.Duration
16    scChan      <-chan ServiceConfig
17    authority   string
18    copts       transport.ConnectOptions
19    callOptions []CallOption
20    // This is used by v1 balancer dial option WithBalancer to support v1
21    // balancer, and also by WithBalancerName dial option.
22    balancerBuilder balancer.Builder
23    // This is to support grpclb.
24    resolverBuilder             resolver.Builder
25    channelzParentID            int64
26    disableServiceConfig        bool
27    disableRetry                bool
28    disableHealthCheck          bool
29    healthCheckFunc             internal.HealthChecker
30    minConnectTimeout           func() time.Duration
31    defaultServiceConfig        *ServiceConfig // defaultServiceConfig is parsed from defaultServiceConfigRawJSON.
32    defaultServiceConfigRawJSON *string
33}

 1func DialContext(ctx context.Context, target string, opts ...DialOption) (conn *ClientConn, err error) {
 2    cc := &ClientConn{
 3        target:            target,
 4        csMgr:             &connectivityStateManager{},
 5        conns:             make(map[*addrConn]struct{}),
 6        dopts:             defaultDialOptions(),
 7        blockingpicker:    newPickerWrapper(),
 8        czData:            new(channelzData),
 9        firstResolveEvent: grpcsync.NewEvent(),
10    }
11    ···
12    for _, opt := range opts {
13        opt.apply(&cc.dopts)
14    }
15    ···
16}

 1// CallOption configures a Call before it starts or extracts information from
 2// a Call after it completes.
 3type CallOption interface {
 4    // before is called before the call is sent to any server.  If before
 5    // returns a non-nil error, the RPC fails with that error.
 6    before(*callInfo) error
 7
 8    // after is called after the call has completed.  after cannot return an
 9    // error, so any failures should be reported via output parameters.
10    after(*callInfo)
11}

 1// callInfo contains all related configuration and information about an RPC.
 2type callInfo struct {
 3    compressorType        string
 4    failFast              bool
 5    stream                ClientStream
 6    maxReceiveMessageSize *int
 7    maxSendMessageSize    *int
 8    creds                 credentials.PerRPCCredentials
 9    contentSubtype        string
10    codec                 baseCodec
11    maxRetryRPCBufferSize int
12}

 1// Header returns a CallOptions that retrieves the header metadata
 2// for a unary RPC.
 3func Header(md *metadata.MD) CallOption {
 4    return HeaderCallOption{HeaderAddr: md}
 5}
 6
 7// HeaderCallOption is a CallOption for collecting response header metadata.
 8// The metadata field will be populated *after* the RPC completes.
 9// This is an EXPERIMENTAL API.
10type HeaderCallOption struct {
11    HeaderAddr *metadata.MD
12}
13
14func (o HeaderCallOption) before(c *callInfo) error { return nil }
15func (o HeaderCallOption) after(c *callInfo) {
16    if c.stream != nil {
17        *o.HeaderAddr, _ = c.stream.Header()
18    }
19}

1// WithDefaultCallOptions returns a DialOption which sets the default
2// CallOptions for calls over the connection.
3func WithDefaultCallOptions(cos ...CallOption) DialOption {
4    return newFuncDialOption(func(o *dialOptions) {
5        o.callOptions = append(o.callOptions, cos...)
6    })
7}

1response, err := myclient.MyCall(ctx, request, grpc.CallContentSubtype("mycodec"))

1myclient := grpc.Dial(ctx, target, grpc.WithDefaultCallOptions(grpc.CallContentSubtype("mycodec")))

1type Codec interface {
2    // Marshal returns the wire format of v.
3    Marshal(v interface{}) ([]byte, error)
4    // Unmarshal parses the wire format into v.
5    Unmarshal(data []byte, v interface{}) error
6    // String returns the name of the Codec implementation.  This is unused by
7    // gRPC.
8    String() string
9}

 1// RegisterCodec registers the provided Codec for use with all gRPC clients and
 2// servers.
 3//
 4// The Codec will be stored and looked up by result of its Name() method, which
 5// should match the content-subtype of the encoding handled by the Codec.  This
 6// is case-insensitive, and is stored and looked up as lowercase.  If the
 7// result of calling Name() is an empty string, RegisterCodec will panic. See
 8// Content-Type on
 9// https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md#requests for
10// more details.
11//
12// NOTE: this function must only be called during initialization time (i.e. in
13// an init() function), and is not thread-safe.  If multiple Compressors are
14// registered with the same name, the one registered last will take effect.
15func RegisterCodec(codec Codec) {
16    if codec == nil {
17        panic("cannot register a nil Codec")
18    }
19    if codec.Name() == "" {
20        panic("cannot register Codec with empty string result for Name()")
21    }
22    contentSubtype := strings.ToLower(codec.Name())
23    registeredCodecs[contentSubtype] = codec
24}

 1// Compressor is used for compressing and decompressing when sending or
 2// receiving messages.
 3type Compressor interface {
 4    // Compress writes the data written to wc to w after compressing it.  If an
 5    // error occurs while initializing the compressor, that error is returned
 6    // instead.
 7    Compress(w io.Writer) (io.WriteCloser, error)
 8    // Decompress reads data from r, decompresses it, and provides the
 9    // uncompressed data via the returned io.Reader.  If an error occurs while
10    // initializing the decompressor, that error is returned instead.
11    Decompress(r io.Reader) (io.Reader, error)
12    // Name is the name of the compression codec and is used to set the content
13    // coding header.  The result must be static; the result cannot change
14    // between calls.
15    Name() string
16}

1type MD map[string][]string