Технология CORBA

delete from transactions;
drop table transactions;
drop sequence transactions id;

delete from accounts;
drop table accounts;
drop sequence accounts id;

create table accounts   (id number,
name varchar2(12 8), password varchar2(12 8), balance number default 0, closed char(1),
constraint accounts pk primary key   (id));

create table transactions (id number, transaction date number, source account id number, 
	dest account id number, amount number, transaction comment varchar2(12 8), 
	constraint transactions pk primary key (id), 
	constraint source account fk foreign key (source account id) references accounts(id),
	constraint dest account fk foreign key (dest account id)   references accounts(id));

create sequence transactions id start with 1 increment by 1; 
create sequence accounts id start with 1 increment by 1;

create or replace and compile java source named "Trigger" as

import java.net.*;
import java.io.*;
import java.math.BigInteger;

public class Trigger  
{
private static java.net.Socket s = null; 
private static OutputStream outputStream = null;
public static synchronized void trig(long id,   String host,   int port)   
	{
	try 
		{
		byte[]   b = new byte[8];
		for (int i = 0;  i < 8;  ++i)
			{
			b[i] = ( byte )(id % 256); 
			id >>= 8;
			}
		if (connect(host, port)) 
			{ 
			outputStream.write(b); 
			outputStream.flush();
			}
		}   
	catch   (Exception e)   
		{
		System.out.println("Failed"); e.printStackTrace();
		}
	}
private static boolean connect(String host,   int port)   throws Exception  
	{
	if ( s == null )
		s = new Socket( host,  port  );
	outputStream = s.getOutputStream();
	return true;
	public static void disconnect()   
		{
		try 
			{
			s.close(); 
			s = null; 
			}   
		catch   (Exception e)   
			{}
		}
	}

/
show errors java source "Trigger"
create or replace procedure account changed(accountId number, host varchar2, port number)   as
language java name   'Trigger.trig(long,   java.lang.String,   int)';

/
create or replace procedure disconnect as

language java name   'Trigger.disconnect()';
/

create or replace trigger transactions trigger after insert on transactions
referencing new as new for each row 
begin
account changed( rnew.source account id, 'smal', 12345); 
account changed( rnew.dest account id,  'smal', 12345); 
end;

/

show errors

interface Bank 
{
AccountId CreateAccount(  in wstring usrName,     in wstring usrPasswd ) raises(BankException);
Account	OpenAccount ( in AccountId id,	in wstring usrPasswd )
raises(BankException);
void	CloseAccount (in AccountId id,	in wstring usrPasswd )
raises(BankException);
};

CORBA::Object var obj  = orb->resolve initial references("RootPOA"); 
PortableServer::POA var rootPOA = PortableServer::POA::  narrow(obj);

CORBA::PolicyList policies;
policies.length(1);

policies[(CORBA::ULong)0]   = rootPOA->create lifespan policy(PortableServer::PERSISTENT );

// get the POA Manager
PortableServer::POAManager var poa manager = rootPOA->the POAManager();
PortableServer::POA var
bankPOA = rootPOA->create POA(   "banking poa",  poa manager,  policies  );
const int MAXBUF = 1024; char ior[MAXBUF];

// Convert from string to object 
std::ifstream in(argv[1]); 
if   (   !in )
throw std::runtime error(  std::string("Can't open file \"")   + argv[1] + "\""  );
in.getline(ior,  MAXBUF);

// Create the servant
ParamsPtr params = ReadParams();
BankImpl bankServant(orb,   ior,   *params);

// Decide on the ID for the servant
PortableServer::ObjectId var bankId = PortableServer::string_to_ObjectId("Bank");

// Activate the servant with the ID on bankPOA
bankPOA->activate object with id(bankId,   &bankServant);

// Activate the POA Manager 
poa manager->activate();
CORBA::Object var reference = bankPOA->servant to reference(  &bankServant);

// Wait for incoming requests
orb->run();

::CORBA::LongLong BankImpl::CreateAccount(  const wchar t*    usrName,   const wchar t*    usrPasswd )
{
database::AccountId id;
CheckResult( bank ->CreateAccount(    usrName,    usrPasswd,   &id )   ); 
return id;
}

banking::Account ptr BankImpl::OpenAccount(   ::CORBA::LongLong    id,   const wchar t*    usrPasswd )
{
database::AccountPtr db acc;
CheckResult( bank ->OpenAccount(id, usrPasswd, &db acc ));
AccountsMap::iterator it = accounts.find(id );
if (it == accounts.end())
	{
	VISMutex var lock(channelsMutex);
	std::string const channelIOR  (  CreateChannel( id )); 
	AccountImpl * servant = new AccountImpl( db acc,   channelIOR ); 
	CORBA::Object var ref (accountPOA ->servant to reference(servant));
	servant-> remove ref();
	banking::Account var account = banking::Account:: narrow(ref); 
	it = accounts.insert(  std::make pair(    id,   account  )   ).first;
	}
return banking::Account::  duplicate(it->second);
}

void BankImpl::CloseAccount(::CORBA::LongLong    id,   const wchar t*    usrPasswd)
{
CheckResult( bank ->CloseAccount( id, usrPasswd ));
}

void BankImpl::OnDBChanged( database::AccountId id )
{
VISMutex var lock(  channelsMutex    );
EventChannelsMap::const iterator it = channels.find(id );
if (it != channels .end()   )
it->second->add message(  id );
}

interface Account
{
readonly attribute wstring	HolderName;
readonly attribute Money	Balance;
readonly attribute AccountId	Id;
readonly attribute string	ChannelIOR;
TransactionList      Transactions();
Transaction	ProcessTransaction(  in AccountId dest, in Money amount,   in wstring comment  )

raises(AccountException)
};

class AccountImpl
:  public virtual POA banking::Account
,  public virtual PortableServer::RefCountServantBase
{
public:
AccountImpl( database::AccountPtr account, std::string const& channelIOR )
:   account	(account)
,   channelIOR_ (channelIOR )
	{
	account_->PutMoney(  1000,   L"Initial balance", 0); 
	std::cout << "Account created" << std::endl;
	}
~AccountImpl() 
	{
	std::cout << "Account destructed" << std::endl;
	}


virtual wchar_t* 			HolderName() 	{ return CORBA::wstring_dup( account_->HolderName() ); }
virtual ::CORBA::Float 		Balance() 	{ return account_->Balance(); }
virtual ::CORBA::LongLong 	Id() 		{ return account_->Id(); }
virtual char * 			ChannelIOR() 	{ return ORBA::string_dup(channelIOR_.c_str() ; }

virtual banking::TransactionList* Transactions() 
{
database::TransactionsListPtr tl = account_->Transactions();
banking::TransactionList_var res = new banking::TransactionList; 
res->length(  tl->size() );
CORBA::ULong i = 0;

for ( database::TransactionsList::const_iterator it = tl->begin();  it != tl->end();  ++it )
	{
	res[i]=CreateTransaction( *it );
	++i;
	return res._retn();
	}

virtual banking::Transaction * ProcessTransaction( ::CORBA::LongLong _dest, ::CORBA::Float amount, const wchar t* comment)
	{
	database::Transaction trans;
	CheckResult(  account_->ProcessTransaction( _dest,  _amount,  _comment, &trans));
	return new banking::Transaction(  CreateTransaction(  trans ));
	}

private:
database::AccountPtr const account_;
std::string	const channelIOR_;
};