dart-lang/sdk
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Remove server socket references

Browse Source 
The use of server socket references was deprecated in 1.9 and marked
for removal in 1.10.

R=kustermann@google.com

BUG=http://dartbug.com/22187

Review URL: https://codereview.chromium.org/1072783003 .
This commit is contained in:
Søren Gjesse
2015-10-05 12:25:20 +02:00
parent da8baacae4
commit 65872873d2
7 changed files with 0 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/bin/io_natives.cc
-1
View File
@@ -132,7 +132,6 @@ namespace bin {
V(Socket_SetOption, 4) \
V(Socket_JoinMulticast, 4) \
V(Socket_LeaveMulticast, 4) \
V(Socket_MarkSocketAsSharedHack, 1) \
V(Socket_GetSocketId, 1) \
V(Socket_SetSocketId, 2) \
V(Stdin_ReadByte, 1) \
runtime/bin/socket.cc
-23
View File
@@ -170,20 +170,6 @@ bool ListeningSocketRegistry::CloseSafe(intptr_t socketfd) {
}
Dart_Handle ListeningSocketRegistry::MarkSocketFdAsSharableHack(
intptr_t socketfd) {
MutexLocker ml(ListeningSocketRegistry::mutex_);
SocketsIterator it = sockets_by_fd_.find(socketfd);
if (it != sockets_by_fd_.end()) {
it->second->shared = true;
return Dart_True();
} else {
return Dart_False();
}
}
void FUNCTION_NAME(InternetAddress_Parse)(Dart_NativeArguments args) {
const char* address =
DartUtils::GetStringValue(Dart_GetNativeArgument(args, 0));
@@ -855,15 +841,6 @@ void FUNCTION_NAME(Socket_LeaveMulticast)(Dart_NativeArguments args) {
}
void FUNCTION_NAME(Socket_MarkSocketAsSharedHack)(Dart_NativeArguments args) {
intptr_t socketfd =
Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
ListeningSocketRegistry *registry = ListeningSocketRegistry::Instance();
Dart_SetReturnValue(args, registry->MarkSocketFdAsSharableHack(socketfd));
}
void Socket::SetSocketIdNativeField(Dart_Handle socket, intptr_t id) {
Dart_Handle err =
Dart_SetNativeInstanceField(socket, kSocketIdNativeField, id);
runtime/bin/socket.h
-7
View File
@@ -395,13 +395,6 @@ class ListeningSocketRegistry {
// this function.
bool CloseSafe(intptr_t socketfd);
// Mark an existing socket as sharable if it is not already marked as
// sharable.
//
// NOTE: This is a temporary measure until ServerSocketReference's are
// removed.
Dart_Handle MarkSocketFdAsSharableHack(intptr_t socketfd);
Mutex *mutex() { return mutex_; }
private:
runtime/bin/socket_patch.dart
-57
View File
@@ -1083,8 +1083,6 @@ class _NativeSocket extends _NativeSocketNativeWrapper with _ServiceObject {
bool nativeLeaveMulticast(
List<int> addr, List<int> interfaceAddr, int interfaceIndex)
native "Socket_LeaveMulticast";
bool _nativeMarkSocketAsSharedHack()
native "Socket_MarkSocketAsSharedHack";
}
@@ -1187,50 +1185,10 @@ class _RawServerSocket extends Stream<RawSocket>
}
}
RawServerSocketReference get reference {
if (_referencePort == null) {
bool successfull = _socket._nativeMarkSocketAsSharedHack();
_referencePort = new ReceivePort();
_referencePort.listen((sendPort) {
sendPort.send(
[_socket.address,
_socket.port,
_v6Only]);
});
}
return new _RawServerSocketReference(_referencePort.sendPort);
}
void set _owner(owner) { _socket.owner = owner; }
}
class _RawServerSocketReference implements RawServerSocketReference {
final SendPort _sendPort;
_RawServerSocketReference(this._sendPort);
Future<RawServerSocket> create() {
var port = new ReceivePort();
_sendPort.send(port.sendPort);
return port.first.then((List args) {
port.close();
InternetAddress address = args[0];
int tcpPort = args[1];
bool v6Only = args[2];
return
RawServerSocket.bind(address, tcpPort, v6Only: v6Only, shared: true);
});
}
int get hashCode => _sendPort.hashCode;
bool operator==(Object other)
=> other is _RawServerSocketReference && _sendPort == other._sendPort;
}
class _RawSocket extends Stream<RawSocketEvent>
implements RawSocket {
final _NativeSocket _socket;
@@ -1393,17 +1351,6 @@ patch class ServerSocket {
}
class _ServerSocketReference implements ServerSocketReference {
final RawServerSocketReference _rawReference;
_ServerSocketReference(this._rawReference);
Future<ServerSocket> create() {
return _rawReference.create().then((raw) => new _ServerSocket(raw));
}
}
class _ServerSocket extends Stream<Socket>
implements ServerSocket {
final _socket;
@@ -1436,10 +1383,6 @@ class _ServerSocket extends Stream<Socket>
Future close() => _socket.close().then((_) => this);
ServerSocketReference get reference {
return new _ServerSocketReference(_socket.reference);
}
void set _owner(owner) { _socket._owner = owner; }
}
sdk/lib/io/socket.dart
-69
View File
@@ -253,41 +253,6 @@ abstract class RawServerSocket implements Stream<RawSocket> {
* is fully closed and is no longer bound.
*/
Future<RawServerSocket> close();
/**
* Get the [RawServerSocketReference].
*
* WARNING: This feature is *highly experimental* and currently only
* works on Linux. The API will be removed in Dart 1.10. Use the
* `shared` optional argument on the `bind` method instead.
*
* The returned [RawServerSocketReference] can be used to create other
* [RawServerSocket]s listening on the same port,
* using [RawServerSocketReference.create].
* Incoming connections on the port will be distributed fairly between the
* active server sockets.
* The [RawServerSocketReference] can be distributed to other isolates through
* a [RawSendPort].
*/
@Deprecated('This will be removed in Dart 1.10. Use the '
'`shared` optional argument on the `bind` method instead.')
RawServerSocketReference get reference;
}
/**
* A [RawServerSocketReference].
*
* WARNING: This class is used with [RawServerSocket.reference] which is highly
* experimental.
*/
@Deprecated('This will be removed in Dart 1.10.')
abstract class RawServerSocketReference {
/**
* Create a new [RawServerSocket], from this reference.
*/
Future<RawServerSocket> create();
}
@@ -358,40 +323,6 @@ abstract class ServerSocket implements Stream<Socket> {
* is fully closed and is no longer bound.
*/
Future<ServerSocket> close();
/**
* Get the [ServerSocketReference].
*
* WARNING: This feature is *highly experimental* and currently only
* works on Linux. The API will be removed in Dart 1.10. Use the
* `shared` optional argument on the `bind` method instead.
*
* The returned [ServerSocketReference] can be used to create other
* [ServerSocket]s listening on the same port,
* using [ServerSocketReference.create].
* Incoming connections on the port will be distributed fairly between the
* active server sockets.
* The [ServerSocketReference] can be distributed to other isolates through a
* [SendPort].
*/
@Deprecated('This will be removed in Dart 1.10. Use the '
'`shared` optional argument on the `bind` method instead.')
ServerSocketReference get reference;
}
/**
* A [ServerSocketReference].
*
* WARNING: This class is used with [ServerSocket.reference] which is highly
* experimental.
*/
@Deprecated('This will be removed in Dart 1.10.')
abstract class ServerSocketReference {
/**
* Create a new [ServerSocket], from this reference.
*/
Future<ServerSocket> create();
}
tests/standalone/io/server_socket_reference_issue21383_and_issue21384_test.dart
-73
View File
@@ -1,73 +0,0 @@
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'dart:async';
import 'dart:io';
import 'package:async_helper/async_helper.dart';
testBothListen() {
asyncStart();
ServerSocket.bind('127.0.0.1', 0).then((mainServer) {
mainServer.reference.create().then((refServer) {
refServer.listen((_) {});
mainServer.listen((_) {});
Timer.run(() {
mainServer.close();
refServer.close();
asyncEnd();
});
});
});
}
testRefServerListen() {
asyncStart();
ServerSocket.bind('127.0.0.1', 0).then((mainServer) {
mainServer.reference.create().then((refServer) {
refServer.listen((_) {});
Timer.run(() {
mainServer.close();
refServer.close();
asyncEnd();
});
});
});
}
testMainServerListen() {
asyncStart();
ServerSocket.bind('127.0.0.1', 0).then((mainServer) {
mainServer.reference.create().then((refServer) {
mainServer.listen((_) {});
Timer.run(() {
mainServer.close();
refServer.close();
asyncEnd();
});
});
});
}
testNoneListen() {
asyncStart();
ServerSocket.bind('127.0.0.1', 0).then((mainServer) {
mainServer.reference.create().then((refServer) {
Timer.run(() {
mainServer.close();
refServer.close();
asyncEnd();
});
});
});
}
main() {
testNoneListen();
testMainServerListen();
testRefServerListen();
testBothListen();
}
tests/standalone/io/socket_bind_test.dart
-65
View File
@@ -82,69 +82,6 @@ Future testBindDifferentAddresses(InternetAddress addr1,
});
}
testSocketReferenceInteroperability(String host) {
asyncStart();
ServerSocket.bind(host, 0).then((ServerSocket socket) {
Expect.isTrue(socket.port > 0);
asyncStart();
socket.reference.create().then((socket2) {
bool gotResponseFrom1;
bool gotResponseFrom2;
Expect.isTrue(socket.port > 0);
Expect.equals(socket.port, socket2.port);
asyncStart();
asyncStart();
asyncStart();
socket.listen((client) {
client.drain().whenComplete(asyncEnd);
client.write('1: hello world');
client.close().whenComplete(asyncEnd);
// NOTE: Closing the socket un-subscribes as well, which means the
// other client connection must go to the other socket.
socket.close().whenComplete(asyncEnd);
}, onDone: asyncEnd);
asyncStart();
asyncStart();
asyncStart();
socket2.listen((client) {
client.drain().whenComplete(asyncEnd);
client.write('2: hello world');
client.close().whenComplete(asyncEnd);
// NOTE: Closing the socket un-subscribes as well, which means the
// other client connection must go to the other socket.
socket2.close().whenComplete(asyncEnd);
}, onDone: asyncEnd);
var futures = [];
for (int i = 0; i < 2; i++) {
asyncStart();
futures.add(
Socket.connect(socket.address, socket.port).then((Socket socket) {
socket.close().whenComplete(asyncEnd);
asyncStart();
return socket
.transform(ASCII.decoder).join('').then((String result) {
if (result == '1: hello world') gotResponseFrom1 = true;
else if (result == '2: hello world') gotResponseFrom2 = true;
else throw 'Unexpected result from server: $result';
asyncEnd();
});
}));
}
asyncStart();
Future.wait(futures).then((_) {
Expect.isTrue(gotResponseFrom1);
Expect.isTrue(gotResponseFrom2);
asyncEnd();
});
});
});
}
testListenCloseListenClose(String host) async {
asyncStart();
@@ -184,8 +121,6 @@ void main() {
negTestBindV6OnlyMismatch(host, true);
negTestBindV6OnlyMismatch(host, false);
testSocketReferenceInteroperability(host);
testListenCloseListenClose(host);
}