streaming soap with attachments

[pmakoi]

dear all
this might be a piece of cake for some of you out there but it is causing me a lot of stress given the fact that there is not enogh documentation out there regarding this topic

I am writing a web service that uses soap with attachments to send a large streaming data,
The concept works quite well but when I started to test it I got this problem.
When my client program calls a method that should return a real time data the streaming starts after 10 seconds
How can I avoid the fact that the message calls waits that long before the data starts streaming in?
To be more specific
I have a method that returns a streaming data in 10 seconds [getSteamingData(long seconds)]
I would like to test if I already get some data steaming in after one second of it starts.
To do so I started a thread that checks the OutputSteam size every 1 second and then compare the result with the previous size say a second ago, there should be an increase in size each second!!!
But when I start the thread… the streaming does not start right away instead, it starts after 10 seconds causing the thread to return null size
In real life with real large streaming data that 10 seconds could be 10 hours or God forbidden 10 years
Is there a way around or is that not possible in SwA?
Anybody have any idea
thanks in advance

[r035198x]

dear all
this might be a piece of cake for some of you out there but it is causing me a lot of stress given the fact that there is not enogh documentation out there regarding this topic

I am writing a web service that uses soap with attachments to send a large streaming data,
The concept works quite well but when I started to test it I got this problem.
When my client program calls a method that should return a real time data the streaming starts after 10 seconds
How can I avoid the fact that the message calls waits that long before the data starts streaming in?
To be more specific
I have a method that returns a streaming data in 10 seconds [getSteamingData(long seconds)]
I would like to test if I already get some data steaming in after one second of it starts.
To do so I started a thread that checks the OutputSteam size every 1 second and then compare the result with the previous size say a second ago, there should be an increase in size each second!!!
But when I start the thread… the streaming does not start right away instead, it starts after 10 seconds causing the thread to return null size
In real life with real large streaming data that 10 seconds could be 10 hours or God forbidden 10 years
Is there a way around or is that not possible in SwA?
Anybody have any idea
thanks in advance

Unfortunately once things over a network cable lots of things come into into play. It could be just your network playing tricks e.t.c. I don't know if posting your method for sending the data will help.

[pmakoi]

thxs for the quick reply
here is the code

 public javax.activation.DataHandler[] returnStreamingByteArray(final int timeout) {
        DataHandler ret = new DataHandler(new DataSource() {
            private long start = System.currentTimeMillis();
            private long end = start + timeout;
 
            public String getContentType() {
                return "text/plain";
            }
 
            public InputStream getInputStream() throws IOException {
                return new InputStream() {
                    public int read() throws IOException {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            //ignore this exception
                        }
                        if (System.currentTimeMillis() > end) {
                            return -1;
                        } else {
                            return (int)(Math.random() *  256);
                        }
                    }
                };
            }
 
            public String getName() {
                return "";
            }
 
            public OutputStream getOutputStream() throws IOException {
                return null;
            }
 
        });
        return new DataHandler[]{ret};
    }

[r035198x]

thxs for the quick reply
here is the code

 public javax.activation.DataHandler[] returnStreamingByteArray(final int timeout) {
        DataHandler ret = new DataHandler(new DataSource() {
            private long start = System.currentTimeMillis();
            private long end = start + timeout;
 
            public String getContentType() {
                return "text/plain";
            }
 
            public InputStream getInputStream() throws IOException {
                return new InputStream() {
                    public int read() throws IOException {
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            //ignore this exception
                        }
                        if (System.currentTimeMillis() > end) {
                            return -1;
                        } else {
                            return (int)(Math.random() *  256);
                        }
                    }
                };
            }
 
            public String getName() {
                return "";
            }
 
            public OutputStream getOutputStream() throws IOException {
                return null;
            }
 
        });
        return new DataHandler[]{ret};
    }

What value are you passing for the timeout?

[pmakoi]

the value that i gave it is 10000

here is a part of a unit test class that i used to test it

 package com.markit.soapattachments.client;
 
import javax.activation.DataHandler;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;
 
public class AttachmentsService_ServiceWernerTestCase extends junit.framework.TestCase {
 
……………………………………
…………………………………
 
 
 
//this is the thread that runs the test
    private class StreamListener extends Thread {
 
        private int time;
        private ByteArrayOutputStream outputStream;
 
        public StreamListener(int time) {
            this.time = time;
        }
 
        public void run() {
            try {
                //Write
                DataHandler[] ret = binding.returnStreamingByteArray(time);
 
assertNotNull("Expected non-null value to be returned",ret);
assertEquals("Expected length of DataHandler array to be 1", 1, ret.length);
 
                //Read
                DataHandler handler = ret[0];
 
                InputStream is = handler.getInputStream();
                int value;
                outputStream = new ByteArrayOutputStream();
                try {
                    while ((value = is.read()) != -1) {
                        outputStream.write(value);
                    }
                } finally {
                    outputStream.close();
                }
            } catch (Exception e) {
                fail("Unexpected exception: " + e);
            }
        }
 
        public int getNrBytesRead() {
            return outputStream == null ? 0 : outputStream.size();
        }
 
        public byte[] getBytes() {
            return outputStream == null ? new byte[0] : outputStream.toByteArray();
        }
    }
 
    public void testAttachmentsServiceReturnStreamingByteArray() throws Exception {
        // Test operation
        long start = System.currentTimeMillis();
 
        StreamListener listener = new StreamListener(10000);
        listener.start();
        int nrOfBytesRead = 0;
        int previousNrOfBytesRead = 0;
 
        while (System.currentTimeMillis() < start + 10000) {
            Thread.sleep(1000);
            nrOfBytesRead = listener.getNrBytesRead();
            assertTrue("Expected number of bytes read to have incremented", nrOfBytesRead > previousNrOfBytesRead);
            previousNrOfBytesRead = nrOfBytesRead;
        }
        listener.join();
 
        byte[] returnedBytes = listener.getBytes();
 
        assertTrue("Expected streaming to have lasted more than 10 seconds", System.currentTimeMillis() - start > 10000);
 
        assertTrue("Expected byte array to be filled", returnedBytes.length > 0);
 
    }
 
 
}

[pmakoi]

first i would like to thank every viewer for their attention and r035198x in particular

I have been goggling around trying to figure out what might have been going wrong during the transmission? And I came up with some questions that might provide a hint as to where the problems might be coming from?
1- in old postings about SwA it is stated that the attachments are sent in a one-go fashion, is that still the case now or can some new implementations support streaming the attachments through the network?
If there are no data streaming soap with attachments implementations out there, would my problem be, that the streaming that I am trying to simulate in the above code is just using the activations framework streaming capabilities and the 10000 ms overhead is just a result of the work done by the processor to allocate resources for the large amount of data that is being received in one-go?