两点之间

痛，在 Claude Code 配置目录被误删之后

Sat, 18 Apr 2026 18:00:00 +0800

昨天手误 rm -rf ~/.claude，把 Claude Code 的整个配置目录删了——CLAUDE.md、MCP 配置、settings、自定义 skills，几乎全部归零。后来靠 VS Code 的缓存找回了一部分，但也只够勉强止损。

非常痛，吸取教训，做了两件事。

用 rmtrash 替代 rm

安装 rmtrash，让 rm 变为移到废纸篓而非直接删除：

1

brew install rmtrash

在 ~/.zshrc 中加入 alias：

1
2


alias rm='rmtrash'
alias rmdir='rmdirtrash'

这样即使再次误删，也能从废纸篓恢复。

创建配置仓库

将需要版本管理的配置文件抽取到独立仓库，通过同步机制映射回各工具期望的路径。

仓库结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


claude-config/
├── claude/ # Claude Code 配置
│ ├── CLAUDE.md
│ ├── settings.json
│ └── mcp.json
├── codebuddy/ # CodeBuddy Code 配置
│ ├── CODEBUDDY.md
│ ├── AGENTS.md
│ ├── settings.json
│ └── mcp.json
├── rules/ # 共享规则（两个工具复用）
├── skills/ # 共享 skills（两个工具复用）
├── sync.conf # 同步规则声明
└── sync.sh # 同步脚本（含 launchd agent 管理）

核心设计

配置分离，规则共享：claude/ 和 codebuddy/ 各自维护独立的 settings 和 MCP 配置，但 rules/ 和 skills/ 目录两者共享。

同步方案（sync.sh）

Claude Code / CodeBuddy 使用原子写入（write-file-atomic）保存配置文件——写临时文件再 rename 覆盖目标。这会破坏硬链接和文件级软链接。因此配置文件不使用链接，改为 launchd WatchPaths + 双向 rsync 实现自动同步。

sync.conf 用简单的 DSL 声明两种同步关系：

[sync] — 文件双向同步，按 mtime 判断方向，较新者覆盖较旧者
[link] — 目录软链接（rules/、skills/），不受原子写入影响

用法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# 手动执行一次同步
bash sync.sh

# 安装 launchd agent（文件变更自动触发同步）
bash sync.sh install

# 查看 agent 状态
bash sync.sh status

# 卸载 agent
bash sync.sh uninstall

安装后，任何被监听文件的变更都会在 3 秒内自动触发双向同步，零人工干预。

日志位于 ~/Library/Logs/claude-config/sync.log。

迁移新Blog啦🎉，回顾2025、展望2026

Tue, 24 Feb 2026 11:45:40 +0800

迁移新Blog啦🎉

WordPress上的最后一篇博客停留在2014年，算起来也是12年前了，中间除了写过几篇公众号，没有其它记录了。

我对个人数据一直有备份，WordPress之前的Sablog的数据还在，但更早以前发布在外部平台的，百度Hi上的彻底没了。这些年，陆续有业务关停，大的像猫扑、网易的Blog和相册、天涯等，伴随着的就是数据消失。这些丢弃的数据，对个人来还是挺可惜的，想要保留好，还是回归博客，放在自己的手里更安全。

新年折腾了一下新博客，基于 Hugo + Git + Workflows，发布方式非常符合现在的使用习惯。尤其是日常的 Markdown 笔记，转一下就可以发布出来。

GitHub Pages需要公开仓库，可以先将私有仓库同步到GitHub上，再通过Cloudflare的Pages搞个备份。

回顾2025、展望2026

博客搞好了，正好也是新的一年开始，回顾一下2025，展望一下2026。 2025最大的变化，就是对AI的力量有了具象化的感受。

工作中大量使用GitHub Copilot。在片段代码、具体含义实现基本上可以替代人，有时候还会给一些“原来还可以这样写”的惊喜。
2025年小朋友升到了五年级，进入了另一个阶段，有很多自己的主意。暑假通关了《双人成行》，好游戏带给人的驱动力还是很特别的。
回顾2件让我感受到情绪上涌的事情，一件是省心租的合约、另一件是高铁。这两件事在发生时，自己能明显感受到，也控制住了，应对的非常好。
不要求人也不预设人，只接受人的参差，只专注事，破除焦虑，接受就是这个结果。

2026年，我和老婆的工作都会迎来很大变化，继续保持耐心、专注、开放以及学习的心态，继续在事上练。

Hugo小脚本：自动完善slug及image属性

Sun, 15 Feb 2026 17:47:11 +0800

重要

👍Gemini 3，脚本全是它写的！

主要功能

1. 自动生成 Slug

脚本会自动读取文章的 title：

如果标题是中文，它可以利用 deep-translator 自动将其翻译成英文，然后生成 Slug。
或者使用 --pinyin 参数将其转换为拼音 Slug。
它还会智能判断是否已经存在 Slug，避免覆盖手动设置好的内容。

2. 自动下载封面图

对于使用了 post-bundle 格式（即文件夹形式）的文章：

脚本会先检查目录中是否已经存在 cover.jpg、feature.jpg 等常见的封面文件。
如果没有，且 Front Matter 中的 image 字段为空，它会根据文章标题生成关键词，从 Picsum 下载一张高质量的随机图片作为封面。

3. 支持多语言

脚本考虑到了 Hugo 的多语言特性，如果在同一个文件夹下有 index.zh.md 和 index.en.md，它们会共享下载好的封面图，避免重复下载。

如何使用

安装依赖：

1

pip install python-frontmatter python-slugify deep-translator requests

运行脚本：

仅完善 Slug: python3 tools/front_matter.py content --slug
一键全搞定: python3 tools/front_matter.py content --slug --image --add-missing

脚本代码

 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
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342


import os
import argparse
import logging
import sys
import re
import yaml
import requests
from pathlib import Path

# Try to import required libraries, if missing, we will catch ImportError later or let it fail
try:
 import frontmatter
 from slugify import slugify
 from deep_translator import GoogleTranslator
except ImportError:
 pass

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class HugoContentProcessor:
 def __init__(self, content_dir, enable_slug=False, enable_pinyin=False, enable_image=False, add_missing=False):
 self.content_dir = Path(content_dir)
 self.enable_slug = enable_slug
 self.enable_pinyin = enable_pinyin # New flag for Pinyin
 self.enable_image = enable_image
 self.add_missing = add_missing
 # Initialize translator only if needed to avoid overhead or connection checks immediately
 self._translator = None

 @property
 def translator(self):
 if self._translator is None:
 self._translator = GoogleTranslator(source='auto', target='en')
 return self._translator

 def process(self):
 if not self.content_dir.exists():
 logger.error(f"Directory not found: {self.content_dir}")
 return

 logger.info(f"Scanning directory: {self.content_dir}")
 for root, dirs, files in os.walk(self.content_dir):
 for file in files:
 if file.endswith(('.md', '.markdown')):
 file_path = Path(root) / file
 self.process_file(file_path)

 def process_file(self, file_path):
 try:
 # Read file content as text to preserve formatting
 content = file_path.read_text(encoding='utf-8')

 # Extract Front Matter block using Regex
 # Matches content between the first two '---' lines
 match = re.search(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
 if not match:
 logger.debug(f"Skipped (no front matter): {file_path}")
 return

 fm_text = match.group(1)
 original_fm_text = fm_text

 # Use PyYAML just to parse the structure for logic checking
 try:
 metadata = yaml.safe_load(fm_text)
 except yaml.YAMLError:
 logger.warning(f"Skipped (invalid YAML): {file_path}")
 return

 if not metadata:
 return

 if self.enable_slug:
 fm_text = self._process_slug_logic(fm_text, metadata)

 if self.enable_image:
 fm_text = self._process_image_logic(fm_text, metadata, file_path)

 if fm_text != original_fm_text:
 # Reconstruct the full file content
 new_content = content[:match.start(1)] + fm_text + content[match.end(1):]

 file_path.write_text(new_content, encoding='utf-8')
 logger.info(f"Updated: {file_path}")
 else:
 logger.debug(f"Skipped (no changes): {file_path}")

 except Exception as e:
 logger.error(f"Failed to process {file_path}: {e}")

 def _process_slug_logic(self, fm_text, metadata):
 # 1. Check if 'slug' key exists
 slug_exists = 'slug' in metadata

 if not slug_exists and not self.add_missing:
 return fm_text

 # 2. Check if slug is already set (non-empty)
 existing_slug = metadata.get('slug')
 if existing_slug and str(existing_slug).strip():
 return fm_text

 # 3. Get Title for generation
 title = metadata.get('title')
 if not title:
 return fm_text

 # --- Generation Logic ---
 logger.info(f"Generating slug for title: '{title}'")
 slug_text = title

 # Check if translation is needed
 # Logic: If pinyin is enabled, skip translation and use title directly (slugify converts to pinyin)
 # Otherwise, translate non-English titles to English.
 if not self.enable_pinyin and not self.is_english(title):
 try:
 # Translate to English
 translated = self.translator.translate(title)
 slug_text = translated
 logger.info(f"Translated '{title}' to '{slug_text}'")
 except Exception as e:
 logger.warning(f"Translation failed for '{title}': {e}. Falling back to raw title.")

 new_slug = slugify(slug_text)

 if not new_slug:
 return fm_text

 # --- Text Replacement ---
 slug_pattern = r'^(\s*slug:)(\s*)$'

 def replace_callback(m):
 return f"{m.group(1)} {new_slug}"

 new_fm_text, count = re.subn(slug_pattern, replace_callback, fm_text, count=1, flags=re.MULTILINE)

 # If not found but we want to add new slugs
 if count == 0 and self.add_missing and not slug_exists:
 # Add slug field to the end of front matter
 if not fm_text.endswith('\n'):
 new_fm_text = fm_text + '\n'
 else:
 new_fm_text = fm_text

 new_fm_text += f"slug: {new_slug}\n"

 return new_fm_text

 def _process_image_logic(self, fm_text, metadata, file_path):
 # 1. Check if 'image' key exists
 image_exists = 'image' in metadata

 if not image_exists and not self.add_missing:
 return fm_text

 # 2. Check if image is already set (non-empty)
 existing_image = metadata.get('image')
 if existing_image and str(existing_image).strip():
 return fm_text

 # --- Check for existing image in the same directory (Multi-language support) ---
 # If we have index.zh.md and index.en.md, they share the same folder.
 # If cover.jpg exists, we should just use it instead of downloading a new one.
 parent_dir = file_path.parent
 existing_cover = self._find_existing_cover(parent_dir)

 if existing_cover:
 logger.info(f"Found existing image for {file_path.name}: {existing_cover}")
 image_filename = existing_cover
 else:
 # --- Download Logic ---
 title = metadata.get('title', '')
 # Prepare prompt for image generation
 prompt = self._generate_image_prompt(title, content_preview=None) # We could pass content if needed

 logger.info(f"Downloading image for: {file_path.name} with prompt: '{prompt}'")
 image_filename = self._download_image(parent_dir, prompt)

 if not image_filename:
 return fm_text

 # --- Text Replacement ---
 image_pattern = r'^(\s*image:)(\s*)$'

 def replace_callback(m):
 return f"{m.group(1)} {image_filename}"

 new_fm_text, count = re.subn(image_pattern, replace_callback, fm_text, count=1, flags=re.MULTILINE)

 # If not found but we want to add new image field
 if count == 0 and self.add_missing and not image_exists:
 # Add image field to the end of front matter
 if not fm_text.endswith('\n'):
 new_fm_text = fm_text + '\n'
 else:
 new_fm_text = fm_text

 new_fm_text += f"image: {image_filename}\n"
 else:
 new_fm_text = fm_text if count == 0 else new_fm_text

 return new_fm_text

 def _find_existing_cover(self, directory):
 """Look for common cover image filenames in the directory."""
 common_names = ['cover.jpg', 'cover.png', 'feature.jpg', 'featured.jpg', 'thumbnail.jpg']
 # Also check for any file starting with cover_

 try:
 for file in directory.iterdir():
 if file.is_file():
 if file.name.lower() in common_names:
 return file.name
 if file.name.lower().startswith('cover') and file.suffix.lower() in ['.jpg', '.png', '.jpeg', '.webp']:
 return file.name
 except Exception:
 pass
 return None

 def _generate_image_prompt(self, title, content_preview=None):
 """Translate title to English to serve as a prompt."""
 if not title:
 return "abstract minimal background"

 prompt = title
 if not self.is_english(title):
 try:
 translated = self.translator.translate(title)
 prompt = translated
 except Exception as e:
 logger.warning(f"Translation failed for prompt '{title}': {e}")

 # Add some style keywords to make the image better for a blog cover
 return f"{prompt}, aesthetic, minimalist, high quality, 4k, wallpaper"

 def _download_image(self, target_dir, prompt):
 # Determine strict save path
 filename = "cover.jpg"
 save_path = target_dir / filename

 # Ensure unique filename if cover.jpg exists and we are genuinely downloading new one
 # (Though logic outside should often catch existing ones, this is a safety net)
 counter = 1
 while save_path.exists():
 filename = f"cover_{counter}.jpg"
 save_path = target_dir / filename
 counter += 1

 # Common Headers to avoid being blocked (403/503)
 headers = {
 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
 }

 # Download from Picsum (Random high quality placeholders)
 try:
 logger.info(f"Downloading image from Picsum (Random)")
 url = "https://picsum.photos/1200/630"

 response = requests.get(url, headers=headers, timeout=20, allow_redirects=True)
 if response.status_code == 200:
 with open(save_path, 'wb') as f:
 f.write(response.content)
 logger.info(f"Saved image from Picsum to: {save_path}")
 return filename
 except Exception as e:
 logger.error(f"Download attempt failed: {e}")

 return None

 def is_english(self, text):
 """Check if text contains only ASCII characters."""
 try:
 text.encode(encoding='utf-8').decode('ascii')
 except UnicodeDecodeError:
 return False
 return True

def check_dependencies():
 missing = []
 try:
 import frontmatter
 except ImportError:
 missing.append("python-frontmatter")

 try:
 from slugify import slugify
 except ImportError:
 missing.append("python-slugify")

 try:
 from deep_translator import GoogleTranslator
 except ImportError:
 missing.append("deep-translator")

 if missing:
 print("Missing required libraries. Please install them:")
 print(f"pip install {' '.join(missing)}")
 sys.exit(1)

if __name__ == "__main__":
 check_dependencies()

 parser = argparse.ArgumentParser(
 description="Process Hugo content front matter to generate English slugs from titles and download cover images.",
 formatter_class=argparse.RawTextHelpFormatter,
 epilog="""
Examples:
 1. Default mode (No action by default now, must specify flag):
 python3 tools/front_matter.py content --slug

 2. Process images only:
 python3 tools/front_matter.py content --image

 3. Add missing slugs and images:
 python3 tools/front_matter.py content --slug --image --add-missing
"""
 )
 parser.add_argument("dir", nargs="?", default="content", help="Content directory to process (relative to current path)")
 parser.add_argument("--slug", action="store_true", help="Enable slug processing")
 parser.add_argument("--pinyin", action="store_true", help="Use Pinyin for slug generation instead of English translation")
 parser.add_argument("--image", action="store_true", help="Enable image processing (downloads from Picsum)")
 parser.add_argument("--add-missing", action="store_true", help="Add fields ('slug'/'image') if they are missing")
 args = parser.parse_args()

 # If neither is specified, maybe warn? Or just do nothing?
 if not (args.slug or args.image):
 parser.print_help()
 sys.exit(0)

 # Resolve absolute path
 base_dir = Path(os.getcwd())
 target_dir = base_dir / args.dir

 processor = HugoContentProcessor(
 target_dir,
 enable_slug=args.slug,
 enable_pinyin=args.pinyin,
 enable_image=args.image,
 add_missing=args.add_missing
 )
 processor.process()

图片优化：Webp、水印、清除exif及原图不打包

Sat, 14 Feb 2026 00:31:55 +0800

Webp转换及水印

Hugo图片优化：Fancybox、Webp和水印 | 月青悠

完全按照这个操作，写的非常清晰。有一点改动的是，我有图片Exif不是空，但里面的Orientation是nil，另外将水印调整到了右下角。

不打包进publish文件夹

我按这个配置一直不生效。最后发现是stack模板加载图片helper/image会引用RelPermalink，导到打进了publish目录。

修改点

hugo.toml

1
2
3
4
5
6
7


# https://discourse.gohugo.io/t/set-page-build-options-publishresources-in-the-site-or-theme-configuration/55942/5 
# https://gohugo.io/content-management/build-options/ 
[[cascade]] 
 [cascade.target] 
 path = "/**" 
 [cascade.build] 
 publishResources = false

render-image.html

 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


{{/* {{- $image := partial "helper/image" (dict "Resources" .Page.Resources "Image" .Destination) -}} */}}
{{- $alt := .PlainText | safeHTML -}}

{{/* 将helper/image中的访问图片的代码copy过，防止访问RelPermalink，原图又会打包进去 */}}
{{ $url := urls.Parse .Destination }}
{{ $resource := "" }}
{{ if not (in (slice "https" "http") $url.Scheme) }}
 {{ $resource = .Page.Resources.Get (printf "%s" (.Destination | safeURL)) }}
{{ else }}
 {{ with try (resources.GetRemote $url) }}
 {{ with .Err }}
 {{ errorf "%s" . }}
 {{ else with .Value }}
 {{ $resource = . }}
 {{ else }}
 {{ errorf "Unable to get remote resource %q" $url }}
 {{ end }}
 {{ end }} 
{{ end }}

{{/* 获取当前页面匹配.Destination的资源图像 */}}
{{ $hugoImage := $resource }}
{{/* 从资源中获取logo图像，透明背景图片效果最好 */}}
{{/* 该图像需要放置在根目录的assets/images目录下 */}}
{{ $logo := (resources.Get "img/watermark.png") }}
{{/* 检查图像的媒体类型是否不是gif或svg */}}
{{ if not (in (slice "gif" "svg") $hugoImage.MediaType.SubType) }}
 {{/* 保留原始图像的引用 */}}
 {{ $rawImage := $hugoImage }}
 {{/* 计算图像高度的80%，并确保最小值为250 */}}
 {{ $size := math.Round (mul $hugoImage.Height 0.80) }}
 {{ $size := cond (ge $size 250) $size 250.0 }}
 {{/* 调整logo的透明度为50% */}}
 {{ $logo := $logo.Filter (images.Opacity 0.5) }}
 {{/* 调整logo的大小，高度为计算出的$size，保持纵横比，圆角半径为30 */}}
 {{/* $logo := $logo.Resize (printf "%.0fx png r30" $size) */}}
 {{/* 如果原始图像有EXIF信息 */}}
 {{ with $rawImage.Exif }}
 {{/* 根据图像的方向调整图像的大小和旋转 */}}
 {{ if or (eq .Tags.Orientation 1) (eq .Tags.Orientation nil) }}
 {{ $hugoImage = $hugoImage.Resize (print $hugoImage.Width "x" $hugoImage.Height " webp") }}
 {{ else if eq .Tags.Orientation 3 }}
 {{ $hugoImage = $hugoImage.Resize (print $hugoImage.Width "x" $hugoImage.Height " webp r180") }}
 {{ else if eq .Tags.Orientation 6 }}
 {{ $hugoImage = $hugoImage.Resize (print $hugoImage.Height "x" $hugoImage.Width " webp r270") }}
 {{ else if eq .Tags.Orientation 8 }}
 {{ $hugoImage = $hugoImage.Resize (print $hugoImage.Height "x" $hugoImage.Width " webp r90") }}
 {{ end }}
 {{ else }}
 {{/* 如果没有EXIF信息，则只调整大小，不旋转 */}}
 {{ $hugoImage = $hugoImage.Resize (print $hugoImage.Width "x" $hugoImage.Height " webp") }}
 {{ end }}
 {{/* 在图像上添加logo水印，位置在图像的右下，fm可以通过unwatermarked关闭水印 */}}
 {{ if and (ge $hugoImage.Width 500) (ne .Page.Params.unwatermarked true) }}
 {{ $hugoImage = $hugoImage.Filter (images.Overlay $logo (sub $hugoImage.Width $logo.Width) (sub $hugoImage.Height $logo.Height)) }}
 {{ end }}
{{ end }}

{{ $image := $hugoImage }}
{{/* SVG and external images won't work with gallery layout, because their width and height attributes are unknown */}}
{{- $galleryImage := and $image.Height $image.Width -}}

<img src="{{ $image.RelPermalink }}"
	{{ with $image.Width }}width="{{ . }}"{{ end }}
	{{ with $image.Height }}height="{{ . }}"{{ end }}
	loading="lazy"
	{{ with $alt }}
		alt="{{ . }}"
	{{ end }}
	{{ if $galleryImage }}
		class="gallery-image" 
		data-flex-grow="{{ div (mul $image.Width 100) $image.Height }}"
		data-flex-basis="{{ div (mul $image.Width 240) $image.Height }}px"
	{{ end }}
>

清理exif

Image processing

转换过程中会hugo会删除掉exif，不过为了隐私，最好还是自已先删掉

exiftool -r -all= ./

在Gitea中使用workflows实现持续部署

Tue, 10 Feb 2026 14:51:25 +0800

Gitea Actions与GitHub Actions相似且兼容，actions基本都可以复用

安装 Runner

1
2


wget https://dl.gitea.com/act_runner/0.2.13/act_runner-0.2.13-linux-amd64 -O ./act_runner
./act_runner generate-config > config.yaml

注册

在Gitea中获取token：管理后台 -> Actions -> Runners -> Create new Runner，可以获取token
Gitea instance URL, 注意使用不要localhost，容器会请求Gitea仓库，可以使用内网IP

1
2
3
4
5


# 注册
./act_runner register
# 运行容器
echo "nohup ./act_runner daemon --config config.yaml > ./runner.log 2>&1 &" > start.sh
chmod +x start.sh && ./start.sh

workflow

支持部署到多台机器

 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
89
90


name: Build ❗Formal blog and Deploy 
 
on: 
 push: 
 branches: 
 - main 
 pull_request: 
 branches: 
 - main 
env: 
 OUTPUT_DIR: hugo_output 
 PUBLISH_DIR: hugo_output
 # 远端目录 
 LINODE_PUBLISH_DIR: ${{ secrets.M1_REMOTE_TARGET }}/${{ env.PUBLISH_DIR }} 
 
jobs: 
 build: 
 # https://gitea.com/gitea/runner-images 
 runs-on: ubuntu-latest 
 env: 
 HUGO_CACHEDIR: /tmp/hugo_cache # <- Define the env variable here, so that Hugo's cache dir is now predictible in your workflow and doesn't depend on the Hugo's version you're using. 
 
 steps: 
 - run: echo "🎉 任务已被 ${{ gitea.event_name }} 事件自动触发。" 
 - run: echo "🔎 您的分支是 ${{ gitea.ref }}，仓库是 ${{ gitea.repository }}。" 
 - run: echo "👤 此次提交由 ${{ gitea.actor }} 完成。" 
 
 - name: Checkout Repository 
 uses: actions/checkout@v4 
 with: 
 submodules: true 
 
 # 增加 Hugo 模块缓存 
 - uses: actions/cache@v4 
 with: 
 path: ${{ env.HUGO_CACHEDIR }} # <- Use the same env variable just right here 
 key: ${{ runner.os }}-hugomod-${{ hashFiles('**/go.sum') }} 
 restore-keys: | 
 ${{ runner.os }}-hugomod- 
 
 - name: Validate Environment Variables 
 run: | 
 if [ -z "${{ env.OUTPUT_DIR }}" ] || [ -z "${{ env.LINODE_PUBLISH_DIR }}" ]; then 
 echo "❌ 错误：目录没有设置！" 
 echo "OUTPUT_DIR: ${{ env.OUTPUT_DIR }}" 
 echo "LINODE_PUBLISH_DIR: ${{ env.LINODE_PUBLISH_DIR }}" 
 exit 1 
 fi 
 echo "✅ 环境变量验证通过" 
 echo "OUTPUT_DIR: ${{ env.OUTPUT_DIR }}" 
 echo "M1_PUBLISH_DIR: ${{ env.LINODE_PUBLISH_DIR }}"
 
 - name: Install Hugo 
 uses: peaceiris/actions-hugo@v2 
 with: 
 hugo-version: 'latest' 
 extended: true 
 with-deps: true 
 
 - name: Clear Previous Build Output 
 run: | 
 mkdir -p ${{ env.OUTPUT_DIR }} 
 rm -rf ${{ env.OUTPUT_DIR }}/* 
 
 - name: Build Hugo Site 
 run: hugo --minify --destination ${{ env.OUTPUT_DIR }} --cleanDestinationDir 
 
# - name: Install rsync 
# run: sudo apt-get update && sudo apt-get install -y rsync 
# 
# - name: Deploy Hugo Site 
# run: | 
# mkdir -p ${{ env.PUBLISH_DIR }} 
# rsync -av --delete --checksum --no-times ${{ env.OUTPUT_DIR }}/ ${{ env.PUBLISH_DIR }}/ 
 - name: Deploy to Linode 
 uses: easingthemes/ssh-deploy@main 
 with: 
 SSH_PRIVATE_KEY: ${{ secrets.SSH_PRIVATE_KEY }} 
 ARGS: "-rlgoDzvc -i --delete" 
 SOURCE: ${{ env.OUTPUT_DIR }}/* 
 REMOTE_HOST: ${{ secrets.LINODE_REMOTE_HOST }} 
 REMOTE_PORT: ${{ secrets.LINODE_REMOTE_PORT }} 
 REMOTE_USER: ${{ secrets.REMOTE_USER }} 
 TARGET: ${{ env.LINODE_PUBLISH_DIR }} 
 EXCLUDE: "/dist/, /node_modules/" 
 
 - name: List files in the repository 
 run: | 
 ls ${{ gitea.workspace }} 
 - run: echo "🍏 执行结束，此任务的状态是 ${{ job.status }}。"

Ubuntu换源

部署阿里云，如果慢的话，可以替换一下源，有点效果不大

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


jobs: 
 build: 
 steps:
 - name: Configure Aliyun Mirror 
 run: | 
 sudo tee /etc/apt/sources.list.d/ubuntu.sources >/dev/null <<EOF 
 Types: deb 
 URIs: http://mirrors.cloud.aliyuncs.com/ubuntu/ 
 Suites: noble noble-updates noble-backports 
 Components: main restricted universe multiverse 
 Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg 
 
 Types: deb 
 URIs: http://mirrors.cloud.aliyuncs.com/ubuntu/ 
 Suites: noble-security 
 Components: main restricted universe multiverse 
 Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg 
 EOF 
 
 echo "✅ 已配置阿里云内网镜像源" 
 sudo apt-get update

VPS配置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 本地生成密钥
ssh-keygen -t ed25519 -C "xx@xx.com"

# 创建账号
useradd -m -s /bin/bash git

# 上传公钥
su git
mkdir -p ~/.ssh && echo "ssh-ed25519 xxxx" > ~/.ssh/authorized_keys
chmod 700 ~/.ssh && chmod 600 ~/.ssh/authorized_keys

#验证
ssh git@xxx -i ~/.keys/git

参考文档

c++笔记：vector转数组

Wed, 23 Jul 2014 01:00:00 +0000

二种转换方式，一种是直接获得vector首地址的指针，别一种再copy一份

vector<char*> vecChar;
	char* p1 = "p12113";
	vecChar.push_back(p1);
	char* p2 = "fdsafdsa";
	vecChar.push_back(p2);
	char* p3 = "sasssssss";
	vecChar.push_back(p3);
	char** a1 = &vecChar[0];
	for (int z = 0; z < vecChar.size(); z++) {
		cout << "pointer: " << *(a1 + z) << " "<< z << " " << vecChar[z] << endl;
	}
	char* arr[vecChar.size()];
	std::copy(vecChar.begin(), vecChar.end(), arr);
	for (int z = 0; z < vecChar.size(); z++) {
		cout << "copy: " << arr[z] << " "<< z << " " << vecChar[z] << endl;
	}

c++笔记：动态内存管理

Fri, 18 Jul 2014 17:45:18 +0000

内存主要有四块，栈，堆，全局和静态，常量。

栈，堆和java一样，开发主要是集中在堆里，能过new,malloc来操作，其它内存都是系统申请释放的。

关于常量如果用指针修改会报段错误：

char* charP1 = "test const";
	*(charP1+1) = 'c';
	cout << charP1 << endl;

堆操作：

#include <iostream>
#include<stdlib.h>

using namespace std;

void test(string &str);
void test(char* charP);
void getPos();

int main() {
	// stack
	string str = "abcdefghijk";
	test(str);
	// error: type 'struct std::string' argument given to 'delete', expected pointer
	// str没有用new分配的是heap空间，数据在stack中，超出作用域自动释放，手动删除会报错
	// 看错误提示，delete后需要跟指针，所以只能delete new返回的
	//delete str;
	cout << str << endl;

	// heap
	string* str1 = new string();
	*str1 = "abcdefghijk";
	test(*str1);
	cout << *str1 << " str1 address:" << (void*)str1 << endl;
	// new分配的heap空间，不删除会内存泄露
	// 删除后可以看到&pos = str1;
	delete str1;
	str1 = NULL;
	getPos();

	int mallSize = 10;
	char* str2 = (char*)malloc(mallSize * sizeof(char));
	memset(str2, 0x00, mallSize);
	strcpy(str2, "abcdef");
	test(str2);
	cout << str2 << endl;
	free(str2);
	return 0;
}
void test(string &str) {
	int size = str.size();
	cout << size << endl;
	char* charP = new char[str.size() + 1];
	memset(charP, 0x00, str.size() + 1);
	for (int i = 0; i < str.size(); i++) {
		*(charP + str.size() - i - 1) = *(str.c_str() + i);
	}
	//memcpy(charP, str.c_str(), str.size());
	//string &r = str;
	//cout << (void*) charP << endl;
	//r = charP;
	str = charP;
	delete[] charP;
	charP = NULL;
	cout << "return: " << (void*) charP << endl;
}
void test(char* charP) {
	char* tmpP = new char[strlen(charP)];
	strcpy(tmpP, charP);
	for (int i = 0; i < strlen(charP); i++) {
		*(charP + strlen(charP) - i - 1) = *(tmpP + i);
	}
	delete[] tmpP;
}

void getPos() {
	char* pos = new char[1];
	*pos = 0;
	cout << "pos address:" << (void*)pos << endl;
}

java中char,unicode

Mon, 07 Jan 2013 07:55:02 +0000

char c = '张';
 byte b[] = new byte[3];
 b[0] = (byte) ((c & 0xFF0000) >> 16); 
 b[1] = (byte) ((c & 0x00FF00) >> 8); 
 b[2] = (byte) (c & 0x0000FF);
 System.out.println(Arrays.toString(b));
 System.out.println(Arrays.toString(new Character(c).toString().getBytes("UNICODE")));

输出：

[0, 95, 32]
[-2, -1, 95, 32]

“张”的code point：U+5F20，可以看出java内部char使用的是双字节来存储unicode，这样的话，除了BPM，其它其它辅助平面里面的字符是没有办法直接使用，只能当成byte来处理。但是，当我显式获得字符的unicode的时候却是4个字节，看情况应该是ucs4，但是高16位却是-2，-1而不是0，我试了一下其它的字也都是这样。记一下这个问题。

文档：

http://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8#Unicode_.E7.BC.96.E7.A0.81.E8.A1.A8

update: 显式也是双字节，输出的4个字，其中前两个字节-2， -1就是oxFEFF，是个BOM头。。。

System.out.println(Arrays.toString(new String("张张").getBytes("UNICODE")));

[-2, -1, 95, 32, 95, 32] 只输出了一次BOM头

BOM：http://baike.baidu.com/view/126558.htm#sub5073178

使用phpunit

Wed, 12 Dec 2012 06:37:57 +0000

在快速开发，频繁上线的项目中，代码很容易出现问题，这时候做好单元测试就非常的重要。

安装

项目地址：https://github.com/sebastianbergmann/phpunit/

手动安装很麻烦，推荐使用pear直接安装

yum install php-pear.noarch

pear install phpunit/PHPUnit
pear install phpunit/PHP_Invoker
pear install phpunit/PHPUnit_Selenium
pear install phpunit/PHPUnit_Story

使用

 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
89
90
91
92
93
94
95


<?php

class CarTest extends CTestCase
{
	public $queue;
	
	public $fixtures=array(
		'car'=>'Car',
	);

	/**
	 * 不是test开头的测试方法使用@test
	 * 
	 * @test 注解么？
	 */
	public function noTest()
	{
		$this->assertEquals(1, 1);
		$this->assertEquals(1, 1);
		return false;
	}

	/**
	 * 依赖于noTest noTest返回值是这个参数值，noTest不过，这个检查跳过
	 * 
	 * @depends noTest
	 */
	public function testCreate($return)
	{
		$this->assertFalse($return, 'failed');
	}
	
	/**
	 * 使用数据源验验证测试
	 * 
	 * @dataProvider testProvider
	 */
	public function testArry($arr)
	{
		$this->assertArrayHasKey("return", $arr);
	}
	
	public function testProvider()
	{
		return array(
			array(array('return' => 'ss')),
			array(array('return' => 'ss')),
			array(array('return' => 'ss')),
		);
	}
	
	
	public function testException()
	{
		// 期待的异常
		$this->setExpectedException('Exception');
		// 抛出异常，测试通过
		throw new Exception('test');
	}

	/**
	 * 错误异常
	 * 
	 * @expectedException PHPUnit_Framework_Error
	 */
	public function testError()
	{
		// $this->fail('test');
		// PHP错误会抛出框架内置的异常 PHPUnit_Framework_Error
		include 'nofileffa.php';
	}
	
	public function setUp()
	{
		fwrite(STDOUT, 'set up');
		$this->queue = array(1, 2, 3);
	}
	
	public function tearDown()
	{
		fwrite(STDOUT, 'tear down');
		$this->queue = null;
	}
	
	public function testFixture()
	{
		$this->assertEquals(array(1, 2, ), $this->queue);
	}
	
	public function onNotSuccessfulTest(Exception $e)
	{
		fwrite(STDOUT, 'not success');
		parent::onNotSuccessfulTest($e);
	}
}

部分资料

断言：http://www.phpunit.de/manual/current/en/writing-tests-for-phpunit.html#writing-tests-for-phpunit.assertions

fixtures：http://www.phpunit.de/manual/current/en/fixtures.html

注解：http://www.phpunit.de/manual/current/en/appendixes.annotations.html

yii test：http://www.yiiframework.com/doc/guide/1.1/zh_cn/test.overview PHPUnit 3.7的authload换成了匿名函数，需要改一下，不然yii加载会有问题.

yii绑定onEndRequest事件的bug

Fri, 10 Aug 2012 06:22:45 +0000

yii在CListIterator中使用引用，导致迭代在特殊情况下会出现BUG

public function actionIndex()
{
 $data = array('a', 'b', 'c');
 $a = new CList($data);
 foreach ($a as $k => $v) {
 if ($k == 0) {
 unset($a[0]);
 }
 echo $v;
 }
}

如果预先不知道这个情况，很容易出现问题，框架中也有这个问题，看一段代码：

public function setGlobalState($key,$value,$defaultValue=null)
{
 // ...

 if($this->_stateChanged!==$changed)
 $this->attachEventHandler('onEndRequest',array($this,'saveGlobalState'));
}

// ...

/**
* Saves the global state data into persistent storage.
* @see getStatePersister
* @throws CException if the state persister is not available
*/
public function saveGlobalState()
{
 if($this->_stateChanged)
 {
 $this->_stateChanged=false;
 $this->detachEventHandler('onEndRequest',array($this,'saveGlobalState'));
 $this->getStatePersister()->save($this->_globalState);
 }
}

public function raiseEvent($name,$event)
{
 $name=strtolower($name);
 if(isset($this->_e[$name]))
 {
 foreach($this->_e[$name] as $handler)
 {
 // ...
 }
 }
 // ...
}

当runtime目录被清空时，onEndRequest事件触发saveGlobalState动作，在操作的过程中却又解除了saveGlobalState动作的绑定。这会导致raiseEvent事件的时候，原来N个动作变成N-1个动作，但是计算器还是N个，就会下标越界。

向官方提交了这个BUG，想修正的话可以先注释掉这行：

$this->detachEventHandler('onEndRequest',array($this,'saveGlobalState'));

zf增加.html的后缀，即可以实现静态化的插件

Mon, 12 Dec 2011 10:23:44 +0000

之前是.php后缀的页面，如何只需把后缀改成.html，像：http://www.gudalu.com/index.php，访问：http://www.gudalu.com/index.html 就会自成生成静态文件呢？

前段时间古大陆的cpu有点高，处理txt章节不给，决定搞成这种自动静态，zend framework很方便，三步搞定

1.创建一个ZendEx_Plugin_Html的插件，用来处理写html

_filePath = $filePath;
	}
	public function dispatchLoopShutdown()
 {
		$htmlContent = $this->_response->__toString();
		$pathinfo = pathinfo($this->_filePath);
		!is_dir($pathinfo['dirname']) && mkdir($pathinfo['dirname'], 0777, true);
		file_put_contents($filePath, $htmlContent);
	}
}

在入口把所有.html的请求全部转发到HtmlController中~

$router = $front->getRouter();
	$htmlRoute = new Zend_Controller_Router_Route_Regex(
		'[\d\w\/]+\.html',
		array(
			'module' => 'default',
			'controller' => 'html',
			'action' => 'handle'
		)
	);

2.HtmlController注册ZendEx_Plugin_Html插件,这里可以对uri进行处理

_request->getRequestUri();
		$requestUri = parse_url($requestUri);
		$requestPath = $requestUri['path'];
		// --- 通过条件定位对应的参数来静态化数据
		$module = 'default';
		$controller = $action = '';
		$params = array();
		if (preg_match('/^\/index.html$/', $requestPath, $rs)) {
			$controller = 'index';
			$action = 'index';
		}
		// --- 文章页
		if (preg_match('/^\/file\/([\d]+)\/index\.html$/', $requestPath, $rs)) {
			$id = $rs[1];
			$controller = 'file';
			$action = 'view';
			$params = array('id' => $id);
		}
		if (empty($controller) || empty($action)) {
			//$this->_showError('无法解析地址');
			$this->_closeView();
			$this->_response->setHeader('Status', '404 Not Found', true);
			return;
		}
		
		$this->_forward($action, $controller, $module, $params);
		$this->_closeView();
		$filePath = str_replace('_app', '_www', APP_PATH) . $requestPath;
		// --- 给更低的运行级别，在render之后运行
		$helperHtml = new ZendEx_Plugin_Html();
		$helperHtml->setFilePath($filePath);
		$helperHtml->setRequest($this->_request)->setResponse($this->_response);
		$this->getFrontController()->registerPlugin($helperHtml);
	}
}

linode的东京机房太给力了

Thu, 22 Sep 2011 02:57:14 +0000

昨天刚更换完，速度很给力，电信100以下，基本上可以媲美国内的服务器了。

换机房也很简单，提个ticket工作人员立马响应，二个小时左右换完，以后用联通的线路再也不用天天掉线了。鼓舞…

FastDFS

Thu, 21 Jul 2011 03:53:18 +0000

fastdfs是一个分布式的文件存储系统，

项目主页：http://code.google.com/p/fastdfs/

支持论坛：http://bbs.chinaunix.net/forum-240-1.html

测试了一下，发现很好用，优点：

1，简单：tracker做负载均衡，storage存储数据。

2，良好的横行和纵向扩展：增加group即可实现容量扩充，增加group内的storage即可实现性能扩充

3，节省成本：数据不分块存储，前端无须再加一层缓存，直接将storage当做web server来使用

4，良好的灾备：不需要raid，group内的storage存储相同的数据

5，持续的的更新，作者很用心

配置文件：http://bbs.chinaunix.net/thread-1941456-1-1.html

回望2010

Fri, 31 Dec 2010 16:55:48 +0000

今天的年终总结是坚持，明年的计划仍然是坚持。
从去年11.4开始跑步，这一年一直在跑，今早上秤81.7kg。
三年又三年，这是第二个三年的结束，也是第三个三年的开始。上次我给自己画了一个大饼，结果变成了一烧饼，这次不画饼了，改成给自己吹个泡泡。

2010年再见，2011年你好。分享一首05年超级女生，就是李宇春那一届，有个叫赵静怡的选手唱了一首歌。

我的左手旁边是你的右手

旧的记事本

Wed, 29 Dec 2010 13:43:48 +0000

收拾衣服的时候，翻出了一本日记，从05年6月12号，一直写到07年1月20号，断断续续写了一年多。
随手翻翻，看着深浅不一的笔迹，依稀能回忆起当时的心境。

06/23/2005 正在看让我痴迷不已的诛仙，写了二页感想，这要是发到网上，那就是长评。
07/27/2005 非常想家
09/30/2005 连续好几篇都在写做游戏帮派论坛，做金山游戏推广员，怎么在学校里帖小广告，以及如何是被坑的悲惨故事。
12/05/2005 反思了自己的一些想法，以及看了《乱世铜炉》的感想。现在的我和5年前的我在一些价值观上仍然一致。
12/09/2005 第一次用java写程序的兴奋。
12/24/2005 平安夜让我回忆起了昔日的网友。
12/31/2005 年终的我发现又混过了一年
05/26/2006 确定电脑是我的饭碗
01/20/2007 年终总结：害怕

之后就开始工作了，刚工作时睡眠严重不足，就没有时间扯蛋了，整个日记也就断了。不写日记，我发现脑子里记的全是事，关于个人的感受已经模糊不清。现在又开始续写这本日记，不过留了一页空白，代表已逝去近四载的时光。

心跳那几秒

Tue, 28 Dec 2010 16:32:36 +0000

晚上去吃饭，回来已经8点多了，折腾折腾，9点半左右才出去跑步，比平时晚了40多分钟。穿过像伊拉克一样的唐家岭废墟，沿着土井路跑，到达一个三叉路口，正常情况下我会沿着这条路一直跑到东北旺然后再原路返回。就在拐弯的时候，我看三十多米开外，有一条硕大的黑狗，慢悠悠的穿过马路，消失在黑暗里，当时没引起我警惕，因为一般情况下，这么大的狗都是有人带着的。

谁曾想，我刚跑到这个地方，这条连个绳子都没有的狗，突然从黑暗里窜了出来冲我狂叫，我当时第一反应是，这狗不会过来这狗不会过来，还没想完，这狗就冲我扑过来了。当时离的很近，我后退侧身闪过，手好像砸到什么，大拇指有点疼，当时第一感觉就是手破了手破了，要打狂犬疫苗了。大狗见没有扑到，就往后退了一点，冲我狂叫，我也面对着大狗戒备着，边对峙脚边往后退，当时不是很怕，感觉这条狗不像野狗，扑的时候不凶，也不快，可能是从家跑出来的，退到7，8米左右，这条狗又扑过来了，一个1米多高的狗快速冲人跑过来，还是非常恐怖的，我再次侧身闪过，幸好这时候来了一辆车，灯打过来时这狗就有点虚，一击不中，就又往后退，在那儿冲我吼，这时候已经离的比较远了，我也象征性在路边找了找砖头，可惜也没有找到，望了我一会儿，这狗就又消失在黑暗中了。没有找到砖头的我，思考了一下，决定这条路今天先不跑了，在路灯下看了看大拇指也没破皮，万幸。

这条路我跑了一年多，经常碰到流浪狗，尤其是唐家岭拆迁以后，更时不时的碰到拉帮结派5，6条在一起的狗群。有时候跑步也会被执著的狗追，但一般只要我停一下，这些狗就不敢靠近了，有些不长眼的狗，我要反过来追它们一下。但这次碰到这么大的，这么凶猛的，上来就扑的，还真是第一次，两个字总结：肝颤。明天早点，可不想再和这狗搏斗了。

nginx下wordpress的rewrite

Fri, 08 Oct 2010 04:26:21 +0000

国庆前买了 linode 的VPS，算是edong撤走了，不用再去照相了，照相这种备案方式和以前BBS专项备案一样，没有什么操作性，迟早也要取消的。以前用edong vps，跑的是nginx+apache，这次直接换成nginx+spawn-fcgi。

# BEGIN WordPress
<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /index.php [L]
</IfModule>
# END WordPress

上面是推荐的rewrite规则，但是这样规则会将不存在的图片,css等文件也都转发到index.php，这些文件应该报个404的。

#现在nginx上使用的rewrite
 server {
 server_name yuehei.37net.com;
 
 access_log /var/log/nginx/yuehei_37net_com_access.log main;
 error_log /var/log/nginx/yuehei_37net_com_error.log info;

 root /data/html/37net.com/yuehei;
 index index.html index.htm index.php;
 
 error_page 403 =200 /403.html;
 location = /403.html {
 root /data/html;
 }
 error_page 404 =200 /404.html;
 location = /404.html {
 root /data/html;
 }
 
 location / {
 if (!-e $request_filename) {
 rewrite ^(.*)$ /index.php last;
 break;
 }
 }

 location ~ \.(gif|jpg|jpeg|png|css|js)$ {
 expires 365d;
 }

 location ~ \.php$ {
 include /etc/nginx/fastcgi_params;
 }
 }

测试一下: https://yuehei.37net.com/test_test.png 报的是404了

5.2 – 6.5收藏

Sat, 05 Jun 2010 05:12:51 +0000

5公里，这段时间下雨，聚会，玩三国杀，跑的比较懈怠，85.5KG

1，EasyUI for jQuery

2，Persona——Web人物角色介绍

3，Web服务器压力测试工具http_load、webbench、ab、Siege使用教程

4，wxpython in action 非常详细的wxpython讲解，对我这种没有做GUI编程的人用处很大。刚看完到11章，准备写一个简单的使用SQLite的报表。

看完《孤独六讲》

Fri, 07 May 2010 18:34:37 +0000

这本书断断续续看了快了一个月，今天把最后几页看完。我打了四颗星，总体上来说还是不错，但是感觉太零碎，作者像是随手拾来，看不到严密的逻辑，感觉天马行空，这种书一般都不讨我喜。

很少人能坦然面对负面情绪，一出现就会想办法消除或者转移走，就像这个时代每个人都在强调自信，强调勇气，每个都在害怕自卑，害怕懦弱一样。人有七情六欲，交替博弈，是一个正反合的过程，一个再自信的人也有自卑的时候，一个再勇敢的人也有懦弱的时候，只要是个人它就无法摆脱这些情绪。不能坦然面对这些负面的情绪，就不能认识自我，更无法获得真正的自信，勇气。

这是一本很诚恳的书，很喜欢刚开始的一句：孤独没有什么不好，使孤独变得不好的，是害怕孤独。

这么晚了还不睡，主要是因为今天很点背，晚上取钱的时候，银行卡忘记拿出来了，一个杯具。

WebGame 开发过程与备忘（一）前端基础框架的封装

Thu, 06 May 2010 12:38:42 +0000

这个webgame虽然还有bug，有一些功能要完善，界面也要重新更换，但基本上告一段落，我会一般修bug，一边做总结，这是这篇总结的第一章，算是一个备忘。

做这个项目之前，我有2年左右的PHP开发经验，对python有一些了解，javascript一般般，但用起来倒也得心应手。之前对webgame有一些了解，自己也玩过，也debug其中一些认为做的比较好的，这样也就不算陌生。

我的技术背景决定整个webgame是基于PHP+javascript来完成，为了更好的用户体验，我决定采用OPOA的形式。javascript项目有一个问题，就是连接保持，现在流行的comet方式，我都试了一遍，如果没有一个支持这一特性的web server配合的话，都不理想，最后还是使用了flash的socket，后面我会用专门一章节来讲。

其次，在做的过程中也走过一些弯路，比如刚开始，我过于强调所谓的性能，而把很多计算放到客户端来做，为了保证客户端时间正确，又把服务器的时间同步过来等等，做了一些无用功。javascript虽然功能很强大，但过于依赖javascript，限于个人的水平，会导致前端不可控，错误不可重现，bug无法排查，最后会被活活急死。

另一个重要的问题，就是整个后端返回的是数据还是html，我曾经debug一个知名的webgame，发现它整个后端都返回html，当时我不以为然，认为完全没有必要，所以我采用的就是返回json。现在看来其实两个都各有好处，返回html可以避免前端再进行处理（譬如非常烦人的数据组装），只要一个dom就可搞定。返回数据则可以减少数据量，加快响应速度，我现在采用的是数据+javascript模板的方式，javascript模板很少发现有网站在用，模板对于普通网站来说，可能弊大于利，但对于OPOA类的程序，好处显而易见的，配合延迟加载也可以减少一些弊端。

一般应用的过程是：前端 -> 调用后端 -> 处理结束 -> 返回前端，这个过程webgame也有，但webgame有时候会回调前端，即：
前端 -> 调用后端 -> 处理结束 -> 返回前端 -> 再回调前端。

/*
一个例子：购买一个道具，就更新银两的显示。把JRun.loadBack看成是一个ajax的封装。
一般情况下代码会像下面这样写，但这样有一个弊端，不止买道具，其它很多地方(比如卖)也可能要更新银两显示，
难道每一次更新都要这样写吗？
*/
JRun.loadBack('/goods/buy', {goods_id: 1, num: 5}, function(data) {
 var status = data.status;
 if (status == 1) {
 $('#role_tael').html(data.tael);
 }
});

/*
下面的代码换了一种写法，所有更新银两的显示都调用了JRole.updateTael。
但是又有一个新的问题，买道具不一定非要银两，有可能是声望，购买成功以后也更新声望的显示，
这时候就需要扩展status，来告诉前端如何处理。
*/
JRun.loadBack('/goods/buy', {goods_id: 1, num: 5}, function(data) {
 var status = data.status;
 if (status == 1) {
 JRole.updateTael(data.tael);
 } else if (status == 2) {
	JRole.updateRepute(data.repute);
 }
});
var JRole = {
 updateTael: function(tael) {
 $('#role_tael').html(tael);
 },
 updateRepute: function(repute) {
	$('#role_repute').html(repute);
 }
};

随着要处理的类型的增多，status会越来越多，整个前端会很臃肿，而且会越来越不可控。如何让后端更自由的调用前端？有一些webgame返回的是html，里面内嵌javascript，这种方式并不推荐。可以采用格式化的返回数据来解决这个问题。

// 前端调用
JRun.loadBack('/goods/buy', {goods_id: 1, num: 5});
// goods/buy返回数据格式
{status: 1, data: {tael: 5}, callBack: "JRole.updateTael(data.tael);"}

这样就清晰简单多了，前端只需一行代码。服务器处理完成以后，自定义callBack作为返回内容，前端会自动调用并将数据传入。只要对JRun.loadBack进行简单的封闭，让它识别callBack的内容。后端对前端的可控性会降低前端的代码量，同时也可应对复杂的交互。

这样的前端设计基本上能满足我目前的应用。另外如果我能在开发早期注意到问题，完全可以在实现控制(JRun.loadBack)，模型(后端PHP)，模板(javascript渲染)的分离。

旭日东升，照我窗台

Mon, 03 May 2010 15:06:59 +0000

早上躺在床上，初升的太阳顺着后楼的空隙，穿过窗台，照在我喝完水的杯子上。看着光线中微尘翻滚，心就像宽阔的湖面，无限平静。

我经常搬家，住过很多房子，屋子里的东西往往还没堆满的就要搬，碰到那些认为有用的东西，也会留下来了，但搬家的时候却全被扔掉了，仿佛是一个杯子，不停的接水倒掉。回家的时候也一样，我会打包衣服，思量什么东西要用到，却很少带全。其实我知道，任何时候我能孤身一人，很多东西都能丢，不能丢的都带在身上。

孤身一人的时候我会迟疑，也能说服自己，继续前行，知道当下即是过往，期待明日有所收获。往往事与愿违，可能等待了很长时间，走了许多的路，到结束却连个痕迹也没有留下。回望的时候，才发现当初的迟疑徘徊即是全部，明日只是一个结束。有人说，希望是至善，我却认为希望是可有可无的，身陷囹圄的人才会觉得无比重要。有勇气面对自己，有勇气正视环境，听从内心，做自己能做的事，知道自己不能做的事，明白通过练习可以做到的事，就已足够。更多时候，希望是一些人用来证明自己生命的意义，而我的生命没有意义，我的时光就是用来感受时光的消逝，我的生命就是用来感受生命的终结。当然，这只是一种理想的状态，看着九零后前仆后继，身为八零后，身为唐家岭的蚁族，我感到压力很大。

漫步时，许多的背影在身边穿行，我仿佛赤着脚，行走于路间，感受赤热冰凉，喜怒哀乐，我知道你也一样，却不知道你是否如我一样。我常怀疑自己，也常贪图片刻的安宁，我能正视自己，也能感受内心的坚定。我活在当下，不期许虚妄的未来，不纠缠无谓的过往。知盈虚有数，不奢望恒久的快乐，不排斥安静的孤独。我喜欢平静，知道平静才能长久，我想做真正的自己，虽然这话听起来是在蛋逼，却不知道你是怎么想？

三国杀忠臣，内奸，反贼的识别

Sat, 01 May 2010 19:11:29 +0000

玩三国杀我比较喜欢5人局，1主公1忠臣2反贼1内奸，这种人数搭配进度快，也能看出忠臣的无奈，反贼的徘徊，内奸的摇摆不定。做为一个英明的主公，如何能识别出这些面具背后的身份？

首先，第一局如果有牌就要出手，逻辑上来说，蒙的概率还是很高的，有3/4的机会杀到反贼和内奸。先手之后，就很容易根据大家的表现猜出大致的身份。

1，忠臣，因为无所顾忌，在战斗中会表现出一往无前的气势，逮谁踹谁，一踹到底，不死不休，而且还喜欢杀体力少的，容易杀的。

2，内奸，我遇过两种风格，一种很低调很安静，走反贼路线，这种我一般是放到最后才收拾。另一种则是表现出很强大的气场，走忠臣路线，到了后期就很难分辨谁是忠臣谁是内奸。做为一个英明的主公，在这个时候应该低调，忠臣死可以，但不能死在你手里。让他们自相残杀，如果有什么【南蛮入侵】，【万箭齐发】之类的，可以统统放出来通杀。至于装备，那是一定要拆的。等他们分出胜负，伤痕累累的面对一个武装到牙齿的你，胜利是一定的。

3，反贼，识别这个没有什么难度，同伙身份未明，下手就会顾忌，怕错杀自己人。我也遇过两种风格，一种是上次来就跳，攻击主公，向同伙表明反贼身份。我经常这么干，尤其是用许禇的时候，配合连弩，再裸衣，绝对是猛将中的猛将，无敌。另一种就是继续扮演，这就有难度了，只要反贼不傻，就不会像忠臣那样猛干，他可能会左打一下，右打一下，谁都不打死，直到忠臣的身份明朗后才会跳出来猛杀。

做为一个刚入门的菜鸟，在选择主公的时候，还是推荐使用曹操，至少可以保障手中有能进攻的牌。武将推荐夏候墩（刚烈），赵子龙（龙胆），大乔（国色，流离），甄姬（洛神，倾国），技能都偏向于防御，比较好用。

4.20 – 5.2收藏

Sat, 01 May 2010 18:12:33 +0000

这段时间一直在跑5公里，体重85.6KG

1，MVC模式已死

2，90后的用户形态研究 90后用户形态研究（第二期）

3，Python于Web 2.0网站的应用

4，一个危机公关的实例案例分析：一份道歉信

５，有时候梦想未必是好事梦想有时也许只不过是陷阱

4.12 – 4.19收藏

Sun, 18 Apr 2010 10:37:13 +0000

这是第一篇用 live writer写的blog，住的地方网速很不理想，用这种方法免得丢失。我用rss阅读，但大部都是看了过，过了忘，忘了就一片空白，这样囫囵吞枣也没有什么收获。新加了一个收藏的分类备忘一下，一来让自己零碎的阅读有点记录，二来也是分享一下我感觉有用处的文章。

1，微博之战微博方便了作者，却麻烦了读者。大量的消息虽然及时却凌乱，分享还可以，发表观点却不够。

2，我从11楼跳下去……才知道……

3，给你一个真实的芙蓉姐姐可以从8分钟演讲的时候看，我看到一个自信，从容，淡定的女人。

4，多服务器同步：rsync使用小结金山逍遥网 sersync 服务器实时镜像、自动同步程序开源

10，适用于 PHP 开发人员的 Python 基础知识

11，囚徒困境

12，戈森定律

13，斯坦福监狱实验

在vps主机配置awstats日志数据分析软件

Thu, 11 Feb 2010 15:44:05 +0000

盘今的主机，是我用过最烂的，虽然客服很尽责，但是速度已经不能用慢来形容，ping可以ping，网页只是偶尔能打开。买了一下E动VPS，界面很方便，速度还不错，稳定性有待观察。

我是按装这个【文档】来进行awstats日志的配置。有一些写的不详细：

第（2）步我改成了虚拟主机

<VirtualHost *:80>
 Alias /awstats/icon/ /var/www/awstats/icon/
 Alias /awstats/ /var/www/awstats/

 <Directory /var/www/awstats/>
 DirectoryIndex index.html
 Options ExecCGI
 order deny,allow
 allow from all
 </Directory>
</VirtualHost>

打开浏览器，如果看到是pl的源代码，在apache的配置文件中增加

AddHandler cgi-script .cgi .pl

如果显示的界面是英文，则在第（4）部中，将LANG=“auto" 改成 LANG=“cn”

回首2009，展望2010

Tue, 12 Jan 2010 13:15:40 +0000

2009年底，空间商抱着机器从上海跑到重庆再跑到北京，也没让我赶在年末写上一份总结。也能理解，都不容易，现在正常了，也顺道展望一下2010。

回首2009，是有些收获：
1，学习了python。虽然是刚刚入门，总算是写了一个在线聊天的服务器。php虽然好使，但语言特性还是很难遇上诸如内存释放，线程，管道之类的问题，不遇到问题就没有机会搞懂。
2，封装了一个PHP框架。虽然我很鄙视我在做重复的工作，但是thinkphp，zf真的让我感觉很不方便。我有自已习惯，也知道程序部署的环境，所以就很简单，借鉴了部门老大对zf的修改，使用autoload自动加载，用xdebug测试的时候，基本上效率没有什么影响。
3，从09年4月份开始，中间虽然有断层，但基本上我全部精力都放在一个网页游戏上，遇到了很多问题，有的解决有的绕过。一个深刻的教训是，我以后绝不对没有做过的东西说“好做”。为了给用户更自然的体现，应用只用了一个html页面，前端js写了有5000多行，比5w行php都难写。更别提遇到的一些js内存泄漏，莫名其妙的卡，浏览器关闭。在firefox下还好，总有工具可以用。ie下那些debug工具都是不靠谱的，我只能一行一行的删除，alert调试。总算在年终的时候内测，虽然还有很多问题。

展望2010：
1，我知道js做ria的不足，所以今年的一个重要的任务就是学习flex。
2，有武侠情结，想写一个武侠类的网页游戏。因为对实时要求比较高，架构采用我熟悉的js和我不熟悉的python。一直在关注一个框架eurasia，准备尝试一下，主要还是想深入一下python，手熟一下python。
3，存xx的钱，08年09年我原地踏步走，积累了两年应该再上个台阶了。

还有一些我不想说出来的计划，我在心中也默默的说一遍。事情总有反复，事情总有后退，事情总有一日不如一日，事情总在一个漫长的周期上一直向上。
2009是很好的一年，希望2010也是很好的一年。

今天跑完一个环线

Mon, 16 Nov 2009 14:57:27 +0000

一直绕操场跑圈圈，今天和志远跑了一次环线。遥想07年初我和鸭子也是跑这条线，一直跑到我吐，那滋味真不好受。今天速度控制的还可以，跑的比较轻松。

QQ群前端使用的 javascript loader

Mon, 16 Nov 2009 07:51:58 +0000

开始主要想看一下qq群所使用的javascript模板，后来发现他们用的也是一个jquery的插件。
不过这个加载写的也很不错，分析了一下，原JS： http://qun.qq.com/god/m/js/loader.zh-cn.js

; (function() {
 var window = this,
 undefined,
 jLoader = window.jLoader = window.jL = {
 _version: "1.2.1",
 _sequence: [],
 _queue: {},
 _xhr: function() {
 return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
 },
 // 直接加载脚本
 _script: function(uri, context) {
 context = context || document;
 var head = context.getElementsByTagName("head")[0] || context.documentElement,
 script = context.createElement("script");
 script.type = "text/javascript";
 script.src = uri;
 head.appendChild(script);
 return script;
 },
 _style: function(uri, context) {
 context = context || document;
 var head = context.getElementsByTagName("head")[0] || context.documentElement,
 link = context.createElement("link"),
 links = context.getElementsByTagName("link", context);
 link.type = "text/css";
 link.rel = "stylesheet";
 link.href = uri;
 if (0 < links.length) {
 var _last = links[links.length - 1];
 _last.parentNode.insertBefore(_link, _last.nextSibling);
 } else {
 head.appendChild(link);
 }
 return link;
 },
 _replace: function(pattern, uri, context) {
 if (!pattern || !uri) {
 return;
 }
 context = context || document;
 var links = context.getElementsByTagName("link", context);
 for (var i = links.length - 1; i >= 0; i--) {
 if ( - 1 != links[i].href.indexOf(pattern)) {
 links[i].parentNode.removeChild(links[i]);
 }
 }
 if (uri) {
 jLoader._style(uri, context);
 }
 },
 // 将脚本内容插入当前页面来执行
 _globalEval: function(data, context) {
 if (data && /\S/.test(data)) {
 context = context || document;
 var head = context.getElementsByTagName("head")[0] || context.documentElement,
 script = context.createElement("script");
 script.type = "text/javascript";
 if (jLoader._excute) {
 script.appendChild(context.createTextNode(data));
 } else {
 script.text = data;
 }
 head.insertBefore(script, head.firstChild);
 head.removeChild(script);
 return true;
 }
 return false;
 },
 // 执行回调方法数组。有可能请求多次，绑定了多个的回调方法。
 _call: function(mark) {
 if (jLoader._queue<mark></mark>.callbacks) {
 var cl = jLoader._queue<mark></mark>.callbacks.length;
 for (var j = 0; j < cl; j++) {
 jLoader._queue<mark></mark>.callbacks[j][0](jLoader._queue<mark></mark>.callbacks[j][1]);
 }
 }
 },
 // 这是一个顺序加载的过程，每加载一个JS，都会放入sequence队列，如果depend=true,则该脚本之前的脚本全部加载完后该脚本才执行
 _inject: function() {
 var len = jLoader._sequence.length;
 for (var i = 0; i < len; i++) {
 var seq = jLoader._queue[jLoader._sequence[i]];
 if (!seq.done) {
 if (!seq.response) {
 return;
 } else {
 seq.done = true;
 seq.response = [seq.response, ";jLoader._call(\"", jLoader._sequence[i], "\");"].join("");
 jLoader._globalEval(seq.response);
 }
 }
 }
 },
 scripted: function(mark) {
 if ("undefined" == typeof jLoader._queue<mark></mark>) {
 return false;
 } else {
 if (jLoader._queue<mark></mark>.done) {
 return true;
 } else {
 return false;
 }
 }
 },
 script: function(options) {
 options = options || {};
 // 参数不全
 if (!options.mark || !options.uri)
 return;
 options.depend = options.depend || false;
 options.params = options.params || {};
 options.onload = options.onload || null;
 // 如果没有依赖关系和回调方法，则直接引入
 if (!options.onload && !options.depend) {
 jLoader._script(options.uri);
 jLoader._queue[options.mark] = {
 uri: options.uri,
 response: null,
 done: true
 };
 return;
 }
 // 是否为第一次请求
 if ("undefined" == typeof jLoader._queue[options.mark]) {
 jLoader._queue[options.mark] = {
 uri: options.uri,
 response: null,
 done: false
 };
 // 设置回调方法和回调的参数
 if ("function" == typeof options.onload) {
 jLoader._queue[options.mark].callbacks = [[options.onload, options.params]];
 }
 } else {
 // 虽然不是第一次请求，但有没有真正加载。没有真正加载的原因此时正在异步请求脚本内容
 if (false == jLoader._queue[options.mark].done) {
 // 如果已经设置为callbacks, 则追加callbacks, 前面设置的callbacks是数组
 if ("function" == typeof options.onload) {
 if ("undefined" == typeof jLoader._queue[options.mark].callbacks) {
 jLoader._queue[options.mark].callbacks = [[options.onload, options.params]];
 } else {
 var cl = jLoader._queue[options.mark].callbacks.length;
 jLoader._queue[options.mark].callbacks[cl] = [options.onload, options.params];
 }
 }
 } else {
 // 已真正加载，直接执行回调方法
 if ("function" == typeof options.onload) {
 options.onload(options.params);
 }
 }
 return;
 }
 // 将脚本按顺序放入队列，self._inject会用到
 var len = jLoader._sequence.length;
 if (options.depend) {
 jLoader._sequence[len] = options.mark;
 }
 var xhr = jLoader._xhr();
 xhr.onreadystatechange = function() {
 if (4 == xhr.readyState) {
 // 如果设置了依赖关系，则检查依赖。如果没有设置，则执行脚本内容和回调函数
 if (options.depend) {
 jLoader._queue[options.mark].response = xhr.responseText;
 jLoader._inject();
 } else {
 jLoader._queue[options.mark].done = true;
 var response = [xhr.responseText, ";jLoader._call(\"", options.mark, "\");"].join("");
 jLoader._globalEval(response);
 }
 }
 };
 xhr.open("GET", options.uri, true);
 xhr.send("");
 }
 };
 // 很好，很强大，因为getTime()结果不一样，所以用这种方法可以准确的定位到某一个类有没有执行
 jLoader._excute = false;
 var root = document.documentElement,
 script = document.createElement("script"),
 id = "script" + (new Date).getTime();
 script.type = "text/javascript";
 try {
 script.appendChild(document.createTextNode("window." + id + "=1;"));
 } catch(e) {}
 root.insertBefore(script, root.firstChild);
 if (window[id]) {
 jLoader._excute = true;
 delete window[id];
 }
 root.removeChild(script);
})();

看完《蚁族》

Thu, 12 Nov 2009 15:32:42 +0000

在唐家岭住了2年多，终于看到一本描述唐家岭的书《蚁族》，立马和同在这儿住的同事买了，看完后发现虽然不是很全面但还是真实客观的。只是那些调查人员感觉唐家岭脏，乱在我眼里却很平常，或许我习惯了，除了下雨天路难走，别的还可以。

在唐家岭住，生活成本比较低，吃饭的地方比较多，而且租一间房子比合租小区更自由。除了难挤的公交车，我觉得这里倒是暂住的好地方。另外，这本书后面个别章节有一种在上俯视众生，我很不喜欢。唐家岭虽然没那么好，但也没那么惨，在这里住两年就知道了。

还是值一买本，当当链接：http://product.dangdang.com/product.aspx?product_id=20684969
前三章节试读：http://book.ifeng.com/book.php?book_id=2414

update 100210：做为一个在唐家岭的蚁族，我认为张鸣的这篇文章远比廉思的那本书要清醒和现实 http://news.qq.com/a/20100210/001085.htm

使用自己的FTP做为xmark的服务器

Thu, 29 Oct 2009 15:22:31 +0000

在众多网站阵亡之后，我最常用，最必不可少的xmark也倒下了。
因为平时在公司和在家里用的不是一台电脑，很多收藏要同步，每次同步都要挂代理，太麻烦了。在xmark里有选项可以使用自己的服务器，试了一下，只要是简单的FTP权限即可以，而且速度比以前也理想。
1。在【设置】- 【status】里面填上自己的FTP用户名和密码

2。在【设置】 - 【高级】中，填上在FTP的保存收藏的URI，xmark会在服务器自动建立文件。

国内虚拟主机架设dabr

Thu, 22 Oct 2009 01:43:17 +0000

基于dabr212修改的，下载附件，然后覆盖 common 目录下的 twitter.php 文件，请求API的速度大概在1秒左右比较慢，最好是自己用。

下载文件

update 20091030：国内的虚拟主机可以架设一个，将文件覆盖即可，方便手机访问。主要是将dabr原来curl请求 twitter api的方式，换成一个socket方试请求，使用一个twitter上推荐的，号称不会被封的ip，并且使用了https，测试功能一切正常。

hello world

Wed, 16 Sep 2009 11:05:39 +0000

sablog的代码高亮不怎么方便，换成新版的wp，感觉还不错。
旧BLOG：https://yuehei.37net.com/old/
更旧BLOG：http://hi.baidu.com/wooo

_role);
		$ret = $modelExp->listExp();
		if ($ret === false) {
			exit(json_encode(array('status' => 0)));
		} else {
			$timestamp = time();
			$sec = strtotime($ret['end_time']) - $timestamp;
			exit(json_encode(array('status' => 1, 'sec' => $sec, 'map_id' => $ret['map_id'])));
		}
	}
}

#!/usr/bin/python#Filename:socket_server.py
# coding=utf-8
# 聊天网关

from twisted.internet import protocol, reactor
import time, os, qing_game

PORT = 8888