Weakyon Blog
0%

发表于 更新于 分类于 ， 本文字数： 3.5k 阅读时长 ≈ 3 分钟

最近在完善强一致性的存储系统的时候，发现对强一致性的理解不够透彻，步入了误区

强一致性存储系统的简单理解和定义

强一致性的理解：

resp返回给客户端之前，保证所有节点的内容都一致。

只要保证存储系统，在同步追加过程中强一致性，那么就能保证各个节点也为强一致性

阅读全文 »

发表于 更新于 分类于 本文字数： 2.8k 阅读时长 ≈ 3 分钟

在使用grpc的时候，对通信协议有着调用链追踪的需求

这部分要封装进框架，对使用方透明，因此协程上下文(Goroutine Local Storage)的用法顺理成章

但是搜索了些资料，发现golang并没有gls

google提供的解决方法是使用golang.org/x/net/context包来传递上下文信息

google的设计理念:context

阅读全文 »

发表于 更新于 分类于 ， 本文字数： 2k 阅读时长 ≈ 2 分钟

这是GPRC+ETCD服务发现的一种变种实现

在服务端代码的封装上有很大的区别，一个简单的服务发现系统中，服务端之间的状态互不影响

在主从系统中，主需要知道从的IP来向从复制数据（或者反过来从需要知道主的IP来拉取数据）,当主挂了，需要选举一台从来切换成主

服务发现的变种实现

阅读全文 »

发表于 更新于 分类于 本文字数： 2.4k 阅读时长 ≈ 2 分钟

安装

先安装protobuf的C库

然后安装protoc工具

1
2
3
go get -u github.com/golang/protobuf/proto

go get -u github.com/golang/protobuf/protoc-gen-go

最后安装gRPC-go

阅读全文 »

发表于 更新于 分类于 ， 本文字数： 4.1k 阅读时长 ≈ 4 分钟

难点：

最近公司做用户数据迁移，4TB的量，租借了20Gb的带宽，完整迁移需要25天，给的迁移期只有30天，整个迁移过程的容错性和可靠性要非常强

另外由于数据的特殊性，用户数据的错乱比起迁移失败等等无疑是更严重的问题，所以迁移过程要保证强独立性

然而迁移过程的开发时间只有5天，测试时间5天，非常仓促（实际上线后确实遇到不少问题，又花了5天才全部解决）

分析和解决：

阅读全文 »

发表于 更新于 分类于 本文字数： 1.9k 阅读时长 ≈ 2 分钟

需求是图片，视频等文件的存储

属于少写多读的场合，修改操作较少。文件粒度是大小文件都有。

fastdfs

先谈谈fastdfs，我在公司已经应用了两年了，对他的基本特性比较熟悉，在这种场合下有这些优缺点

阅读全文 »

发表于 更新于 分类于 本文字数： 5.9k 阅读时长 ≈ 5 分钟

golang的http上传文件的实现细节严格遵循了multipart/form-data的RFC1867规范，细节网上已经分析了很多了

本篇只是讨论golang上如何使用官方库实现的框架

客户端上传很简单，利用"mime/multipart"官方库即可完成上传

可以看到这里上传文件时全部加载在内存的bodyBuf字符数组中，所以这里只是上传小文件，大文件这么上传会写爆内存

阅读全文 »

发表于 更新于 分类于 本文字数： 2.3k 阅读时长 ≈ 2 分钟

codis在迁移方案上下了不少功夫，我认为codis和twemproxy最大的区别之一是：

codis是面向slot的管理，而twemproxy只是面向redis后端的管理

codis迁移是由Topom结构体的SlotCreateAction方法开始的，这个方法也许叫做SlotMoveToGroupCreateAction更加容易让人理解

这个方法需要两个参数，slot id以及group id，目的是吧这个slot（以及该slot的所有key）迁移到目标group中

SlotCreateAction检测了一些边界条件，例如slot正在被迁移，或者该slot已经存在与目标group

阅读全文 »

发表于 更新于 分类于 本文字数： 4.6k 阅读时长 ≈ 4 分钟

记录下踩到的坑

一 接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
package main                                                                       
                                                                                   
import (                                                                           
    "fmt"                                                                          
    "bytes"                                                                        
)                                                                                  
                                                                                   
type Stringer interface{                                                           
    String() string                                                                
}                                                                                  
                                                                                   
type Point struct{X,Y float64}                                                     
                                                                                   
func (p *Point) String() string{                                                   
    var buf bytes.Buffer                                                           
    fmt.Fprintf(&buf, "%f-%f",p.X,p.Y)                                             
    return buf.String()                                                            
}                                                                                  
                                                                                   
func main(){                                                                       
    r1 := Point{1,2}                                                               
    var r2 Stringer                                                                
    r2 = &r1                                                                       
    fmt.Println(&r1)            //1.000000-2.000000                                
    fmt.Println(r1)             //{1 2}
    fmt.Println(r1.String())    //1.000000-2.000000                                          
    fmt.Println(r2)             //1.000000-2.000000                                
}
```  

第一个语句是调用了带指针的String()结果

第二个Print语句输出r1，是Point结构体的，因为没有声明带指针的String方法，因此fmt输出了默认String方法，也就是{1,2}

第三个语句r1.String()为何能正确执行呢，这是因为编译器自动加了&r1.String()

第四个语句r2是接口类型，赋值r1以后检查类型Stringer实现的接口都被Point实现了，因此可以赋值，并且在调用时调用了r2带指针的String方法，而不是默认的那个

这里要注意的是,r2 = &r1是必须的，因为Point没有声明不带指针的String方法，如果要调用带指针的方法，必须对这个结构体取地址

**二 切片**

```go  
package main                                                                       
                                                                                   
import "fmt"                                                                       
                                                                                   
func main() {                                                                      
    array1 := [3]int{1,2}                                                          
    array2 := [5]int{}                                                             
    array3 := [...]int{}                                                           
    array4 := []int{1,2,3,4}                                                       
    array5 := []int{}                                                              
    fmt.Println(array1)     //[1 2 0]                                                            
    fmt.Println(array2)     //[0 0 0 0 0]                                              
    fmt.Println(array3)     //[]                                          
    fmt.Println(array4)     //[1 2 3 4]                                                   
    fmt.Println(array5)     //[]                                            
}
```  

切片和数组的声明很类似，困扰了我好久

array1,2,3都是数组类型,4,5是切片类型

在类型的[]里，有数字或者...的都是数组，如果什么都没有则是切片

在我的理解看来，切片是对数组的封装，保存了一个数组的指针

1 切片赋值为数组或者切片并且append小于原来的尺寸

```go
//demo1
array1 := [3]int{1,2}                                                          
array2 := []int{}                                                              
array2 = array1[0:1]                                                           
array2 = append(array2, 3, 4)                                            

//demo2
array3 := []int{1,2}                                                          
array4 := []int{}                                                              
array4 = array3[0:1]                                                           
array4 = append(array4, 3)                                            

fmt.Println(array1)         //[1 3 4]
fmt.Println(array2)         //[1 3 4]
fmt.Println(array3)         //[1 3]
fmt.Println(array4)         //[1 3]

对于demo1来说数组能够容纳下这一块数据，因此array2依然指向array1，array1被改为[1 3 4]

对于demo2来说array3底层的数组能够容纳下这一块数据，因此array4依然指向array3底层的数组，array3被改为[1,3]

阅读全文 »