fbintf/testsuite/Test11.pas

unit Test11;

{$mode objfpc}{$H+}
{$codepage utf8}

{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: string);
    procedure BackupRestore(Service: IServiceManager; DBName: string);
  public
    function TestTitle: string; override;
    procedure RunTest(CharSet: string; SQLDialect: integer); override;
  end;

implementation

{ TTest11 }

procedure TTest11.GetStatistics(Service: IServiceManager; DBName: string);
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: string);
var Req: ISRB;
    Results: IServiceQueryResults;
    BakFile: TFileStream;
    QueryResultsItem: IServiceQueryResultItem;
    ReqLength: integer;
    SQPB: ISQPB;
    bytesWritten: integer;
    bytesAvailable: integer;
    i: integer;
    RestoreDBName: string;
    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) 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 -= 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: string;
begin
  Result := 'Test 11: Services API';
end;

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