Daemons and Services/zh CN: what changed

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

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