工作
经过几番调试终于对radosgw部分的代码框架有了大致的了解，当然工作任务是顺利完成了。细细想来有下面的总结。
radosgw通过下面的代码，针对http不同请求(GET, POST, PUT, HEAD…)创建不同的对象，处理不同的业务需求。值得注意的是RSET(Representational state transfer)是一个表现层的协议。
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
34RGWOp* RGWHandler_REST::get_op(void)
{
RGWOp *op;
switch (s->op) {
case OP_GET:
op = op_get();
break;
case OP_PUT:
op = op_put();
break;
case OP_DELETE:
op = op_delete();
break;
case OP_HEAD:
op = op_head();
break;
case OP_POST:
op = op_post();
break;
case OP_COPY:
op = op_copy();
break;
case OP_OPTIONS:
op = op_options();
break;
default:
return NULL;
}
if (op) {
op->init(store, s, this);
}
return op;
} /* get_op */封装libcurl, 实现httpclient
代码src\rgw\rgw_http_client.cc, 需要细细品。读日志vs动态调试
不得不说当你对代码熟悉的时候，读日志比动态调试代码高效很多。我可以清晰地看到来自civetweb的报文信息，以及radosgw的各种处理。valgrind
valgrind只是简单的用了下。
生活
-
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17class Solution:
def findRepeatedDnaSequences(self, s: str) -> List[str]:
# 滑动窗口
# 先将k-1的数据放入窗口(这里k=10)
k = 10
record = [c for c in s[:k-1]]
R = dict()
for in_ in s[k-1:]:
record.append(in_)
dk = ''.join(record)
R[dk] = R.get(dk, 0) + 1
record.pop(0)
ans = []
for k, v in R.items():
if v != 1:
ans.append(k)
return ans -
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
# 滑动窗口
# 先将k-1个元素，加入窗口
k += 1
record = dict()
for n in nums[:k-1]:
record[n] = record.get(n, 0) + 1
if record[n] != 1:
return True
for in_, out in zip(nums[k-1:], nums):
record[in_] = record.get(in_, 0) + 1
if record[in_] != 1:
return True
record[out] -= 1
if record[out] == 0:
del record[out]
return False -
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19from typing import *
import bisect
class Solution:
def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
# 滑动窗口
# 初始化先将k-1个元素放入窗口内
# 二分插入
k += 1
record = sorted([n for n in nums[:k-1]])
for i in range(len(record) - 1):
if record[i+1] - record[i] <= t:
return True
for in_, out in zip(nums[k-1:], nums):
ix = bisect.bisect(record, in_)
record.insert(ix, in_)
if (ix - 1 >= 0 and record[ix] - record[ix-1] <= t) or (ix + 1 < len(record) and record[ix + 1] - record[ix] <= t):
return True
del record[bisect.bisect(record, out)-1]
return False -
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
28import bisect
class dep:
def __init__(self):
self.sk = []
def insert(self, x):
while self.sk and self.sk[-1] < x:
self.sk.pop()
self.sk.append(x)
def first(self):
return self.sk[0]
def popfirst(self):
self.sk.pop(0)
class Solution:
def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
# 单调队列
# 先将k-1个元素放入窗口内
record = dep()
for n in nums[:k-1]:
record.insert(n)
ans = []
for in_, out in zip(nums[k-1:], nums):
record.insert(in_)
f = record.first()
ans.append(f)
if f == out:
record.popfirst()
return ansps 评论区有意思的东西
单调队列真是一种让人感到五味杂陈的数据结构，它的维护过程更是如此…..就拿此题来说，队头最大，往队尾方向单调……有机会站在队头的老大永远心狠手辣，当它从队尾杀进去的时候，如果它发现这里面没一个够自己打的，它会毫无人性地屠城，把原先队里的人头全部丢出去，转身建立起自己的政权，野心勃勃地准备开创一个新的王朝…..这时候，它的人格竟发生了一百八十度大反转，它变成了一位胸怀宽广的慈父！它热情地请那些新来的“小个子”们入住自己的王国……然而，这些小个子似乎天性都是一样的——嫉妒心强，倘若见到比自己还小的居然更早入住王国，它们会心狠手辣地找一个夜晚把它们通通干掉，好让自己享受更大的“蛋糕”；当然，遇到比自己强大的，它们也没辙，乖乖夹起尾巴做人。像这样的暗杀事件每天都在上演，虽然王国里日益笼罩上白色恐怖，但是好在没有后来者强大到足以干翻国王，江山还算能稳住。直到有一天，闯进来了一位真正厉害的角色，就像当年打江山的国王一样，手段狠辣，野心膨胀，于是又是大屠城……历史总是轮回的。
觉得现代官场更加能阐明这个基本道理。比如你这个倒霉蛋25岁二本毕业在机关当科员， 熬了十年后老处长退休， 你们科长升处长， 你升科长。你梦想着再熬10年处长退休·你接班。结果是赵家人不讲武德。直接空降一个25岁的付处。他比你先接班，你等他退休也没戏， 所以这一辈子和处长没关系，自然可以从queue里pop out， 不用排队。
- 读书:《政治的人生》
细细想来我已经好久没有读过这样的书了。我不敢相信这是1994年写的书，因为我感觉作者的思考的问题，表达的事情在2022年并不过时。
