![]() ![]() ![]() ![]() ![]() ![]() |
SCA (Service Component Architecture)の重要な側面の1つは、新しいプログラミング・モデルが導入されたことです。Oracle Tuxedoアーキテクチャの一部としてSCAを採用することで、SOA環境において高い出力性能、高可用性およびスケーラビリティをバランスよく兼ね備えたアプリケーションを開発できるようになりました。
SCAコンポーネントは、ATMIバインディングを使用してOracle Tuxedoインフラストラクチャ上で実行します。ATMIバインディングを実装することによって、SCAコンポーネント間だけでなく、SCAコンポーネントとOracle Tuxedoプログラム(クライアントとサーバー)の間のネイティブなOracle Tuxedo通信も可能になります。
プログラミング・モデルに加えてSCDL (Service Component Definition Language)を使用することで、コンポーネント間の相互作用において実行できる内容を記述し、必要なリンク(ワイヤ)を設定するようフレームワークに指示します。
Oracle Tuxedo SCAプログラミングとともに、次のユーティリティが使用されます。
buildscaclient
: SCAコンポーネントを呼び出すクライアント・プロセスをビルドします。buildscacomponent
: SCAコンポーネントをビルドします。buildscaserver:
SCAコンポーネントを含むOracle Tuxedoサーバーをビルドします。SCAHOST
: Python、RubyまたはPHP SCAコンポーネントの一般的なサーバー。scatuxgen
: SCAインタフェースから、Oracle Tuxedoサービス・メタデータ・リポジトリのインタフェース情報を生成します。scastructc32、scastructc
: 構造体記述ファイル・コンパイラ。scastructdis32、scastructdis
: バイナリ構造体ファイルおよびビュー・ファイルの逆アセンブラ。tuxscagen
: Oracle Tuxedoサービス用にSCAファイル、SCDLファイル、およびサーバー側のインタフェース・ファイルを生成します。詳細は、「SCAコマンド・リファレンス」を参照してください。
実行時の参照バインディング拡張は、SCAコンテナのクライアント側の実装です。他のサービス(SCAコンポーネント、Oracle TuxedoサーバーまたはWebサービスなど)の呼出しに使用される必要なコードを、SCAベースのコンポーネントから透過的にカプセル化します。
SCAクライアント・プログラムを開発する手順は、次のとおりです。
アプリケーションの物理表現を定義する必要があります。厳密なSCAクライアント・アプリケーションは、SCAコンポーネント・タイプです。リスト2-1には、アプリケーション内にSCAコンポーネントを配置する際に使用するディレクトリ構造を示します。
myApplication/ (top-level directory, designated by the APPDIR environment variable)
root.composite (SCDL top-level composite, contains the list of components in this application)
myClient/ (directory containing actual client component described in this section)
myClient.composite (SCDL for the client component)
myClient.cpp (client program source file)
TuxService.h (interface of component called by client program)
リスト2-2には、典型的なroot.composite
の内容の例を示します。
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="simple.app">
<component name="myClientComponent">
<implementation.composite name="myClient"/>
</component>
</composite>
implementation.composite@name
パラメータは、「myClientComponent」
という名前のコンポーネントを格納するディレクトリを参照します。この値は実行時に必要になります。詳細は、「クライアント アプリケーションを実行する」を参照してください。
クライアント・プログラムには、単一のAPIに対する呼出しを実装する必要があります。次に示すこの呼出しは、SCAランタイムを設定するために必要なものです。
...
CompositeContext theContext = CompositeContext::getCurrent();
...
実際の呼出しは、インタフェースに基づいて行われます。このインタフェースは、通常は呼び出すコンポーネントに合せて開発されます。既存のOracle Tuxedo ATMIサービスの場合は、Oracle Tuxedoメタデータ・リポジトリにアクセスすることで、このインタフェースを生成できます。
外部Webサービスを呼び出す場合は、サービスWSDLに適合するインタフェースを指定する必要があります。詳細は、「SCAデータ型のマッピング」のWSDL型とC++型の対応に関する説明を参照してください。
リスト2-3には、インタフェースの例を示します。
#include <string>
/**
* Tuxedo service business interface
*/
class TuxService
{
public:
virtual std::string TOUPPER(const std::string inputString) = 0;
};
リスト2-3に示すインタフェースでは、単一のメソッドTOUPPER
が定義されています。これは、タイプstd::string
の単一のパラメータを取得し、タイプstd::string
の値を返します。このインタフェースは、固有の.h
ファイル内に記述する必要があり、.h
ファイルをインクルードすることによって、クライアント・プログラムから参照されます。
リスト2-4には、呼出しを実行するために必要な一連の呼出しの例を示します。
// SCA definitions
// These also include a Tuxedo-specific exception definition: ATMIBindingException
#include "tuxsca.h"
// Include interface
#include "TuxService.h"
...
// A client program uses the CompositeContext class
CompositeContext theContext = CompositeContext::getCurrent();
...
// Locate Service
TuxService* toupperService =
(TuxService *)theContext.locateService("TOUPPER");
...
// Perform invocation
const std::string result = toupperService->TOUPPER("somestring");
...
注: | この呼出し自体は、ローカル呼出しを実行するのと同じになります(プログラム自体でリンクが設定されている別のファイルにクラスが存在するのと同じようになります)。 |
注: | 詳細なコード例については、次のディレクトリにあるSCAサンプルを参照してください。 |
ローカル呼出しと実際のコンポーネントの間のリンクは、SCDLサイドファイルでバインディングを定義することによって設定します。たとえば、リスト2-4では既存のOracle Tuxedo ATMIサービスへの呼出しを示し、リスト2-5に示すSCDL記述子を使用する必要があります。このSCDLは、<componentname>.composite
というファイル内に記述します。
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="simpapp.client">
<reference name="TOUPPER">
<interface.cpp header="TuxService.h"/>
<binding.atmi requires="legacy">
<inputBufferType target="TOUPPER">STRING</inputBufferType>
<outputBufferType target="TOUPPER">STRING</outputBufferType>
</binding.atmi>
</reference>
</composite>
このコンポジット・ファイルはクライアント・コンポーネントがTOUPPER
リファレンスへの呼出しを実行し、この呼出しがATMIバインディングを使用して実行される可能性があることを示します。その結果、"TOUPPER
" Oracle Tuxedoサービスへのtpcall()
が生成されます。このOracle Tuxedoサービスは、実際にある既存のOracle Tuxedo ATMIサービスか、ATMIバインディングを使用して公開される別のSCAコンポーネントである場合があります。詳細は、「SCAコンポーネントのプログラミング」を参照してください。
inputBufferType
およびoutputBufferType
要素は、データ交換に使用するOracle Tuxedoバッファのタイプを識別するために使用します。詳細は、「SCAデータ型のマッピング」および ATMIバインディング要素のリファレンスのbinding.atmi
要素で使用できるすべての値に関する記述を参照してください。
すべての要素が整ったら、buildscaclientコマンドを使用して、クライアント・プログラムをビルドします。次の手順を実行する必要があります。
構文エラーやコンパイル・エラーが発生していなければ、クライアント・プログラムは使用できる状態になっています。
クライアント・プログラムを実行するには、次の環境変数を指定する必要があります。
APPDIR
- アプリケーション・ディレクトリを指定します。SCAの場合は、通常、ここに最上位のSCDLコンポジットが格納されています。SCA_COMPONENT
- デフォルトのSCAコンポーネント(リスト2-2
に示す例では、値「myClientComponent」)。これは、locateService()
呼出しでサービスを検索する際に開始する場所をSCAランタイムに示します。SCAクライアント・プログラムから既存のOracle Tuxedo ATMIサービスにアクセスする場合は、リスト2-6、リスト2-7およびリスト2-8に示す例を使用すると、簡単に行うことができます。
注: | これらの例は、サーバー側のSCAコンポーネントにも使用できます。 |
リスト2-6に示すようにOracle Tuxedo METADATA
リポジトリ・エントリから開始し、tuxscagen(1)コマンドを使用してインタフェースおよびSCDLを生成できます。
service=TestString
tuxservice=ECHO
servicetype=service
inbuf=STRING
outbuf=STRING
service=TestCarray
tuxservice=ECHO
servicetype=service
inbuf=CARRAY
outbuf=CARRAY
#ifndef ECHO_h
#define ECHO_h
#include <string>
#include <tuxsca.h>
class ECHO
{
public:
virtual std::string TestString(const std::string arg) = 0;
virtual std::string TestCarray(const struct carray_t * arg) = 0; }; #endif /* ECHO_h */
<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="ECHO">
<reference name="ECHO">
<interface.cpp header="ECHO.h"/>
<binding.atmi requires="legacy">
<serviceType target="TestString">RequestResponse</serviceType>
<inputBufferType target="TestString">STRING</inputBufferType>
<outputBufferType target="TestString">STRING</outputBufferType>
<serviceType target="TestCarray">RequestResponse</serviceType>
<inputBufferType target="TestCarray">CARRAY</inputBufferType>
<outputBufferType target="TestCarray">CARRAY</outputBufferType>
</binding.atmi>
</reference>
</composite>
これらのサービスを呼び出す手順は、リスト2-6からリスト2-8に示した例と同じです。
非SCA Oracle Tuxedo ATMIサービスを呼び出すとエラーを返すことがありますが、tpreturn(TPFAIL, …)
を使用してデータが戻されます。この場合、SCAクライアントやSCAコンポーネントは、ATMIBindingException
型によって中断されます。
サービスから返されたデータがある場合は、ATMIBindingException.getData()
APIを使用して取得できます。詳細は、「TPFAIL戻り値データ」を参照してください。
リスト2-9の例は、リスト2-10
に示すbinding.atmi定義に対応します。
...
try {
const char* result = toupperService->charToup("someInput");
} catch (tuscany::sca::atmi::ATMIBindingException& abe) {
// Returns a pointer to data corresponding to
// mapping defined in <errorBufferType> element
// in SCDL
const char* *result = (const char **)abe.getData();
if (abe.getData() == NULL) {
// No data was returned
} else {
// Process data returned
...
}
} catch (tuscany::sca::ServiceInvocationException& sie) {
// Other type of exception is returned
}
...
...
<binding.atmi requires="legacy">
<inputBufferType target="charToup">STRING</inputBufferType>
<outputBufferType target="charToup">STRING</outputBufferType>
<errorBufferType target="charToup">STRING</errorBufferType>
<binding.atmi/>
...
他のデータ型が返された場合は、対応する型にキャストする必要があります。たとえば、commonj::sdo::DataObjectPtr
を返す呼出しは、リスト2-11に示すようになります。
...
<errorBufferType target="myMethod">FML32/myType</errorBufferType>
...
ATMIBindingException.getData()
の結果は、リスト2-12に示すようになります。
...
catch (tuscany::sca::atmi::ATMIBindingException& abe) {
const commonj::sdo::DataObjectPtr *result =
(const commonj::sdo::DataObjectPtr *)abe.getData();
...
呼出し側のアプリケーションにTPFAIL
データを返すルールは、次のとおりです。
Oracle Tuxedoバッファ・タイプとC++データ情報の間の変換ルールの詳細は、「SCAデータ型のマッピング」を参照してください。
SCAコンポーネントという用語は、他のSCAランタイム・コンポーネントや非SCAランタイム・コンポーネントから呼び出すことができるSCAランタイム・アーティファクトを指します。同様に、SCAコンポーネントは、他のSCAコンポーネントや非SCAコンポーネントに対する呼出しも実行できます。一方、厳密なSCAクライアントは、他のSCAコンポーネントや非SCAコンポーネントに対する呼出しは実行できても、それらからSCAクライアントを呼び出すことはできません。
Oracle TuxedoのSCAコンテナは、Oracle Tuxedoサーバー環境でSCAコンポーネントをホストする機能を提供します。これにより、Oracle Tuxedoの実証された品質である信頼性、スケーラビリティおよびパフォーマンスを最大限に活用できます。
表2-1は、SCAコンポーネントとOracle Tuxedoサーバーのマッピング・ルールをまとめたものです。
Oracle Tuxedoリファレンスを使用しているSCAコンポーネントに特別な処理は必要ありませんが、サービスを提供しているSCAコンポーネントは引き続きOracle Tuxedo環境で処理する必要があります。
<binding.atmi>
定義を使用して1つ以上のサービスを宣言しているSCAコンポジットは、SCAコンポジットと同じ数のサービスを通知している単一のOracle Tuxedoサーバーにマップします。binding.atmi
セクションにあるサービスと同じ数のサービスが通知されます。/binding.atmi/@map
属性を使用したOracle Tuxedoのネイティブ・サービスにリンクされます。/binding.atmi/@map
属性によって宣言されていないメソッドは、Oracle Tuxedoからアクセスできません。重複したサービス名の使用はサーバーの生成時に検出されるため、単一のOracle Tuxedoサーバー・インスタンス内でのOracle Tuxedoサービス名とインタフェース・メソッドとのマッピングは、1対1になります。 SCAコンポジットをOracle Tuxedoアプリケーションにデプロイするには、生成されたSCAサーバーのインスタンスをUBBCONFIG
ファイルに構成します。複数のインスタンスをデプロイできます。マルチスレッド機能も使用可能で、既存のOracle Tuxedo機能を使用して制御できます。
SCAコンポーネント・プログラムを開発する手順は、次のとおりです。
まず、アプリケーションの物理表現を定義する必要があります。リスト2-13には、アプリケーション内にSCAコンポーネントを配置する際に使用するディレクトリ構造を示します。
myApplication/ (top-level directory, designated by the APPDIR environment variable)
root.composite (SCDL top-level composite, contains the list of components in this application)
myComponent/ (directory containing actual component described in this section)
myComponent.composite (SCDL for the component)
myComponent.componentType
myComponentImpl.cpp (component implementation source file)
TuxService.h (interface of component being exposed)
TuxServiceImpl.h (component implementation definitions)
リスト2-14には、典型的なroot.composite
の内容を示します。
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="simple.app">
<component name="myComponent">
<implementation.composite name="myComponent"/>
</component>
</composite>
implementation.composite@name
パラメータは、「myComponent」
コンポーネントを格納するディレクトリを参照します。
他のコンポーネントから呼び出すように設計されたコンポーネントでは、SCAランタイムを認識する必要はありません。ただし、インタフェース機能については次の制限があります。
std::string
およびcommonj::sdo::DataObjectPtr
以外)は、パラメータや戻り値としては使用できません。詳細は、「SCAデータ型のマッピング」を参照してください。
リスト2-15には、クライアント・プログラム用に実装するインタフェースの例を示します。
#include <string>
/**
* Tuxedo service business interface
*/
class TuxService
{
public:
virtual std::string TOUPPER(const std::string inputString) = 0;
};
コンポーネント実装は、通常は2つのソース・ファイルで構成されます(リスト2-16およびリスト2-17にそれぞれ示します)。
<servicename>Impl.hファイル
に記述) <servicename>Impl.cppファイル
に記述)#include "TuxService.h"
/**
* TuxServiceImpl component implementation class
*/
class TuxServiceImpl: public TuxService
{
public:
virtual std::string toupper(const std::string inputString);
};
#include "TuxServiceImpl.h"
#include "tuxsca.h"
using namespace std;
using namespace osoa::sca;
/**
* TuxServiceImpl component implementation
*/
std::string TuxServiceImpl::toupper(const string inputString)
{
string result = inputString;
int len = inputString.size();
for (int i = 0; i < len; i++) {
result[i] = std::toupper(inputString[i]);
}
return result;
}
また、サイドファイル(componentType
)も必要です。これには、SCAラッパーの生成に必要な情報が格納されます。場合によっては(このコンポーネントが別のコンポーネントを呼び出す場合)、プロキシ・コードが格納されます。
このcomponentType
ファイル(<componentname>Impl.componentType
)はSCDLファイル・タイプです。リスト2-18には、componentType
ファイル(TuxServiceImpl.componentType
)の例を示します。
<?xml version="1.0" encoding="UTF-8"?>
<componentType xmlns="http://www.osoa.org/xmlns/sca/1.0" >
<service name="TuxService">
<interface.cpp header="TuxService.h"/>
</service>
</componentType>
ローカル実装と実際のコンポーネントの間のリンクは、SCDLサイドファイルでバインディングを定義することによって設定します。たとえば、リスト2-18のファイル・タイプでは、Oracle Tuxedo ATMIサービスとして公開するには、リスト2-19のSCDLを使用する必要があります。このSCDLは、<componentname>.composite
というファイル(たとえばmyComponent.composite
)内に記述します。
<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" name="myComponent">
<service name="TuxService">
<interface.cpp header="TuxService.h"/>
<binding.atmi requires="legacy"/>
<map target="toupper">TUXSVC</map>
<inputBufferType target="toupper">STRING</inputBufferType>
<outputBufferType target="toupper">STRING</outputBufferType>
<reference>MYComponent</reference>
</service>
<component name="MYComponent">
<implementation.cpp library="TuxService" header="TuxServiceImpl.h"/>
</component>
</composite>
このコンポジット・ファイルは、サービスmySVC
をOracle Tuxedoインフラストラクチャを介して呼び出すことができることを示しています。また、Oracle Tuxedoシステム内で、toupper()
メソッドがTUXSVC
サービスとして通知されることも示しています。このサービスを初期化すると、他のSCAコンポーネントや非SCA Oracle Tuxedo ATMIクライアントから呼び出せるようになります。
inputBufferType
およびoutputBufferType
要素は、データ交換に使用するOracle Tuxedoバッファのタイプを識別するために使用します。詳細は、「SCAデータ型のマッピング」および ATMIバインディング要素のリファレンスのbinding.atmi
要素で使用できるすべての値に関する記述を参照してください。
注: | mycomponent.componentType サービス名は、コンポジット・ファイルと同じにする必要があります。それ以外の場合は例外が発生します。 |
すべての要素が整ったら、buildscacomponentコマンドを使用して、コンポーネントをビルドします。手順は次のとおりです。
コンポーネントがOracle Tuxedo環境でサポートされるようにするには、ホストOracle Tuxedoサーバーを構築する必要があります。これはbuildscaserverコマンドを使用して実行できます。
例: $ buildscaserver -c myComponent -s . -o mySCAServer
コマンドを実行すると、mySCAServer
が使用できるようになります。SCDLに従ってデプロイするコンポーネントが自動的に検索され、Oracle TuxedoとSCAの間の適切な関連付けが行われます。
SALTを介したOracle Tuxedoなどの環境でのPythonスクリプト、RubyスクリプトまたはPHPスクリプトの統合は、プログラム開発において、柔軟性をより高めることを目的としています。
Python、RubyおよびPHPは、C/C++に対して次の多くの利点を提供する、比較可能なオブジェクト指向スクリプト言語です。
SALT SCA Python、RubyおよびPHPサポートでは、Python、RubyまたはPHPのクライアント・プログラムからSCA呼出しを実行するAPIのセット、および、Python、RubyまたはPHPコンポーネントを呼び出す言語拡張子が提供されます。詳細は、「Python、RubyおよびPHPクライアント・プログラミング」および「Python、RubyおよびPHPコンポーネント・プログラミング」を参照してください。
buildscaclient
、buildscaserver
およびbuildscacomponent
コマンドは、実行ファイルやコンポーネント・ライブラリの作成に必要ではないため、Python、RubyまたはPHPプログラムでの使用に適合させる必要はありません。
注: | システム・サーバーSCAHOST は、Python、RubyまたはPHPスクリプトに対するリクエストおよびレスポンスを正しくマーシャルするために提供されます。これには、(Oracle Tuxedoメタデータ・リポジトリを介して)SCAサービスとして公開されるPython、RubyおよびPHPスクリプトが含まれます。定義では、パラメータを記述し、それに対応する公開されたPython、RubyまたはPHP関数のタイプが返されます。 |
注: | 詳細は、「Python、RubyおよびPHPデータ型のマッピング」のサービス・メタデータ・リポジトリの入力例を参照してください。 |
使用可能なバインディングは、Python、RubyまたはPHPプログラムから使用するか、Python、RubyまたはPHPコンポーネントの呼出しに使用されます。C++などのPython、RubyおよびPHP言語拡張子は、バインディングに依存していません。
図2-2には、SALT SCA環境のPython、RubyおよびPHPのサポート・アーキテクチャの概要を示しています。
クライアント・コンポーネントの観点から、SCDLコードのみが、参照コンポーネントと、場合によっては使用するバインディングを記述する必要があります(つまり、インタフェース要素は必要ありません)。
たとえば、次のスニペットによって、Python、RubyまたはPHPクライアントは、デフォルトのバッファ・タイプ(STRING入力、STRING出力)を使用して、ATMIバインディングを介したSCAコンポーネントを呼び出すことができます。
<reference name="CalculatorComponent">
<binding.atmi/>
</reference>
PythonプログラムからSCAコンポーネントを呼び出すには、次を実行する必要があります。
RubyプログラムからSCAコンポーネントを呼び出すには、次を実行する必要があります。
PHPプログラムからSCAコンポーネントを呼び出すには、次を実行する必要があります。
コンポーネントとしてSCAでPython、RubyまたはPHPスクリプトを使用するために、implementation.python
、implementation.ruby
およびimplementation.php
パラメータを使用する必要があります。
注: | implementation.python 、implementation.ruby およびimplementation.php の使用方法は、implementation.cpp 要素に似ています(リスト2-19およびリスト2-31を参照)。相違点は、interface.python 要素とinterface.ruby 要素、または.componentType は必要ないという点です。 |
implementation.python
<implementation.python
module="string"
scope="scope"? >
<implementation.python/>
implementation.python
要素には次の属性があります。
implementation.ruby
<implementation.ruby
script="string"
class="string"
scope="scope"? >
<implementation.ruby/>
implementation.ruby要素には次の属性があります。
コンポーネントがスクリプト・ファイルに含まれるクラスのメソッドの形式で提供する操作を含むRubyスクリプト(.rb
ファイル)の名前。スクリプトの名前は、その完全な名前です(つまり.rb
拡張子も含まれます)。
コンポーネントが提供する操作を含むRubyクラス(.rb
ファイル)の名前。
コンポーネント実装の範囲を特定します。デフォルトはstatelessで、サービス・リクエストのディスパッチに使用する実装インスタンス間の相関がないことを示します。composite値は、含まれるコンポジットの存続期間中、すべてのサービス・リクエストが同じ実装インスタンスにディスパッチされることを示します。
implementation.php
<implementation.php
script="string"
class="string"
scope="scope"? >
<implementation.php/>
implementation.php要素には次の属性があります。
このコンポーネントがスクリプト・ファイルに含まれるクラスのメソッドの形式で提供する操作を含むPHPスクリプト(.php
ファイル)の名前。スクリプトの名前は、その完全な名前です(つまり.php
拡張子も含まれます)。
このコンポーネントが提供する操作を含むPHPクラス(.php
ファイル)の名前。
コンポーネント実装の範囲を特定します。デフォルトはstatelessで、サービス・リクエストのディスパッチに使用する実装インスタンス間の相関がないことを示します。composite値は、含まれるコンポジットの存続期間中、すべてのサービス・リクエストが同じ実装インスタンスにディスパッチされることを示します。
リスト2-20には、ATMIバインディングを使用してアクセスできるSCAコンポジット内のPythonコンポーネントの例を示します。この例では、ランタイムは、コンポジット・ファイルと同じ場所でToupperService.py
という名前のファイルにあるPythonコンポーネントを探します。
同様に、コンポジット・ファイルと同じ場所のToupperService.rb
という名前のファイルに、Rubyコンポーネントが必要です。
<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="simpapp.server">
<service name="SCASVC">
<binding.atmi/>
<reference>ToupperServiceComponent</reference>
</service>
<component name="ToupperServiceComponent">
<implementation.python module="ToupperService"
scope="composite"/>
</component>
</composite>
リスト2-21には、ATMIバインディングを使用してアクセスできるSCAコンポジット内のPHPコンポーネントの例を示します。
<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="simpapp.PHP">
<service name="TESTPHP">
<!-- No interface, it is contained in TMMETADATA -->
<binding.atmi>
<map target="charToup">TOUPPHP</map>
<inputBufferType target="charToup">STRING</inputBufferType>
<outputBufferType target="charToup">STRING</outputBufferType>
</binding.atmi>
<reference>ToupperServiceComponent</reference>
</service>
<component name="ToupperServiceComponent">
<implementation.php script="toupper.php"
class="Toupper"/>
scope="composite"/>
</component>
</composite>
Python操作は、Pythonモジュール・ファイルに含まれるモジュール・レベルの関数として公開されます。たとえば、ToupperService.py
ファイルには、リスト2-22に示すコードが含まれます。
def charToup(val1):
print "input: " + val1
result = "result"
print "Python - toupper"
return result
パラメータおよび戻り値型は、実行時に動的に決定されます。アプリケーション例外は、拡張ランタイムによって取得され、tuscany::sca::ServiceInvocationException
として再スローされます。
入力中に、サポートされていない型や入力DataObjectのエラー処理がある場合、次の例外が発生します。tuscany::sca::ServiceDataException
出力中に、単純な戻り値型が常に処理されます。(XMLデータからの)DataObjectの生成でエラーがある場合、次の例外が発生します。tuscany::sca::ServiceDataException
詳細は、「Python、RubyおよびPHPデータ型のマッピング」を参照してください。
Ruby操作は、Rubyスクリプト・ファイル(.rb
拡張子)に含まれる実装クラスのメソッドとして公開されます。たとえば、ToupperService.rb
ファイルには、リスト2-23に示すコードが含まれます。
class ToupperService
def initialize()
print "Ruby - ToupperService.initialize\n"
end
def charToup(arg1)
print "Ruby - ToupperService.div\n"
arg1.ToUpper()
end
end
パラメータおよび戻り値型は、実行時に動的に決定されます。アプリケーション例外は、拡張ランタイムによって取得され、tuscany::sca::ServiceInvocationException
として再スローされます。
入力中に、サポートされていない型や入力DataObjectのエラー処理がある場合、次の例外が発生します。tuscany::sca::ServiceDataException
出力中に、単純な戻り値型が常に処理されます。(XMLデータからの)DataObjectの生成でエラーがある場合、次の例外が発生します。 tuscany::sca::ServiceDataException
詳細は、「Python、RubyおよびPHPデータ型のマッピング」を参照してください。
PHP操作は、PHPクラスに含まれる関数として公開されます。たとえば、toupper.php
ファイルには、リスト2-24に示すコードが含まれます。
<?php
class MyClass {
public static function toupper(val) {
print "PHP - toupper";
return val.toupper();
}
}
?>
パラメータおよび戻り値型は、実行時に動的に決定されます。アプリケーション例外は、拡張ランタイムによって取得され、tuscany::sca::ServiceInvocationException
として再スローされます。
入力中に、サポートされていない型や入力DataObjectのエラー処理がある場合、次の例外が発生します。tuscany::sca::ServiceDataException
出力中に、単純な戻り値型が常に処理されます。(XMLデータからの)DataObjectの生成でエラーがある場合、次の例外が発生します。 tuscany::sca::ServiceDataException
詳細は、「Python、RubyおよびPHPデータ型のマッピング」を参照してください。
注: | この項の内容は、アプリケーションで定義された構造体のみに適用されます。Oracle Tuxedo SCAの定義済の構造体に関する詳細は、「SCAデータ型のマッピング」を参照してください。 |
次に示すように、SCAメソッド・パラメータ定義またはSCAメソッドからの戻り値の定義で指定されるstruct
データ型を使用する必要があります。
構造体の中の要素は、SCAパラメータとしてサポートされている、次に示す単純なデータ型/配列のいずれかになります。
bool
char、unsigned char、signed char
wchar_t
short、unsigned short
int、unsigned int
long、unsigned long
long long、unsigned long long
float
double
long double
struct
nestedstructurename注: | scagen ユーティリティは、typedef およびstruct キーワードを解析します。詳細は、「SCAコマンド・リファレンス」を参照してください。 |
構造体記述ファイルは、SCA構造体パラメータのフォーマットの記述に使用できます。構造体記述ファイルは、SCAに追加された機能において、Oracle Tuxedoのビュー・ファイルと非常に似ています。
注: | 構造体記述ファイルの使用は省略可能で、構造体要素に対応するFMLフィールド名が構造体要素の名前と異なる場合、またはその他の非デフォルト構造体に関連する機能が必要な場合のみ、構造体記述ファイルを使用する必要があります。アプリケーションが、Associated Length Member、Associated Count Member、または構造体要素のアプリケーション指定のデフォルト値を使用する場合、構造体記述ファイルを使用するよう選択できます。 |
特定の構造体に構造体記述ファイルを指定しない場合、アプリケーション・コードで使用される構造体定義が使用され、SCA-ATMIモードでのFMLフィールド名は、構造体要素名と同じです。SCA-SCAアプリケーションではフィールド番号が自動的に生成されるため、これらのアプリケーションでは構造体記述ファイルを指定する必要がありません。
構造体記述ファイルの形式は、Oracle Tuxedoビュー・ファイルの形式と同じですが、次の例外があります。
構造体記述ファイルに記述された構造体がSCA-ATMIアプリケーションで実行時にFML32またはFMLバッファに対して変換される場合、対応するFMLフィールドの名前は、列3に指定したfbname
値(存在する場合)で、列3に指定した値がない場合は、列2に指定したcname
値です。コンパイル時に、リスト2-25に示すように、構造体記述ファイルはバイナリ構造体記述ファイルを作成します。バイナリ構造体ヘッダー・ファイルは、リスト2-26に示します。
注: | SCA-SCAアプリケーションでは、FML32フィールド番号は自動的に生成されます。 |
VIEW empname
#TYPE CNAME FBNAME COUNT FLAG SIZE NULL
string fname EMP_FNAME 1 - 25 -
char minit EMP_MINI 1 - - -
string lname EMP LNAME 1 - 25 -
END
VIEW emp
struct empname ename 1 - - -
unsignedlong id EMP_ID 1 - - -
long ssn EMP_SSN 1 - - -
double salaryhist EMP_SAL 10 - - -
END
struct empname {
char fname[25];
char minit;
char lname[25];
};
struct emp {
struct empname ename;
unsigned long id;
long ssn;
double salaryhist[10];
}
scastructc32
およびscastructc
コマンドは、ソース構造体記述ファイルをバイナリ構造体記述ファイルに変換し、構造体記述ファイルに構造体を記述するヘッダー・ファイルの生成に使用されます。scastructdis32
およびscastructdis
コマンドは、viewdis32
およびviewdis
と同じ引数を受け付けます。詳細は、「SCAコマンド・リファレンス」を参照してください。
注: | scastructc32 およびscastructc では、UNIXの場合は接尾辞.Vで、Windowsの場合は接尾辞.VVで、バイナリ・ファイルが生成されます。 |
注: | Oracle Tuxedoビューで使用できないSCA拡張が構造体記述ファイルに含まれていない場合、バイナリ構造体記述ファイルのmagic値は、viewc32で使用されるmagic値と同じになります。SCA固有の拡張が使用されている場合、バイナリ構造体記述ファイルには別のmagic値が使用されます。 |
オプション-S
で呼び出すとき、tuxscagen(1)は、関数パラメータの構造体を生成するか、生成しない場合は
DataObjectPtr
を使用して渡された値を戻します。
注: | tuxscagen -S を実行すると、-S オプションなしでtuxscagen を実行した場合と同じように、単純なデータ型が生成されます。1つのメタデータ・リポジトリ内に、単純なデータ型、構造体、および他の複雑なデータ型を混在させることができます。構造体も使用するアプリケーションで単純なデータ型を使用するために、 -S なしでtuxscagenを実行する必要はありません。 |
SCA Oracle Tuxedo呼出しでは、次のリモート・プロトコルがサポートされます。
SCAコンテナを使用して行うSCA呼出しは、Oracle Tuxedo WorkStationプロトコル(/WS)を使用して実行できます。これを行うには、<binding.atmi>
要素の<remoteAccess>
要素に、値WorkStation
を指定します(WebServices
との混同を避けるため、短縮しません)。
このモードで使用できるのは、参照タイプの呼出しのみです。サービス・タイプの呼出しは、/WSを使用して透過的に実行する場合があります(動作や構成に違いはなく、SCAサービスの<remoteAccess>
要素をWorkStation
に設定しても影響はありません)。
ネイティブなライブラリとWorkStation
ライブラリを同じプロセス内に混在させることはできないため、選択したリモート・アクセスのタイプに応じて、クライアント・プロセスを個別にビルドする必要があります。
注: | /binding.atmi/@requires に値propagatesTransaction を使用すると、実際のATMIバインディングの動作では、トランザクションの伝播が実行されません。このプロトコルの使用は、Oracle Tuxedo (SCAまたは非SCA)アプリケーションへのクライアント側のアクセスに対してのみ予約されるため、実際にはトランザクションが開始されます。詳細は、「ATMIバインディング」を参照してください。 |
SCAコンテナを使用して行うSCA呼出しは、Oracle Tuxedo /Domainsプロトコルを使用して実行できます。SCDLファイル内の<binding.atmi>
宣言には、追加の構成は必要ありません。
注: | /Domains相互運用性の構成は、Oracle Tuxedo管理者が制御します。 |
注: | Oracle Tuxedo /Domainsに構成されたSCAサービス名は、次のとおりです。 |
注: | 詳細は、「SCAとOracle Tuxedoの相互運用性」を参照してください。 |
Oracle Tuxedo通信は、<binding.atmi>
要素を使用してSCDLで構成されます。これによってATMIトランスポートに固有の構成要素、たとえばTUXCONFIGファイルの場所、使用されるネイティブOracle Tuxedoバッファ・タイプ、Oracle Tuxedo固有の認証、または/WS (WorkStation)構成要素などを指定できます。
リスト2-27には、<binding.atmi>
要素の要約を示します。
注: |
詳細は、付録A「Oracle Tuxedo SCA ATMIバインディングのリファレンス」を参照してください。
<binding.atmi requires="transactionalintent legacyintent"?>
<tuxconfig>...</tuxconfig>?
<map target="name">...</map>*
<serviceType target="name">...</serviceType>*
<inputBufferType target="name">...</inputBufferType>*
<outputBufferType target="name">...</outputBufferType>*
<errorBufferType target="name">...</errorBufferType>*
<workStationParameters>?
<networkAddress>...</networkAddress>?
<secPrincipalName>...</secPrincipalName>?
<secPrincipalLocation>...</secPrincipalLocation>?
<secPrincipalPassId>...</secPrincipalPassId>?
<encryptBits>...</encryptBits>?
</workStationParameters>
<authentication>?
<userName>...</userName>?
<clientName>...</clientName>?
<groupName>...</groupName>?
<passwordIdentifier>...</passwordIdentifier>?
<userPasswordIdentifier>...
</userPasswordIdentifier>?
</authentication>
<fieldTablesLocation>...</fieldTablesLocation>?
<fieldTables>...</fieldTables>?
<fieldTablesLocation32>...</fieldTablesLocation32>?
<fieldTables32>...</fieldTables32>?
<viewFilesLocation>...</viewFilesLocation>?
<viewFiles>...</viewFiles>?
<viewFilesLocation32>...</viewFilesLocation32>?
<viewFiles32>...</viewFiles32>?
<remoteAccess>...</remoteAccess>?
<transaction timeout="xsd:long"/>?
</binding.atmi>
Java ATMI (JATMI)バインディングを使用すると、Javaで記述したSCAクライアントからOracle TuxedoサービスやSCAコンポーネントを呼び出すことができます。Oracle Tuxedo WorkStationプロトコル(/WS)に基づいて、Oracle Tuxedoサービスの一方向呼出しを提供します。この呼出しは、Java環境からサーバーとして動作するOracle Tuxedoアプリケーションへのアウトバウンド通信にのみ使用できます。SCDLバインディング宣言のコンポジット・ファイルと異なり、外部構成は必要ありません。サービス名、ワークステーション・アドレスおよび認証データは、バインディング宣言内で提供されます。
注: | SSLはOracle 12c JCA Adapterを介してサポートされます。LLEは現時点ではサポートされていません。 |
JATMIバインディングは、Oracle Tuxedo CPP ATMIバインディング要素のほとんどでサポートされており、使用方法も同じです。ただし、基礎となるテクノロジの違いおよび実行環境の違いにより、サポートされない要素や、サポートされていても要素名が異なる要素があります。
次のOracle Tuxedo CPP ATMIバインディング要素はサポートされません。
次のOracle Tuxedo CPP ATMIバインディングworkStationParameters
要素はサポートされません。
次のOracle Tuxedo CPP ATMIバインディング要素は、制限付きでサポートされます。
次に示す要素内のすべてのクラスは、JavaのCLASSPATHに指定する必要があります。
binding.atmi/fieldTables
- weblogic.wtc.jatmi.TypedFML
ベース・クラスから拡張されたJavaクラスのリストをカンマ区切りで指定します。binding.atmi/fieldTables32
- weblogic.wtc.jatmi.TypedFML32
ベース・クラスから拡張されたJavaクラスのリストをカンマ区切りで指定します。binding.atmi/viewFiles
- weblogic.wtc.jatmi.TypedView
ベース・クラスから拡張されたJavaクラスのリストをカンマ区切りで指定します。これらの派生クラスは、通常はweblogic.wtc.jatmi.viewj
コンパイラを使用してOracle Tuxedoビュー・ファイルから生成されます。これらには、weblogic.wtc.jatmi.TypedXCType
およびweblogic.wtc.jatmi.TypedXCommon
からの派生クラスも含まれます。詳細は、『Oracle Tuxedo WebLogic Tuxedo Connectorプログラマーズ・ガイド』のviewjコンパイラの使用方法に関する項を参照してください。
binding.atmi/viewFiles32
- webogic.wtc.jatmi.TypedView32
ベース・クラスから拡張されたJavaクラスのリストをカンマ区切りで指定します。これらの派生クラスも、通常はweblogic.wtc.jatmi.viewj32
コンパイラを使用してOracle Tuxedoビュー・ファイルから生成されます。 リスト2-28には、Oracle Tuxedoサービスのバインディング宣言を記述した「ECHO」
という名前のコンポジット・ファイルの例を示します。
<?xml version="1.0" encoding="UTF-8"?>
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0" xmlns:f="binding-atmi.xsd"
name="ECHO">
<reference name="ECHO" promote="EchoComponent/ECHO">
<interface.java interface="com.abc.sca.jclient.Echo" />
<f:binding.atmi requires="legacy">
<f:inputBufferType target="echoStr">STRING</f:inputBufferType>
<f:outputBufferType target="echoStr">STRING</f:outputBufferType>
<f:errorBufferType target="echoStr">STRING</f:errorBufferType>
<f:workStationParameters>
<f:networkAddress>//STRIATUM:9999,//STRIATUM:1881</f:networkAddr
ess>
</f:workStationParameters>
<f:remoteAccess>WorkStation</f:remoteAccess>
</f:binding.atmi>
</reference>
<component name="EchoComponent">
<implementation.java class="com.abc.sca.jclient.EchoComponentImpl" />
</component>
</component>
リスト2-29には、リスト2-28に記述した例のインタフェースを示します。
package com.abc.sca.jclient;
import com.oracle.jatmi.AtmiBindingException;
public interface Echo {
String echoStr(String requestString) throws AtmiBindingException;
}
リスト2-30には、SCAクライアント実装の例を示します。
package com.abc.sca.jclient;
import org.osoa.sca.annotations.Constructor;
import org.osoa.sca.annotations.Reference;
import com.oracle.jatmi.AtmiBindingException;
/**
* A simple client component that uses a reference with a JATMI binding.
*/
public class EchoComponentImpl implements Echo {
private Echo echoReference;
@Constructor
public EchoComponentImpl(@Reference(name = "ECHO", required = true) Echo
echoReference) {
this.echoReference = echoReference;
}
public String echoStr(String requestString) throws AtmiBindingException {
return echoReference.echoStr(requestString);
}
}
Python、RubyおよびPHP言語拡張子は、バインディングに依存していません。つまり、バインディング拡張では、クライアントやコンポーネントの言語が認識されません。言語拡張子からは、使用するバインディングは認識されません。
バインディング拡張は、Python、RubyおよびPHPプログラム・サポートに準拠するよう変更されません。次のことに注意してください。
binding.atmi
と、数値データを処理するPython関数)。SCAHOST
コマンドでは-w
オプションを使用する必要があります。注: | SCAHOST では、1つのSCAHOST インスタンスに、ATMIとWebサービスの両方のバインディング・タイプを混在させることはできません。 |
詳細は、「SCAコマンド・リファレンス」を参照してください。
TMMETADATA
サーバーが必要です。Python、RubyおよびPHPバインディングを使用する場合、次の制限があります。
requires="legacy"
が設定されている場合)、名前付きパラメータと名前なしパラメータを混在させることはできません(たとえば、Python: def func(a, *b, **c)
、Ruby: def func(a, *b, hash)
)。これは、パラメータ名を復元するメカニズムがないためです。 パラメータの名前は、FML32表で(ATMIバインディングの場合)、またはWSDLによって(Webサービス・バインディングの場合)、構成する必要があります。名前なしパラメータのリストと相互運用することはできません。これは、FML/FML32
Oracle Tuxedoバッファの保証された順序付けがないことにより、このような呼出しをC++またはWSDLインタフェースに正確にマップできないためです。
def func(a, b, c)
(Python、RubyおよびPHPで同じ構文)def func(a, *b)
(PythonとRubyで同じ構文)$svc->searchBike(array('COLOR' => 'RED', 'TYPE' => 'MTB'))
。詳細は、「PHPデータ型マッピング」を参照してください。def func(**a)
、Ruby: def func(hash)
注: | ** で定義されたPythonパラメータは、名前付きパラメータとみなされます。hash で定義されたRubyパラメータは、名前付きパラメータとみなされます。詳細は、「Pythonパラメータ」および「Rubyパラメータ」を参照してください。 |
MBSTRING
バッファやFLD_MBSTRING
フィールドはサポートされません。 Webサービス・バインディング(binding.ws
)では、WebサービスのトラフィックをGWWSゲートウェイ経由にすることで、以前からのOracle Tuxedo機能を利用します。SCAコンポーネントはOracle Tuxedoサーバーでホストされ、それらのサーバーとの通信はGWWSゲートウェイ経由で行います。
サーバーを実行する環境が、Oracle Tuxedo環境である場合も、ネイティブなTuscany環境(たとえばAxis2 Webサービス・バインディングでコンポーネントを公開する環境)である場合も、Webサービス・バインディングを使用するSCAクライアントを変更する必要はありません。
注: | HTTPSは現時点ではサポートされていません。 |
SCAコンポーネントをWebサービス・バインディング(binding.ws
)を使用して公開する場合、ツールによって、WSDF情報、メタデータ・エントリおよびFML32フィールド定義の生成が実行されます。
SCAコンポーネントのSCDLコードを、<binding.ws
>要素を含むOracle Tuxedoドメイン(たとえばサービス要素)でホストする場合、buildscaserver
コマンドを実行すると、service.wsdf
(service
は公開するサービスの名前)というファイルにWSDFエントリが生成されます。これに伴い、Webサービスに関連付けられたWSDLインタフェースの内容に基づいて、service.mif
およびservice.fml32
フィールド表ファイルも生成されます。WSDLインタフェースはユーザーが構成する必要があります。WSDLインタフェースが見つからない場合は、エラー・メッセージが生成されます。
Oracle TuxedoドメインからWebサービス・バインディング(たとえばSCDLのreference要素)を使用してアクセスするWebサービスは、次の手順に従って手動で構成する必要があります。
wsdlcvt
ツールを使用して、WSDLファイルをWSDFエントリに変換します。同時に、サービス・メタデータ・エントリ・ファイル(.mif
)とfml32マッピング・ファイルが生成されます。TMMETADATA
およびGWWSサーバーが構成されていることを確認します。SALTDEPLOY
ファイルにインポートします。wsloadcf
を使用して、SALTDEPLOY
ファイルをバイナリに変換します。 tmloadrepos
コマンドを使用して、サービス・メタデータ・エントリ・ファイル(.mif
)をサービス・メタデータ・リポジトリにロードします。Webサービス・バインディングの参照拡張によって、Webサービス呼出しが初期化されます。
リスト2-31には、Webサービスとして公開されるSCAコンポーネント・サービスを示します。
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="bigbank.account">
...
<service name="AccountService">
<interface.wsdl interface="http://www.bigbank.com/AccountService
#wsdl.interface(AccountService)"/>
<binding.ws/>
<reference>AccountServiceComponent</reference>
</service>
<component name="AccountServiceComponent">
<implementation.cpp
library="Account" header="AccountServiceImpl.h"/>
<reference name="accountDataService">
AccountDataServiceComponent
</reference>
</component>
...
</composite>
対応するサービスを公開するのに必要な手順は、次のとおりです。
buildscacomponent
を使用してアプリケーション・コンポーネント・ランタイムをビルドします。buildscaserver -w
を使用して、SCDLコードをWSDFエントリに変換し、デプロイ可能なサーバー(Oracle Tuxedoサーバー + ライブラリ + SCDL)を作成します。 上述のSCDLからのサービスによって、リスト2-32に示すようなWSDFエントリが作成されます。
<Definition>
<WSBinding id="AccountService_binding">
<ServiceGroup id="AccountService">
<Service name="TuxAccountService"/>
</ServiceGroup>
</WSBinding>
</Definition>
buildscaserver -w
でも、SCDLおよびインタフェースの解析に基づいて、サービス・メタデータ・リポジトリ・エントリが作成されます。インタフェースはWSDL形式である必要があり、このリリースでは手動で構成する必要があります。TMMETADATA
およびGWWSサーバーが構成されていることを確認します。wsloadcf
を使用して、WSDFファイルをSALTDEPLOY
ファイルにインポートし、SALTDEPLOY
をバイナリに変換する必要があります。.mif
)がサービス・メタデータ・リポジトリにロードされます。 Webサービス処理(たとえばGWInstance
やサーバー・レベル・プロパティの構成など)に使用するGWWSゲートウェイを設定するためには、SALTDEPLOY
の構成に加えて、これらの手順を実行する必要があります。手順が完了すると、(SCAまたはその他の)Webサービス・クライアントからWebサービスにアクセスできるようになります。
リスト2-33には、Webサービスにアクセスする参照を示します。
<composite xmlns="http://www.osoa.org/xmlns/sca/1.0"
name="bigbank.account">
...
<reference name="StockQuoteWebService">
<interface.wsdl interface="http://www.webserviceX.NET/#
wsdl.interface(StockQuoteSoap)"/>
<binding.ws endpoint="http://www.webserviceX.NET/#
wsdl.endpoint(StockQuote/StockQuoteSoap)"/>
</reference>
...
</composite>
Webサービスにアクセスするのに必要な手順は、次のとおりです。
wsdlcvt
ツールを使用して、WSDLファイルをWSDFエントリに変換する必要があります。同時に、サービス・メタデータ・エントリ・ファイル(.mif
)とfml32マッピング・ファイルが生成されます。wsloadcf
を使用して、WSDFファイルをSALTDEPLOY
ファイルにインポートし、SALTDEPLOY
をバイナリに変換する必要があります。tmloadrepos
コマンドを使用して、サービス・メタデータ・エントリ・ファイル(.mif
)をサービス・メタデータ・リポジトリにロードします。 Webサービス処理(たとえばGWInstance
やサーバー・レベル・プロパティの構成など)に使用するGWWSゲートウェイを設定するためには、SALTDEPLOY
の構成に加えて、これらの手順を実行する必要があります。手順が完了すると、SCAクライアントからWebサービスにアクセスできるようになります。
クライアントが、スタンドアロンSCAプログラムの場合でも、Webサービス・バインディングを介した別のSCAコンポーネントを参照する(すでにサーバーである)SCAコンポーネントの場合でも、このプロセスは同じです。
ATMIバインディングを使用すると、Oracle Tuxedoインフラストラクチャを活用できます。そのため、SCAコンポーネント間のデータ交換や、Oracle Tuxedoクライアント/サービスとSCAクライアント/コンポーネントの間のデータ交換は、Oracle Tuxedoタイプ・バッファを使用して行われます。表2-1から表2-10に、ネイティブ・タイプとOracle Tuxedoバッファ/タイプの間の対応(および適用可能な場合はSOAPタイプとの対応)をまとめます。
リスト2-34の例では、実装がOracle Tuxedo STRING
バッファを送受信しています。ソフトウェア(バインディングおよび参照の拡張実装)においては、SCDL構成内の/binding.atmi/inputBufferType
、/binding.atmi/outputBufferType
、または/binding.atmi/errorBufferType
要素の内容と、サーバー(またはクライアント)から返された(または送信された)バッファのタイプに従って、実際に使用するOracle Tuxedoバッファを決定します。ここでは、クライアントやサーバーがATMIプログラムかSCAコンポーネントであるかは関係ありません。
Oracle Tuxedoのsimpapp
サービスには、namespace services
内に独自のnamespace
があります。C++のメソッドtoupper
は、このサービスに関連付けられています。
#include <string>
namespace services
{
namespace simpapp
{
/**
* business interface
*/
class ToupperService
{
public:
virtual std::string
toupper(const std::string inputString) = 0;
};
} // End simpapp
} // End services
単純なOracle Tuxedoバッファとみなされるのは、次のバッファです。
表2-1では、SCAバインディングにマップされる単純なOracle Tuxedoバッファ・タイプを示します。
SCAクライアントから呼び出されたサービスが正常に返されると、サービスによって返されたデータへのポインタが、buildscaclient
によって生成されたプロキシ・スタブに渡されます。プロキシ・スタブは、このポインタを逆参照し、データをアプリケーションに返します。
表2-1は次のように解釈できます。
STRING
バッファを参照するときは、その方向に応じてchar*
、char array
、std::string
パラメータ、またはreturn
タイプを探します。異なるタイプが見つかると、何が起こったかを説明するメッセージとともに例外が発生します。char*
を単一のパラメータまたは戻り値型として参照するときは、binding.atmi
要素内のバッファ・タイプとしてのSTRINGを探します。異なるOracle Tuxedoバッファ・タイプが見つかると、何が起こったかを説明するメッセージとともに例外が発生します。 Oracle Tuxedoでは、マルチバイト文字列を使用してマルチバイト文字データを表現します。使用するエンコーディング名は、Oracle Tuxedoで定義されているiconv
に基づきます。C++では、wstring
、wchar_t*
またはwchar_t[]
データ型を使用してマルチバイト文字データを表現します。使用するエンコーディング名は、C++ライブラリで定義されています。
特定のマルチバイト・エンコーディングを表すエンコーディング名が、Oracle TuxedoとC++で異なる場合があります。Oracle Tuxedoエンコーディング名とC++エンコーディング名の間のマッピングは、次のとおりです。
SCAクライアントまたはサーバーが、MBSTRING
バッファや、FLD_MBSTRING
フィールドを含むFML32
バッファを受信した場合は、そのマルチバイト文字列のエンコーディングが次のケースに当てはまる最初のロケールとみなされます。
FLD_MBSTRING
フィールドが存在する場合はそれに関連付けられたロケール。注: | 詳細は、表2-2を参照してください。 |
MBSTRING
またはFML32
バッファに関連付けられたロケール。 ケースaまたはbに当てはまる場合、Oracle Tuxedoでは、受信したバッファのロケールで、ロケール・タイプLC_CTYPE
のsetlocale()
関数が呼び出されます。setlocale()
が失敗し(そのようなロケールが存在しないことが示され)、省略可能な$TUXDIR/locale/setlocale_alias
ファイルでこのロケールに代替名が関連付けられている場合、Oracle Tuxedoでは、LC_CTYPE
ロケールの代替ロケールへの設定が試行されます。
$TUXDIR/locale/setlocale_alias
ファイルは、必要に応じてOracle Tuxedo管理者が作成します。このファイルが存在する場合は、Oracle Tuxedo MBSTRING
コードセット名の、setlocale()
関数で受け付けられた同等のオペレーティング・システム・ロケールへのマッピングが記述されています。
Oracle Tuxedo MBSTRINGコードセット名を含む行の後には、空白とOSロケール名が続きます。特定のMBSTRING
コードセット名に対応するファイルの最初の行のみが考慮されます。コメント行は#
で始めます。
MBSTRING
データをC++のwstring
またはwchar_t[]
データに変換する場合、SALT SCAソフトウェアによって、$TUXDIR/locale/setlocale_alias
ファイルが使用されます。Oracle Tuxedo MBSTRING
コードセット名の使用時にsetlocale()
が失敗した場合、SALT SCAソフトウェアでは、存在する場合は別名の使用が試行されます。たとえば、ファイルに「GB2312 zh_CN.GB2312」
という行が含まれている場合、setlocale(LC_CTYPE, 'GB2312')
が失敗すると、SALT SCAソフトウェアでは、setlocale(LC_CTYPE, 'zh_CN.GB2312')
が試行されます。
SCAクライアントまたはサーバーがwstring
、wchar_t[]
またはwchar_t*
をMBSTRING
バッファまたはFLD_MBSTRING
フィールドに変換する際には、C++のワイド文字をマルチバイト文字列に変換する際に設定するロケールとしてTPMBENC
環境変数の値が使用されます。このロケールがオペレーティング・システムで認識されない場合、Oracle Tuxedoでは、$TUXDIR/locale/setlocale_alias
ファイルが存在すればその代替ロケールが使用されます。
注: | MBSTRING バッファ、FML32 FLD_MBSTRING フィールドまたはVIEW32 mbstringフィールドから取得したマルチバイト・データを転送できます。SDO setString() メソッドを使用して入力したマルチバイト・データを転送することもできます。 |
注: | ただし、マルチバイト文字をXMLドキュメントに直接入力し、このデータをSALTを経由で転送することはできません。これは、XMLドキュメントに入力されたマルチバイト文字はマルチバイト文字列にトランスコーディングされ、SDOではwchar_t 配列を使用してマルチバイト文字を表現するためです。 |
(戻り値型として使用される)C++の次の組込み型は、複雑な型とみなされ、「複雑なOracle Tuxedoバッファ・データのマッピング」に示す複雑なバッファ・マッピング・ルールに従って、単一の汎用フィールドとしてFML/FML32
バッファに自動的にカプセル化されます。このメカニズムによって、対応するOracle Tuxedoバッファを使用できない型を返す必要がある場合に対処できます。
注: | 組込み型を返すインタフェースでは、FML/FML32 が出力バッファ・タイプとみなされます。この汎用フィールドの名前は、返されるデータの型に基づいて、TUX_RTN datatypeになります。TUX_RTN datatypeフィールドは、Oracle Tuxedoに付属のUsysflds.h/Usysfl32.h およびUsysflds/Usysfl32 で定義されます。 |
bool
: TUX_RTNCHAR
フィールドにマップします。char
: TUX_RTNCHAR
フィールドにマップします。signed char
: TUX_RTNCHAR
フィールドにマップします。unsigned char
: TUX_RTNCHAR
フィールドにマップします。short
: TUX_RTNSHORT
フィールドにマップします。unsigned short
: TUX_RTNSHORT
フィールドにマップします。int
: TUX_RTNLONG
フィールドにマップします。unsigned int
: TUX_RTNLONG
フィールドにマップします。long
: TUX_RTNLONG
フィールドにマップします。unsigned long
: TUX_RTNLONG
フィールドにマップします。long long:
TUX_RTNLONG
フィールドにマップします。unsigned long long
: TUX_RTNLONG
フィールドにマップします。float
: TUX_RTNFLOAT
フィールドにマップします。double
: TUX_RTNDOUBLE
フィールドにマップします。TUX_RTNDOUBLE
フィールドにマップします。複雑なOracle Tuxedoバッファとみなされるのは、次のバッファです。
表2-2では、SCAバインディングにマップされる複雑なOracle Tuxedoバッファ・タイプを示します。
FMLおよびFML32バッファの場合は、インタフェース内のパラメータ名をフィールド名に対応させ、Oracle Tuxedoフィールドに適用される制限(長さ、使用可能な文字)に従う必要があります。tuxscagen(1)を使用してこれらのインタフェースをメタデータから生成した場合は、生成されたコードに適切なフォーマットのパラメータ名が含まれています。
アプリケーションで、パラメータ名を使用せずに手動でインタフェースを開発したり、手動で誤ったインタフェースを開発したり、SALTによって生成されたインタフェースに互換性のない変更を加えたりすると、誤った結果が発生する可能性があります。
VIEW(および等価のX_*
)とVIEW32バッファでは、SDOのDataObject
ラッパーを使用する必要があります。
リスト2-35には、インタフェースの例を示します。(インタフェースの後に)関連付けられているフィールド定義は、プロセス環境内に配置する必要があります。
「SCA構造体のサポート」も参照。
|
...
int myService(int param1, float param2); ...
Field table definitions
#name number type flag comment
#---------------------------------------------------------
param1 20 int - Parameter 1
param2 30 float - Parameter 2
...
パラメータまたは戻り値型としてcommonj::sdo::DataObjectPtr
オブジェクトを使用するC++のメソッド・プロトタイプは、FML、FML32、VIEWまたはVIEW32
バッファにマップされます。
SDOオブジェクトを記述するXMLスキーマを提供する必要があります。このスキーマをサービスや参照の拡張ランタイムに対して使用可能にするには、影響を受ける参照やサービスの定義が格納されているSCDLコンポジット・ファイルと同じ場所に、スキーマ・ファイル(.xsd
ファイル)を配置する必要があります。このスキーマは、要素名とフィールド名の関連付けのために内部的に使用されます。
注: | viewまたはview32を使用する場合は、使用するviewまたはview32に一致する名前のスキーマ・タイプ(たとえばcomplexType )が必要になります。 |
詳細は、SALT 11gリリース1 (11.1.1.0)コマンド・リファレンスの「mkfldfromschema」および「mkfld32fromschema」を参照してください。
たとえば、C++のメソッド・プロトタイプは、ヘッダー内に次のように定義されています。
long myMethod(commonj::sdo::DataObjectPtr data);
リスト2-36には、関連付けられるスキーマを示します。
<xsd:schema xmlns:xsd=http://www.w3.org/2001/XMLSchema
xmlns="http://www.example.com/myExample"
targetNamespace="http://www.example.com/myExample">
<xsd:element name="bike" type="BikeType"/>
<xsd:element name="comment" type="xsd:string"/>
<xsd:complexType name="BikeType">
<xsd:sequence>
<xsd:element name="serialNO" type="xsd:string"/>
<xsd:element name="name" type="xsd:string"/>
<xsd:element name="type" type="xsd:string"/>
<xsd:element name="price" type="xsd:float"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
表2-3には、生成されるフィールド表を示します。
scatuxgen
および tuxscagen
ユーティリティは、SCAデータ型のマッピングを手動で生成するのに使用されます。scatuxgen
マッピング・ルールは次のようになります。
注: | tuxscagen のマッピング・ルールは、逆方向で実行されます(Oracle Tuxedoバッファ・タイプ→C++パラメータ型)。 |
表2-4には、パラメータ/戻り値型とOracle Tuxedoバッファ・タイプ間の対応を示します(inbufサービス・レベル・キーワード)。
表2-5には、パラメータ/戻り値型とOracle Tuxedoバッファ・タイプ間の対応を示します(outbufまたはerr bufサービス・レベル・キーワード)。
表2-7には、メソッド・シグネチャで複数のパラメータが使用されている場合、scatuxgen
がインタフェース・パラメータ型を処理し、Oracle Tuxedoサービス・メタデータ・リポジトリのパラメータ・レベルのキーワード値に変換する方法を示します。
メソッドが引数としてSDOオブジェクトを取得するか、またはSDOオブジェクトを返す場合、たとえば次のようになります。commonj::sdo::DataObjectPtr myMethod(commonj::sdo::DataObjectPtr input)
リスト2-37に示すように、対応するランタイム型がXMLスキーマによって記述され、リスト2-38に示すように、バインディングで参照されます。
<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="tuxedo" targetNamespace="tuxedo">
<xsd:complexType name="BikeInventory">
<xsd:sequence>
<xsd:element name="BIKES" type="Bike"
minOccurs="0" maxOccurs="unbounded"/>
<xsd:element name="STATUS" type="xsd:string" maxOccurs="1"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="Bike">
<xsd:sequence>
<xsd:element name="SERIALNO" type="xsd:string"/>
<xsd:element name="SKU" type="xsd:string"/>
<xsd:element name="NAME" type="xsd:string"/>
<xsd:element name="TYPE" type="xsd:string"/>
<xsd:element name="PRICE" type="xsd:float"/>
<xsd:element name="SIZE" type="xsd:int"/>
<xsd:element name="INSTOCK" type="xsd:string"/>
<xsd:element name="ORDERDATE" type="xsd:string"/>
<xsd:element name="COLOR" type="xsd:string"/>
<xsd:element name="CURSERIALNO" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
</xsd:schema>
...
<reference name="UBIK">
<interface.cpp header="uBikeService.h"/>
<binding.atmi>
<inputBufferType>FML32/Bike</inputBufferType>
<outputBufferType>FML32/BikeInventory</outputBufferType>
</binding.atmi>
</reference>
...
このようなスキーマが存在する場合、scatuxgen
はこれを解析し、表2-7に示すように、対応するパラメータ・レベルのマッピング・エントリを生成します。
メソッドが引数としてC構造体を取得するか、またはC構造体を返す場合(例: リスト2-39)、scatuxgen
はこれを解析し、表2-8に示すように、対応するパラメータ・レベルのマッピング・エントリを生成します。
struct customer {
char firstname[80];
char lastname[80];
char address[240];
};
struct id {
int SSN;
int zipCode;
};
struct customer* myMethod(struct *id input);
パラメータ・レベルのキーワードの場合、Oracle Tuxedoバッファ・タイプ/パラメータ型の制限は、tmloadrepos
に必要な内容と一致しています。表2-9および表2-10に示されていない組合せを一致させようとすると、エラー・メッセージが返されます。
次の項では、ネイティブでC/C++ベースの環境に関して、およびATMIバインディングで必要なOracle Tuxedoサービス・メタデータ・リポジトリ・インタフェースの書込みに対応するために、Python、RubyおよびPHPクライアントまたはコンポーネントでサポートされているデータ型について説明します。ATMIバインディングまたはWebサービス・バインディングで使用するための、対応するOracle Tuxedoバッファおよびフィールド型も示します。
Pythonでは、クライアントまたはコンポーネントのみが、パラメータを使用し、表2-11に示すタイプの値を返します。FML32 Oracle Tuxedoバッファを使用して、(複数のパラメータがC++でサポートされているのと同じ方法で、)複数のパラメータがサポートされます。
注: | バインディングまたはC++言語拡張子でサポートされていないため、配列はサポートされません。 |
注: | int (short)、long、int (long)、float (float)は、C++からPython方向のみで使用できます。Pythonランタイムは、オーバーフローの状況を捕捉します(例: C++ longをPython intにコピーする場合)。 |
注: | string of length 1をchar*/std::string/STRING にマップするために、開始Python変数には、最後にゼロを2つ付ける必要があります(例: 't = "a\x00" )。 |
PythonでサポートされているXMLオブジェクトは、xml.etree.ElementTree objects
である必要があります(つまり、言語拡張子は、xml.etree.ElementTree
オブジェクトをcommonj::sdo::DataObjectPtr
オブジェクトに変換し、commonj::sdo::DataObjectPtr
オブジェクトをxml.etree.ElementTree
オブジェクトに変換します)。
「Pythonパラメータ」および「ディクショナリ」で説明するように、リストおよびディクショナリの使用もサポートされています。
注: | リストおよびディクショナリはパラメータとしては使用できますが、リストおよびディクショナリを返すことはできません。 |
複数のパラメータおよびリストに関する制限が、バインディングの使用に対して有効になる場合があります。詳細は、「Python、RubyおよびPHPバインディング」を参照してください。
リストの表記法(*)を使用して、不明なパラメータ数をPythonプログラムに対して渡すことができます。例:
この表記法は、次のようなパラメータの実際のリストがあることと同じになります。
def test(parm1, parm2, parm3, parm4, parm5)
サポートされている個々のタイプは、表2-11に示すタイプに制限されています。
ATMIバインディングまたはWebサービス・バインディングを使用したSCAサービスとしてPython関数を公開するには、インタフェースが必要です。このインタフェースは、「Python、RubyおよびPHPコンポーネント・プログラミング」に示すように、Oracle Tuxedoサービス・メタデータ・リポジトリに格納されます。
呼出し時に、Python関数は、インタフェースが指定するものに正確に対応するパラメータのリストを受信します。クライアントが渡した余分なパラメータは無視され、タイプの不一致によりデータ・マッピング例外が発生します。
注: | この表記法の使用は、ローカル呼出し(バインディングなし)またはSCAコンポーネント間のATMIバインディングの使用(つまり、requires="legacy" 属性がない<binding.atmi> 要素)に制限されます。 |
ローカル呼出し(バインディングを指定しない)または参照の場合、インタフェースは必要ありません。
名前付きパラメータの表記法(**)を使用して、ディクショナリとも呼ばれる名前/値のペアを、Pythonプログラムに対して渡すことができます。例:
print "key:", p, " parameter:", params[p]
サポートされている個々のタイプは、表2-11に示すタイプに制限されています。
ATMIバインディングまたはWebサービス・バインディングを使用したSCAサービスとしてPython関数を公開するには、インタフェースが必要です。このインタフェースは、「Python、RubyおよびPHPコンポーネント・プログラミング」に示すように、Oracle Tuxedoサービス・メタデータ・リポジトリに格納されます。
たとえば、リスト2-40に示すOracle Tuxedoサービス・メタデータ・リポジトリ・エントリを考えてみます。
##
service=testPython2
tuxservice=TESTPT
inbuf=FML32
outbuf=FML32
param=NUMBER
type=long
access=in
param=TEXT
type=string
access=in
param=FNUMBER
type=double
access=in
##
呼出し時に、Python関数は、インタフェースが指定するものに正確に対応するパラメータのリストを受信します。クライアントが渡した余分なパラメータは無視され、タイプの不一致によりデータ・マッピング例外が発生します。
パラメータの名前は、Python関数に渡されるキー名と一致します。インタフェースを取得するには、TMMETADATA
サーバーへの内部呼出しを行います。Python、RubyまたはPHP関数を呼び出すために、TMMETADATA
サーバーを実行している必要があります。
インタフェースを使用して呼び出されるPython関数は、次のPython呼出しと同じです。
表2-12では、サポートされているRuby、C/C++およびOracle Tuxedoバッファ・タイプを示します。FML32 Oracle Tuxedoバッファを使用して、(複数のパラメータがC++でサポートされているのと同じ方法で、)複数のパラメータがサポートされます。
バインディングまたはC++言語拡張子でサポートされていないため、配列はサポートされません。
注: | Rubyランタイムは、オーバーフロー例外を捕捉することがあります。 |
注: | Ruby BignumがC++ doubleより大きい場合、精度が失われる可能性があります。 |
注: | Float (float)は、C++からRuby方向のみで使用できます。 |
注: | Rubyで使用可能な単一の文字(char/FLD_CHAR)へのマッピングはありません。 |
RubyでサポートされているXMLオブジェクトは、REXMLである必要があります(つまり、言語拡張子は、REXML::Document
オブジェクトをcommonj::sdo::DataObect
オブジェクトに変換し、commonj::sdo::DataObjectPtr
オブジェクトをREXML::Document
オブジェクトに変換します)。
次の段落で説明するように、可変引数のリストおよびハッシュの使用もサポートされています。
注: | 可変引数のリストおよびハッシュはパラメータとしては使用できますが、可変引数のリストおよびハッシュを返すことはできません。 |
複数のパラメータおよびリストに関する制限が、バインディングの使用に対して有効になる場合があります。詳細は、「Python、RubyおよびPHPバインディング」を参照してください。
リストの表記法(*)を使用して、不明なパラメータ数をRubyスクリプトに対して渡すことができます。例:
otherargs.each { |arg| puts arg }
次のように呼び出すことができます: func(1, 2, 3, 4, 5)
サポートされている個々のタイプは、表2-12に示すタイプに制限されています。
ATMIバインディングまたはWebサービス・バインディングを使用したSCAサービスとしてRuby関数を公開するには、インタフェースが必要です。このインタフェースは、「Python、RubyおよびPHPコンポーネント・プログラミング」に示すように、Oracle Tuxedoサービス・メタデータ・リポジトリに格納されます。
たとえば、リスト2-41に示すOracle Tuxedoサービス・メタデータ・リポジトリ・エントリを考えてみます。
##
service=testRuby
tuxservice=TESTRU
inbuf=FML32
outbuf=FML32
param=first
type=char
access=in
param=next
type=long
access=in
param=last
type=string
access=in
##
呼出し時に、Ruby関数は、インタフェースが指定するものに正確に対応するパラメータのリストを受信します。クライアントが渡した余分なパラメータは無視され、タイプの不一致によりデータ・マッピング例外が発生します。
注: | この表記法の使用は、ローカル呼出し(バインディングなし)またはSCAコンポーネント間のATMIバインディングの使用(つまり、requires="legacy" 属性がない<binding.atmi> 要素)に制限されます。 |
注: | ローカル呼出し(バインディングを指定しない)または参照では、インタフェースは必要ありません。 |
名前付きパラメータを使用して、ハッシュ・タイプ・パラメータの形式で、名前/値のペアをRubyスクリプトに対して渡すことができます。例:
次のように呼び出すことができます: func2("first" => true, "next" => 5, "last" => "hi")
サポートされている個々のタイプは、表2-12に示すタイプに制限されています。
ATMIバインディングまたはWebサービス・バインディングを使用したSCAサービスとしてRuby関数を公開するには、インタフェースが必要です。このインタフェースは、「Python、RubyおよびPHPコンポーネント・プログラミング」に示すように、Oracle Tuxedoサービス・メタデータ・リポジトリに格納されます。
呼出し時に、Ruby関数は、インタフェースが指定するものに正確に対応するパラメータのリストを受信します。クライアントが渡した余分なパラメータは無視され、タイプの不一致によりデータ・マッピング例外が発生します。
パラメータの名前は、Ruby関数に渡されるキー名と一致します(つまり、上述のインタフェースを使用して呼び出されるRuby関数は、次のRubyクライアント呼出しと同じです)。
func2("first" => true, "next" => 5, "last" => "hi")
値「true」、「5」および「hi」は任意で、キーではありません。
表2-13では、サポートされているRuby、C/C++およびOracle Tuxedoバッファ・タイプを示します。FML32 Oracle Tuxedoバッファを使用して、(複数のパラメータがC++でサポートされているのと同じ方法で、)複数のパラメータがサポートされます。
バインディングまたはC++言語拡張子でサポートされていないため、配列はサポートされません。
PHPでXMLデータが返される場合は、次のようにSTRINGオブジェクトが返され、そのオブジェクトがSimpleXMLElement
に変換されます。
$ret = $svc->searchBike('YELLOW');
$xml = new SimpleXMLElement($ret, LIBXML_NOWARNING);
XMLオブジェクトが一度構築されると、次のようにアクセスされるようになります。
echo "First serialno:".$xml->BIKES[0]->SERIALNO."\n";
echo "Second serialno:".$xml->BIKES[1]->SERIALNO."\n";
PHP拡張子を使用してSCAリファレンスを作成する際、不明なパラメータ数を渡すことができます。例:
サポートされている個々のタイプは、表2-13に示すタイプに制限されています。commonj::sdo::DataObjectPtr objects
から生じるタイプ、または結果的にこのようになるタイプは例外です。
注: | この表記法の使用対象は次のとおりです。 |
注: | インタフェースは必要ありません。 |
名前付きパラメータを使用して、PHP SCA拡張子を使用して名前/値のペアを渡すことができます。例:
$svc->searchBike(array('COLOR' => 'RED', 'TYPE' => 'MTB'));
サポートされている個々のタイプは、表2-13に示すタイプに制限されています。
SCA-ATMIアプリケーションでは、SCA構造体パラメータを、ATMI FML32、FML、VIEW32、VIEW、X_COMMONまたはX_C_TYPE
データ型にマップできます。これは、SCAコンポジット・ファイルで指定されるデータ型です。
VIEW32、VIEW、X_COMMONまたはX_C_TYPE
データ型を指定した場合、このビューは、SCAパラメータまたは戻り値型として使用される構造体と正確に一致する必要があります。
注: | ビューを構造体と正確に一致させるために、ビューのコンパイルでは、アプリケーションで使用される構造体と同じフィールドおよびオフセットを持つ、同じ構造体を作成する必要があります。 |
SCA構造体パラメータをFML32またはFMLにマップする場合、関連付けられたFML32
またはFML
フィールドのフィールド型は、SCA構造体のデータ型に対して変換できる型になります。詳細は、「SCAデータ型のマッピング」を参照してください。
SCA-SCAアプリケーションでは、フィールドはフィールド番号によって識別され、FML32フィールド番号は自動的に生成されます。ネストされた構造体の場合は、内部構造体が外部構造体の中に定義された場所で外部構造体のフラット・フィールドとして内部構造体のフィールドが生じるのと同じように、フィールド番号が割り当てられます。
SCA-ATMIアプリケーションでは、構造体要素に関連付けられたFML32またはFMLフィールド名を構造体記述ファイルから取得します。詳細は、「SCA構造体記述ファイルの使用」を参照してください。
FML32またはFMLのstring、carrayまたはmbstringフィールドを構造体要素に変換する際、構造体要素に適合しないデータは、指定された長さに(警告なしで)切り捨てられます。
たとえば、構造体要素がchar COMPANY_NAME[20]
で、値が「International Business Machines」のFMLフィールドCOMPANY_NAME
をこの構造体要素にマップする場合、「International Busine」が末尾のnull文字なしで構造体要素にコピーされます。
SCA構造体をVIEW32、VIEW、X_OCTETまたはX_C_TYPE
データ型にマップする場合、Oracle Tuxedoのビュー・ベースの型に使用する構造体は、SCA構造体に正確に一致する必要があり、バイト単位でコピーされます。つまり、SCA構造体およびビューの間で変換する際に、データのマーシャリングは行われません。データのマーシャリングが必要な場合は、FML32またはFMLを使用する必要があります。
SCA構造体をOracle Tuxedoのビュー・ベースの型にマップする場合、SCA構造体の中に、bool
、wchar_t
、long long
、unsigned long long
、long double
、またはネストされた構造体のデータ型を指定できません。これは、対応するデータ型がOracle Tuxedoのビュー内に存在しないためです。Oracle TuxedoのAssociated Count MemberまたはAssociated Length Memberフィールドに対応する要素を指定する必要があります。SCA構造体をOracle Tuxedoのビューに変換する場合、このような要素に適した値をアプリケーションで指定する必要もあります。
現時点で、mbstringフィールド型はVIEW32に存在します(詳細は、tpconvvmb32
を参照してください)。SCA構造体は、mbstringフィールド型をVIEW32の場合と同じ方法で処理します。エンコーディング情報は、mbstringの構造体要素の一部であり、構造体のmbstringデータを使用して、アプリケーション・プログラムにFmbunpack32()
およびFmbpack32()
を使用する必要があります。
TPFAILで返されるデータとして構造体ポインタを指定できるのは、正常な出力でも同じ構造体ポインタが返される場合です。SCAには、アプリケーション・データとともに、返された構造体を記述する内部情報を格納する必要があるため、リスト2-42
に示すように、<tuxsca.h>
は構造体およびtypedefの定義に使用されます。
struct scastruct_t {
void *data;
void *internalinfo;
};
typedef struct scastruct_t *SCASTRUCT_PTR;
アプリケーションが通常、「struct mystruct *
」データを返す場合、リスト2-42に示すように、TPFAILデータにアクセスします。
… catch (Tuscany::sca::atmi::ATMIBindingException& abe) {
SCASTRUCT_PTR *scap = (SCASTRUCT_PTR *)abe.getData();
struct mystruct *result = (struct mystruct *)scap->data;
}
既存のOracle Tuxedoサービスと相互運用するには、/binding.atmi/@requires
属性の値として「legacy」を使用します。値「legacy」を指定した場合、次の動作を使用して、呼出しが実行されます。
また、FML32やFMLのフィールド表が必要ないように、 /binding.atmi/@requires
属性を使用して内部的にデータ・マッピングを管理します。
注: | 指定しない場合、実際のOracle Tuxedoサービス名が/service/@name または/reference/@name と実際のメソッド名から構成されている、SCA→SCAのセマンティクスで通信するとみなされます(リスト2-27に示す擬似スキーマを参照)。 |
ATMIバインディング・スキーマでは、/binding.atmi/@requires
属性と3つのトランザクション値を使用して、SCAトランザクション・ポリシーをサポートします。これらのトランザクション値によって、ATMIバインディングの使用時にバインディング拡張が従うトランザクション動作を指定します(リスト2-27に示す擬似スキーマを参照)。
すべてのトランザクション動作はOracle Tuxedo構成によって制御されます。Oracle Tuxedo構成でトランザクションがサポートされている場合は、トランザクションが存在していればそのトランザクションを伝播できます。
Oracle Tuxedo構成でトランザクションがサポートされていないのにトランザクションが存在する場合、エラーが発生します。
注: | トランザクションが存在しない場合、トランザクションは開始されません。 |
suspendsTransaction
指定すると、トランザクション・コンテキストは呼び出されたサービスには伝播されません。<service>
の場合、トランザクションが存在すれば、アプリケーション・コードを呼び出す前に自動的に中断され、呼出しの結果に関係なく後で再開されます。<reference>
の場合、TPNOTRAN
フラグを指定してtpcall()
を実行した場合と同じになります。
propagatesTransaction
<reference>
要素にのみ適用でき、<service>
要素では無視されます。トランザクションが存在しない場合は新しいトランザクションが開始され、存在する場合は既存のトランザクションに追加されます。このような動作は、UBBCONFIGで<service>
をAUTOTRAN
に構成することで、コンポーネントまたはコンポジット内で取得できます。Oracle TuxedoサーバーがSCAコンポーネントの実装をホストしており、UBBCONFIGでトランザクション・グループに構成されていない場合は、エラーが生成されます。
SCA参照は、binding.atmi
SCDL要素の<authentication>
要素を使用して、資格証明を渡します。
SCAサービスは、内部名を参照することによってACLで保護できます。SCA→SCAモードの場合は/binding.atmi/service/@name
属性の後に「/」
とメソッド名を付加し、legacy
モード(SCA→Tux相互運用モード)の場合は/binding.atmi/service/@name
属性を使用します。
詳細は、「SCAとOracle Tuxedoの相互運用性」を参照してください。
![]() ![]() ![]() |