ANN: kbmMW Professional and Enterprise Edition v. 5.04.20 released!

We are happy to announce v5.04.20 of our popular middleware for Delphi and C++Builder.

If you like kbmMW, please let others know! Share the word!

We strive hard to ensure kbmMW continues to set the bar for what an n-tier product must be capable of in the real world!

This release is primarily bugfix release, but does also contain a number of new things:

  • Support for scheduling multiple parallel child jobs for recurrent runs.
  • XML <> Object Notation conversion improvements
  • kbmMW Configuration improvements

Please look in the end of this post for a detailed change list.

Professional and Enterprise Edition is available for all with a current active SAU. If your SAU has run out, please visit our shop to extend it with another 12 months.

CodeGear Edition is available for free, but only supports a specific Delphi/Win32 SKU, contains a limited feature set and do not include source.

Please visit https://portal.components4developers.com to download.

—-

kbmMW is the premiere n-tier product for Delphi, C++Builder and FPC on .Net, Win32, Win64, Linux, Java, PHP, Android, IOS, embedded devices, websites, mainframes and more.

Please visit http://www.components4developers.com for more information about kbmMW.

—-

Components4Developers is a company established in 1999 with the purpose of providing high quality development tools for developers and enterprises. The primary focus is on SOA, EAI and systems integration via our flagship product kbmMW.

kbmMW is a portable, highly scalable, high end application server and enterprise architecture integration (EAI) development framework for Win32, ..Net and Linux with clients residing on Win32, .Net, Linux, Unix, Mainframes, Minis, Embedded and many other places. It is currently used as the backbone in hundreds of central systems, in
hospitals, courts, private, industries, offshore industry, finance, telecom, governements, schools, laboratories, rentals, culture institutions, FDA approved medical devices, military and more.

—-

5.04.20 Nov 12 2017

New stuff
 =========
 - Added ability to Schedule batches of tasks as one job, similarly as Run.
 Using Schedule, it can be recurrent.

Fixes
 =====
 - Updated several database adapters with various fixes.
 - Fixed error popping up in TkbmMWCustomHashItem when range check is enabled in compiler.
 - Fixed bugs in kbmMWScheduler.
 - Fixed leaks in kbmMWScheduler related to scheduling of batches of tasks.
 - Fixed TkbmMWLockFreeHashArray2.Enum not returning AKey2 value.
 This shows up if one enable the nice debug flag
 KBMMW_MREW_NOTIFY_LONG_LOCKS_DEBUG (generally not to be used in production).
 It ensures that deadlocks due to locking will show up in the Windows monitor
 with exact info about which thread(s) held the lock and the type of lock.
 - Fixed off by one in counting when to GC a service instance resulting
 in leaving one too little left when minimum of instances has been defined.
 - Fixed service GC issue when a service has a very long running operation
 that times out and thus should be removed, resulting in less than
 defined minimum number of instances.
 - Fixed kbmMWMT database adapter's resolver to not require a table name.
 - Fixed TkbmMWConfiguration.

Changes/minor additions
 =======================
 - Updated MT demo to match current kbmMW version.
 - Significantly improved XML SaveToObjectNotation and LoadFromObjectNotation.
 Amongst other s added the following options:
 mwxonoAutoIdentifyArrayElement - Set to include i=IndexNumber of array
 attribute.
 mwxonoReservedNameAsElement - Set to not interpret id and type names but
 instead treat them as elements.
 mwxonoAutoNumberUnnamedArrays - Set to add array level to unnamed arrays.
 If not set, sub array will have same name as parent.
 - Added BSON as storage format for TkbmMWConfiguration.
 - Added Prepare...Storage utility methods to TkbmMWConfiguration to easily
 setup specific storage type.
 - Added kbmMWConfiguration sample.
 - Added SetDateTimeTimeZone to TkbmMWDateTime, which specifically sets a
 datetime with a specific timezone.

kbmMemTable v. 7.77.30 Standard and Professional Edition released

This is a bugfix release fixing the following issues:

  • Fixed compilation in D2009/D2010.
  • Fixed ftString PopulateField and CompareFields bug affecting NextGen compilers (locate/sort).
  • Fixed order of destruction of FRowOrderIndex.

kbmMemTable is the premier high performance, high functionality in
memory dataset for Delphi and C++Builder with kbmMemTable Professional
topping the scales as being the worlds fastest!

If you have an up to date Service and Update (SAU) subscription, then
you can immediately visit https://portal.components4developers.com to
download the latest kbmMemTable release.

If not, please visit our shop at http://www.components4developers.com
and extend your SAU with another 12 months.

kbmMW Scheduler Tidbits #5 -Synchronize multiple parallel jobs

Next release of kbmMW further improves on the TkbmMWScheduler. The scheduler supports adding jobs to run given a quite extensive set of time conditions. It also already supports running jobs in the background, and when they are done, handle some foreground update of the GUI in a safe and consistent way.

However what if you want to run a number of jobs in parallel in the background and only call the job a success when all the background sub jobs has finished.

kbmMW will allow you to do that in a simple way in next release. Here is some example code.

procedure TForm1.Button10Click(Sender: TObject);
var
  d1:int64;
begin
  d1:=TkbmMWTiming.GetTimeUS;
  Scheduler.Run([
   procedure(const AScheduledEvent:IkbmMWScheduledEvent)
   var
      i,n:integer;
      d:int64;
   begin
        AScheduledEvent.Data:=0;
        n:=500;
        d:=TkbmMWTiming.GetTimeUS;
        for i:=0 to n-1 do
        begin
             if AScheduledEvent.Terminating then
                break;
             sleep(10);
        end;
        d:=TkbmMWTiming.Diff(d);
        AScheduledEvent.Data:=d;
   end,
   procedure(const AScheduledEvent:IkbmMWScheduledEvent)
   var
      i,n:integer;
      d:int64;
   begin
        AScheduledEvent.Data:=0;
        n:=400;
        d:=TkbmMWTiming.GetTimeUS;
        for i:=0 to n-1 do
        begin
             if AScheduledEvent.Terminating then
                break;
             sleep(10);
        end;
        d:=TkbmMWTiming.Diff(d);
        AScheduledEvent.Data:=d;
   end]
  )
  .NamedAs('MultipleWithSync')
  .SynchronizedAfterRun(
   procedure(const AScheduledEvent:IkbmMWScheduledEvent)
   begin
        mData.Lines.Add('Run multiple with sync - anonym (uS):'+VarToStr(AScheduledEvent.ChildEvent[0].Data)+','+VarToStr(AScheduledEvent.ChildEvent[1].Data));
        mData.Lines.Add(' Total passed time (uS):'+IntToStr(TkbmMWTiming.Diff(d1)));
   end)
  .Activate;
end;

One interesting part is the Run method, which now takes an array of procedures or functions to run. What happens internally, is that a scheduled event is defined, which in turn defines a number of child scheduled events that each process the given jobs.

Only when all jobs are done, the AfterRun method is executed.

Another interesting thing to notice, is that the AfterRun method can tap into data provided by any of the child events. In this case the child events time how long time they ran. The AfterRun method displays that, along with the total run time.

In this case, the total time is only slightly longer than the time for the longest running job because the jobs ran in parallel.

A few more fluent methods has also been added:

WithObject(AObject:TObject) and WithInterface(AInterface:IInterface) which allows you to tag on an object or an interface to an event. It could be used to provide data for the job, or to receive data from the job.

Only remember, that jobs are run multithreaded. Thus your object or interface must be threadaware.

Finally this example shows how a long running job should check for termination. Termination happens when the Terminate method is called on the running scheduled event, or when the scheduler is closing down, for example due to the application being shutdown.

That’s all for now.

kbmMemTable 7.77.20 Std/Pro bugfix release and kbmFMX 1.03.00 Tokyo support release

We are happy to announce a bugfix release for kbmMemTable Standard and Professional Edition, fixing a couple of bugs reported by users:

Whats new in 7.77.20 Oct 1 2017
---------------------------------
 - Fixed offset bug in PopulateField on 10.2 (Tokyo) IOS/Android.
 - Fixed Unicode comparison issues in SQL.
 - Fixed LIKE incorrect match bug in SQL.
 - Added support for ftFMTBcd in PopulateField.

Further we have released a RAD Studio 10.2 (Tokyo) compatible version of kbmFMX, which is our high performance Firemonkey controls for Windows, IOS, Android and OSX, which includes:

  • TkbmFMXDBGrid – A high performance, readonly, TDataset dataaware grid.
  • TkbmFMXDBMemo – A TDataset dataaware memo control.
  • TkbmFMXDBImage – A TDataset dataware image control.
  • TkbmFMXImageControl – A super versatile image control with build in support for pan, zoom (pinch and mousewheel) and rotate. In addition it supports adding active hotspots (zones) on the image.
  • TkbmFMXNumberEdit – A simple to use numeric editor control, which visually formats the number according to FormatSettings.
  • TkbmFMXVerticalLayout – A layout that automatically resizes vertically to contain all child controls. Useful in combo with a scrollbox.
  • TkbmFMXMemo – A regular TMemo, which correctly supports caret position.
  • TkbmFMXPaintBox – A paintbox, great for capturing signatures.
  • TkbmFMXProgress – A progress overlay.

kbmFMX is available as a free bundle with kbmMemTable Standard Edition, kbmMemTable Professional Edition, kbmMW Professional Edition and kbmMW Enterprise Edition.

Please visit https://portal.components4developers.com to download the
latest and greatest versions of our paid for and free products.

 

kbmMemTable SQL new features coming

In the upcoming release of kbmMemTable, a number of improvements of the optional SQL parser is included.

Now the following syntax is also supported (see examples further down):

  • CASE … WHEN … THEN … ELSE… END
  • SELECT … INTO… FROM….
  • CREATE TABLE
  • CREATE INDEX
  • DROP INDEX
  • ALTER TABLE… ADD COLUMN…
  • ALTER TABLE… DROP COLUMN…
  • ALTER TABLE… MODIFY COLUMN…
  • LIST TABLES
  • LIST INDEXES ON …
  • DESCRIBE TABLE …
  • DESCRIBE INDEX …

Further multiple statements separated by semicolon is now also supported. All will be run in order.

The DESCRIBE functions will return SQL 2003 style metadata descriptions.

In addition kbmMemTable SQL now supports simple inner joins.

<TEASER>

Many of these new features will be utilized by next version of kbmMW, which supports extensive SQL rewriting for major databases. Hence you will be able to write most SQL in the standard kbmMemTable SQL way which is SQL 92 compatible, and kbmMW will optionally automatically rewrite it to match the actual database, making supporting different databases a breeze. More about that in another blogpost.

</TEASER>

Examples:

SELECT fld1, fld2,
CASE
WHEN fld2<100 THEN ‘LOW’
WHEN fld2>=100 AND fld2<200 THEN ‘MEDIUM’
ELSE ‘HIGH’
END AS FLD3 INTO table7
FROM Table1

SELECT fld1, fld2,
CASE fld2
WHEN 10 THEN 99999
WHEN 20 THEN 22222
ELSE -1
END
FROM Table1

CREATE TABLE table9 (
id VARCHAR(40),
fld1 VARCHAR(50),
fld2 VARCHAR(5) NOT NULL,
fld3 BLOB NOT NULL,
fld4 INTEGER,
fld5 FLOAT,
fld6 TIMESTAMP,
PRIMARY KEY (id))

DROP TABLE table3

CREATE INDEX idx5 ON table1 (fld2 DESC)

DROP INDEX idx5 ON table1

CREATE TABLE (id INT, fld7 CLOB, PRIMARY KEY (id) )

CREATE TABLE (
id INT PRIMARY KEY,
fld2 VARCHAR(10),
fld7 CLOB ) ; CREATE INDEX idx5 (fld2 DESC) ; DROP INDEX idx5

ALTER TABLE table1 ADD COLUMN NewField VARCHAR(30)

ALTER TABLE table1 DROP COLUMN Fld2

ALTER TABLE table1 ALTER COLUMN Fld1 VARCHAR(30)

ALTER TABLE table3 MODIFY COLUMN Fld8 VARCHAR(30)

ALTER TABLE table3 MODIFY COLUMN Fld8 INTEGER

ALTER TABLE table1 ADD NewField VARCHAR(30)

ALTER TABLE table1 DROP Fld2

ALTER TABLE table1 ALTER Fld1 VARCHAR(30)

ALTER TABLE table3 MODIFY Fld8 VARCHAR(30)

ALTER TABLE table3 MODIFY Fld8 INTEGER

LIST TABLES

LIST INDEXES ON TABLE table1

LIST INDEXES ON table1

LIST INDEXES FOR TABLE table1

LIST INDEXES FOR table1

LIST INDEXES table1

DESC TABLE table1

DESCRIBE TABLE table1

DESCRIBE INDEX iDescend ON table1

DESCRIBE INDEX iDescend FOR table1

DESCRIBE INDEX iDescend ON TABLE table1

NB: If you like our blog posts, feel free to share then with your social network!

Access to www.components4developers.com

Our site may have limited access at the moment.

It seems that NetNames, who is our DNS/web forwarder, is having some issues at the moment, resulting in lack of access to our website from some countries in the world of some currently unknown reason.

And no… our domain subscriptions has not lapsed. They are paid up and current for the next couple of years. 🙂

If you want to visit our homepage, you can do so directly on http://66.85.163.250 until the issue has been solved.

The portal at https://portal.components4developers.com is continuing to be accessible.

REST easy with kbmMW #3 – SSL

I have in the former two “REST easy with kbmMW” articles shown, how to make a REST server with kbmMW, and how to use that REST server to easily return and store data from/to a database all in less than 30 lines of real code.

This blog post will center around how to ensure that communication with the server stays protected using SSL (Secure Socket Layer). In other words, how to make the REST server talk HTTPS rather than HTTP.

There are multiple ways to secure a kbmMW based application server with SSL, but I will focus on one simple way to do it using OpenSSL.

First we should create a certificate we can use. SSL certificates can be purchased from various places where they sell official certificates, or you can create one that is self signed. A self signed certificate is generally as secure as anything else, but it is not automatically trusted by other servers, which may flag your certificate as unsafe.

For inhouse use however, a self signed certificate is usually fine.

There are many places on the internet explaining the procedure of how to create SSL certificates using OpenSSL. You can click here for one of them.

After you have gotten access to either a bought or a homemade certificate, we can continue integrating it with the REST server.

Add a TIdServerIOHandlerSSLOpenSSL component to the main form (Unit7).

2017-05-21 22_13_49-Project6 - RAD Studio 10.1 Berlin - Unit7.png

You will need to set it’s SSLOptions properties like this:

  • SSLOptions.Mode must be sslmServer
  • Of the supported SSLOptions.SSLVersions I will suggest enabling only sslvTLSv1_2

Leave the remaining properties as is at the moment.

Now double click the OnGetPassword event handler of the IdServerIOHandlerSSLOpenSSL1 component to write some code in an event handler.

procedure TForm7.IdServerIOHandlerSSLOpenSSL1GetPassword(var Password: string);
begin
 Password:='yourCertificatePassword';
end;

The code going in the event should simply return the password you used when you created the private part of the certificate. It is required by OpenSSL to have access to this, to be able to use your private key.

Despite the above example, I would suggest you, not to hardcode the password inside your application, but rather read it from an external configuration file, of security reasons, in case your REST server executable got leaked elsewhere.

But for the current sample, with a homemade sample certificate, we can do with the hardcoded password.

Next we need to tell the kbmMW server side transport to let the OpenSSL code handle the main communication of our data. One part of that is to write an event handler for the OnConnect event of the kbmMWTCPIPIndyServerTransport1 component.

procedure TForm7.kbmMWTCPIPIndyServerTransport1Connect(AContext: TIdContext);
begin
  if AContext.Connection.IOHandler is TIdSSLIOHandlerSocketBase then
     TIdSSLIOHandlerSocketBase(AContext.Connection.IOHandler).
     PassThrough:=false;
end;

To make the compiler happy, we also need to add IdContext to the interface sections uses clause.

uses
 Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
 Vcl.Controls, Vcl.Forms, Vcl.Dialogs, kbmMWCustomTransport, kbmMWServer,
 kbmMWTCPIPIndyServerTransport, kbmMWRESTTransStream,
 kbmMWCustomConnectionPool, kbmMWCustomSQLMetaData, kbmMWSQLiteMetaData,
 kbmMWSQLite, kbmMWORM, IdBaseComponent, IdComponent, IdServerIOHandler, IdSSL,
 IdSSLOpenSSL, IdContext;

And finally we need to link the SSL component to the server transport, and make the certificate files available to OpenSSL.

We do that by writing the following piece of code, for example in the OnCreate event handler of the main form (containing the kbmMW Indy server transport).

procedure TForm7.FormCreate(Sender: TObject);
begin
 ORM:=TkbmMWORM.Create(kbmMWSQLiteConnectionPool1);
 ORM.CreateTable(TContact);

 // Make sure that the server is now listening on port 443 which is 
 // the default port for HTTPS communication.
 kbmMWTCPIPIndyServerTransport1.Bindings.Items[0].Port:=443;
 IdServerIOHandlerSSLOpenSSL1.SSLOptions.CertFile:='YourCertificateFile.cer';
 IdServerIOHandlerSSLOpenSSL1.SSLOptions.KeyFile:='YourPrivateKeyFile.key';

 // Optional root certificate file if purchased certificate or empty if self signed.
 IdServerIOHandlerSSLOpenSSL1.SSLOptions.RootCertFile:='';
 kbmMWTCPIPIndyServerTransport1.IdTCPServer.IOHandler:=IdServerIOHandlerSSLOpenSSL1;

 kbmMWServer1.AutoRegisterServices;
 kbmMWServer1.Active:=true;
end;

Make sure that the files YourCertificateFile.cer and YourPrivateKeyFile.key is available to the REST executable when it runs, but also make sure that they are not accessible for download for anyone else. It’s of high importance that those files (along with your private key password) is kept a secret for anybody else.

As you may notice, we change the port number for the first binding from 80 to 443, since we want to support the standard HTTPS port. You may also notice that it is possible to provide a Root certificate file. The Root certificate file typically contains a chain of public certificates that can be used by OpenSSL and browsers to verify that your own certificate is a valid and trusted certificate generated by the entity from which you have the root certificate.

Self signed certificates usually do not need any root certificate files.

Now your REST server is ready serving clients securely over SSL.

REST easy with kbmMW #1

REST easy with kbmMW #2 – Database

REST easy with kbmMW #4 – Access management

REST easy with kbmMW #5 – Logging