fbintf/testsuite/Test11.pas

unit Test11;
{$IFDEF MSWINDOWS} 
{$DEFINE WINDOWS} 
{$ENDIF}

{$IFDEF FPC}
{$mode delphi}
{$codepage utf8}
{$ENDIF}

{Test 11: Services API}

{
  This test attaches to the Server Manager associated with the Employee Database
  and then accesses and prints out:

  Version Info
  Config Params
  Database Information
  User Information
  Statistics
  Licence Info
  Licence Mask Info
  Capabilities
  limbo transactions

  Note that two exceptions are normal as Firebird does not provide licence info.
}

interface

uses
  Classes, SysUtils, TestManager, IB;

type

  { TTest11 }

  TTest11 = class(TTestBase)
  private
    procedure GetStatistics(Service: IServiceManager; DBName: AnsiString);
    procedure BackupRestore(Service: IServiceManager; DBName: AnsiString);
  public
    function TestTitle: AnsiString; override;
    procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
  end;

implementation

{ TTest11 }

procedure TTest11.GetStatistics(Service: IServiceManager; DBName: AnsiString);
var Req: ISRB;
    Results: IServiceQueryResults;
begin
  {Version Info}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_version);
  Req.Add(isc_info_svc_server_version);
  Req.Add(isc_info_svc_implementation);
  Results := Service.Query(nil,Req);
  WriteServiceQueryResult(Results);

  {Config Params}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_get_env_lock);
  Req.Add(isc_info_svc_get_config);
  Req.Add(isc_info_svc_get_env_msg);
  Req.Add(isc_info_svc_user_dbpath);
  Results := Service.Query(nil,Req);
  WriteServiceQueryResult(Results);

  {Database Information}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_svr_db_info);
  Results := Service.Query(nil,Req);
  WriteServiceQueryResult(Results);

  {User Information}
  Req := Service.AllocateSRB;
  Req.Add(isc_action_svc_display_user);
  Service.Start(Req);
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_get_users);
  Results := Service.Query(nil,Req);
  WriteServiceQueryResult(Results);

  Service.Detach;
  Service.Attach;

  {Statistics}

  if Owner.ShowStatistics then
  begin
    writeln(OutFile,'Get Statistics');
    writeln(OutFile);
    Req := Service.AllocateSRB;
    Req.Add(isc_action_svc_db_stats);
    Req.Add(isc_spb_dbname).SetAsString(DBName);
    Req.Add(isc_spb_options).SetAsInteger(isc_spb_sts_data_pages or {
                                          isc_spb_sts_hdr_pages or} isc_spb_sts_idx_pages or
                                          isc_spb_sts_sys_relations);

    try
      Service.Start(Req);
      Req := Service.AllocateSRB;
      Req.Add(isc_info_svc_line);
      repeat
        Results := Service.Query(nil,Req);
      until not WriteServiceQueryResult(Results);
    except on E: Exception do
      writeln(OutFile,'Statistics Service Start: ',E.Message);
    end;
    writeln(OutFile);
  end;

  {Licence Info}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_get_license);
  Req.Add(isc_info_svc_get_licensed_users);
  try
    Results := Service.Query(nil,Req);
    WriteServiceQueryResult(Results);
  except on E: Exception do
    writeln(OutFile,'Licence Info: ',E.Message);
  end;
  writeln(OutFile);

  {Licence Mask Info}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_get_license_mask);
  try
    Results := Service.Query(nil,Req);
    WriteServiceQueryResult(Results);
  except on E: Exception do
    writeln(OutFile,'Licence Mask Info: ',E.Message);
  end;
  writeln(OutFile);

  {Capabilities}
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_capabilities);
  try
    Results := Service.Query(nil,Req);
    WriteServiceQueryResult(Results);
  except on E: Exception do
    writeln(OutFile,'Capabilities: ',E.Message);
  end;
  writeln(OutFile);

  {limbo transactions}

  writeln(OutFile,'Get Limbo transactions');
  writeln(OutFile);
  Req := Service.AllocateSRB;
  Req.Add(isc_info_svc_limbo_trans);
  try
    Results := Service.Query(nil,Req);
    WriteServiceQueryResult(Results);
  except on E: Exception do
    writeln(OutFile,'limbo transactions: ',E.Message);
  end;
  writeln(OutFile);
end;

procedure TTest11.BackupRestore(Service: IServiceManager; DBName: AnsiString);
var Req: ISRB;
    Results: IServiceQueryResults;
    BakFile: TFileStream;
    QueryResultsItem: IServiceQueryResultItem;
    ReqLength: integer;
    SQPB: ISQPB;
    bytesWritten: integer;
    bytesAvailable: integer;
    i: integer;
    RestoreDBName: AnsiString;
    Attachment: IAttachment;
    DPB: IDPB;
begin
  {Local Backup}

  writeln(OutFile,'Local Backup');
  Req := Service.AllocateSRB;
  Req.Add(isc_action_svc_backup);
  Req.Add(isc_spb_dbname).AsString := DBName;
  Req.Add(isc_spb_bkp_file).AsString := 'stdout';
  try
    BakFile := TFileStream.Create(Owner.GetBackupFileName,fmCreate);
    try
      Service.Start(Req);
      Req := Service.AllocateSRB;
      Req.Add(isc_info_svc_to_eof);
      repeat
        bytesWritten := 0;
        Results := Service.Query(Req);
        QueryResultsItem := Results.Find(isc_info_svc_to_eof);
        if QueryResultsItem <> nil then
          bytesWritten := QueryResultsItem.CopyTo(BakFile,0);
      until ((bytesWritten = 0) and (Results.Find(isc_info_svc_timeout) = nil))
        or not WriteServiceQueryResult(Results);
      writeln(OutFile,'Local Backup Complete');
    finally
      BakFile.Free;
    end;
  except on E: Exception do
    writeln(OutFile,'Local Backup Service: ',E.Message);
  end;
  writeln(OutFile);

  {Local Restore}
  writeln(OutFile,'Local Restore');
  RestoreDBName := Owner.GetNewDatabaseName;
  i := Pos(':',RestoreDBName);
  if i > 0 then
    system.Delete(RestoreDBName,1,i);
  Req := Service.AllocateSRB;
  Req.Add(isc_action_svc_restore);
  Req.Add(isc_spb_dbname).AsString := RestoreDBName;
  Req.Add(isc_spb_verbose);
  Req.Add(isc_spb_bkp_file).AsString := 'stdin';
  Req.Add(isc_spb_res_access_mode).AsByte := isc_spb_prp_am_readwrite;
  Req.Add(isc_spb_options).SetAsInteger(isc_spb_res_create);
  BakFile := TFileStream.Create(Owner.GetBackupFileName,fmOpenRead);
  try
    bytesAvailable := BakFile.Size;
    try
      Service.Start(Req);
      ReqLength := 0;
      repeat
        SQPB := Service.AllocateSQPB;
        if ReqLength > 0 then
            bytesWritten := SQPB.Add(isc_info_svc_line).CopyFrom(BakFile,ReqLength);
        bytesAvailable := bytesAvailable - bytesWritten;
        Req := Service.AllocateSRB;
        Req.Add(isc_info_svc_stdin);
        Req.Add(isc_info_svc_line);
        Results := Service.Query(SQPB,Req);
        QueryResultsItem := Results.Find(isc_info_svc_stdin);
        if QueryResultsItem <> nil then
          ReqLength := QueryResultsItem.AsInteger;
        WriteServiceQueryResult(Results);
      until (ReqLength = 0) ;
      writeln(OutFile,'Local Restore Complete');
    except on E: Exception do
      writeln(OutFile,'Local Restore Service: ',E.Message);
    end;
  finally
    BakFile.free;
  end;
  writeln(OutFile);
  writeln(OutFile,'Open Database Check');
  DPB := FirebirdAPI.AllocateDPB;
  DPB.Add(isc_dpb_user_name).AsString := Owner.GetUserName;
  DPB.Add(isc_dpb_password).AsString := Owner.GetPassword;
  Attachment := FirebirdAPI.OpenDatabase(Owner.GetNewDatabaseName,DPB);
  if Attachment <> nil then
    writeln(OutFile,'Database OK');
  Attachment.DropDatabase;
  writeln(OutFile,'Database Dropped');
end;

function TTest11.TestTitle: AnsiString;
begin
  Result := 'Test 11: Services API';
end;

procedure TTest11.RunTest(CharSet: AnsiString; SQLDialect: integer);
var SPB: ISPB;
    Service: IServiceManager;
    I: integer;
    ServerName: AnsiString;
    DBName: AnsiString;
begin
  if not FirebirdAPI.HasServiceAPI then Exit;

  ServerName := Owner.GetEmployeeDatabaseName;
  I := Pos(':',ServerName);
  if i > 0 then
    DBName := system.copy(ServerName,i+1,length(ServerName) - 2);
  system.Delete(ServerName,i,Length(ServerName)-i+1);

  SPB := FirebirdAPI.AllocateSPB;
  SPB.Add(isc_spb_user_name).setAsString(Owner.GetUserName);
  SPB.Add(isc_spb_password).setAsString(Owner.GetPassword);
  Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);

  GetStatistics(Service,DBName);
  BackupRestore(Service,DBName);

end;

initialization
  RegisterTest(TTest11);

end.

Revision:	143
Committed:	Fri Feb 23 12:11:21 2018 UTC (6 years, 9 months ago) by tony
Content type:	text/x-pascal
File size:	8194 byte(s)
Log Message:	Fixes Merged
#	Content
1	unit Test11;
2	{$IFDEF MSWINDOWS}
3	{$DEFINE WINDOWS}
4	{$ENDIF}
5
6	{$IFDEF FPC}
7	{$mode delphi}
8	{$codepage utf8}
9	{$ENDIF}
10
11	{Test 11: Services API}
12
13	{
14	This test attaches to the Server Manager associated with the Employee Database
15	and then accesses and prints out:
16
17	Version Info
18	Config Params
19	Database Information
20	User Information
21	Statistics
22	Licence Info
23	Licence Mask Info
24	Capabilities
25	limbo transactions
26
27	Note that two exceptions are normal as Firebird does not provide licence info.
28	}
29
30	interface
31
32	uses
33	Classes, SysUtils, TestManager, IB;
34
35	type
36
37	{ TTest11 }
38
39	TTest11 = class(TTestBase)
40	private
41	procedure GetStatistics(Service: IServiceManager; DBName: AnsiString);
42	procedure BackupRestore(Service: IServiceManager; DBName: AnsiString);
43	public
44	function TestTitle: AnsiString; override;
45	procedure RunTest(CharSet: AnsiString; SQLDialect: integer); override;
46	end;
47
48	implementation
49
50	{ TTest11 }
51
52	procedure TTest11.GetStatistics(Service: IServiceManager; DBName: AnsiString);
53	var Req: ISRB;
54	Results: IServiceQueryResults;
55	begin
56	{Version Info}
57	Req := Service.AllocateSRB;
58	Req.Add(isc_info_svc_version);
59	Req.Add(isc_info_svc_server_version);
60	Req.Add(isc_info_svc_implementation);
61	Results := Service.Query(nil,Req);
62	WriteServiceQueryResult(Results);
63
64	{Config Params}
65	Req := Service.AllocateSRB;
66	Req.Add(isc_info_svc_get_env_lock);
67	Req.Add(isc_info_svc_get_config);
68	Req.Add(isc_info_svc_get_env_msg);
69	Req.Add(isc_info_svc_user_dbpath);
70	Results := Service.Query(nil,Req);
71	WriteServiceQueryResult(Results);
72
73	{Database Information}
74	Req := Service.AllocateSRB;
75	Req.Add(isc_info_svc_svr_db_info);
76	Results := Service.Query(nil,Req);
77	WriteServiceQueryResult(Results);
78
79	{User Information}
80	Req := Service.AllocateSRB;
81	Req.Add(isc_action_svc_display_user);
82	Service.Start(Req);
83	Req := Service.AllocateSRB;
84	Req.Add(isc_info_svc_get_users);
85	Results := Service.Query(nil,Req);
86	WriteServiceQueryResult(Results);
87
88	Service.Detach;
89	Service.Attach;
90
91	{Statistics}
92
93	if Owner.ShowStatistics then
94	begin
95	writeln(OutFile,'Get Statistics');
96	writeln(OutFile);
97	Req := Service.AllocateSRB;
98	Req.Add(isc_action_svc_db_stats);
99	Req.Add(isc_spb_dbname).SetAsString(DBName);
100	Req.Add(isc_spb_options).SetAsInteger(isc_spb_sts_data_pages or {
101	isc_spb_sts_hdr_pages or} isc_spb_sts_idx_pages or
102	isc_spb_sts_sys_relations);
103
104	try
105	Service.Start(Req);
106	Req := Service.AllocateSRB;
107	Req.Add(isc_info_svc_line);
108	repeat
109	Results := Service.Query(nil,Req);
110	until not WriteServiceQueryResult(Results);
111	except on E: Exception do
112	writeln(OutFile,'Statistics Service Start: ',E.Message);
113	end;
114	writeln(OutFile);
115	end;
116
117	{Licence Info}
118	Req := Service.AllocateSRB;
119	Req.Add(isc_info_svc_get_license);
120	Req.Add(isc_info_svc_get_licensed_users);
121	try
122	Results := Service.Query(nil,Req);
123	WriteServiceQueryResult(Results);
124	except on E: Exception do
125	writeln(OutFile,'Licence Info: ',E.Message);
126	end;
127	writeln(OutFile);
128
129	{Licence Mask Info}
130	Req := Service.AllocateSRB;
131	Req.Add(isc_info_svc_get_license_mask);
132	try
133	Results := Service.Query(nil,Req);
134	WriteServiceQueryResult(Results);
135	except on E: Exception do
136	writeln(OutFile,'Licence Mask Info: ',E.Message);
137	end;
138	writeln(OutFile);
139
140	{Capabilities}
141	Req := Service.AllocateSRB;
142	Req.Add(isc_info_svc_capabilities);
143	try
144	Results := Service.Query(nil,Req);
145	WriteServiceQueryResult(Results);
146	except on E: Exception do
147	writeln(OutFile,'Capabilities: ',E.Message);
148	end;
149	writeln(OutFile);
150
151	{limbo transactions}
152
153	writeln(OutFile,'Get Limbo transactions');
154	writeln(OutFile);
155	Req := Service.AllocateSRB;
156	Req.Add(isc_info_svc_limbo_trans);
157	try
158	Results := Service.Query(nil,Req);
159	WriteServiceQueryResult(Results);
160	except on E: Exception do
161	writeln(OutFile,'limbo transactions: ',E.Message);
162	end;
163	writeln(OutFile);
164	end;
165
166	procedure TTest11.BackupRestore(Service: IServiceManager; DBName: AnsiString);
167	var Req: ISRB;
168	Results: IServiceQueryResults;
169	BakFile: TFileStream;
170	QueryResultsItem: IServiceQueryResultItem;
171	ReqLength: integer;
172	SQPB: ISQPB;
173	bytesWritten: integer;
174	bytesAvailable: integer;
175	i: integer;
176	RestoreDBName: AnsiString;
177	Attachment: IAttachment;
178	DPB: IDPB;
179	begin
180	{Local Backup}
181
182	writeln(OutFile,'Local Backup');
183	Req := Service.AllocateSRB;
184	Req.Add(isc_action_svc_backup);
185	Req.Add(isc_spb_dbname).AsString := DBName;
186	Req.Add(isc_spb_bkp_file).AsString := 'stdout';
187	try
188	BakFile := TFileStream.Create(Owner.GetBackupFileName,fmCreate);
189	try
190	Service.Start(Req);
191	Req := Service.AllocateSRB;
192	Req.Add(isc_info_svc_to_eof);
193	repeat
194	bytesWritten := 0;
195	Results := Service.Query(Req);
196	QueryResultsItem := Results.Find(isc_info_svc_to_eof);
197	if QueryResultsItem <> nil then
198	bytesWritten := QueryResultsItem.CopyTo(BakFile,0);
199	until ((bytesWritten = 0) and (Results.Find(isc_info_svc_timeout) = nil))
200	or not WriteServiceQueryResult(Results);
201	writeln(OutFile,'Local Backup Complete');
202	finally
203	BakFile.Free;
204	end;
205	except on E: Exception do
206	writeln(OutFile,'Local Backup Service: ',E.Message);
207	end;
208	writeln(OutFile);
209
210	{Local Restore}
211	writeln(OutFile,'Local Restore');
212	RestoreDBName := Owner.GetNewDatabaseName;
213	i := Pos(':',RestoreDBName);
214	if i > 0 then
215	system.Delete(RestoreDBName,1,i);
216	Req := Service.AllocateSRB;
217	Req.Add(isc_action_svc_restore);
218	Req.Add(isc_spb_dbname).AsString := RestoreDBName;
219	Req.Add(isc_spb_verbose);
220	Req.Add(isc_spb_bkp_file).AsString := 'stdin';
221	Req.Add(isc_spb_res_access_mode).AsByte := isc_spb_prp_am_readwrite;
222	Req.Add(isc_spb_options).SetAsInteger(isc_spb_res_create);
223	BakFile := TFileStream.Create(Owner.GetBackupFileName,fmOpenRead);
224	try
225	bytesAvailable := BakFile.Size;
226	try
227	Service.Start(Req);
228	ReqLength := 0;
229	repeat
230	SQPB := Service.AllocateSQPB;
231	if ReqLength > 0 then
232	bytesWritten := SQPB.Add(isc_info_svc_line).CopyFrom(BakFile,ReqLength);
233	bytesAvailable := bytesAvailable - bytesWritten;
234	Req := Service.AllocateSRB;
235	Req.Add(isc_info_svc_stdin);
236	Req.Add(isc_info_svc_line);
237	Results := Service.Query(SQPB,Req);
238	QueryResultsItem := Results.Find(isc_info_svc_stdin);
239	if QueryResultsItem <> nil then
240	ReqLength := QueryResultsItem.AsInteger;
241	WriteServiceQueryResult(Results);
242	until (ReqLength = 0) ;
243	writeln(OutFile,'Local Restore Complete');
244	except on E: Exception do
245	writeln(OutFile,'Local Restore Service: ',E.Message);
246	end;
247	finally
248	BakFile.free;
249	end;
250	writeln(OutFile);
251	writeln(OutFile,'Open Database Check');
252	DPB := FirebirdAPI.AllocateDPB;
253	DPB.Add(isc_dpb_user_name).AsString := Owner.GetUserName;
254	DPB.Add(isc_dpb_password).AsString := Owner.GetPassword;
255	Attachment := FirebirdAPI.OpenDatabase(Owner.GetNewDatabaseName,DPB);
256	if Attachment <> nil then
257	writeln(OutFile,'Database OK');
258	Attachment.DropDatabase;
259	writeln(OutFile,'Database Dropped');
260	end;
261
262	function TTest11.TestTitle: AnsiString;
263	begin
264	Result := 'Test 11: Services API';
265	end;
266
267	procedure TTest11.RunTest(CharSet: AnsiString; SQLDialect: integer);
268	var SPB: ISPB;
269	Service: IServiceManager;
270	I: integer;
271	ServerName: AnsiString;
272	DBName: AnsiString;
273	begin
274	if not FirebirdAPI.HasServiceAPI then Exit;
275
276	ServerName := Owner.GetEmployeeDatabaseName;
277	I := Pos(':',ServerName);
278	if i > 0 then
279	DBName := system.copy(ServerName,i+1,length(ServerName) - 2);
280	system.Delete(ServerName,i,Length(ServerName)-i+1);
281
282	SPB := FirebirdAPI.AllocateSPB;
283	SPB.Add(isc_spb_user_name).setAsString(Owner.GetUserName);
284	SPB.Add(isc_spb_password).setAsString(Owner.GetPassword);
285	Service := FirebirdAPI.GetServiceManager(ServerName,TCP,SPB);
286
287	GetStatistics(Service,DBName);
288	BackupRestore(Service,DBName);
289
290	end;
291
292	initialization
293	RegisterTest(TTest11);
294
295	end.
296