Daemons and Services/zh CN: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~## Contents~~
2		-
3		-	* 1 守护进程、服务和代理的概念
4		-	* 2 用 Lazarus 和可视化组件创建服务/守护进程
5		-	* 2.1 前提：安装 LazDaemon 包
6		-	* 2.2 创建并使用 Daemon 项目框架
7		-	* 2.3 发布 DaemonMapper 类
8		-	* 2.4 编写守护进程的方法
9		-	* 2.5 启动/停止信号的处理
10		-	* 2.6 关机消息的处理
11		-	* 2.7 Linux 下的安装和卸载（systemd）
12		-	* 2.8 工作线程
13		-	* 2.9 用代码初始化 TDaemon 属性
14		-	* 3 纯代码创建服务/守护进程
15		-	* 4 守护进程/服务的安装
16		-	* 4.1 Windows
17		-	* 4.2 Linux
18		-	* 5 日志文件的读取
19		-	* 6 守护进程/服务的调试
20		-	* 6.1 Windows
21		-	* 6.2 Linux
22		-	* 7 已知问题
23		-	* 7.1 与权限相关的问题
24		-	* 7.2 EStreamError 异常："no streaming method available"
25		-	* 7.3 “Stream Read”和“Unkown Properties”错误 ...
26		-	* 7.4 Lazarus IDE 建议清理 .lpm 中的非法属性
27		-	* 7.5 因不支持线程而在 Unix 中无法启动守护进程
28		-	* 7.6 Windows 系统中出现的调试问题
29		-	* 7.7 Linux 系统中出现的调试问题
30		-	* 7.8 守护进程无权限访问网络/云存储(Onedrive 和 Dropbox）
31		-	* 7.9 Linux 中指定运行服务的用户无法生效
32		-	* 7.10 系统代码页 / UTF-8
33		-	* 8 [一些旧的内容：有待验证、合并或删除]
34		-	* 8.1 Linux（仅限旧版 Debian）
35		-	* 9 参阅
36		-
37	1		## 守护进程、服务和代理的概念
38	2
39	3		Unix 中的“守护进程”和 Windows 中的“服务”是系统级程序，运行时无需用户交互；macOS 中的“代理”是用户级程序（相对系统级的守护进程而言），运行时有无用户交互均有可能。尽管叫法不同，但他们的功能类似：比如 www 或 ftp 服务在 Linux 下称作守护进程，而在 Windows 下则叫服务。由于不直接与用户交互，因此在启动时会关闭stdin、stdout、stderr 描述符。
40	4
41	5		在 Free Pascal 和 Lazarus 中，可以利用 Lazarus 的 lazdaemon 包以平台无关的方式编写守护进程/服务。为避免与 Delphi 组件命名冲突，这些类命名为“daemon”。
42	6
43	7
44	8
45	9		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 本文重点介绍 Windows 和 Linux。如需了解 Lazarus 和 macOS 的“代理”，请参阅[[macOS daemons and agents\|macOS 守护进程和代理]]。
46	10
47	11		## 用 Lazarus 和可视化组件创建服务/守护进程
48	12
49	13		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 完整源代码在文末提供。
50	14
51	15		### 前提：安装 LazDaemon 包
52	16
53	17		在开始使用 Lazarus IDE 创建守护进程之前，必须通过“软件包”-“安装/卸载软件包”安装 LazDaemon 包，或者直接从.../lazarus/components/daemon/lazdaemon.lpk 安装 lpk 文件。
54	18
55	19		LazDaemon 包会在 IDE 中安装一些新的组件和菜单。
56	20
57	21		[![2022-02-21 14 34 28-LINDER-LAZW7 - VMware Workstation.png](/wiki-images/3/31/2022-02-21_14_34_28-LINDER-LAZW7_-_VMware_Workstation.png)](</File:2022-02-21_14_34_28-LINDER-LAZW7_-_VMware_Workstation.png>)
58	22
59	23		鉴于 Lazarus 软件包的工作方式，安装 LazDaemon 包需要“保存并重新构建IDE”。
60	24
61	25		### 创建并使用 Daemon 项目框架
62	26
63	27		LazDaemon 包安装完成后，从“项目-新建项目”菜单选择“守护进程（服务）应用”。
64	28
65	29		[![2022-02-17 16 31 12-Create a new project.png](/wiki-images/e/ec/2022-02-17_16_31_12-Create_a_new_project.png)](</File:2022-02-17_16_31_12-Create_a_new_project.png>)
66	30
67	31		这会自动创建两个单元，一个派生自 TDaemon（DaemonUnit），另一个派生自 TDaemonMapper（DaemonMapperUnit）。以及一个主项目文件（TestDaemon.lpr），需要稍作修改才能使用：
68	32		```
69	33		Program TestDaemon;
70	34
71	35		Uses
72	36
73	37		// This is the scaffolded code, needs modification like shown below,
74	38		// since UseCThreads is usually not definied, and is not needed here
75	39		// {$IFDEF UNIX}{$IFDEF UseCThreads}
76	40		// CThreads,
77	41		// {$ENDIF}{$ENDIF}
78	42
79	43		{$IFDEF UNIX}
80	44		CThreads,
81	45		{$ENDIF}
82	46		DaemonApp, lazdaemonapp, daemonmapperunit, DaemonUnit
83	47		{ add your units here };
84	48
85	49		{$R *.res}
86	50
87	51		begin
88	52		Application.Initialize;
89	53		Application.Run;
90	54		end.
91	55		```
92	56
93	57		[![Warning-icon.png](/wiki-images/b/b2/Warning-icon.png)](</File:Warning-icon.png>)
94	58
95	59		Warning: 自动生成的 .lpr 文件中多了一条 {$IFDEF UseCThreads} ... {$ENDIF} 子句（上述示例中已被注释掉了），据观察，除非另作定义 UseCThreads，否则这个子句无法工作。可整句删除也可如上所示注释掉，或者在 Linux 下编译守护进程时添加 -dUseCThreads 选项。编写 Windows 服务不受影响。
96	60
97	61		守护进程虽然没有 GUI，但 DaemonApp 和 DaemonMapper 单元都支持 Lazarus 窗体编辑器。这样就可以用熟悉的图形界面来设置守护进程和映射类的各种属性。当然，也可以完全用代码初始化所有属性，如下所示。
98	62
99	63		自动生成的 DaemonApp 和 DaemonMapper 单元中都有多余的“var”定义（var DaemonMapper1: TDaemonMapper1; var Daemon1: TDaemon1;）。这两个变量在守护进程运行时并未实际用到，依然保持未初始化状态，对他们进行访问会导致致命错误 access violation。只要进一步了解了守护进程应用的内部工作原理，就会发现代码只与类相关（TDaemonMapper1、TDaemon），这两个变量完全可忽略或删除。
100	64
101	65		TDaemon 类的代码主要用于响应操作系统发送的各种控制消息。TDaemonMapper 包含了描述服务的一些数据结构。这两个类都需要在守护进程应用框架中注册，将在守护进程启动时供内部使用，完成对守护进程的配置。在以下示例中，注册是在单元的“Initialization”部分完成的。
102	66
103	67		只要在单元的 uses 部分加入 DaemonApp，即可引入守护进程类应用的主“Application”对象。守护进程应用的“Application”提供了完整的服务框架，包括安装和卸载、记录日志之类的高级功能。守护进程的“工作线程”需要自行创建，可参阅后续的示例代码，请勿使用 TDaemon 类的“Execute”方法。
104	68
105	69		### 发布 DaemonMapper 类
106	70
107	71		下面先填充一些基本属性，让程序跑起来。请注意，DaemonClassName 必须与 DaemonClass 单元中定义的类名完全一致。
108	72
109	73		[![2022-01-31 23 32 52-Settings.png](/wiki-images/1/19/2022-01-31_23_32_52-Settings.png)](</File:2022-01-31_23_32_52-Settings.png>)
110	74
111	75		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 跨平台程序员请注意：Unix 系统区分大小写，通常使用小写字母，因此如果如上定义了大小写混合的服务名称，可能会引发一些混淆。
112	76
113	77		不妨简单介绍一下 WinBindings 属性，即可通过 Windows 服务管理器配置各种服务属性，例如启动类型和用户帐户。虽然这个简单的守护应用中并未用到，但对于真正的守护进程应用程序而言，合理设置这些选项非常重要。WinBindings 在 Linux 中无效，请参阅关于 Linux 安装和卸载功能的章节，了解如何在 systemd “单元”（.service）文件中设置选项，以便为 Linux 实现相同的功能。
114	78
115	79		### 编写守护进程的方法
116	80
117	81		TDaemons 支持以下方法：
118	82
119	83		方法/事件 \| 说明
120	84		---\|---
121	85		`OnStart` \| 守护进程将启动时调用。本方法必须立即返回并置 _OK:=True_ 。
122	86		`OnStop` \| 守护进程将停止时调用。本方法必须立即返回并置 _OK:=True_ 。
123	87		`OnShutDown` \| 守护进程将被杀掉时调用，因为系统将要关闭。本方法必须立即停止守护进程，并置 _OK:=True_ 返回。本方法在 Linux 系统中不会触发。Linux 会直接杀掉守护进程。
124	88		`OnPause` \| 守护进程将暂停时调用。本方法必须立即返回并置 _OK:=True_ 。本方法在 Linux 系统中不会触发，系统内核会停止整个守护进程并触发 OnStop 事件。
125	89		`OnContinue` \| \- \| `OnExecute` \| 不要用本方法实现工作线程，请参考示例代码实现工作线程的任务。
126	90		`BeforeInstall` \| 服务即将安装时调用。
127	91		`AfterInstall` \| 服务安装成功后调用。
128	92		`BeforeUninstall` \| 服务卸载前调用。
129	93		`AfterUninstall` \| 服务卸载完成后调用。
130	94
131	95		以下代码片段展示了成功实现简单守护进程所需的主要事件处理程序。已在 Windows 7/10/11 和几个 Linux 版本（Debian 10.8 和 Ubuntu 20.04.3）中测试通过。
132	96
133	97		有些便利性辅助函数已剥离至单独的单元中，以防扰乱守护进程的核心代码。
134	98
135	99		* FileLoggerUnit：线程安全的记录日志文件的辅助工具。日志是必需记录的，因为 TDaemon 应用的控制信号接收器和服务代码需运行于单独的线程，否则服务代码运行时守护进程将无法响应控制信号。因此，在守护进程中至少涉及两个任务，这两个任务同时访问日志文件时可能会发生冲突。关于如何运用 TRTLCriticalSection 保证代码线程安全，实现对单一资源的串行访问，详情请参阅 Lazarus 维基的[[Multithreaded Application Tutorial\|多线程应用开发教程]]。FileLoggerUnit 会将日志文件写入程序所在目录，请确保程序拥有写入权限。这里的代码会每天写一个文件，文件名包含创建日期。如果需要更高级的日志记录工具，可以考虑使用 [[LazLogger]] 单元。
136	100		* [DaemonWorkerThread](<https://gitlab.com/freepascal.org/lazarus/lazarus/-/tree/main/examples/TDaemon>)：TThread 的派生类，可容纳守护进程的“工作”代码。关于 TThread.Execute 方法,其中不可避免包含了“无限”循环，详情请参阅 Lazarus 维基的[[Multithreaded Application Tutorial\|多线程应用开发教程]]。由 TDaemon 启动的工作线程并没有什么特别的，就和其他线程一样。
137	101		* [<https://gitlab.com/freepascal.org/lazarus/lazarus/-/tree/main/examples/TDaemon> DaemonSystemdInstallerUnit：该单元为 Linux 系统提供 -install 和 -uninstall 命令行参数支持。通过对 /lib/systemd/system 写入相应的控制文件，加入对 systemd/systemctl 的支持。
138	102
139	103		### 启动/停止信号的处理
140	104		```
141	105		// ---------------------
142	106		// 启动和停止信号
143	107		// ---------------------
144	108
145	109		procedure TDaemon1.DataModuleStart(Sender: TCustomDaemon; var OK: Boolean);
146	110		begin
147	111		LogToFile(Format('Daemon received start signal, PID:%d', [GetProcessID]));
148	112		// 创建挂起的工作线程 - 参见 DaemonWorkerThread 单元
149	113		FDaemonWorkerThread := TDaemonWorkerThread.Create;
150	114		// 设置参数
151	115		FDaemonWorkerThread.FreeOnTerminate := False;
152	116		// 启动工作线程
153	117		FDaemonWorkerThread.Start;
154	118		OK := True;
155	119		end;
156	120
157	121		procedure TDaemon1.DataModuleStop(Sender: TCustomDaemon; var OK: Boolean);
158	122		begin
159	123		LogToFile('Daemon received stop signal');
160	124		// 停止并销毁工作线程
161	125		if assigned(FDaemonWorkerThread) then
162	126		begin
163	127		FDaemonWorkerThread.Terminate;
164	128		// 等待线程停止
165	129		FDaemonWorkerThread.WaitFor;
166	130		FreeAndNil(FDaemonWorkerThread);
167	131		end;
168	132		LogToFile('Daemon stopped');
169	133		OK := True;
170	134		end;
171	135		```
172	136
173	137		上述代码负责处理操作系统发出的启动和停止信号。守护进程启动时，将会调用 DataModuleStart，生成 DaemonWorkerThread 单元定义的“工作”线程，至于守护进程的实际工作代码请参阅 TDeamonWorkerThread.Execute 方法。对线程代码的理解，可参考[[Multithreaded Application Tutorial\|多线程应用开发教程]]和 TThread 的文档。
174	138
175	139		[![Warning-icon.png](/wiki-images/b/b2/Warning-icon.png)](</File:Warning-icon.png>)
176	140
177	141		Warning: 编写守护进程的代码时，或许有人想在 TDaemon 的“execute”方法中实现处理过程。但这样的运行效果并不理想，特别是在 Windows 系统中。因为 Execute 方法并不会作为单独的线程运行，在其运行期间守护进程会停止处理控制消息。于是，守护进程可以启动并正常运行，但要用 Windows 服务管理器或 sc 命令来停止/暂停/恢复时，守护进程将不会响应，就像被挂起了一样。
178	142
179	143		### 关机消息的处理
180	144
181	145		此处的处理代码仅适用于 Windows 系统，当操作系统关闭时用于停止守护进程。如果不做处理，Windows 会直接强行杀死守护进程，已打开的文件可能会遭到损坏。下面演示的服务较为简单，可直接调用 DataModuleStop 事件处理程序，执行正常停止服务的代码。Linux 系统不支持关机消息的处理，而会直接调用停止服务的处理代码。
182	146		```
183	147		procedure TDaemon1.DataModuleShutDown(Sender: TCustomDaemon);
184	148		// 仅 Windows 系统支持
185	149		begin
186	150		self.Stop; // 系统关机时调用停止服务的处理代码。对于本演示程序而言完全够用了。
187	151		LogToFile('Daemon received shutdown signal');
188	152		end;
189	153		```
190	154
191	155		### Linux 下的安装和卸载（systemd）
192	156
193	157		LazDaemon 中内置的安装和卸载功能（通过 -install 和 -uninstall 命令行参数）仅适用于 Windows。以下给出了简单的示例代码，展示了如何为安装和卸载事件创建自定义处理过程，以便添加 Linux 下的类似功能。
194	158		```
195	159		// --------------------------------
196	160		// Installation and De-Installation
197	161		// --------------------------------
198	162
199	163		procedure TDaemon1.DataModuleAfterInstall(Sender: TCustomDaemon);
200	164
201	165		var
202	166		isInstalled: boolean = True;
203	167		FilePath: string;
204	168
205	169		begin
206	170		LogToFile('Daemon installing');
207	171		{$IFDEF UNIX}
208	172		FilePath := GetSystemdControlFilePath(Self.Definition.Name);
209	173		isInstalled := CreateSystemdControlFile(self, FilePath);
210	174		if not isInstalled then
211	175		LogToFile('Error creating systemd control file: ' + FilePath);
212	176		{$ENDIF}
213	177		if isInstalled then
214	178		LogToFile('Daemon installed');
215	179		end;
216	180
217	181		procedure TDaemon1.DataModuleBeforeUnInstall(Sender: TCustomDaemon);
218	182		var
219	183		isUnInstalled: boolean = True;
220	184		FilePath: string;
221	185
222	186		begin
223	187		LogToFile('Daemon uninstalling');
224	188		{$IFDEF UNIX}
225	189		FilePath := GetSystemdControlFilePath(Self.Definition.Name);
226	190		isUnInstalled := RemoveSystemdControlFile(FilePath);
227	191		if not isUninstalled then
228	192		LogToFile('Error removing systemd control file: ' + FilePath);
229	193		{$ENDIF}
230	194		if isUninstalled then
231	195		LogToFile('Daemon uninstalled');
232	196		end;
233	197		```
234	198
235	199		上述处理代码仅适用于 Unix/Linux 系统，利用 DaemonSystemdInstallerUnit 中的函数建立一个 systemd 控制文件（.service 文件），并放入 /lib/systemd/system 目录，以便用 systemctl 命令来控制守护进程。在卸载守护进程时，将会删除此 .service 文件。
236	200
237	201		如果 .service 文件中未指定用户账户，systemd 将会以 root 身份运行此守护进程。出于安全考虑，以“root”（Linux）或“LocalSystem”（Windows）身份运行守护进程不是个好习惯，可能会带来很多其他障碍，其中之一就是难以调试正在运行的守护进程。可以考虑在 DaemonSystemdInstallerUnit.CreateSystemdControlFile 中加入指定用户的代码：
238	202		```
239	203		[...]
240	204		f.WriteString('Service', 'Type', 'simple');
241	205		f.WriteString('Service', 'User', '...'); // insert a service account here, otherwise the daemon will run as root
242	206		f.WriteString('Service', 'ExecStart', Application.ExeName + ' -r');
243	207		[...]
244	208		```
245	209
246	210		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 程序运行时，TDaemonMapper 的全部参数，特别是TDaemonMapper.WinBindings 的设置，都可从“self.Definition”和“self.Definition.WinBindings”结构读取。尽可以用其中的一些参数来填充 .service 文件中的设置。
247	211
248	212		若要全面了解 systemd .service 文件（有时也称为 systemd“单元文件”）中所有可用设置，请参阅 Linux 的发行文档。
249	213
250	214		### 工作线程
251	215
252	216		守护进程的主要内容都有一段执行实际工作的代码，这里称作“工作”线程。因为守护进程要继续在后台监听控制消息并作出处理，所以工作线程需为单独的线程。上述 TDaemon.DataModuleStart 和 TDaemon.DataModuleStop 例程已给出了工作线程的创建和销毁代码。
253	217		```
254	218		procedure TDaemonWorkerThread.Execute;
255	219
256	220		var
257	221		i: integer;
258	222
259	223		begin
260	224		LogToFile('Daemon worker thread executing');
261	225		while not Terminated do
262	226		begin
263	227		// 以下仅为占位代码，请在此插入实际的服务代码
264	228		// ...
265	229		LogToFile('Daemon worker thread running');
266	230		// 线程和 CPU 负载都不高的延时5秒循环
267	231		for i := 1 to 50 do
268	232		begin
269	233		if Terminated then break;
270	234		Sleep(100);
271	235		end;
272	236		// ...
273	237		// ----------------------------------------
274	238		end;
275	239		LogToFile('Daemon worker thread terminated');
276	240		end;
277	241		```
278	242
279	243		上述工作线程没有太多任务，只是循环至线程终止，每5秒在日志中写入消息。
280	244
281	245		将两个“...”之间的代码替换掉，即可实现自己的守护进程功能。
282	246
283	247		TThread.Execute 方法的内部循环必须以某种方式频繁检查“Terminated”标志。Terminated 标志由 TThread.Terminate 方法设置，正如前文 TDaemon.DataModuleStop 所示，TThread.Terminate 方法用于优雅地结束线程的执行。关于 TThread 的更多信息，请参阅[[Multithreaded Application Tutorial\|多线程应用开发教程]]。
284	248
285	249		为了让示例代码尽量简单，这里没有以任何方式处理运行时错误。记录日志单元的错误将静默忽略，守护进程的其他运行时错误将导致进程崩溃。请参阅[[Exceptions\|异常]]以总体了解异常的捕获和处理方式，查看 TThread.HandleException 文档以了解在工作线程的 execute 方法中正确捕获和转发异常的方式。
286	250
287	251		### 用代码初始化 TDaemon 属性
288	252
289	253		如果不想用 Lazarus IDE 及其窗体编辑器设置 TDaemon 和 TDaemonMapper 的属性，完全用代码完成也是没问题的。请注意，这时项目不能像其他应用那样基于 LCL/Form 创建，而应该基于 DaemonApp。否则会报大量的流加载错误，代码将无法运行。
290	254
291	255		前文已介绍了 TDaemon 的用法（事件驱动的守护进程编程），现在的区别只是在代码中要将事件处理过程赋值如下：
292	256		```
293	257		TDaemon1 = class(TDaemon)
294	258		{...}
295	259		procedure DataModuleStart(Sender: TCustomDaemon; var OK: Boolean); // 事件处理过程的示例
296	260		{...}
297	261		public
298	262		constructor Create(AOwner: TComponent); override; // 覆盖构造函数，初始化事件处理过程
299	263		end;
300	264
301	265		{...}
302	266
303	267		constructor TDaemon1.Create(AOwner: TComponent);
304	268		begin
305	269		inherited Create(AOwner);
306	270		{...}
307	271		onStart := @DataModuleStart; // 赋值示例的事件处理过程
308	272		{...}
309	273		end;
310	274		```
311	275
312	276		TDaemonMapper 的编写方式类似。
313	277
314	278		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 如果更愿意用OOP继承的方式定制 TDaemon 和 TDaemonMapper 类，也可以如下操作：从 TCustomDaemon 继承自己的守护进程，从 TCustomDaemonMapper 继承自己的映射器，并根据需要重写“Protected”部分的各个虚函数。
315	279
316	280		以下是 DaemonApp 单元中显示可用属性的部分代码：
317	281		```
318	282		TCustomDaemon = Class(TDataModule)
319	283		private
320	284
321	285		[...]
322	286
323	287		Protected
324	288		Function Start : Boolean; virtual;
325	289		Function Stop : Boolean; virtual;
326	290		Function Pause : Boolean; virtual;
327	291		Function Continue : Boolean; virtual;
328	292		Function Execute : Boolean; virtual;
329	293		Function ShutDown : Boolean; virtual;
330	294		Function Install : Boolean; virtual;
331	295		Function UnInstall: boolean; virtual;
332	296
333	297		[...]
334	298		```
335	299
336	300		## 纯代码创建服务/守护进程
337	301
338	302		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 文末提供了完整的示例代码链接。
339	303
340	304		TestDaemonCodeOnly 作为演示项目，用到了 TCustomDaemon 和 TCustomDaemonMapper类，并且不依赖 Lazarus IDE。因此，该项目无需 .lpr 或 .lfm 之类的 Lazarus 辅助文件，并且可用任何纯文本编辑器进行维护。该项目并不使用 GUI 核心代码那种事件驱动模式，而是基于 OOP 和继承。至于其他的那些辅助单元则与以上 GUI 示例的相同，包括记录文件日志、守护进程工作线程、基于 Linux systemd 的 -install 和 -uninstall 支持等功能。
341	305
342	306		Linux 的 -install 和 -uninstall 支持功能，同样由以上示例用到的 DaemonSystemdInstallerUnit 提供。Windows 服务的安装和卸载功能已内置于 DaemonApp 单元中了。TDaemonMapper 类的 WinBindings 属性可用于配置 Windows 服务，Linux 系统中不用此属性也没有效果。DeamonSystemdInstallerUnit 中的代码为 Linux/systemd/systemctl 提供了类似的功能。
343	307
344	308		Windows 不支持 -run 参数，而是提供了自己的服务控制工具（Windows 服务控制管理器或“sc”命令行工具）。
345	309
346	310		守护进程的代码需要用多个线程实现，一个用于处理守护进程控制消息，另一个独立线程用于守护进程的“工作”代码。仅仅重写 TCustomDaemon.Execute 方法是不够的，因为守护进程在 TDaemon.Execute 方法中循环时，无法处理控制消息。因此，在 Windows 服务控制管理器中会显示为挂起状态，并且不会响应 sc 命令。“工作”线程的代码与以上 GUI 示例中的相同，并且已在 DaemonWorkerThread 单元中实现。
347	311
348	312		因为没有了 GUI 和控制台，所以需要用到记录日志功能。TCustomDaemon 对象提供了日志记录功能（通过 EventLog 属性），但不是线程安全的。FileLoggerUnit 提供了简单的线程安全的文件日志记录功能。如果需要更复杂的日志记录功能，可以考虑使用[[LazLogger]]单元。
349	313
350	314		[![Warning-icon.png](/wiki-images/b/b2/Warning-icon.png)](</File:Warning-icon.png>)
351	315
352	316		Warning: FileLoggerUnit 生成的日志文件将写入程序所在目录，请确保程序拥有写入权限。
353	317
354	318		关于多线程的详细信息，以及通过 CriticalSection 保障代码的线程安全，请参阅[[Multithreaded Application Tutorial\|多线程应用开发教程]]。
355	319		```
356	320		program TestDaemonCodeOnly;
357	321
358	322		{$mode objfpc}{$H+}
359	323
360	324		uses
361	325		{$IFDEF UNIX}
362	326		cthreads,
363	327		{$ENDIF}
364	328		Classes,
365	329		SysUtils,
366	330		{ you can add units after this }
367	331		DaemonApp,
368	332		FileLoggerUnit, // 线程安全的文件日志记录工具
369	333		DaemonWorkerThread, // TThread 的派生类，用于执行守护工作
370	334		DaemonSystemdInstallerUnit; // Linux/systemd 的 -install 和 -uninstall 功能
371	335
372	336
373	337		// ------------------------------------------------------------------
374	338		// TDaemonMapper: 定义守护进程的配置
375	339		// ------------------------------------------------------------------
376	340
377	341		type
378	342		TDaemonMapper1 = class(TCustomDaemonMapper)
379	343		public
380	344		constructor Create(AOwner: TComponent); override;
381	345		end;
382	346
383	347		constructor TDaemonMapper1.Create(AOwner: TComponent);
384	348
385	349		begin
386	350		inherited Create(AOwner);
387	351		with TDaemonDef(self.DaemonDefs.Add) do
388	352		begin
389	353		DaemonClassName := 'TDaemon1'; // 必须与守护进程类名完全一样
390	354		Name := 'TestDaemonCodeOnly'; // 服务名
391	355		DisplayName := 'Test Daemon (CodeOnly)'; // 显示的服务名
392	356		Description := 'Lazarus Daemons and Services Wiki Demo Service (Created in Code only)';
393	357		Options := [doAllowStop, doAllowPause];
394	358		WinBindings.StartType := stManual; // stBoot, stSystem, stAuto, stManual, stDisabled
395	359		WinBindings.ServiceType := stWin32;
396	360		end;
397	361		end;
398	362
399	363		// -------------------------------------------------------------------
400	364		// TDaemon: 定义守护进程任务，并处理 Windows/Linux 服务管理器的事件
401	365		// -------------------------------------------------------------------
402	366
403	367		type
404	368
405	369		{ TDaemon1 }
406	370
407	371		TDaemon1 = class(TCustomDaemon)
408	372		private
409	373		FDaemonWorkerThread: TDaemonWorkerThread;
410	374		public
411	375		function Start: boolean; override; // 启动工作线程
412	376		function Stop: boolean; override; // 停止工作线程
413	377		function Pause: boolean; override; // 暂停工作线程（仅限 Windows）
414	378		function Continue: boolean; override; // 回复工作线程（仅限 Windows）
415	379		function ShutDown: boolean; override; // 由于操作系统关机而停止工作线程
416	380		function Install: boolean; override; // 在 Linux 下添加 -install 功能
417	381		function UnInstall: boolean; override; // 在 Linux 下添加 -uninstall 功能
418	382		end;
419	383
420	384		{ TDaemon1 }
421	385
422	386		// ------------------------------------------------
423	387		// 启动和停止信号的处理
424	388		// ------------------------------------------------
425	389
426	390		function TDaemon1.Start: boolean;
427	391		begin
428	392		// 创建挂起的工作线程 - 参阅 DaemonWorkerThread 单元
429	393		FDaemonWorkerThread := TDaemonWorkerThread.Create;
430	394		// 设置参数
431	395		FDaemonWorkerThread.FreeOnTerminate := False;
432	396		// 启动工作线程
433	397		FDaemonWorkerThread.Start;
434	398		LogToFile(Format('TDaemon1: service %s started, PID=%d', [self.Definition.Name, GetProcessID]));
435	399		Result := True;
436	400		end;
437	401
438	402		function TDaemon1.Stop: boolean;
439	403		begin
440	404		// 停止并销毁工作线程
441	405		if assigned(FDaemonWorkerThread) then
442	406		begin
443	407		FDaemonWorkerThread.Terminate;
444	408		// 等待线程终止
445	409		FDaemonWorkerThread.WaitFor;
446	410		FreeAndNil(FDaemonWorkerThread);
447	411		end;
448	412		Result := True;
449	413		LogToFile(Format('TDaemon1: service %s stopped', [self.Definition.Name]));
450	414		end;
451	415
452	416		// ------------------------------------------------
453	417		// 暂停和恢复运行信号的处理（仅限 Windows）
454	418		// ------------------------------------------------
455	419
456	420		function TDaemon1.Pause: boolean;
457	421		begin
458	422		FDaemonWorkerThread.Suspend; // 已过时，不过还能用
459	423		LogToFile(Format('TDaemon1: service %s paused', [self.Definition.Name]));
460	424		Result := True;
461	425		end;
462	426
463	427		function TDaemon1.Continue: boolean;
464	428
465	429		begin
466	430		LogToFile(Format('TDaemon1: service %s continuing', [self.Definition.Name]));
467	431		FDaemonWorkerThread.Resume; // 已过时，不过还能用
468	432		Result := True;
469	433		end;
470	434
471	435		// --------------------------------------------------------------
472	436		// 操作系统关机时停止信号的处理（仅限 Windows）
473	437		// --------------------------------------------------------------
474	438
475	439		function TDaemon1.ShutDown: boolean;
476	440		begin
477	441		Result := self.Stop; // 关机时，触发停止服务的事件处理。对示例而言足够了。
478	442		LogToFile(Format('TDaemon1: service %s shutdown', [self.Definition.Name]));
479	443		end;
480	444
481	445		// -----------------------------------------------------------------------------------------
482	446		// Linux 下的安装和卸载功能， Windows 下已内置于 TCustomDaemon
483	447		// -----------------------------------------------------------------------------------------
484	448
485	449		function TDaemon1.Install: boolean;
486	450
487	451		var
488	452		FilePath: string;
489	453
490	454		begin
491	455		Result := False;
492	456		{$IFDEF WINDOWS}
493	457		Result := inherited Install;
494	458		{$ELSE}
495	459		{$IFDEF UNIX}
496	460		FilePath := GetSystemdControlFilePath(Self.Definition.Name);
497	461		LogToFile(Format('TDaemon1: installing control file: %s',[FilePath]));
498	462		Result := CreateSystemdControlFile(self, FilePath);
499	463		if not Result then
500	464		LogToFile('TDaemon1: Error creating systemd control file: ' + FilePath);
501	465		{$ENDIF}
502	466		{$ENDIF}
503	467		LogToFile(Format('TDaemon1: service %s installed: %s', [self.Definition.Name, BoolToStr(Result, 'ok', 'failure')]));
504	468		end;
505	469
506	470		function TDaemon1.UnInstall: boolean;
507	471
508	472		var
509	473		FilePath: string;
510	474
511	475		begin
512	476		Result := False;
513	477		{$IFDEF WINDOWS}
514	478		Result := inherited UnInstall;
515	479		{$ELSE}
516	480		{$IFDEF UNIX}
517	481		FilePath := GetSystemdControlFilePath(Self.Definition.Name);
518	482		Result := RemoveSystemdControlFile(FilePath);
519	483		if not Result then
520	484		LogToFile('TDaemon1: Error removing systemd control file: ' + FilePath);
521	485		{$ENDIF}
522	486		{$ENDIF}
523	487		LogToFile(Format('TDaemon1: service %s uninstalled: %s', [self.Definition.Name, BoolToStr(Result, 'ok', 'failure')]));
524	488		end;
525	489
526	490		// ---------------------
527	491		// 主程序，包含初始化代码
528	492		// ---------------------
529	493
530	494		begin
531	495		RegisterDaemonClass(TDaemon1);
532	496		RegisterDaemonMapper(TDaemonMapper1);
533	497		Application.Run;
534	498		end.
535	499		```
536	500
537	501		## 守护进程/服务的安装
538	502
539	503		### Windows
540	504
541	505		在任一提权后的命令提示符下，只要带 -install 参数启动可执行文件，即可安装服务。
542	506
543	507		打开一个提权（以管理员身份运行）的终端窗口，进入编译完成的 TestDaemon 所在目录，即可执行以下命令：
544	508
545	509		命令 \| 说明
546	510		---\|---
547	511		`TestDaemon -install` \| 安装服务
548	512		`sc query TestDaemon` \| 查看服务状态
549	513		`sc config TestDaemon start=auto` \| 将服务配置为随机器启动而自动运行
550	514		`sc config TestDaemon start=manual` \| 将服务配置为手动启动
551	515		`sc config TestDaemon start=disabled` \| 禁用服务（无法手动启动）
552	516		`TestDaemon -uninstall` \| 删除服务
553	517
554	518		[![Screenshot taken 2/2022 on a Windows 11 machine](/wiki-images/a/a4/2022-01-31_23_50_28-Lazarus_IDE_v2.2.0RC2_-_Daemon_application.png)](</File:2022-01-31_23_50_28-Lazarus_IDE_v2.2.0RC2_-_Daemon_application.png> "Screenshot taken 2/2022 on a Windows 11 machine")
555	519
556	520		服务安装成功后，可通过 sc 命令行或“服务”管理控制台中的 GUI 对服务进行控制。在较新的 Windows 版本中，任务管理器的“服务”页也提供了基础的服务控制功能。
557	521
558	522		服务安装后，最重要的 sc 控制命令包括：
559	523
560	524		命令 \| 说明
561	525		---\|---
562	526		`sc start TestDaemon` \| 启动服务
563	527		`sc query TestDaemon` \| 查询服务状态
564	528		`sc stop TestDaemon` \| 停止服务
565	529
566	530		也可以使用 Windows 的服务控制管理器。
567	531
568	532		[![ServiceControlManager.png](/wiki-images/0/07/ServiceControlManager.png)](</File:ServiceControlManager.png>)
569	533
570	534		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: Windows 服务的大多数属性，都可以通过 DaemonMapperUnit1 中的 TDaemonMapper1.WinBindings 属性进行设置，比如随系统自动启动或使用指定帐户等。
571	535
572	536		### Linux
573	537
574	538		与 Windows 不同，TDaemonApp 应用不提供自动安装功能，因为在 Linux/Unix 系统下存在各种各样的服务控制子系统。可在 TCustomDaemon 对象的安装和卸载事件处理过程中实现自己的安装脚本，类似上述代码示例中展示的对 systemd 的支持。如果采用这种方法，那么安装和卸载的过程基本与 Windows 相同。
575	539
576	540		可以在终端中用 sudo 再加 -install 或 -uninstall 参数来启动可执行文件，以便安装或卸载服务：
577	541
578	542		命令 \| 说明
579	543		---\|---
580	544		`sudo ./TestDaemon -install` \| 安装服务
581	545		`sudo ./TestDaemon -uninstall` \| 卸载服务
582	546		`systemctl enable TestDaemon` \| 将服务配置为随系统自动启动
583	547		`systemctl disable TestDaemon` \| 将服务配置为不随系统自动启动
584	548
585	549		服务安装完成后，可以用 systemctl 命令进行控制：
586	550
587	551		命令 \| 说明
588	552		---\|---
589	553		`systemctl start TestDaemon` \| 启动服务
590	554		`systemctl status TestDaemon` \| 查询服务状态
591	555		`systemctl stop TestDaemon` \| 停止服务
592	556
593	557		[![OnLinuxWithSystemctl.png](/wiki-images/4/4f/OnLinuxWithSystemctl.png)](</File:OnLinuxWithSystemctl.png>)
594	558
595	559		由命令行参数 -install 触发的 DaemonSystemdInstallerUnit.CreateSystemdControlFile 代码，将会读取 TDaemonMapper 类最为基本的属性，并在 /lib/systemd/system 目录下写入一个简单的 systemd .service 文件，使得守护进程接受 systemd 的控制。若要进行手动操作，可以用任何文本编辑器按照以下模板创建自己的 .service 文件：
596	560		```
597	561		[Unit]
598	562		Description=Long description of your application
599	563		After=network.target
600	564
601	565		[Service]
602	566		Type=simple
603	567		User=name_of_a_service_user_account
604	568		ExecStart=complete_path_and_file_name -r
605	569		RemainAfterExit=yes
606	570		TimeoutSec=25
607	571
608	572		[Install]
609	573		WantedBy=multi-user.target
610	574		```
611	575
612	576		* 请编辑以下内容
613	577		* Description - 服务的详细说明
614	578		* ExecStart - 编译好的全路径可执行文件名
615	579		* User - 指定用户，省略则以 root 身份运行，但强烈不建议以 root 身份运行守护进程
616	580
617	581		* 保存文件
618	582		* 进入 /lib/systemd/system/
619	583		* 将文件命名为 name_of_your_service.service
620	584
621	585		在 DaemonSystemdInstallerUnit.CreateSystemdControlFile 创建的 .service 文件中，还有很多条目可用于自定义 systemd 的控制方式，请参阅 Linux systemd “unit”文件参考手册。
622	586
623	587		## 日志文件的读取
624	588
625	589		以下是个在 Windows 下创建的日志文件示例，显示守护进程运行时的内部状态，在 Linux 下的显示将完全相同。
626	590
627	591		[![2022-02-01 12 17 27-TestDaemon.png](/wiki-images/d/d1/2022-02-01_12_17_27-TestDaemon.png)](</File:2022-02-01_12_17_27-TestDaemon.png>)
628	592
629	593		[![Warning-icon.png](/wiki-images/b/b2/Warning-icon.png)](</File:Warning-icon.png>)
630	594
631	595		Warning: FileLoggerUnit 将把日志写入守护程序所在目录，请确保程序拥有写入权限。
632	596
633	597		## 守护进程/服务的调试
634	598
635	599		守护进程的调试并不像普通应用程序那么直接，因为运行中的守护进程通常既没有 GUI 也没有控制台，并且其运行/停止状态通常由操作系统管理。Windows 和 Linux 的调试方式也不一样，特别是调试会话的启动方式。一旦将调试进程附加到守护进程并到达第一个断点，后续的操作就与调试其他任何应用一样了，可以直接从 Lazarus GUI 控制调试器和守护进程的源代码。
636	600
637	601		在开始调试之前，需用“调试”模式编译服务/守护进程的代码，以便插入调试代码并生成相应的调试符号文件（.dbg 文件）。
638	602
639	603		### Windows
640	604
641	605		在 Windows 中的调试策略取决于要查看哪部分代码：
642	606
643	607		\- 若要调试 -install 或 -uninstall 部分，请在 Lazarus GUI 中将“运行-运行参数”设为 -install 或 -uninstall，设置好断点，然后运行代码[F9]。
644	608
645	609		\- 若需调试服务的工作线程代码，请通过操作系统（使用 sc 命令或 Windows 服务管理器）启动服务，确定进程ID（PID），然后选择“运行-附加到程序”。一旦附加成功，调试器将自动停止于 ntdll.dll!DbgUserBreakPoint 处预设的临时断点，此时服务将运行于工作线程代码的循环内。在工作线程的代码中设好断点和监视后，用[F9]运行代码继续调试。
646	610
647	611		[![2022-02-21 21 25 22-Lazarus IDE v2.2.0 - Daemon application $debugging ...$.png](/wiki-images/3/38/2022-02-21_21_25_22-Lazarus_IDE_v2.2.0_-_Daemon_application_%28debugging_...%29.png)](</File:2022-02-21_21_25_22-Lazarus_IDE_v2.2.0_-_Daemon_application_$debugging_...$.png>)
648	612
649	613		[![Warning-icon.png](/wiki-images/b/b2/Warning-icon.png)](</File:Warning-icon.png>)
650	614
651	615		Warning: 如果是远程调试正在运行的进程，Lazarus 快捷菜单中的暂停按钮似乎不起作用，如果按下暂停则会挂起调试器。请在添加断点后用“运行”[F9]继续调试。
652	616
653	617		\- “若需调试创建或启动服务的处理代码，或是在“附加到程序”之前就可能要执行的代码，可插入以下代码让代码等待，直至调试进程附加完成：
654	618		```
655	619		// 以下代码将维持循环至调试进程附件完成
656	620		While not IsDebuggerPresent do sleep(100); // 循环至调试进程附件完成
657	621		// ... 在循环后可加入断点，以便在循环结束后立即捕获异常
658	622		```
659	623
660	624		[![2022-02-21 21 36 38-Lazarus IDE v2.2.0 - Daemon application $debugging ...$.png](/wiki-images/c/c7/2022-02-21_21_36_38-Lazarus_IDE_v2.2.0_-_Daemon_application_%28debugging_...%29.png)](</File:2022-02-21_21_36_38-Lazarus_IDE_v2.2.0_-_Daemon_application_$debugging_...$.png>)
661	625
662	626		调试进程完成并按下[F9]后，守护进程将停止于断点位置。
663	627
664	628		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: Linux 支持的 -run 参数在 Windows 上不可用。Windows 必须用服务控制管理器启动和停止服务。若要把调试进程附加到正在运行的服务进程上，需以管理员权限（提权）运行 Lazarus IDE，否则在尝试附加到服务进程时会收到错误5（拒绝访问）。如果 Lazarus 已提权运行了，但仍难以附加到服务进程上（“拒绝访问”或“运行-附加到程序”呈灰色状态），请确保在“项目-项目设置-调试器”中正确设置了调试器，很可能需选择“Gdb（Gnu 调试器）”。
665	629
666	630		### Linux
667	631
668	632		从某种程度上说，在 Linux 中守护进程可能更容易调试，因为可在 Lazarus IDE 中像其他程序一样运行，只需在“运行-运行参数”菜单的“命令行参数”中输入 -run 即可。不过请记得，很多问题都源自操作系统的安全限制。当守护进程在用户模式下运行时，这些限制很多都不适用。
669	633
670	634		[![2022-02-22 12 18 20-Debian 10.8 Buster - VMware Workstation.png](/wiki-images/f/fd/2022-02-22_12_18_20-Debian_10.8_Buster_-_VMware_Workstation.png)](</File:2022-02-22_12_18_20-Debian_10.8_Buster_-_VMware_Workstation.png>)
671	635
672	636		现在可以像普通应用一样，用[F9]启动守护进程并进行调试了。
673	637
674	638		[![2022-02-22 12 19 41-Debian 10.8 Buster - VMware Workstation.png](/wiki-images/e/e9/2022-02-22_12_19_41-Debian_10.8_Buster_-_VMware_Workstation.png)](</File:2022-02-22_12_19_41-Debian_10.8_Buster_-_VMware_Workstation.png>)
675	639
676	640		如果确实需要将调试器附加到正在运行的守护进程上，比如怀疑问题与某项安全限制相关，那么可通过“运行-附加到程序”来实现，前提是已将守护进程配置为指定用户运行，而不是 root 用户。请参阅上述关于 Linux 安装和卸载功能的内容，了解如何向 .service 文件添加适当的参数。
677	641
678	642		很遗憾，Linux 不支持像 Windows 那么方便的“IsDebuggerPresent”，但以下技巧的效果也不错。
679	643		```
680	644		procedure WaitForDebugger;
681	645
682	646		var
683	647		SetMeValue:boolean=false;
684	648
685	649		begin
686	650		// Linux 技巧：附加调试进程，SetMeValue 改为 true。
687	651		while not SetMeValue do
688	652		sleep(100); // 在此设置断点
689	653		end;
690	654		```
691	655
692	656		请在“sleep”命令的那行设置一个断点。一旦守护进程由 systemctl 启动后，将在 while 循环中的断点处停止运行。此时可将调试进程附加于从 systemctl 状态信息获取的 PID，对“SetMeValue”变量设置监视（[Ctrl-F5]），然后用“评估/修改”上下文菜单将“SetMeValue”变量值由“false”改为“true”，并继续运行（[F9]）。于是程序会立即退出 while 循环，并运行至下一个断点。
693	657
694	658		## 已知问题
695	659
696	660		### 与权限相关的问题
697	661
698	662		虽然大部分核心守护进程代码可在某个用户帐户下和 IDE（Lazarus）中完成开发，但实时守护进程很可能要在不同的上下文中“后台”运行。出于安全考虑，现代操作系统运行守护进程的环境或多或少都存在一些限制。守护进程没有终端和 GUI 来显示消息，因此此类问题可能会很难调试。遗憾的是，在 FPC/Lazarus 支持的所有操作系统中，没有通用的方法可以解决全部与服务相关的问题，因为 Windows、Linux 和 macOS 对服务的限制策略差别很大，甚至相同操作系统的不同版本也在不断变化，新版本的限制往往更多。
699	663
700	664		当从开发者帐户迁至“上线”状态，并测试服务用户帐户或“Localsystem”、“root”账户下运行的守护进程时（顺便提一下，用超级帐户运行历来视为不安全做法），请花时间研究一下操作系统的安全文档，了解代码在后台运行时所受的安全限制和其他特性。
701	665
702	666		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: 请参阅上文，了解将调试器附加到正在运行的代码以调试后台运行的守护进程。守护进程由操作系统启动后，应等待调试器附加完成。然后即可观察执行过程，检测与安全限制相关的异常，以及其他与安全/后台操作相关的棘手问题。
703	667
704	668		### EStreamError 异常："no streaming method available"
705	669		```
706	670		Exception at 0041A30E: EStreamError:
707	671		Failed to initialize component class "TDaemon1": No streaming method available.
708	672		```
709	673
710	674		说明在纯用代码创建的守护进程项目中，包含了可视化组件（这些组件需由 GUI 应用的 .lfm 文件创建的内部资源流进行初始化）。如果决定用纯代码创建守护进程，那么可能既不应包含 LazDaemon 包，也不应在 uses 部分加入“LazDaemonApp”。否则，项目虽然可以通过编译，但在启动 exe 文件时，会遇到上述错误。
711	675
712	676		### “Stream Read”和“Unkown Properties”错误 ...
713	677
714	678		用 Lazarus IDE 加载守护进程项目时……。
715	679
716	680		要打开的很可能是一个基于 TDaemon（GUI 组件）的项目，但 LazDaemon 包还未安装。
717	681
718	682		请中止所有加载错误，并按照前文的说明用 Lazarus 软件包管理器安装 LazDaemon 包。重新编译 Lazarus 后，此项目应能加载并顺利编译了。
719	683
720	684		[![Image 9.png](/wiki-images/f/fb/Image_9.png)](</File:Image_9.png>)
721	685
722	686		[![Image 10.png](/wiki-images/b/b3/Image_10.png)](</File:Image_10.png>)
723	687
724	688		### Lazarus IDE 建议清理 .lpm 中的非法属性
725	689
726	690		要打开基于 TDaemon（GUI 组件）的项目时，会出现的另一个问题，LazDaemon 包尚未安装。
727	691
728	692		[![Image 11.png](/wiki-images/1/13/Image_11.png)](</File:Image_11.png>)
729	693
730	694		请中止所有加载错误，并按照前文说明用 Lazarus 软件包管理器安装 LazDaemon 包。重新编译 Lazarus 后，该项目应能加载并顺利编译。
731	695
732	696		### 因不支持线程而在 Unix 中无法启动守护进程
733	697
734	698		代码编译没有问题，但用控制台和 -run 参数运行守护进程时，会显示类似“no thread support compiled in”的信息。如果用 systemctl 启动守护进程则不显示任何信息，貌似根本就没有运行。可用“systemctl status”查看守护进程的最后一条报错信息，会与用 -run 参数启动时的崩溃信息相同。
735	699
736	700		` This binary has no thread support compiled in. Recompile the application with a thread-driver in the program uses clause before other units using thread. Runtime error 232 at ...
737	701		...
738	702		No heap dump by heaptrc unit Exitcode = 232 `
739	703
740	704		很有可能在编译项目时没有启用对 CThreads 库的支持（在 Windows 中不需要此库）。请参阅前文的项目 lpr 文件示例代码和“UseCThreads”的说明文档。简而言之，需打开 .lpr 文件，并移除包裹“uses CThreads”语句的 {$IFDEF UseCThreads} ... {$ENDIF} 条件编译指令，这样在 Linux 中就会将 CThreads 库链接到代码中。在 Windows 中用不到 CThreads 库。
741	705
742	706		### Windows 系统中出现的调试问题
743	707
744	708		在 Lazarus 的快捷菜单栏中，断点命中后会激活“暂停”按钮。但远程调试正在运行的进程时，按下按钮似乎并不起作用，反而会挂起调试器。因此断点命中后，请换用“运行”[F9]键继续调试。
745	709
746	710		若要将调试器附加到正在运行的守护进程上，需以管理员权限（提权）运行 Lazarus IDE，否则会收到“Error 5 (access denied)”的提示。
747	711
748	712		如果“运行”菜单中的所有调试项均不可用（灰色），请进入“项目-项目选项-调试器”，将“调试器后端”设为“Gdb [GNU调试器(gdb)]”。据观察，如果将项目源码文件从一台计算机/Lazarus 环境复制到另一台时，可能会出现此类问题。
749	713
750	714		### Linux 系统中出现的调试问题
751	715
752	716		用“附加到程序”功能通过进程ID（PID）调试正在运行的守护进程，似乎并不起作用，报错“Debugger Error”……“Attach failed”。其中一个原因可能是未在服务控制文件中指定用户账号，因此服务以“root”身份运行，使得调试无法进行。除了使用专用于服务的用户运行服务之外，还有一种解决办法是在 Lazarus 中加载守护进程，即在“运行-运行参数”输入 -run 命令行参数。这样确实可以进行调试，但请注意代码这时运行于不同的上下文中（是当前用户而不是系统或服务专用用户），运行效果可能因权限问题而发生变化。
753	717
754	718		### 守护进程无权限访问网络/云存储(Onedrive 和 Dropbox）
755	719
756	720		This may be confusing, since -install and -uninstall will likely work and log fine, because they are usually executed by hand and thus run in your user's context. 若要选择守护进程可执行文件存放数据的目录（默认也用于记录日志），请记住后台运行的守护进程通常会运行于系统或服务账户的上下文中。如果虚拟驱动器是由某个普通用户创建的，则通常其他用户和系统用户均无法使用。从网络/云驱动器很可能无法启动守护进程，因为操作系统找不到可执行文件，并且日志也会写入失败，因为日志文件默认将写入可执行文件所在位置。而 -install 和 -uninstall 命令通常是手动执行的，即运行于当前用户的上下文中，因此或许可以正常执行并记入日志，于是或许会很令人困惑。
757	721
758	722		### Linux 中指定运行服务的用户无法生效
759	723
760	724		守护进程启动后，如果查看其运行于哪个用户下，虽然在 systemd 的 .service 文件中指定了用户账号，但似乎仍以 root 身份在运行。
761	725
762	726		有（未经证实的）报告称，（在某些版本的 Linux 中？）控制 systemd 的 .service 文件中，“User”条目必须位于“ExecStart”条目之前才能生效，Linux 安装和卸载功能部分的例程已有展示。
763	727
764	728		### 系统代码页 / UTF-8
765	729
766	730		[陈旧内容，需要验证 3/2022, 或许已废弃]
767	731
768	732		LazDeamon 项目正在使用默认的、非 UTF-8 的代码页。 _项目选项 ..._ -> _编译器选项_ -> _附加和覆盖_ -> _使用系统编码_ 中的 _-dDisableUTF8RTL_ 选项必须启用。
769	733
770	734		## [一些旧的内容：有待验证、合并或删除]
771	735
772	736		[Old content, needs verfification 3/2022, may be obsolete]
773	737
774	738		### Linux（仅限旧版 Debian）
775	739
776	740		下载、配置、另存为 - 网上的归档文件 [[1]](<https://web.archive.org/web/20130209102726/http://aurawin.com/lazarus/debian-service.sh>) （原始链接已失效久矣）。
777	741
778	742		* SVC_ALIAS 是应用的详细说明。
779	743		* SVC_FILENAME 是编译好的服务应用的实际文件名。
780	744		* SVC_DIR 是服务应用的存放位置。
781	745		* SVC_SERVICE_SCRIPT 是将自定义 debian-service.sh 另存后的最终名称。
782	746
783	747		将自定义脚本放入 /etc/init.d/ 目录。
784	748
785	749		用“sudo service Name_Of_Your_Script start”命令启动服务。
786	750
787	751		![Light bulb](https://upload.wikimedia.org/wikipedia/commons/d/d8/Nuvola_apps_ktip.png) Note: sudo 有很多版本的用法，比如：
788	752		```
789	753		sudo -s #
790	754
791	755		sudo -H #
792	756
793	757		sudo -i #
794	758
795	759		sudo su #
796	760		```
797	761
798	762
799	763		sudo sh #
800	764
801	765		服务若需在系统启动时能自动运行，可用 update-rc.d 命令或第三方工具来实现。
802	766
803	767		第一种方式：
804	768		```
805	769		sudo update-rc.d Name_Of_Your_Script defaults
806	770		```
807	771
808	772		第二种方式：
809	773		```
810	774		sudo apt-get install chkconfig
811	775		sudo chkconfig --add Name_Of_Your_Script
812	776		sudo chkconfig --level 2345 Name_Of_Your_Script on
813	777		```
814	778
815	779		## 参阅
816	780
817	781		* [GitHub Repository](<https://github.com/arminlinder/Lazarus-FPC-Wiki-Code-Samples/zipball/master/>) 示例项目完整源码（.zip）
818	782		* [[macOS daemons and agents]] \- macOS 原生代理，用到了 launchd
819	783		* [[ServiceManager]] Windows 服务管理的 Free Pascal 示例单元
820	784		* [Michaël Van Canneyt 撰写的文章：Taming the daemon](<https://www.freepascal.org/~michael/articles/daemons/daemons.pdf>)
821	785		* [[Docker Containerization]] \- 容器化，一种创建守护进程/服务的手段
822	786		* [[UniqueInstance]]
823	787
824	788		---
825	789		From the Free Pascal wiki, page "Daemons and Services/zh CN", as the Internet Archive kept it on 2025-03-27, last changed on 2024-12-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history