FilesExpand file tree

 master

/

IO.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

98 lines (76 loc) · 2.72 KB

 master

/

IO.java

Copy path

Top

File metadata and controls

• Code
• Blame

98 lines (76 loc) · 2.72 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

package io.socket.client;

import io.socket.parser.Parser;

import javax.net.ssl.HostnameVerifier;

import javax.net.ssl.SSLContext;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

import java.util.concurrent.ConcurrentHashMap;

import java.util.logging.Logger;

public class IO {

private static final Logger logger = Logger.getLogger(IO.class.getName());

private static final ConcurrentHashMap<String, Manager> managers = new ConcurrentHashMap<String, Manager>();

/**

* Protocol version.

*/

public static int protocol = Parser.protocol;

public static void setDefaultSSLContext(SSLContext sslContext) {

Manager.defaultSSLContext = sslContext;

}

public static void setDefaultHostnameVerifier(HostnameVerifier hostnameVerifier) {

Manager.defaultHostnameVerifier = hostnameVerifier;

}

private IO() {}

public static Socket socket(String uri) throws URISyntaxException {

return socket(uri, null);

}

public static Socket socket(String uri, Options opts) throws URISyntaxException {

return socket(new URI(uri), opts);

}

public static Socket socket(URI uri) {

return socket(uri, null);

}

/**

* Initializes a {@link Socket} from an existing {@link Manager} for multiplexing.

*

* @param uri uri to connect.

* @param opts options for socket.

* @return {@link Socket} instance.

*/

public static Socket socket(URI uri, Options opts) {

if (opts == null) {

opts = new Options();

}

URL parsed = Url.parse(uri);

URI source;

try {

source = parsed.toURI();

} catch (URISyntaxException e) {

throw new RuntimeException(e);

}

String id = Url.extractId(parsed);

String path = parsed.getPath();

boolean sameNamespace = managers.containsKey(id)

&& managers.get(id).nsps.containsKey(path);

boolean newConnection = opts.forceNew || !opts.multiplex || sameNamespace;

Manager io;

if (newConnection) {

logger.fine(String.format("ignoring socket cache for %s", source));

io = new Manager(source, opts);

} else {

if (!managers.containsKey(id)) {

logger.fine(String.format("new io instance for %s", source));

managers.putIfAbsent(id, new Manager(source, opts));

}

io = managers.get(id);

}

return io.socket(parsed.getPath());

}

public static class Options extends Manager.Options {

public boolean forceNew;

/**

* Whether to enable multiplexing. Default is true.

*/

public boolean multiplex = true;

}

}