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
|
This is the beginning of a server side web system for FPC.
Although it is non-visual, it is geared towards use in Lazarus.
NOTE: the template support (fptemplate unit) was moved to
fcl-base. See the fcl-base/texts/fptemplate.txt file.
Architecture:
httpdefs
--------
contains the basic HTTP system definitions:
header field names
TCookie(s):
collection with cookies in web request
TUploadedFile(s):
collection with uploaded files in request
THTTPHeader:
Class describes HTTP Request/Response headers.
it has properties for all possible HTTP headers, including cookies
TRequest:
Descendent of THTTPHeader, describes client request.
Contains uploaded files.
TResponse:
describes the web server response. Includes headers and contents.
TCustomSession:
Base for all session components.
fphttp:
-------
Basic web system components/classes
TCustomHTTPModule:
Abstract TDataModule descendant, which processes a webrequest
and prepares a response.
TModuleFactory/TModuleItem:
Module registration and creation system.
TCustomWebAction(s):
Webactions.
RegisterHTTPModule():
routine registers a module with the web system.
THTTPContentProducer :
abstract HTTP producer component.
The idea is that the URL relative to the server is taken and parsed as
follows
http://www.server.org/Path1/Path2
Path1 determines which module in the system is created to handle the
request. (the factory is queried)
Path2 determines which web action inside the module is used to handle the
request. (implemented in TWebModule, see fpweb)
websession
----------
Implements basic session support.
TSessionHTTPModule:
TCustomHTTPModule descendent with session support.
TIniWebSession:
TCustomSession descendent which stores session variables in inifiles.
TFPWebSession:
TIniWebSession descendent for use in fpweb. Uses cookies to store session info.
GetDefaultSession() :
returns default session object.
fptemplate
----------
Unit which implements template support.
TTemplateParser:
Template parse object. Does the actual parsing and replacing. Delimiters
are configurable. Standard variables can be specified, callbacks for unknown
values can be set.
TFPCustomTemplate:
TPersistent for use in components. Allows properties to configure the
TTemplateParser. Supports streams, template and template files.
fpweb
-----
Actual usable implementation of TCustomHTTPModule.
TFPWebAction(s):
Web actions with template support.
TCustomFPWebModule:
Descends from TSessionHTTPModule, implements WebActions and has template support.
TFPWebModule:
published TCustomFPWebModule properties for use in Lazarus.
fphtml
------
This creates web modules specialized in creating HTML content.
THTMLContentProducer:
Descendent of THTTPContentProducer which produces HTML
THTMLCustomDatasetContentProducer:
Descendent of THTTPContentProducer which produces HTML from datasets.
THTMLDatasetContentProducer:
Descendent of THTMLCustomDatasetContentProducer which publishes some
properties.
THTMLSelectProducer:
Produces a combo box.
THTMLDatasetSelectProducer
Produces a combo box bases on values in a dataset.
TCustomHTMLModule:
TCustomHTTPModule descendent which produces HTML content only.
Note that classes for HTML document creation come from package fcl-xml.
fpdatasetform
-------------
This contains classes which allow to create complicated HTML/forms
based on a TDataset.
THTMLDatasetFormProducer
Creates an edit form for a TDataset record.
Complicated table layouts are possible.
THTMLDatasetFormGridProducer
Creates a grid with data from a TDataset
Complicated table formatting is possible.
custcgi:
--------
CGI application base class. It knows nothing of the fp
HTTP module system.
TCustomCGIApplication :
TCustomApplication descendent which handles a CGI request.
No instance of this class is created, this is done in fpcgi.
TCGIRequest:
TRequest descendent which retrieves content from the CGI
environment.
TCGIResponse:
TResponse descendent which returns content to the CGI environment.
fpcgi:
------
Standard CGI application instance.
TCGIApplication:
TCustomCGIApplication descendent which uses the fpWeb system
to create a TCustomHTTPModuleClass to handle the request.
It contains an Application instance which handles everything.
fpApache:
---------
Apache Module support.
TCustomApacheApplication:
Uses fpweb to create TCustomHTTPModuleClass instances to
handle the request.
fphttpclient:
-------------
HTTP Protocol client component
TFPCustomHTTPClient:
A component which can be used to communicate with a HTTP Server. It can
execute HTTP GET and POST methods out of the box, but can be used to execute
other HTTP methods as well. It works using the ssockets unit of FPC, so no
third-party package to handle the socket communication is needed.
The class contains class methods, which allow to execute get/post methods in a really
simple, one-command way.
A demo application for this class exists.
fphttpserver:
-------------
TFPCustomHttpServer:
A Component which can be used to create a simple HTTP Server. All requests
are routed through a OnRequest handler. The request and responses are
modeled using the fpWeb TRequest and TResponse objects from httpdefs. The
class itself does not serve files. The OnRequest handler must be
implemented to actually serve files or respond to requests.
It can work threaded or non-threaded.
It works using the ssockets unit of FPC, so no third-party package to
handle the socket communication is needed.
A demo application for this class exists.
custhttpapp:
------------
Integration of TFPCustomHttpServer in a TWebApplication.
TFPHTTPServerHandler:
A TWebHandler descendant which implements a stand-alone HTTP server. It
uses the TFPCustomHttpServer component to implement the server.
TCustomHTTPApplication:
A descendent of TCustomWebApplication which serves as an application
object for stand-alone HTTP applications. It can be used as a parent
component for standalone HTTP application objects.
fphttpApp:
----------
THTTPApplication:
A descendent of TCustomHTTPApplication. It does nothing except expose
properties which exist in TCustomHTTPApplication. A global instance of
this class is defined in fphttpApp. Use this unit and class if you want a
simple standalone http server application for test purposes.
A demo application for this class exists.
fpwebfile:
----------
Used to implement file serving.
TFPCustomFileModule:
TFPCustomHTTPModule descendant which will serve files. Can be used as-is,
but descendents can be made to implement e.g. logging, authorisation etc.
must not be registered directly, register locations using the RegisterFileLocation
call.
|
