mysshiohandler.pas

Crlab公司用来连接MySQL数据库的控件

unit MySSHIOHandler;

interface

uses
{$IFNDEF CLR}
  CLRClasses,
{$ENDIF}
  Classes, MySqlVio, MemUtils, ScSSHClient, ScSSHChannel;

type
  TMySSHIOHandler = class (TMyIOHandler)
  private
    FList: TList;
  protected
    FClient: TScSSHClient;
    //FChannel: TScSSHChannel;

    procedure CheckClient;
    procedure SetClient(Value: TScSSHClient);
    procedure RegisterClient(Client: TObject); override;
    procedure UnRegisterClient(Client: TObject); override;
    procedure ConnectChange(Sender: TObject; Connecting: boolean);
    procedure Notification(Component: TComponent; Operation: TOperation); override;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    function Connect(const Server: string; const Port: integer;
      const SSL_key, SSL_cert, SSL_ca: string): TMyIOHandle; override;
    {$IFNDEF CLR}class{$ENDIF} procedure Disconnect(Handle: TMyIOHandle); override;
    {$IFNDEF CLR}class{$ENDIF} function Read(Handle: TMyIOHandle; {$IFDEF CLR}var{performance opt}{$ENDIF} buffer: TValueArr; offset, count: integer): integer; override;
    {$IFNDEF CLR}class{$ENDIF} function Write(Handle: TMyIOHandle; const buffer: TValueArr; offset, count: integer): integer;  override;

    {$IFNDEF CLR}class{$ENDIF} function GetTimeout(Handle: TMyIOHandle): integer; override;
    {$IFNDEF CLR}class{$ENDIF} procedure SetTimeout(Handle: TMyIOHandle; Value: integer); override;

  published
    property Client: TScSSHClient read FClient write SetClient;

  end;

implementation

uses
  ScConsts, ScSSHUtil, MyAccess;

{ TMySSHIOHandler }

constructor TMySSHIOHandler.Create(AOwner: TComponent);
begin
  inherited;

  FList := TList.Create;
end;

destructor TMySSHIOHandler.Destroy;
begin
  if Assigned(Client) then
    TScClientUtils.UnregisterClient(Client, Self);

  FList.Free;
  inherited;
end;

procedure TMySSHIOHandler.CheckClient;
begin
  if FClient = nil then
    raise EScError.Create(SClientNotDefined);

  FClient.Connect;
end;

function TMySSHIOHandler.Connect(const Server: string; const Port: integer;
  const SSL_key, SSL_cert, SSL_ca: string): TMyIOHandle;
var
  Channel: TScSSHChannel;
begin
  CheckClient;

  Channel := TScSSHChannel.Create(Self);
  try
    Channel.Direct := True;
    Channel.Client := FClient;
    Channel.DestHost := Server;
    Channel.DestPort := Port;
    Channel.Timeout := FClient.Timeout;

    Channel.Connect;
  except
    Channel.Free;
    raise;
  end;
  Result := Channel;
end;

{$IFNDEF CLR}class{$ENDIF} procedure TMySSHIOHandler.Disconnect(Handle: TMyIOHandle);
var
  Channel: TScSSHChannel;
begin
  Channel := Handle as TScSSHChannel;
  Channel.Connected := False;
  Channel.Free;
end;

{$IFNDEF CLR}class{$ENDIF} function TMySSHIOHandler.Read(Handle: TMyIOHandle; {$IFDEF CLR}var{performance opt}{$ENDIF} buffer: TValueArr; offset, count: integer): integer;
var
  Channel: TScSSHChannel;
begin
  Channel := Handle as TScSSHChannel;
  Result := Channel.ReadBuffer(buffer{$IFNDEF CLR}[offset]{$ELSE}, offset{$ENDIF}, count);
end;

{$IFNDEF CLR}class{$ENDIF} function TMySSHIOHandler.Write(Handle: TMyIOHandle;
  const buffer: TValueArr; offset, count: integer): integer;
var
  Channel: TScSSHChannel;
begin
  Channel := Handle as TScSSHChannel;
  Result := Channel.WriteBuffer(buffer{$IFNDEF CLR}[offset]{$ELSE}, offset{$ENDIF}, count);
end;

{$IFNDEF CLR}class{$ENDIF} function TMySSHIOHandler.GetTimeout(Handle: TMyIOHandle): integer;
var
  Channel: TScSSHChannel;
begin
  Channel := Handle as TScSSHChannel;
  Result := Channel.Timeout;
end;

{$IFNDEF CLR}class{$ENDIF} procedure TMySSHIOHandler.SetTimeout(Handle: TMyIOHandle; Value: integer);
var
  Channel: TScSSHChannel;
begin
  Channel := Handle as TScSSHChannel;
  Channel.Timeout := Value;
end;

procedure TMySSHIOHandler.Notification(Component: TComponent; Operation: TOperation);
begin
  if (Component = FClient) and (Operation = opRemove) then
    Client := nil;

  inherited;
end;

procedure TMySSHIOHandler.SetClient(Value: TScSSHClient);
begin
  if Value <> FClient then begin
    if FClient <> nil then begin
      TScClientUtils.UnregisterClient(FClient, Self);
      FClient.RemoveFreeNotification(Self);
    end;

    FClient := Value;

    if Value <> nil then begin
      TScClientUtils.RegisterClient(Value, Self, ConnectChange);
      Value.FreeNotification(Self);
    end;
  end;
end;

procedure TMySSHIOHandler.RegisterClient(Client: TObject);
begin
  if Client is TMyConnection then
    FList.Add(Client)
  else
    Assert(False);
end;

procedure TMySSHIOHandler.UnRegisterClient(Client: TObject);
begin
  FList.Remove(Client);
end;

procedure TMySSHIOHandler.ConnectChange(Sender: TObject; Connecting: boolean);
var
  i: Integer;
  Conn: TMyConnection;
begin
  if not Connecting then
    for i := 0 to FList.Count - 1 do begin
      Conn := TMyConnection(FList[i]);
      if (Conn.Pooling = False) and (Conn.Options.DisconnectedMode = False) then
        Conn.Disconnect;
    end;
end;

end.