Lazarus Pascal

Cancel HTTP Get Async Task if not Completed after a Max Time

See more HTTP Examples

Demonstrates how to wait a maximum amount of time for an asynchronous task to completed. If not completed in the allotted amount of time, the task is cancelled. Lazarus Pascal

program ChilkatDemo;

// Demonstrates using the Chilkat Pascal wrapper via the C bridge DLL.
// Builds as a console application under Lazarus (FPC) or Delphi.

{$IFDEF FPC}
  {$MODE DELPHI}
{$ENDIF}
{$APPTYPE CONSOLE}

uses
  {$IFDEF UNIX}
  cthreads,
  {$ENDIF}
  SysUtils,
  CkDllLoader,
  Chilkat.Task,
  Chilkat.Http;

// ---------------------------------------------------------------------------

procedure RunDemo;
var
  success: Boolean;
  http: THttp;
  url: string;
  task: TTask;
  waitMaxMs: Integer;
  wasCanceled: Boolean;
  responseStr: string;

begin
  success := False;

  //  This example requires the Chilkat API to have been previously unlocked.
  //  See Global Unlock Sample for sample code.

  http := THttp.Create;

  //  Set some timeouts, in seconds:
  http.ConnectTimeout := 15;
  //  ReadTimeout specifies the max number of seconds that must elapse when no additional data is received before
  //  timing out.  For example, if a server sends a 300 byte response at the rate of 1 byte per second, then
  //  ReadTimeout would never cause a timeout because there is never a 15 second interval when nothing arrives.
  http.ReadTimeout := 15;

  url := 'https://your-url.com/something';
  task := http.QuickGetStrAsync(url);
  task.Run();

  //  Wait a maximum of waitMaxMs for the task (i.e. the HTTP GET) to complete.
  //  The Wait method returns when the task has been canceled, aborted, or completed, or when the max allotted time has passed.
  waitMaxMs := 20000;
  task.Wait(waitMaxMs);

  //  At this point, the GET may or may not have completed.  
  //  Rather than checking the Task status, we can call task.Cancel because
  //  if the Task is no longer running (because it already completed, was canceled or aborted), then the 
  //  call to Cancel is a NO-OP (meaning it does nothing and the Task's status is unaffected).
  //  Also, task.Cancel returns True if the task was in the "queued" or "running" state and was canceled or aborted. 
  //  The method returns False if the task has any other status.
  wasCanceled := task.Cancel();
  if (wasCanceled = True) then
    begin
      WriteLn('The HTTP GET took too long and was canceled.');
    end
  else
    begin
      //  Find out what happened.
      if (task.StatusInt = 7) then
        begin
          //  The task completed, which means the background thread's call to QuickGetStr completed
          //  with success or failure.  Find out which...
          if (task.TaskSuccess = True) then
            begin
              //  Get the string response for the call to QuickGetStr (which happened in Chilkat's background thread).
              responseStr := task.GetResultString();
              WriteLn(responseStr);
              WriteLn('HTTP GET successful!');
            end
          else
            begin
              WriteLn('HTTP GET failed prior to waitMaxMs...');
              WriteLn(task.ResultErrorText);
            end;
        end
      else
        begin
          //  The task must've been canceled or aborted by some other means..
          WriteLn('Task did not complete.  Final status: ' + task.Status);
        end;
    end;

  task.Free;


  http.Free;

end;

// ---------------------------------------------------------------------------

begin

  try
    RunDemo;
  except
    on E: Exception do
      WriteLn('Unhandled exception: ', E.ClassName, ': ', E.Message);
  end;

  WriteLn;
  {$IFDEF MSWINDOWS}
  WriteLn('Press Enter to exit...');
  ReadLn;
  {$ENDIF}
end.