Asynchronous JAXM

Hello,
I have implemented a web service which sends 2 asynchronous messages via jaxm-provider to 2 different JAXMServlets. After these 2 calls, the web service returns. I have added a JAXMServlet into the web service's WAR, which is responsible for receiving the response messages from jaxm-provider. I have also included the client.xml file, which configures this servlet as the receiver.
The 2 different JAXMServlets receive their messages from the jaxm-provider, process them and send their response back to the jaxm-provider. So far so good.
The problem comes with the servlet which receives messages in the web service's WAR. It should receive 2 responses,that means it should be invoked twice, one time for each response it gets. Yet, only one response is received.
I have exchaustively checked the logs and it seems that either the jaxm-provider is not sending the second response, or the servlet is not receiving it. I have read that there is a known bug where I have to call the ProviderConnection.getMetaData in the init() method of the receiver servlet in order to initialize the providerConnection with the jaxm-provider. Does anyone have any idea of what is going wrong? Is the receiver servlet initialized each time it is called or not?
I need to have one receiver servlet only, since I cannot have 2 client.xml files in the web service's WAR.
I used JAXM-1.1.2 integrated within the JWSDP-1.3 according to the instructions. All receiver servlets extend the JAXMServlet and implement the OneWayListener.
Thanx in advance

HI.
While excuseme if my English is not just perfect :-).
I have a similar problem.
This is my architecture :
Host1 Host2
jaxmservlet ----> provider ---> || ---> provider ------>jaxmservlet --->webservice
jaxmservlet <---- provider< --- || <--- provider <------jaxmservlet <---webservice
From Host1 leave many soapmessage requests......these arrive to Host2.
Host2-jaxmservlet translates the soapmessage and invoke methods of webservice that gives back the responses that jaxmservlet will again translate in a soapmessage and will send back to Host1....
Your work-around works, but,for example, If I send 70 requests I haven't 70 responses....( I have 65-67 responses). The situation is however improved,before I obtained 5-6 responses.....(thanks!)
Another solution that I have found, is been to change the value of "Number of messages per logfile" since 20 to 1 in "Provider Properties" (http://localhost:8080/jaxm-provideradmin/index.jsp).
....this solution provokes 1 file for each request......but in this way, if I send 70 or more requests I have the same number of responses....
I will have to think to a schedulator that eliminates
all the file created from the moment in which it parts, as an example,
to one hour before
So, thanks for your work-around if you had to find one better solution, please contact me on this forum or better, for email ([email protected])
Thank you!

Similar Messages

  • JAXM RI asynchronous delivery -- how does it work?

    After struggling with using a one-way remote messaging with JAXM provider for several days, I finally got two simple clients working on two machines, one message producer on server1 and the other consumer on server2 (no reply message the other way) -- but only on the condition of both servlets are up. If the producer sends message while the consumer is undeployed or the consumer's container is stopped, the consumer does NOT get the message after it is back on line. But isn't that the whole point of "asynchronousness" which the RI spec says "The application itself may be active or quiescent, but the remote provider continues to try to ... receive any incoming messages on the application's behalf. When an application comes up and establishes a connection to the remote provider, messages received by the provider for that application are delivered to it."?
    There are quite some discussions on the confusing topic about configuring the sender and receiver. But I didn't find any discussion on this "asynchronousness" and how it works. any insights would be appreciated. posting my configuration files here.
    ============================================
    Producer side
    client.xml:
    <Endpoint>
    http://Producer
    </Endpoint>
    <CallbackURL>
    http://server1:8080/HelloProducer/Producer
    </CallbackURL>
    <Provider>
    <URI>http://java.sun.com/xml/jaxm/provider</URI>
    <URL>http://127.0.0.1:8081/jaxm-provider/sender</URL>
    </Provider>
    provider.xml
    URI: http://Consumer
    URL: http://server2:8080/jaxm-provider/receiver/soaprp
    ============================================
    Consumer side:
    client.xml
    <Endpoint>
    http://Consumer
    </Endpoint>
    <CallbackURL>
    http://server2:8080/HelloConsumer/Consumer
    </CallbackURL>
    <Provider>
    <URI>http://java.sun.com/xml/jaxm/provider</URI>
    <URL>http://127.0.0.1:8081/jaxm-provider/sender</URL>
    </Provider>
    provider.xml
    No mapping (there is no reply message)
    ============================================
    Bianca

    I've only quickly scanned through your post, but one point is that if you stop the web container, then the messaging provider will also stop and will not receive any messages.
    Although the documentation mentions being able to retrieve messages from a provider once it re-connects, this would only work if you left the container running and re-deployed the application the message is intended for. I haven't read all of the JAXM specs in detail, but I have found in several instances that the documentation/specs will suggest a specific functionality is available, but then I find it has not been implemented at this time.
    Generally, JAXM applications (servlets) tend to initiate a connection to their provider early on, and do not disconnect, so if the JAXM application has an onMessage method, it will receive the SOAP message and process it.
    Additionally, if you configure the provider through the GUI tool provided with JWSDP, then you can set how many times the message should be re-sent by a provider (and some other properties).
    Finally, the definition of asynchronicity should not be confused with the ability discussed above of providers to deliver messages to an application which has been offline. Synchronous messaging is basically the same as a regular function call. For example,
    double ReturnDouble (){
    return 4.35;
    If this method is called by a class, then it will wait for a double to be returned and the calling class is said to be 'blocked'. Only when the function returns a response to the calling class is the method unblocked and the program execution continues. Similarly with synchronous JAXM (SAAJ) messaging (without providers), the method in a listening servlet is:
    SOAPMessage onMessage(SOAPMessage message){
    // Create SOAP
    return soapMessage;
    This method returns a SOAPMessage object to the client, and this client is blocked until it receives this SOAPMessage as a reply.
    With asynchronous messaging, the listening servlet does not return a response to an incoming message (and the sending servlet does not expect one), so the sending application (a JAXM servlet) can send a SOAP message to the listening servlet, and then execute the rest of its code without waiting for a response.
    (Although the onMessage method in asynchronous messaging using providers has a return type of void, using a return type of void in JAX-RPC messaging does NOT imply an asynchronous method call :) )
    Hope that is clear - I haven't had coffee yet ;)
    Simon

  • Asynchronous Web Services in BEA

    I need to build an asynchronous web services SOAP message reciever and an asynchronous
    web services SOAP message sender. Over HTTPS.
    I know how I would do it with JAXM and the Sun RI, but can not seem to find any
    implementation or equivelent in WebLogic (though many of the interfaces and abstract
    classes are in the BEA jar files). We are on WebLogic 7.

    I don't understand what you mean in step 5 that the client does not change. I
    want the client to send a SOAP message instead of call a remote process.
    Steve
    "manoj cheenath" <[email protected]> wrote:
    7.0 supports one-way and it is same as in 8.1.
    You got the steps to write a one-way service right.
    Here is it again:
    1. write the backend component. The method
    that you want to make one-way should return void.
    2. Either run servicegen or autotype+source2wsdd
    to generate the XML codecs and web-services.xml
    DD file.
    3. edit the DD file to change invocation-style as
    shown below.
    <operation name="helloOnewayWorld"
    invocation-style="one-way"...
    4. package and deploy.
    5. There is no change required on the client side. Client
    will knows that an operation is one-way by looking at
    the WSDL.
    -manoj.
    "Steve Watson" <[email protected]> wrote in message
    news:[email protected]...
    Can you send me the WL 8.1 example? How has support for one way messagingchanged
    in 8.1? Would there be any advantage for us to move to 8.1?
    Thanks everyones help so far. I am trying to assemble the rules oncreating one
    way messages - from this thread and bits and peices in the documentationI
    have
    found:
    "a document-oriented Weblogic Web Service operation can have only oneparameter,
    of any supported data type"
    "The backend component that implements the operation must explicitlyreturn void."
    "You specify this type of behavior with the invocation-style attributeof
    the
    <operation> element in web-services.xml"
    Have I missed anything?
    Steve Watson
    "manoj cheenath" <[email protected]> wrote:
    You need to set invocation-style="one-way" in the
    operation element of the web-services.xml dd file [1]
    You can use source2wsdd ant task to generate this DD [2].
    I dont have an example that runs on 7.0. But here is an
    example that works with 8.1.
    -manoj
    [1] http://edocs.bea.com/wls/docs70/webserv/wsp.html#1001373
    [2] http://edocs.bea.com/wls/docs70/webserv/anttasks.html#1080421
    "Steve Watson" <[email protected]> wrote in message
    news:[email protected]...
    I can find very little in the documentation on how to do this -
    is
    there a
    cook
    book?
    Steve Watson
    "manoj cheenath" <[email protected]> wrote:
    WLS only supports JAX-RPC. One can do one-way invokes
    using JAX-RPC. So, you can implement your receiver as a
    web service that accept one way invokes.
    Will this fit your use case?
    -manoj
    "Steve Watson" <[email protected]> wrote in message
    news:[email protected]...
    I need to build an asynchronous web services SOAP message recieverand an
    asynchronous
    web services SOAP message sender. Over HTTPS.
    I know how I would do it with JAXM and the Sun RI, but can not
    seem
    to
    find any
    implementation or equivelent in WebLogic (though many of the
    interfaces
    and abstract
    classes are in the BEA jar files). We are on WebLogic 7.
    begin 666 sample3.zip
    M4$L#!!0`" `(`/>!@BX````````````````)``0`345402U)3D8O_LH```,`
    M4$L'" `````"`````````%!+`P04``@`" #W@8(N````````````````% ``
    M`$U%5$$M24Y&+TU!3DE&15-4+DU&\TW,RTQ++2[1#4LM*L[,S[-2,-0SX.5R
    M+DI-+$E-T76J! F8Z!G&&QCIIB8J: 27YBGX9B87Y1=7%I>DYA8K>.8EZVGR
    M<O%R`0!02P<(V@!HADH```!*````4$L#!!0`" `(`$!U@BX`````````````
    M```.````<')O<&5R=&EE<RYT>'2%4$UKPS ,O0?R'P3==5-W&@1Z&AD4!BL[
    M]1;<1&T]',O(RMHR]M]G)RNL'6PZV4_O0]+L]L\JBQF,%80#B5J*"?I/DRA*
    M?8#."K7*<@)EX$'#H+ C3V*4.MA:E]TRLTG,!6H?<!2;$)QMC5KV,9L`;T'W
    M!)'DG>3NDC%JNPHW9'!(C":-^I9B(^J0LJUQ^-.O+*ZU8^[!'2*V[+=VA_VI
    MX]Y8?Z5+L1L3"09QOP::'DUJ+?:JH4)TW!JWYZC5PWQ^/^V5L6QVEF^$#TD)
    M=*2R^/XL'BM<">_$]/"4+X1+KR2>%.IC<"PDN*S7J^>7U_JN7M?9>#KMN,S-
    MQ_F>GSC!9=$Z2UZ;UID8*5Y0+EME\0502P<(3D:RZ!$!```/`@``4$L#! H`
    M`````.R!@BX````````````````(````<V%M<&QE,R]02P,$% `(``@`VX&"
    M+@```````````````!<```!S86UP;&4S+V)U:6QD+7=E8G-S+GAM;*U6VV[;
    M, Q]+]!_((R]Q@;V[ SH+@4R8$6P"_:L2'2B5K8,24X6#/GW49;MV$F<2]<W
    M2SJ'I,@CTFEI]#-R!P7+<1IM<&%M! (S5BDWC1:55"+Z<']W?P>0.F:6.(#&
    M`0`-@C"L<)PI!0';PO@*^4L$LEBAD>Y!J6GD3(41)#UFY;3;E@AA#?#,UNR3
    MSDM=8.'L-'KW-QBS:-:28UPR_L*6N(L/#WR NZ@U(]"ZS]+L^;IR9>5B(<TN
    M^?WEXV3V])APQ:Q%NGK+:HP_U7<=\^PS$^!I;:!D;M5MT:9?H\*<X@>E.7-2
    M%U?&D?R?'2479VSX;\_W&8YKE['?VO4I:7)XI31I2]06+;6Z,AS?;ZP0;>8H
    MW=S(,H3(#3*'0'%"D[ON7!M@A0"B*LB,SB'8@DPJ;&OGX_M1;Q_7(,!W7<6$
    M>"3F^:S0R:3AV_A/KEH__DYV5F3ZJN(D-;S/;VS^^CX[CK,R:A^DO^UXF"=U
    M''M._<)&A?9&.GL#F=VJLB.1I4E/4IW,N))D<(G%.9&Q@<P")2B+0JHSWY8K
    MG'UE(SWA9!DF@10_,Q/UBGES(1ONR?;2N.BZ2T^=\QOPE<6Y-LYC'^PW="LM
    M`F_0<M,DM.AF=:*W-TV[JP*-BA*-VPY :(PV$:R9JF@/"NW ELAE)E'$\',E
    M+72\O+(.%N@WUE*@H.],&ZH5#0Q9+E.A8!T@R/&.8*F44PN):X@2TIHSZN
    MAT[=*.+>!$DS)A54A4)KV^@.&G;W#G/"T'H$!FV"Z\O5>B7.%6Y\8B[Y\)A7
    M.Z!F<LD^05YM/KR]2QZ:1GVKD_T#&7.P1]QL?/@4QAP,46><#!Y'FC0_2;3Z
    M!U!+!PB&<5T7? (``# )``!02P,$% `(``@`VX&"+@```````````````!$`
    M``!S86UP;&4S+V)U:6QD+GAM;)U62V_;, R^%^A_X(2>BL0^[)ITP- 5&[#M
    MTD./A2(SJ5K%-B2Y25#DOX]Z.;;SZF+ 04SQ\9'Z2&E2Z^H5A862+W'*#%_6
    M"K\R*'#.&V6G;-9(5;"[ZZOK*X#)E_$81+5<5B6088W:2C0P'M_YU2C:P%PJ
    M<I9E^4XILVO+(.\ZZG@P-0HYEP)L!?9%D@#UNQ2X[SKB#,L,WKEJZ/LG*E4]
    M55H5CVDE/V7X7'/QQA<[![:QE99<96T%3MNON&YM>R;'C% _"\6-0=/:W7Q4
    MC:T;^UQ(O<V??GP?__K[D+=:.V_<OH LIDPHB:7-O$;FI,QCC"JH<$G+X/X[
    MYT$[1=VFC(YH=Z'<?,0TM^,8\M6E>]+^E;_S#K(VW"1WGSX5_VFY7F"B6R 7
    MD:W&LC"N4+:I1T2PF@B4A;*-5CB+<#*O/PHH3CWD4%6;UE%(HE/1'@BAD)<.
    MA!%:UE96Y905E)Y%6&")FELLP-AF/F>0*A#7J5J#VG6JU-<YLAN3/& YB,R7
    M8X!,:"1 $$(ZY]2\Q%Q'F!1X^4;B%+?/O2Z^GMHE\/K[Q"#X[:,-*A#]0HE8
    M4#5I?!"#(!B"D04U(L08%,5Q28#1PH/+&,A2J(8<3]EMYA89X#I)`O+\EK6T
    M(+$]EGU*/O<QSN<X)!\[E&38$E)MQU9:K_0(5J90?B*.>BJ)E+NT.;43O6%X
    M^FAC%]YDZZ5B$& %1":"2>GLCYR@E: [66?LI.[>D>&<@^&X;'VD0?H?OAJM
    M6C_Y)6!,U6AQ*)_(C7-^0N]D1)'#H_B\AS@5SU>E-WH"\6B'/]]:R3S!^8_F
    M"J:QN3[56ZF38AD[;;0W'7;U\3)_0FF<'SZD.LE_LNO"_-Z;R4[8]L]L0S>1
    M>B/+!=!A["X.Y\\%__"Z5E)PY[2=GYM^B330^^#[\.:CHS\X'MTM8)OYJT ;
    M>\8-WA\]%DYF/=/5RN @ZR $2YM!9^T"85[IWA6IBQS7*,#]-);/`OI@KWM[
    M1D%!R1([$Y*:<IC8P=Z<Y,[]^5QT,SQ227)@YCE"! ('NZ,ME/WALKR4>)?D
    M_.WI\?[WD+O[B4_R>(.FKW]02P<(81.%XR@#``!-"P``4$L#! H``````-N!
    M@BX````````````````/````<V%M<&QE,R]C;&EE;G0O4$L#!!0`" `(`-N!
    M@BX````````````````8````<V%M<&QE,R]C;&EE;G0O36%I;BYJ879AM9-=
    MJ]- $(;O"_T/0ZY2A$7QSE!$1&G!XQ'+P8O#0::;:;*ZR8;=2=,H_>]N-FD^
    M_+@T!!)F7IYY9V:W0OD=,P*NV5B%6C@L*DTOA=2*2D[6J_5*%96Q#-_PC$(9
    ML;]_=Y%4L3)ELDA>Q*70PE92',B>E:2Y;KVJZJ-6$J1&Y^ .5?FSBP(,<<?(
    M_G,V*H7"9V,XL%5E]O@$:#,'FT$.H$YQ" E-9<8Y;+?P(J0A/"4U`=^+'I\_
    MP2;I<U?2CD8=Y]8T0;W7FC+4;VQ6%[[IT78,T</G#V!.7DO@^J:@- RN(JE.
    MBM)H@G>?ZZ*ENUD;T+A4/U@]&F7;CE9VI+7Y8JQ.A\F-Q;;!X!_YKWN_I7AB
    M)O\D?>JV$U:TO4%%1OS6XH\VZ.)-<ALL0(A 3IB2[?][`Y.RU\T4PA%_Q(+\
    ML&0'A::+]G-98H\F;6_0SI'(.[.["14O*L\!A]8Q%<+4+"H_3=9^KA-NKIS
    M]]XX#CU"M/.[1DO0FOKUW-Q5(LL\AMFI!IJ=IK]5CMZCTI0"&Y"6D D:.HXK
    MZV_.JPB>=:!D6>;WF_%?:@TGT;^_`%!+!PA5MM$EK@$``-\#``!02P,$% `(
    M``@`VX&"+@```````````````!X```!S86UP;&4S+TAE;&QO5V]R;&1397)V
    M:6-E+FIA=F%]4LMJPS 0O!O\#XM/3DJ<0V\)@4(IY-#'P8?VNK&71%26A"3'
    M<4/_O=:C=@)M0""8G9G=64EA]8E[`MM:J1GRPF"C.-VOTR1-EO-YFL <'CK>
    MF55'.T/ZR"H");5]Q88VV:/&K_Y=:EYGCKI,$]7N.*N@XF@,;(ESZ<MED)Z=
    M+T!PAM%;H;9P(*Q)>S9P6:%E4FRR@&:!OG17[!"(!]=A.RGS$9_,9K$KQ-I.
    MUF%FV("@+J#Y;!TX8[4PY%/FEV;%/H(S^!5HLJT6D\[#WW\'E8JT#P9,'&/&
    MA;$]'W8I!2TZ[/^(>I0L)GT;YL4^)BVM9F(/#1GCWM#%=/.4O;'4%+*UA1H(
    MEHL<L@LA&.S-"C*XFZ2W9J93Q=N:_AFKEL(^G90TPTK.-US\$Y\:7KJP;H,@
    M_ \:H+" >N& F^D_7IZOHU_YC>V'\P-02P<(4'P0;$H!``#8`@``4$L#!!0`
    M" `(`-N!@BX````````````````2````<V%M<&QE,R]7;W)L9"YJ879A=9 ]
    M#X(P$(9W$O[#A4D7!B"!A#BY&F/BX%RAP<;2-OU $^-_MQ1$JI)TZMW[W',G
    M4'5%#09M-)<$T5BA5E"<EF$0!L*<*:F@HD@I.'%)ZT<8``A).J0Q'+4DK &&
    M6ES._RFWOX(+0Y$FG#F4K0XPAUFM'0A<%C80;7D_]0ZWOAJ50_&#L"U)FN5)
    MD>5%DA8[U_#TN*-,@_7>,J<!$FLC&>@+4?$DZB<[3FI08VZ^%+PA4]IZ+$#<
    MSG;X87+^J^!=94EDQOB^I:_D'>@7;=\+4$L'"(@-B!+/````WP$``%!+`0(4
    M`!0`" `(`/>!@BX``````@`````````)``0```````````````````!-151!
    M+4E.1B_^R@``4$L!`A0`% `(``@`]X&"+MH`:(9*````2@```!0`````````
    M````````/0```$U%5$$M24Y&+TU!3DE&15-4+DU&4$L!`A0`% `(``@`0'6"
    M+DY&LN@1`0``#P(```X`````````````````R0```'!R;W!E<G1I97,N='AT
    M4$L!`@H`"@``````[(&"+@````````````````@`````````````````%@(`
    M`'-A;7!L93,O4$L!`A0`% `(``@`VX&"+H9Q71=\`@``, D``!<`````````
    M````````/ (``'-A;7!L93,O8G5I;&0M=V5B<W,N>&UL4$L!`A0`% `(``@`
    MVX&"+F$3A>,H`P``30L``!$`````````````````_00``'-A;7!L93,O8G5I
    M;&0N>&UL4$L!`@H`"@``````VX&"+@````````````````\`````````````
    M````9 @``'-A;7!L93,O8VQI96YT+U!+`0(4`!0`" `(`-N!@BY5MM$EK@$`
    M`-\#```8`````````````````)$(``!S86UP;&4S+V-L:65N="]-86EN+FIA
    M=F%02P$"% `4``@`" #;@8(N4'P0;$H!``#8`@``'@````````````````"%
    M"@``<V%M<&QE,R](96QL;U=O<FQD4V5R=FEC92YJ879A4$L!`A0`% `(``@`
    MVX&"+H@-B!+/````WP$``!(`````````````````&PP``'-A;7!L93,O5V]R
    =;&0N:F%V85!+!08`````"@`*`(("```J#0``````
    `
    end

  • JAX-RPC with JAXM?

    I have already created a synchronous messaging client using JAX-RPC. I now find the need to also have a asychronous messaging client as well. I was not able to find much as far as information or examples of asynchronous messaging. The only information I was able to find just says that I should use JAXM. The question I have is can I combine the JAX-RPC and the JAXM together (I'm using tomcat). Also does anyone know of a good asynchronous messaging example using either JAXM or JAX-RPC?
    tyia

    The Java Web Services Tutorial case study example uses JAX-RPC and JAXM together:
    http://java.sun.com/webservices/docs/1.0/tutorial/doc/CB.html

  • JAXM and a non Java Web Service Client

    How can I acces a web service buit using JAXM with a client written using other technology?
    Where do I have to send the SOAP message from the client?
    I saw that JAXM optains the messeage from the HttpRequest! How do I put the SOAP message there?
    Thanks

    if you are not taking advantage of asynchronous messaging via a messaging provider, but want a standard web service that speaks to non java clients then JAX-RPC should be the API of your choice. It is simpler then JAXM and more standard compliant.
    If you want to do asynchronous messaging your client has to have some kind of messaging provider, too, to be able to continously listen to messages. Then the SOAP messages are then exchanged between the two message providers who both in turn notify onMessage the relevant application (message consumer).
    I hope this helps you solve your problem ;-)

  • Asynchronous messaging using SOAP

    Hi,
    Does anybody have experiences using SOAP for asynchronous communications
    like notifications. Is there any way to integrate SOAP with JMS. I would
    appreciate any thoughts / feedback on this.
    Thanks
    Chandra.

    Sorry, I know this is not an answer to your question. I fooled around with JAXM for a while and gave up when I realized it was getting me nowhere. The more I investigated ebXML the more frustrated I became with JAXM.
    I've posted this several times before, but JAXM is absolutely the wrong solution for implementing ebXML. The protocols are in conflict with each other. Sybase provides a true ebXML server and has an outdated, but good, open source toolkit. In addition, Sun has a "technology preview" for what looks to be a server that fully supports ebXML. See http://lists.ebxml.org/archives/ebxml-dev/200210/msg00015.html.
    JAXM only supports parts of the ebXML Message Handling piece. It does not allow the client to dictate whether the conversation is synchronous or asynchronous as ebXML does. JAXM doesn't support using CPA's. In short, you can create messages with JAXM that look like ebXML but aren't.

  • JAXM in JWSDP 1.2

    I can't find JAXM in JWSDP 1.2, yet it was there in 1.1. Is there a reason why it is no longer included in the JWSDP? There is no information about this on the website, and yet nowhere does it say that you even need JAXM anymore. What's the deal?

    I got the following reply from a technology evangelist (which, I believe, might be someone who sends emails to God...):
    JAXM is removed from the Java WSDP due to the following reasons:
    -JAXM is not part of J2EE 1.4
    -Given that SAAJ is taken out as a separate package from JAXM,
    there is nothing much left in JAXM
    -JAX-RPC is "the" Java API for Web services. It does support
    document-driven model (with "doc/literal" and "attachment"
    -MDB (of EJb 2.1) will support asynchronous messaging
    Which doesn't explain why there was no announcement made, nor does it explain why JAXM is still prominently promoted on the Sun web site. But as we are mere mortals, I suppose we are not expected to understand.

  • How to get Acknowledgement from legacy system in an Asynchronous scenario?

    Hello Experts,
    My current scenario is to send an invoice from ECC --> ABAP proxy --> PI --> webservice --> Legacy system & I need acknowledgement back to ECC system from legacy system. How SAP XI acknowledgements work in asynchronous scenarios?
    Please guide.
    Thanks & Regards,
    Nidhi Kukreja

    Hi nidhi,
    please check following link
    http://help.sap.com/saphelp_nw04/helpdata/EN/44/932e8896b610bbe10000000a422035/frameset.htm
    Also check this one.
    http://help.sap.com/saphelp_nw04/helpdata/EN/f4/8620c6b58c422c960c53f3ed71b432/frameset.htm
    hope this helps..
    - Deepak.

  • Can't run report in ASYNCHRONOUS mode

    Hi All,
    I'm trying to make a report run in ASYNCHRONOUS mode. I want to press a button on a form, submit the report to the reports server and be able to navigate within the form while the report is being executed on the reports server.
    My problem is, no matter what mode I choose (ASYNCHRONOUS or SYNCHRONOUS), the mode ALWAYS ends up being SYNCHRONOUS. After I press the button (code below), I get the hourglass and I can't navigate within the form until the report is finished. Then I can view it.
    The reports server I'm using is installed locally on the same PC I'm testing the form.
    Can someone help me please? I'm using using Forms Builder 9.0.2.9.0.
    Thank you,
    Artur
    declare
         v_repid REPORT_OBJECT;
    v_rep in varchar2(100);
    begin
    v_repid := find_report_object('TEST');
    SET_REPORT_OBJECT_PROPERTY(v_repid, REPORT_EXECUTION_MODE, BATCH);
    SET_REPORT_OBJECT_PROPERTY(v_repid, REPORT_COMM_MODE, ASYNCHRONOUS);
    SET_REPORT_OBJECT_PROPERTY(v_repid, REPORT_DESTYPE, 'CACHE');
    SET_REPORT_OBJECT_PROPERTY(v_repid, REPORT_DESFORMAT, 'PDF'); -- OR HTMLCSS
    SET_REPORT_OBJECT_PROPERTY(v_repid, REPORT_SERVER, :TI_REPORTS_SERVER); -- local pc reports server
    v_rep := RUN_REPORT_OBJECT(v_repid, v_param_list);
    end;

    Arthur,
    Communication mode is soemthing forms handles when calling the run report object. Your code looks fine. You might get a quikc answer if you can post this in Forms mailing list
    Thanks
    The Oracle Reports Team

  • Asynchronous Business Object Event not triggering Workflow

    Hello everybody,
    I created a workflow for processing of inbound messages (IDoc). The workflow is correctly started when an IDoc arrives. Then it prepares some data and runs into a waiting step. After the user processes the messages via a custom transaction, the workflow should proceed and send some additional information to the message origin.
    I created a new BO with an event ProcessComplete, which is called in the custom transaction via the following code:
    INCLUDE <cntn01>.
    DATA lo_zisu TYPE swc_object.
    swc_container lo_container.
    swc_create_container lo_container.
    swc_set_element lo_container 'VAR1' lv_var.
    swc_create_object lo_zisu 'ZABC' lv_object_key.
    swc_raise_event lo_zisu 'ProcessComplete' lo_container.
    But when I call this code, the workflow does not continue. When I use SWEL to manually create an event on this object, the workflow only continues when I set the check box "synchronous call". So in some way, the asychronous calls disappears completely.
    Can anyone give me a hint, where to look for these calls? May there be a setting not active on the system for this particular workflow? Other workflows with the same method of event handling work well.
    Thanks and regards,
    Christoph

    Hello,
    I debugged deeper into the whole issue. When I call the function module for the event creation directly (not via the macro posted in my initial post), I have the option to control syncronous va. asynchronous processing:
    CALL FUNCTION 'SWE_EVENT_CREATE'
      EXPORTING
        objtype              = 'ZISU_MDC'
        objkey               = lv_objkey
        event                = 'ProcessComplete'
        start_recfb_synchron = 'X'
      IMPORTING
        receiver_count       = lv_rcvcnt
        event_id             = lv_evtid
      TABLES
        event_container      = lo_container
      EXCEPTIONS
        objtype_not_found    = 1
        OTHERS               = 2.
    The export parameter start_recfb_synchron controls this. In the program flow, the following is the difference between the two ways:
    Synchronous:
          CALL FUNCTION im_handler->m_linkage-recfb
               DESTINATION im_handler->m_linkage-rfcdest
               EXPORTING
                 sender                   = l_sibf_object_por
                 event                    = l_sibf_event
                 rectype                  = l_sibf_rectype
                 handler                  = l_receiver_por
                 exceptions_allowed       = 'X'
                 xml_size                 = l_xml_size
                 event_container          = lt_xml_container
               IMPORTING
                 result                   = l_result
               EXCEPTIONS
                 temp_error               = 1
                 OTHERS                   = 99.
    Asynchronous:
          CALL FUNCTION im_handler->m_linkage-recfb
               IN BACKGROUND TASK
               AS SEPARATE UNIT
               DESTINATION im_handler->m_linkage-rfcdest
               EXPORTING
                 sender                   = l_sibf_object_por
                 event                    = l_sibf_event
                 rectype                  = l_sibf_rectype
                 handler                  = l_receiver_por
                 exceptions_allowed       = ' '
                 xml_size                 = l_xml_size
                 event_container          = lt_xml_container
          CALL FUNCTION 'ID_OF_BACKGROUNDTASK'
               IMPORTING
                    tid = l_trfc_id.
    The first one works fine, the event gets processed, there is an entry in SWEL, the workflow continues. The second way does not work. The second function returns a tRFC ID, but when locking tRFC in the debugger and search for the call via SM58, there is no entry.
    In parallel I opened an OSS message, but did not get any (useful) response yet.
    Regards,
    Christoph

  • Problems with asynchronous(?) function call before return statement

    I have a function as following inside a class deriving from CustomNode:
    override protected function create () : Node {
                    parseContent();
                    return group;
            }parseContent() executes a HttpRequest and then a PullParser. At least that's what it should do. But actually, it doesn't. Is this because the HttpRequest is asynchronous and is "cancelled" because of the return statement? Or can't this be the problem?

    You would have to update or create the view in the finally block of the onOutput: or onInput methods within the request.
    You could also try
    var viewContent: Node;
    override protected function create () : Node {
                    parseContent();
                    FX.deferAction(function():Void{
                           viewContent = group;
                    return Group{ content: bind viewContent }
            }I never tried that, but it might work.
    Another option is to bind the parsed content to whatever view you are pushing it to. Then whenever the request is done, the view will populate its content on the change of the variable where the content is stored.
    Example:
    var allTables: TableModel[];      
    //***************start of table list decleration****************************\\
    public var list: SwingJList = SwingJList {
        var shortcutKey: Boolean = false;
        focusTraversable: true
        selectedIndex: 0
        action: function(){
            FX.deferAction(function():Void{
                openButton.fire();
        items: bind for( table in allTables ){
            table.name
    var searchDataXml = xmlGenerator.generateSearchXMLString(searchData);
    var contentLength: Integer = searchDataXml.getBytes().length;
    def postRequest: HttpRequest = HttpRequest {
        location: "{WEB_APPLICATION_REQUEST_URL}searchData/?database={DATABASE_KEY}";
        method: HttpRequest.POST;
        headers: [
                HttpHeader {
                    name: HttpHeader.CONTENT_TYPE;
                    value: "application/xml";
                HttpHeader {
                    name: HttpHeader.CONTENT_LENGTH;
                    value: "{contentLength}";
        onStarted: function() {
            println("onStarted - started performing method: {postRequest.method} on location: {postRequest.location}");
        onConnecting: function() { println("onConnecting") }
        onDoneConnect: function() { println("onDoneConnect") }
        onWriting: function() { println("onWriting") }
        onOutput: function(os: java.io.OutputStream) {
            try {
                os.write(searchDataXml.getBytes());
            } finally {
                println("onOutput - about to close output stream.");
                os.close();
                os.flush();
        onToWrite: function(bytes: Long) { println("onToWrite - entire content to be written: {bytes} bytes") }
        onWritten: function(bytes: Long) { println("onWritten - {bytes} bytes has now been written") }
        onDoneWrite: function() { println("doneWrite") }
        onReadingHeaders: function() { println("onReadingHeaders") }
        onResponseCode: function(code:Integer) { println("onResponseCode - responseCode: {code}") }
        onResponseMessage: function(msg:String) { println("onResponseMessage - responseMessage: {msg}") }
        onResponseHeaders: function(headerNames: String[]) {
            println("onResponseHeaders - there are {headerNames.size()} response headers:");
            for (name in headerNames) {
                println("    {name}: {postRequest.getResponseHeaderValue(name)}");
        onReading: function() { println("onReading") }
        onToRead: function(bytes: Long) {
            if (bytes < 0) {
                println("onToRead - Content length not specified by server; bytes: {bytes}");
            } else {
                println("onToRead - total number of content bytes to read: {bytes}");
        onRead: function(bytes: Long) {
            // The toread variable is non negative only if the server provides the content length
            def progress =
            if (postRequest.toread > 0) "({(bytes * 100 / postRequest.toread)}%)" else "";
            println("onRead - bytes read: {bytes} {progress}");
        var parser = new XmlPullParser();
        onInput: function(is: java.io.InputStream) {
            // use input stream to access content here.
            // can use input.available() to see how many bytes are available.
            try {
                allTables = parser.processResults(is);
            } finally {
                is.close();
        onException: function(ex: java.lang.Exception) {
            println("onException - exception: {ex.getClass()} {ex.getMessage()}");
        onDoneRead: function() { println("onDoneRead") }
        onDone: function() { println("onDone") }
    postRequest.start();
    } In this case an array of tableModel names are bound to the list view.
    When the httprequest ends, it sets the parsed tableModel array to the array declared in this class.
    The list view will populate the table names from the array when the request finishes.

  • Is this the best design for asynchronous notifications (such as email)? Current design uses Web Site, Azure Service Bus Queue, Table Storage and Cloud Service Worker Role.

    I am asking for feedback on this design. Here is an example user story:
    As a group admin on the website I want to be notified when a user in my group uploads a file to the group.
    Easiest solution would be that in the code handling the upload, we just directly create an email message in there and send it. However, this seems like it isn't really the appropriate level of separation of concerns, so instead we are thinking to have a separate
    worker process which does nothing but send notifications. So, the website in the upload code handles receiving the file, extracting some metadata from it (like filename) and writing this to the database. As soon as it is done handling the file upload it then
    does two things: Writes the details of the notification to be sent (such as subject, filename, etc...) to a dedicated "notification" table and also creates a message in a queue which the notification sending worker process monitors. The entire sequence
    is shown in the diagram below.
    My questions are: Do you see any drawbacks in this design? Is there a better design? The team wants to use Azure Worker Roles, Queues and Table storage. Is it the right call to use these components or is this design unnecessarily complex? Quality attribute
    requirements are that it is easy to code, easy to maintain, easy to debug at runtime, auditable (history is available of when notifications were sent, etc...), monitor-able. Any other quality attributes you think we should be designing for?
    More info:
    We are creating a cloud application (in Azure) in which there are at least 2 components. The first is the "source" component (for example a UI / website) in which some action happens or some condition is met that triggers a second component or "worker"
    to perform some job. These jobs have details or metadata associated with them which we plan to store in Azure Table Storage. Here is the pattern we are considering:
    Steps:
    Condition for job met.
    Source writes job details to table.
    Source puts job in queue.
    Asynchronously:
    Worker accepts job from queue.
    Worker Records DateTimeStarted in table.
    Queue marks job marked as "in progress".
    Worker performs job.
    Worker updates table with details (including DateTimeCompleted).
    Worker reports completion to queue.
    Job deleted from queue.
    Please comment and let me know if I have this right, or if there is some better pattern. For example sake, consider the work to be "sending a notification" such as an email whose template fields are filled from the "details" mentioned in
    the pattern.

    Hi,
    Thanks for your posting.
    This development mode can exclude some errors, such as the file upload complete at the same time... from my experience, this is a good choice to achieve the goal.
    Best Regards,
    Jambor  
    We are trying to better understand customer views on social support experience, so your participation in this interview project would be greatly appreciated if you have time. Thanks for helping make community forums a great place.
    Click
    HERE to participate the survey.

  • Using asynchronous timer for data flow control

    Hi all,
      I am using system sleep to control the data flow (some digital lines and analog output). The pseudo code is something like this
    Sleep(150);
    // the following sections are exectuted in parallel
      #pragma omp parallel sections
        #pragma omp section
          DAQmxWriteDigitalLines(...); // output TTL to one digitla line
        #pragma omp section
          DAQmxWriteDigitalLines(...); // output TTL to another digitla line     
        #pragma omp section
          Sleep(2); // sleep 2ms
    // the following sections are exectuted in parallel
      #pragma omp parallel sections
        #pragma omp section
          DAQmxWriteDigitalLines(...); // output TTL to one digitla line
        #pragma omp section
          DAQmxWriteAnalogScalarF64(...); // analog output to one channel
        #pragma omp section
          Sleep(1); // delay 1ms
    // the following sections are exectuted in parallel
      #pragma omp parallel sections
        #pragma omp section
          DAQmxWriteDigitalLines(...); // output TTL to one digitla line
        #pragma omp section
          DAQmxWriteAnalogScalarF64(...); // analog output to one channel
    #pragma omp section
          DAQmxWriteAnalogScalarF64(...); // analog output to another channel
        #pragma omp section
          Sleep(11); // delay 11ms
    // ... other stuffs
    I am running windows XP and I know it is not possible to get realtime control but  I want a as precise timing as possible. Above code is not perfect but it works 95% of times. I just read an article about using the asynchronous timer to control the time delay. I try that idea with the following code frame
    int CVICALLBACK ATCallback(int reserved, int timerId, int event, void *callbackData, int eventData1, int eventData2)
    if (event==EVENT_TIMER_TICK)
    int *nextdelay = (int *)callbackData;
    SuspendAsyncTimerCallbacks();
    if (timerId>=0)
    double time;
    if (*nextdelay==0) time=2.0;
    else if (*nextdelay==1) time=1.0;
    else time=12.0;
    SetAsyncTimerAttribute(timerId, ASYNC_ATTR_INTERVAL, time);
    if (*nextdelay==0)
    #pragma omp parallel sections
    #pragma omp section
    DAQmxWriteDigitalLines(...); // output TTL to one digitla line
    #pragma omp section
    DAQmxWriteDigitalLines(...); // output TTL to another digitla line
    *nextdelay++;
    else if (*nextdelay==2)
    #pragma omp parallel sections
    #pragma omp section
    DAQmxWriteDigitalLines(...); // output TTL to one digitla line
    #pragma omp section
    DAQmxWriteAnalogScalarF64(...); // analog output to one channel
    *nextdelay++;
    else if (*nextdelay==3)
    #pragma omp parallel sections
    #pragma omp section
    DAQmxWriteDigitalLines(...); // output TTL to one digitla line
    #pragma omp section
    DAQmxWriteAnalogScalarF64(...); // analog output to one channel
    #pragma omp section
    DAQmxWriteAnalogScalarF64(...); // analog output to another channel
    *nextdelay++;
    ResumeAsyncTimerCallbacks();
    return 0;
    void main(void)
    int n = 0;
    int timeid;
    timeid = NewAsyncTimer(120.0/1000.0, 3, 1, ATCallback, &n);
    But it doesn't work. There is no compilation and runtime error but the timing just not right. I wonder do I have to suspend the timer in the callback function when I reset the delay for next call? If I do so, I am worry if it will apply too much delay (since I suspend and resume the timer in the delay) so it will cause even worse timing. But if I don't suspend the timer before I reset the time, what happen if the code running in the callback function not finished before the next callback arrive. It is quite confusing how to use asynchronous timer in this case. Thanks.

    Yeah, unfortunately the 6711 doesn't have clocked digital I/O.  There are only two counters anyway so even if you could use them to generate your signals you wouldn't have enough (*maybe* something with the 4 AO channels and a counter depending on what your output signals need to look like?  The AO channels can output "digital" as well if you write 0V or 5V only).
    A PCI DAQ card which does support clocked digital I/O and has 2 analog outputs is the 6221 (or if you could use PCIe the 6321 is a more updated version with two extra counters and some additional functionality).
    If there isn't a way to implement clocked outputs afterall, one thing you could do to make your code a little more efficient is to consolidate the writes.  You can put your digital lines into a single task and write them at ocne, and you can put your analog channels into a single task and write them at once as well.
    I'm not sure about the callback issue, you might find some more help in the CVI forum.  I don't think it's going to solve your underlying problem though as ultimately the execution timing of your software calls is at the mercy of your OS.
    Best Regards,
    John Passiak

  • Asynchronous HotLog CDC Space to Null Issue

    I have established Asynchronous HotLog CDC in one of our testing database. I have done the following steps (as described in the Asynchronous HotLog CDC oracle documentation):
    ALTER DATABASE FORCE LOGGING;
    ALTER DATABASE ADD SUPPLEMENTAL LOG DATA;
    ALTER TABLE #SCHEMA#.#TABLE_NAME# ADD SUPPLEMENTAL LOG DATA (ALL) COLUMNS;
    In addition, all of the other steps were followed for permissions, pool sizes, change set setup, change table setup, and so forth. This work is being done as a conversion from Synchronous to Asynchronous.
    The issue encountered is that when characters that have a space (' '), it is substituted with a null and inserted into the CT table. I understand per documentation if the supplemental logging is not setup correctly, you can encounter nulls for values that remain static. The problem is this is occurring on our data inserts, with the correct supplemental logging on the table as per documentation.
    Any suggestions are appreciated, DB is 11.2.0.1
    Thanks

    Thank you damorgan, your example was very thorough and helpful. Unfortunately though, after following your steps with my table I was testing, I am still receiving nulls where the insert statement had a space, besides that the asynchronous cdc process works fine.
    It is almost like there is a trimming occurring when inserting into the change table, even though in the source table there is a space ' '. I might just need to stay with synchronous CDC because at least the trigger is capturing the correct change data, not sure why the Asynchronous would be different with the space becoming a null.
    Thanks.

  • Is in PI7.1 possible asynchronous communication between SOAP and ABAPProxy?

    Hi,
    when method execute_asynchronous has disapeared since XI/PI 7.1, is
    there still way how to use ABAP proxy in asynchronous way?
    We need to build asynchronous connection SOAP->PI->ABAP_Proxy.
    In PI, both interfaces are defined as asynchronous (outbound for SOAP and
    inbound for ABAP Proxy).
    Despite of this fact, when message is sent, it is processed
    synchronous way.
    I have set breakpoint in my implementation of method for ABAP Proxy
    message processing. When message is sent and breakpoint is reached,
    whole connection stays open (between SOAP and PI and between PI and
    ABAP Proxy) and waits for processing method (the breakpointed one) to
    return. Only when processing method returns, is connection finelly
    closed.
    If i understand it correctly, this is synchronous behavior. In
    asynchronous behavior, as i understand it, should be connection
    between PI and ABAP Proxy of application server closed immediately
    after message has been delivered. This mean before my processing
    method is even called.
    The same could be said about SOAP and PI communication. Connection
    should be closed immediately after PI has received message. From
    definition of asynchronous communication of PI is obvious, that PI
    should receive message correctly and close connection to sender system
    even when receiver is unreachable. It should deliver message later
    when, receiver system is back on line. So why it keeps connection to
    sender system open while it waits for receiver?
    Why is this happening, when both interfaces are defined as
    asynchronous? Could be the reason for this, if APPLICATION
    ACKNOWLEDGEMENT is set on by default? If so, how can i change it
    to SYSTEM ACKNOWLEDGEMENT, or disable it at all?
    Or is this kind of asynchronous communication even possible since
    XI/PI 7.1 ?
    Processing of message we are sending can take some time, so we dont
    want connection pending open while waiting for finish of
    processing. Thats the reason why we have chose asynchronous model to
    use.

    Quote from How to Use the J2EE SOAP Adapter:
    "If you select Best Effort, the Web service client will receive a response
    message in the SOAP body. Otherwise, the Web service client will not receive a
    response message if no error occurs."
    "if no error occurs" - that is the problem. In either case he still
    waits if some error occure or not. I dont want it. Once PI has
    received message, I want the connection with sender to be closed. If
    there will be error in communication between PI and reciever, I want
    to see it only in PI log. That mean no notification to sender to be
    send about that error.
    Is that possible?

Maybe you are looking for

  • How to use requestScope in faces-config.xml file?

    a managed-bean need get value from request as its property so i configure the manged-bean as below:(use requestScope object) <managed-bean> <description>this is for item test bean.</description> <managed-bean-name> item </managed-bean-name> <managed-

  • PAGINATION ERROR

    Hi, I'm trying to get this pagination code functioning but I keep getting an error on my query. The error says: Microsoft Access Driver] Syntax error (missing operator) in query expression 'titles LIMIT 0' and I'm completely stumped, I pasted my code

  • Snapshot with update on both sides

    Hi, I've created a snapshot with the for update clause, but when I use the dbms_snapshot.refresh procedure, the server looses everything made in the point B. Point A -> master Point B -> snapshot Sequence: 1) Create a simple table in the master an po

  • Unable to see repository objects in directory

    hi, i am unable to see repository objects in directory(like message interface, interface mapping). i have tried cache refresh but the issue still persists.

  • Ipod Wont Respond in windows after disco

    I recently had my Ipod plugged into my Windows XP box. As I was transfering files from the harddrive to the PCs harddrive via windows explorer, my 1 y/o came and forcibly disconnected the Ipod from the computer. Naturally, all the transfered were dis