com.sun.xml.internal.ws.api.pipe.Tube Java Examples

@Override
public void close() {
    TubePool tp = (TubePool) tubes;
    if (tp != null) {
        // multi-thread safety of 'close' needs to be considered more carefully.
        // some calls might be pending while this method is invoked. Should we
        // block until they are complete, or should we abort them (but how?)
        Tube p = tp.takeMaster();
        p.preDestroy();
        tubes = null;
    }
    if (!managedObjectManagerClosed) {
        try {
            final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot());
            // The name is null when the MOM is a NOOP.
            if (name != null) {
                monitoringLogger.log(Level.INFO, "Closing Metro monitoring root: {0}", name);
            }
            managedObjectManager.close();
        } catch (java.io.IOException e) {
            monitoringLogger.log(Level.WARNING, "Ignoring error when closing Managed Object Manager", e);
        }
        managedObjectManagerClosed = true;
    }
}
 

/**
 * Creates a new pipeline for the given port name.
 */
private Tube createPipeline(WSPortInfo portInfo, WSBinding binding) {
    //Check all required WSDL extensions are understood
    checkAllWSDLExtensionsUnderstood(portInfo, binding);
    SEIModel seiModel = null;
    Class sei = null;
    if (portInfo instanceof SEIPortInfo) {
            SEIPortInfo sp = (SEIPortInfo) portInfo;
        seiModel = sp.model;
        sei = sp.sei;
    }
    BindingID bindingId = portInfo.getBindingId();

    TubelineAssembler assembler = TubelineAssemblerFactory.create(
            Thread.currentThread().getContextClassLoader(), bindingId, owner.getContainer());
    if (assembler == null) {
        throw new WebServiceException("Unable to process bindingID=" + bindingId); // TODO: i18n
    }
    return assembler.createClient(
            new ClientTubeAssemblerContext(
                    portInfo.getEndpointAddress(),
                    portInfo.getPort(),
                    this, binding, owner.getContainer(), ((BindingImpl) binding).createCodec(), seiModel, sei));
}
 

@Override
public void close() {
    TubePool tp = (TubePool) tubes;
    if (tp != null) {
        // multi-thread safety of 'close' needs to be considered more carefully.
        // some calls might be pending while this method is invoked. Should we
        // block until they are complete, or should we abort them (but how?)
        Tube p = tp.takeMaster();
        p.preDestroy();
        tubes = null;
    }
    if (!managedObjectManagerClosed) {
        try {
            final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot());
            // The name is null when the MOM is a NOOP.
            if (name != null) {
                monitoringLogger.log(Level.INFO, "Closing Metro monitoring root: {0}", name);
            }
            managedObjectManager.close();
        } catch (java.io.IOException e) {
            monitoringLogger.log(Level.WARNING, "Ignoring error when closing Managed Object Manager", e);
        }
        managedObjectManagerClosed = true;
    }
}
 

@Override
public void close() {
    TubePool tp = (TubePool) tubes;
    if (tp != null) {
        // multi-thread safety of 'close' needs to be considered more carefully.
        // some calls might be pending while this method is invoked. Should we
        // block until they are complete, or should we abort them (but how?)
        Tube p = tp.takeMaster();
        p.preDestroy();
        tubes = null;
    }
    if (!managedObjectManagerClosed) {
        try {
            final ObjectName name = managedObjectManager.getObjectName(managedObjectManager.getRoot());
            // The name is null when the MOM is a NOOP.
            if (name != null) {
                monitoringLogger.log(Level.INFO, "Closing Metro monitoring root: {0}", name);
            }
            managedObjectManager.close();
        } catch (java.io.IOException e) {
            monitoringLogger.log(Level.WARNING, "Ignoring error when closing Managed Object Manager", e);
        }
        managedObjectManagerClosed = true;
    }
}
 

boolean setTubelineHead(Tube newHead) {
    if (newHead == head || newHead == adaptedHead) {
        return false;
    }

    head = newHead;
    tubes.add(head);
    adaptedHead = null;

    if (LOGGER.isLoggable(Level.FINER)) {
        LOGGER.finer(MessageFormat.format("Added '{0}' tube instance to the tubeline.", (newHead == null) ? null : newHead.getClass().getName()));
    }

    return true;
}
 

@Override
public <T> T getImplementation(Class<T> type) {
    for (Tube tube : tubes) {
        if (type.isInstance(tube)) {
            return type.cast(tube);
        }
    }
    return null;
}
 

public static Tube adapt(Pipe p) {
    if (p instanceof Tube) {
        return (Tube) p;
    } else {
        return new PipeAdapter(p);
    }
}
 

protected MUTube(WSBinding binding, Tube next) {
    super(next);
    // MUPipe should n't be used for bindings other than SOAP.
    if (!(binding instanceof SOAPBinding)) {
        throw new WebServiceException(
                "MUPipe should n't be used for bindings other than SOAP.");
    }
    this.binding = (SOAPBindingImpl) binding;
    this.soapVersion = binding.getSOAPVersion();
}
 

public WsaTube(WSDLPort wsdlPort, WSBinding binding, Tube next) {
    super(next);
    this.wsdlPort = wsdlPort;
    this.binding = binding;
    addKnownHeadersToBinding(binding);
    addressingVersion = binding.getAddressingVersion();
    soapVersion = binding.getSOAPVersion();
    helper = getTubeHelper();
    addressingRequired = AddressingVersion.isRequired(binding);
}
 

public static Tube adapt(Pipe p) {
    if (p instanceof Tube) {
        return (Tube) p;
    } else {
        return new PipeAdapter(p);
    }
}
 

@Deprecated
public SEIStub(WSServiceDelegate owner, BindingImpl binding, SOAPSEIModel seiModel, Tube master, WSEndpointReference epr) {
    super(owner, master, binding, seiModel.getPort(), seiModel.getPort().getAddress(), epr);
    this.seiModel = seiModel;
    this.soapVersion = binding.getSOAPVersion();
    databinding = seiModel.getDatabinding();
    initMethodHandlers();
}
 

@Override
public Tube decorateClient(Tube tube, ClientTubelineAssemblyContext context) {
    for (TubelineAssemblyDecorator decorator : decorators) {
        tube = decorator.decorateClient(tube, context);
    }
    return tube;
}
 

@Override
public Tube decorateClientTail(
        Tube tube,
        ClientTubelineAssemblyContext context) {
    for (TubelineAssemblyDecorator decorator : decorators) {
        tube = decorator.decorateClientTail(tube, context);
    }
    return tube;
}
 

public WsaTube(WSDLPort wsdlPort, WSBinding binding, Tube next) {
    super(next);
    this.wsdlPort = wsdlPort;
    this.binding = binding;
    addKnownHeadersToBinding(binding);
    addressingVersion = binding.getAddressingVersion();
    soapVersion = binding.getSOAPVersion();
    helper = getTubeHelper();
    addressingRequired = AddressingVersion.isRequired(binding);
}
 

@Deprecated
public static Dispatch<Source> createSourceDispatch(QName port, Mode mode, WSServiceDelegate owner, Tube pipe, BindingImpl binding, WSEndpointReference epr) {
    if(isXMLHttp(binding))
        return new RESTSourceDispatch(port,mode,owner,pipe,binding,epr);
    else
        return new SOAPSourceDispatch(port,mode,owner,pipe,binding,epr);
}
 

protected MUTube(WSBinding binding, Tube next) {
    super(next);
    // MUPipe should n't be used for bindings other than SOAP.
    if (!(binding instanceof SOAPBinding)) {
        throw new WebServiceException(
                "MUPipe should n't be used for bindings other than SOAP.");
    }
    this.binding = (SOAPBindingImpl) binding;
    this.soapVersion = binding.getSOAPVersion();
}
 

public LoggingDumpTube(Level loggingLevel, Position position, Tube tubelineHead) {
    super(tubelineHead);

    this.position = position;
    this.loggingLevel = loggingLevel;

    this.tubeId = ID_GENERATOR.incrementAndGet();
}
 

public ServerSchemaValidationTube(WSEndpoint endpoint, WSBinding binding,
        SEIModel seiModel, WSDLPort wsdlPort, Tube next) {
    super(binding, next);
    this.seiModel = seiModel;
    this.wsdlPort = wsdlPort;

    if (endpoint.getServiceDefinition() != null) {
        MetadataResolverImpl mdresolver = new MetadataResolverImpl(endpoint.getServiceDefinition());
        Source[] sources = getSchemaSources(endpoint.getServiceDefinition(), mdresolver);
        for(Source source : sources) {
            LOGGER.fine("Constructing service validation schema from = "+source.getSystemId());
            //printDOM((DOMSource)source);
        }
        if (sources.length != 0) {
            noValidation = false;
            sf.setResourceResolver(mdresolver);
            try {
                schema = sf.newSchema(sources);
            } catch(SAXException e) {
                throw new WebServiceException(e);
            }
            validator = schema.newValidator();
            return;
        }
    }
    noValidation = true;
    schema = null;
    validator = null;
}
 

@NotNull
public Tube createClient(ClientTubeAssemblerContext context) {
    Tube head = context.createTransportTube();
    head = context.createSecurityTube(head);
    if (dump) {
        // for debugging inject a dump pipe. this is left in the production code,
        // as it would be very handy for a trouble-shooting at the production site.
        head = context.createDumpTube("client", System.out, head);
    }
    head = context.createWsaTube(head);
    head = context.createClientMUTube(head);
    head = context.createValidationTube(head);
    return context.createHandlerTube(head);
}
 

protected final NextAction doInvoke(Tube next, Packet packet) {
    NextAction na = new NextAction();
    na.invoke(next,packet);
    return na;
}
 

public Tube createTube(ServerTubelineAssemblyContext context) throws WebServiceException {
    return context.getWrappedContext().createHandlerTube(context.getTubelineHead());
}
 

public ServerMessageHandlerTube(SEIModel seiModel, WSBinding binding, Tube next, HandlerTube cousinTube) {
    super(next, cousinTube, binding);
    this.seiModel = seiModel;
    setUpHandlersOnce();
}
 

@Deprecated
public RESTSourceDispatch(QName port, Mode mode, WSServiceDelegate owner, Tube pipe, BindingImpl binding, WSEndpointReference epr) {
    super(port, mode, owner, pipe, binding, epr);
    assert isXMLHttp(binding);
}
 

public PacketDispatch(WSPortInfo portInfo, Tube pipe, BindingImpl binding, WSEndpointReference epr, boolean allowFaultResponseMsg) {
    super(portInfo, Mode.MESSAGE, pipe, binding, epr, allowFaultResponseMsg);
    isDeliverThrowableInPacket = calculateIsDeliverThrowableInPacket(binding);
}
 

public Pool<Tube> getTubes() {
    return tubes;
}
 

public AbstractSchemaValidationTube(WSBinding binding, Tube next) {
    super(next);
    this.binding = binding;
    feature = binding.getFeature(SchemaValidationFeature.class);
    sf = allowExternalAccess(SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI), "file", false);
}
 

public Tube createTube(ServerTubelineAssemblyContext context) throws WebServiceException {
    return context.getTubelineHead();
}
 

@Deprecated
public MessageDispatch(QName port, WSServiceDelegate service, Tube pipe, BindingImpl binding, WSEndpointReference epr) {
    super(port, Mode.MESSAGE, service, pipe, binding, epr);
}
 

@Override
public Tube createTube(ServerTubelineAssemblyContext context) throws WebServiceException {
    return context.getWrappedContext().createValidationTube(context.getTubelineHead());
}
 

public Tube decorateServer(Tube tube, ServerTubelineAssemblyContext context) {
    for (TubelineAssemblyDecorator decorator : decorators) {
        tube = decorator.decorateServer(tube, context);
    }
    return tube;
}