~ubuntu-branches/ubuntu/raring/libjboss-remoting-java/raring

ServerSocketFactory ssf = (ServerSocketFactory) getServerSocketFactoryConstructor().newInstance(new Object[]{new Integer(blockingTime), new Integer(initialWrites)});

429

config.put(Remoting.CUSTOM_SERVER_SOCKET_FACTORY, ssf);

430

}

431

if (setCallbackWriteTimeout)

432

{

433

config.put(SocketWrapper.WRITE_TIMEOUT, writeTimeout);

434

SocketFactory sf = (SocketFactory) getSocketFactoryConstructor().newInstance(new Object[]{new Integer(blockingTime), new Integer(initialWrites)});

435

config.put(Remoting.CUSTOM_SOCKET_FACTORY, sf);

436

}

437

if (callbackTest)

438

{

439

config.put("numberOfCallRetries", "1");

440

}

441

addExtraServerConfig(config);

442

connector = new Connector(serverLocator, config);

443

connector.create();

444

invocationHandler = new TestInvocationHandler();

445

connector.addInvocationHandler("test", invocationHandler);

446

connector.start();

447

}

448

449

450

protected void shutdownServer() throws Exception

451

{

452

if (connector != null)

453

connector.stop();

454

}

455

456

457

static class TestInvocationHandler implements ServerInvocationHandler

458

{

459

Throwable t;

460

461

public void addListener(final InvokerCallbackHandler callbackHandler)

462

{

463

new Thread()

464

{

465

public void run()

466

{

467

try

468

{

469

log.info("sending callback");

470

callbackHandler.handleCallback(new Callback("callback"));

471

}

472

catch (Throwable t)

473

{

474

log.info("throwable: ", t);

475

TestInvocationHandler.this.t = t;

476

}

477

}

478

}.start();

479

}

480

public Object invoke(final InvocationRequest invocation) throws Throwable

481

{

482

return invocation.getParameter();

483

}

484

public void removeListener(InvokerCallbackHandler callbackHandler) {}

485

public void setMBeanServer(MBeanServer server) {}

486

public void setInvoker(ServerInvoker invoker) {}

487

}

488

489

490

static class TestCallbackHandler implements InvokerCallbackHandler

491

{

492

public void handleCallback(Callback callback) throws HandleCallbackException

493

{

494

log.info("received callback");

495

}

496

}

497

498

499

static public class TestServerSocketFactory extends ServerSocketFactory

500

{

501

int timeout;

502

int initialWrites;

503

504

public TestServerSocketFactory()

505

{

506

this.timeout = 5000;

507

this.initialWrites = -1;

508

}

509

public TestServerSocketFactory(int timeout, int initialWrites)

510

{

511

this.timeout = timeout;

512

this.initialWrites = initialWrites;

513

}

514

public ServerSocket createServerSocket() throws IOException

515

{

516

ServerSocket ss = null;

517

if (callbackTest)

518

{

519

ss = ServerSocketFactory.getDefault().createServerSocket();

520

}

521

else

522

{

523

ss = new TestServerSocket(timeout, initialWrites);

524

}

525

log.info("returning: " + ss);

526

return ss;

527

}

528

public ServerSocket createServerSocket(int port) throws IOException

529

{

530

ServerSocket ss = null;

531

if (callbackTest && port != secondaryServerSocketPort)

532

{

533

ss = ServerSocketFactory.getDefault().createServerSocket(port);

534

}

535

else

536

{

537

ss = new TestServerSocket(port, timeout, initialWrites);

538

}

539

log.info("returning: " + ss);

540

return ss;

541

}

542

543

public ServerSocket createServerSocket(int port, int backlog) throws IOException

544

{

545

ServerSocket ss = null;

546

if (callbackTest && port != secondaryServerSocketPort)

547

{

548

ss = ServerSocketFactory.getDefault().createServerSocket(port, backlog);

549

}

550

else

551

{

552

ss = new TestServerSocket(port, backlog, timeout, initialWrites);

553

}

554

log.info("returning: " + ss);

555

return ss;

556

}

557

558

public ServerSocket createServerSocket(int port, int backlog, InetAddress ifAddress) throws IOException

559

{

560

ServerSocket ss = null;

561

if (callbackTest && port != secondaryServerSocketPort)

562

{

563

ss = ServerSocketFactory.getDefault().createServerSocket(port, backlog, ifAddress);

564

}

565

else

566

{

567

ss = new TestServerSocket(port, backlog, ifAddress, timeout, initialWrites);

568

}

569

log.info("returning: " + ss);

570

return ss;

571

}

572

}

573

574

575

static class TestServerSocket extends ServerSocket

576

{

577

int timeout;

578

int initialWrites;

579

580

public TestServerSocket(int timeout, int initialWrites) throws IOException

581

{

582

super();

583

this.timeout = timeout;

584

this.initialWrites = initialWrites;

585

}

586

public TestServerSocket(int port, int timeout, int initialWrites) throws IOException

587

{

588

super(port);

589

this.timeout = timeout;

590

this.initialWrites = initialWrites;

591

}

592

public TestServerSocket(int port, int backlog, int timeout, int initialWrites) throws IOException

593

{

594

super(port, backlog);

595

this.timeout = timeout;

596

this.initialWrites = initialWrites;

597

}

598

public TestServerSocket(int port, int backlog, InetAddress bindAddr, int timeout, int initialWrites) throws IOException

599

{

600

super(port, backlog, bindAddr);

601

this.timeout = timeout;

602

this.initialWrites = initialWrites;

603

}

604

public Socket accept() throws IOException

605

{

606

Socket s = new TestSocket(timeout, initialWrites);

607

implAccept(s);

608

return s;

609

}

610

public String toString()

611

{

612

return "TestServerSocket[" + getLocalPort() + "]";

613

}

614

}

615

616

617

public static class TestSocketFactory extends SocketFactory

618

{

619

int timeout;

620

int initialWrites = -1;

621

622

public TestSocketFactory()

623

{

624

timeout = 5000;

625

}

626

public TestSocketFactory(int timeout, int initialWrites)

627

{

628

this.timeout = timeout;

629

this.initialWrites = initialWrites;

630

}

631

public Socket createSocket()

632

{

633

log.info("callbackTest: " + callbackTest);

634

Socket s = null;

635

if (callbackTest)

636

{

637

s = new Socket();

638

}

639

else

640

{

641

s = new TestSocket(timeout, initialWrites);

642

}

643

log.info(this + " returning " + s);

644

return s;

645

}

646

public Socket createSocket(String arg0, int arg1) throws IOException, UnknownHostException

647

{

648

log.info("callbackTest: " + callbackTest + ", port: " + arg1);

649

Socket s = null;

650

if (callbackTest && arg1 != secondaryServerSocketPort)

651

{

652

s = new Socket(arg0, arg1);

653

}

654

else

655

{

656

s = new TestSocket(arg0, arg1, timeout, initialWrites);

657

}

658

log.info(this + " returning " + s);

659

return s;

660

}

661

662

public Socket createSocket(InetAddress arg0, int arg1) throws IOException

663

{

664

log.info("callbackTest: " + callbackTest + ", port: " + arg1);

665

Socket s = null;

666

if (callbackTest && arg1 != secondaryServerSocketPort)

667

{

668

s = new Socket(arg0, arg1);

669

}

670

else

671

{

672

s = new TestSocket(arg0, arg1, timeout, initialWrites);

673

}

674

log.info(this + " returning " + s);

675

return s;

676

}

677

678

public Socket createSocket(String arg0, int arg1, InetAddress arg2, int arg3) throws IOException, UnknownHostException

679

{

680

log.info("callbackTest: " + callbackTest + ", port: " + arg1);

681

Socket s = null;

682

if (callbackTest && arg1 != secondaryServerSocketPort)

683

{

684

s = new Socket(arg0, arg1);

685

}

686

else

687

{

688

s = new TestSocket(arg0, arg1, arg2, arg3, timeout, initialWrites);

689

}

690

log.info(this + " returning " + s);

691

return s;

692

}

693

694

public Socket createSocket(InetAddress arg0, int arg1, InetAddress arg2, int arg3) throws IOException

695

{

696

log.info("callbackTest: " + callbackTest + ", port: " + arg1);

697

Socket s = null;

698

if (callbackTest && arg1 != secondaryServerSocketPort)

699

{

700

s = new Socket(arg0, arg1);

701

}

702

else

703

{

704

s = new TestSocket(arg0, arg1, arg2, arg3, timeout, initialWrites);

705

}

706

log.info(this + " returning " + s);

707

return s;

708

}

709

}

710

711

static class TestSocket extends Socket

712

{

713

int timeout;

714

int initialWrites;

715

716

public TestSocket(int timeout, int initialWrites)

717

{

718

this.timeout = timeout;

719

this.initialWrites = initialWrites;

720

}

721

public TestSocket(String host, int port, int timeout, int initialWrites) throws UnknownHostException, IOException

722

{

723

super(host, port);

724

this.timeout = timeout;

725

this.initialWrites = initialWrites;

726

}

727

public TestSocket(InetAddress address, int port, int timeout, int initialWrites) throws IOException

728

{

729

super(address, port);

730

this.timeout = timeout;

731

this.initialWrites = initialWrites;

732

}

733

public TestSocket(String host, int port, InetAddress localAddr, int localPort, int timeout, int initialWrites) throws IOException

734

{

735

super(host, port, localAddr, localPort);

736

this.timeout = timeout;

737

this.initialWrites = initialWrites;

738

}

739

public TestSocket(InetAddress address, int port, InetAddress localAddr, int localPort, int timeout, int initialWrites) throws IOException

740

{

741

super(address, port, localAddr, localPort);

742

this.timeout = timeout;

743

this.initialWrites = initialWrites;

744

}

745

public OutputStream getOutputStream() throws IOException

746

{

747

return new TestOutputStream(super.getOutputStream(), timeout, initialWrites);

748

}

749

public String toString()

750

{

751

return "TestSocket[" + getLocalPort() + "->" + getPort() + "]";

752

}

753

}

754

755

static class TestOutputStream extends OutputStream

756

{

757

OutputStream os;

758

int timeout;

759

boolean closed;

760

int initialWrites;

761

boolean doWait = true;

762

public static int counter;

763

764

public TestOutputStream(OutputStream os, int timeout, int initialWrites)

765

{

766

this.os = os;

767

this.timeout = timeout;

768

this.initialWrites = initialWrites;

769

}

770

public void close()throws IOException

771

{

772

closed = true;

773

super.close();

774

log.info(this + " closed");

775

}

776

public void write(int b) throws IOException

777

{

778

System.out.print("b: " + b);

779

if (closed)

780

{

781

log.info("TestOutputStream closed, cannot write");

782

throw new IOException("closed");

783

}

784

if (doWait && ++counter > initialWrites)

785

{

786

try

787

{

788

log.info("TestOutputStream.write() sleeping: " + timeout);

789

Thread.sleep(timeout);

790

}

791

catch (InterruptedException e)

792

{

793

e.printStackTrace();

794

}

795

}

796

os.write(b);

797

}

798

public void write(byte b[], int off, int len) throws IOException

799

{

800

System.out.print("b: ");

801

for (int i = 0; i < len; i++)

802

{

803

System.out.print(b[i] + " ");

804

}

805

System.out.println("");

806

if (closed)

807

{

808

log.info("TestOutputStream closed, cannot write");

809

throw new IOException("closed");

810

}

811

log.info("TestOutputStream: counter = " + counter + ", initialWrites = " + initialWrites);

812

if (++counter > initialWrites)

813

{

814

try

815

{

816

log.info("TestOutputStream.write() sleeping: " + timeout);

817

Thread.sleep(timeout);

818

}

819

catch (InterruptedException e)

820

{

821

e.printStackTrace();

822

}

823

}

824

if (closed)

825

{

826

log.info("TestOutputStream closed, cannot write");

827

throw new IOException("closed");

828

}

829

try

830

{

831

log.info(this + " calling write()");

832

doWait = false;

833

os.write(b, off, len);

834

os.flush();

835

doWait = true;

836

log.info(this + " back from write()");

837

}

838

catch (IOException e)

839

{

840

log.info("exception: ", e);

841

throw e;

842

}

843

}

844

}

845

}

b'\\ No newline at end of file'

Older »