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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2005-2013, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
package scala.actors
package remote
/**
* This object provides methods for creating, registering, and
* selecting remotely accessible actors.
*
* A remote actor is typically created like this:
* {{{
* actor {
* alive(9010)
* register('myName, self)
*
* // behavior
* }
* }}}
* It can be accessed by an actor running on a (possibly)
* different node by selecting it in the following way:
* {{{
* actor {
* // ...
* val c = select(Node("127.0.0.1", 9010), 'myName)
* c ! msg
* // ...
* }
* }}}
*
* @author Philipp Haller
*/
@deprecated("Use the akka.actor package instead. For migration from the scala.actors package refer to the Actors Migration Guide.", "2.11.0")
object RemoteActor {
private val kernels = new scala.collection.mutable.HashMap[InternalActor, NetKernel]
/* If set to <code>null</code> (default), the default class loader
* of <code>java.io.ObjectInputStream</code> is used for deserializing
* objects sent as messages.
*/
private var cl: ClassLoader = null
def classLoader: ClassLoader = cl
def classLoader_=(x: ClassLoader) { cl = x }
/**
* Makes <code>self</code> remotely accessible on TCP port
* <code>port</code>.
*/
def alive(port: Int): Unit = synchronized {
createNetKernelOnPort(port)
}
private def createNetKernelOnPort(port: Int): NetKernel = {
val serv = TcpService(port, cl)
val kern = serv.kernel
val s = Actor.self(Scheduler)
kernels(s) = kern
s.onTerminate {
Debug.info("alive actor "+s+" terminated")
// remove mapping for `s`
kernels -= s
// terminate `kern` when it does
// not appear as value any more
if (!kernels.valuesIterator.contains(kern)) {
Debug.info("terminating "+kern)
// terminate NetKernel
kern.terminate()
}
}
kern
}
/**
* Registers <code>a</code> under <code>name</code> on this
* node.
*/
def register(name: Symbol, a: Actor): Unit = synchronized {
val kernel = kernels.get(Actor.self(Scheduler)) match {
case None =>
val serv = TcpService(TcpService.generatePort, cl)
kernels(Actor.self(Scheduler)) = serv.kernel
serv.kernel
case Some(k) =>
k
}
kernel.register(name, a)
}
private def selfKernel = kernels.get(Actor.self(Scheduler)) match {
case None =>
// establish remotely accessible
// return path (sender)
createNetKernelOnPort(TcpService.generatePort)
case Some(k) =>
k
}
/**
* Returns (a proxy for) the actor registered under
* <code>name</code> on <code>node</code>.
*/
def select(node: Node, sym: Symbol): AbstractActor = synchronized {
selfKernel.getOrCreateProxy(node, sym)
}
private[remote] def someNetKernel: NetKernel =
kernels.valuesIterator.next
}
/**
* This class represents a machine node on a TCP network.
*
* @param address the host name, or <code>null</code> for the loopback address.
* @param port the port number.
*
* @author Philipp Haller
*/
@deprecated("Use the akka.actor package instead. For migration from the scala.actors package refer to the Actors Migration Guide.", "2.11.0")
case class Node(address: String, port: Int)
|
